Compute Substrate Vertical Slice - Implementation Status

Created: 2026-02-10
Last Updated: 2026-02-10
PR: #1148 (E1-E7, A1-A4, B1, C1-C3 complete)

Overview

This document tracks the implementation of compute substrate foundations as part of the ICN vertical slice initiative. The goal is to establish the types and interfaces needed for the complete loop:

Identity → Standing → Governance → Allocations → Workloads → Receipts → Audit → Future Constraints

Completed Work

E-Track: Execution Layer (COMPLETE ✅)

A-Track: Architecture (Kernel/App Separation) (COMPLETE ✅)

B-Track: Business Layer (B1 COMPLETE ✅)

C-Track: Connectivity/Operations (COMPLETE ✅)

D-Track: Demo/Integration

⚠️ Required Architectural Interventions

Before B2/B3, these consolidations must happen:

INT-1: CanonicalReceipt Trait (CRITICAL)

Receipt types proliferating independently risks parallel audit systems.

pub trait CanonicalReceipt {
    fn receipt_id(&self) -> ReceiptId;
    fn scope(&self) -> ScopeLevel;
    fn created_at(&self) -> u64;
    fn subject_hash(&self) -> ContentHash;
    fn parent_receipts(&self) -> Vec<ReceiptId>;
    fn verify(&self) -> Result<()>;
}

All receipts (Decision, Allocation, Execution) implement this trait.

INT-2: SettlementIntent Pattern (CRITICAL)

• Rename SettlementHook → SettlementIntent (declarative)
• LedgerOracle consumes intent (executes)
• Execution NEVER directly mutates ledger

INT-3: Governance Firewall Enforcement

apps/governance may:

• ✅ Produce receipts
• ✅ Emit policy deltas
• ✅ Call executors via trait

apps/governance may NOT:

• ❌ Import ledger internals
• ❌ Mutate ledger state directly
• ❌ Bypass ProposalExecutor boundary

New Types Added

icn-kernel-api/src/storage.rs (E4)

/// Three-tier storage classification
pub enum StorageClass {
    Canonical,     // Immutable: ledger, governance, trust
    ServiceState,  // Mutable: app state, calendars, schedules
    Blobs,         // Content-addressed: documents, media
}

/// Data locality constraints
pub enum DataLocality {
    CellLocal,           // Must stay in originating cell
    CoopReplicated,      // Replicated across coop nodes
    FederationMirrored,  // Cross-entity interoperability
    CommonsPublic,       // Public indices, shared libraries
}

icn-kernel-api/src/state.rs (A1)

/// Replication policy for storage
pub enum ReplicationPolicy {
    LocalOnly,
    ClusterStrong,
    FederationEventual,
    Archive,
    Scoped { scope: ScopeLevel, factor: u8 },
}

/// Service traits for generic state access
pub trait LogService { ... }
pub trait BlobService { ... }
pub trait KvService { ... }

icn-compute/src/types.rs (E1)

/// Determinism classification for workloads
pub enum DeterminismClass {
    Canonical,  // Must be deterministic; outputs become constraints
    Advisory,   // Can be probabilistic; outputs are suggestions
}

/// Privacy classification for workload data
pub enum PrivacyClass {
    Public,      // Open data
    Member,      // Coop members only
    NeedToKnow,  // Selective disclosure via ZK
}

icn-compute/src/receipt.rs (E2)

/// Artifact pointer for execution outputs
pub struct ArtifactPointer {
    pub artifact_type: ArtifactType,
    pub content_hash: ContentHash,
    pub storage_scope: ScopeLevel,
}

/// Verification result for execution
pub enum VerificationResult {
    Pending,
    Passed { witnesses: Vec<String> },
    Failed { reason: String, evidence: ContentHash },
    Disputed { dispute_id: DisputeId },
}

/// Settlement hook for ledger integration
pub struct SettlementHook {
    pub ledger_entry_type: String,
    pub amount: u64,
    pub currency: String,
    pub from_account: String,
    pub to_account: String,
}

Dependency Graph

E1 (Manifest) ─┐
E2 (Receipt)  ─┼─→ E6 (Individual Node) ─┐
E3 (Determinism)─┤                        ├─→ D1 (E2E Tests) ─→ D2 (Demo)
E4 (Storage)  ─┤                        │
E5 (Cell Op)  ─┘                        │
                                         │
A1 (State Gen) ─→ A2 (Gov Extract) ─→ A3 (Membership) ─┤
                                                        │
A4 (Cleanup) ─────────────────────────────────────────┤
                                                        │
C1 (Backup) ─→ C2 (Health) ──────────────────────────┤
C3 (NAT) ─────────────────────────────────────────────┤
                                                        │
B1 (Treasury) ─┐                                       │
B2 (Assets)   ─┼─→ B3 (Receipts) ─────────────────────┘

Sprint Plan

Sprint 1: Parallel Foundations (3-4 days)

All tasks can run simultaneously - no dependencies between them.

Sprint 2: Governance & Membership (4-5 days)

Sequential chain - must complete in order.

Sprint 3: Economics & Assets (3-4 days)

Sprint 4: Integration & Demo (3-4 days)

How to Continue

1. Pick an unblocked task from Sprint 1 (all parallel) or check dependencies
2. Check the GitHub issue for full context
3. Run tests after implementation:

   cd icn
   RUSTC_WRAPPER="" cargo test -p <crate-name>
   RUSTC_WRAPPER="" cargo clippy -p <crate-name> -- -D warnings
   

4. Update this doc when completing work
5. Create PR following ICN conventions (see .github/copilot-instructions.md)

Related Documents

• Compute Substrate Design - Original architecture
• ARCHITECTURE.md - System overview
• kernel_surface.toml - Kernel boundary tracking
• AGENTS.md - Agent operating instructions