@deepstrike/sdk 0.2.49 → 0.2.51

package/dist/runtime/session-log.d.ts

@@ -1,11 +1,7 @@
 import type { KernelPrimitive } from "./kernel-event-log.js";
 import type { ContentPart, ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
 import type { MemoryRecall, MemoryScope } from "../memory/protocols.js";
-import type { DurableAppendReceipt, KernelGenesisReceipt, KernelOperationGenesis, KernelTransaction } from "./kernel-transaction-log.js";
-export interface KernelTransactionEntry {
-    log_seq: number;
-    transaction: KernelTransaction;
-}
+import type { KernelJournal } from "./kernel-journal.js";
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -98,14 +94,6 @@ export type SessionEvent = {
     kind: "page_in";
     turn: number;
     entry_count: number;
-} | {
-    kind: "large_result_spooled";
-    turn: number;
-    call_id: string;
-    tool: string;
-    original_size: number;
-    preview_size: number;
-    spool_ref?: string;
 } | {
     kind: "rollbacked";
     turn: number;
@@ -204,7 +192,9 @@ export type SessionEvent = {
     kind: "agent_process_changed";
     turn: number;
     agent_id: string;
-    parent_session_id: string;
+    parent_task_id?: string;
+    /** Host audit identity; canonical kernel observations never populate it. */
+    parent_session_id?: string;
     role: string;
     isolation: string;
     context_inheritance: string;
@@ -278,6 +268,11 @@ export type SessionEvent = {
     turn: number;
     node_outcomes: import("../types/agent.js").KernelWorkflowNodeOutcome[];
     total_nodes: number;
+} | {
+    kind: "kernel_observation";
+    turn: number;
+    observation_kind: string;
+    raw: Record<string, unknown>;
 } | {
     kind: "run_terminal";
     reason: string;
@@ -312,6 +307,13 @@ export type SessionEvent = {
     reason: string;
     coerced_from?: string;
 };
+/**
+ * The business-projection log (spec §9.2): run started/terminal, stream events, observations,
+ * provider/tool presentation, audit metadata.
+ *
+ * Durable kernel records use the separate `KernelJournal` capability. `SessionLog` contains only
+ * business observations and never adapts or reserializes canonical records.
+ */
 export interface SessionLog {
     append(sessionId: string, event: SessionEvent): Promise<number>;
     read(sessionId: string, fromSeq?: number, primitiveFilter?: KernelPrimitive): Promise<Array<{
@@ -319,18 +321,18 @@ export interface SessionLog {
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
-    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
-    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
-    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
-    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
-    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
 }
+/**
+ * **Single-process dev/test implementation** of both capabilities (spec §9.4: one class may
+ * implement several capabilities; the *interfaces* stay separate). Its `KernelJournal` half is
+ * `InMemoryKernelJournal`, whose CAS is atomic within one process only.
+ */
 export declare class InMemorySessionLog implements SessionLog {
     private store;
+    /** Business event sequence space only — journal records number themselves by `step_seq`. */
     private seqCounters;
-    private genesisStore;
-    private transactionStore;
-    private operationKey;
+    /** The durable transaction capability, held rather than inherited (spec §9.1/§9.4). */
+    readonly kernelJournal: KernelJournal;
     private nextSeq;
     append(sessionId: string, event: SessionEvent): Promise<number>;
     read(sessionId: string, fromSeq?: number, primitiveFilter?: KernelPrimitive): Promise<Array<{
@@ -338,16 +340,21 @@ export declare class InMemorySessionLog implements SessionLog {
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
-    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
-    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
-    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
-    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
-    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
 }
+/**
+ * File-backed `SessionLog`. Business appends are single-writer per session: safe within one
+ * instance, **not** across processes — that limitation is confined to the projection log now.
+ *
+ * The durable transaction capability is delegated to {@link FileKernelJournal}, which *is*
+ * cross-process atomic (spec Task 8b), so the two capabilities no longer share a file, a sequence
+ * space, or a concurrency story.
+ */
 export declare class FileSessionLog implements SessionLog {
     private dir;
     private seqCounters;
     private readonly appends;
+    /** The durable transaction capability, held rather than inherited (spec §9.1/§9.4). */
+    readonly kernelJournal: KernelJournal;
     constructor(dir: string);
     private path;
     private nextSeq;
@@ -357,11 +364,6 @@ export declare class FileSessionLog implements SessionLog {
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
-    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
-    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
-    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
-    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
-    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
     private appendRecord;
     private readRecords;
 }

package/dist/runtime/session-log.js

@@ -4,15 +4,18 @@ import { join } from "node:path";
 import { createInterface } from "node:readline";
 import { primitiveForKind } from "./kernel-event-log.js";
 import { KeyedSerialExecutor } from "./reliability.js";
-import { KernelLogConflictError, KernelLogIntegrityError, verifyKernelOperationGenesis, verifyKernelTransaction, verifyKernelTransactionSuccessor, } from "./kernel-transaction-log.js";
+import { FileKernelJournal, InMemoryKernelJournal } from "./kernel-journal.js";
+/**
+ * **Single-process dev/test implementation** of both capabilities (spec §9.4: one class may
+ * implement several capabilities; the *interfaces* stay separate). Its `KernelJournal` half is
+ * `InMemoryKernelJournal`, whose CAS is atomic within one process only.
+ */
 export class InMemorySessionLog {
     store = new Map();
+    /** Business event sequence space only — journal records number themselves by `step_seq`. */
     seqCounters = new Map();
-    genesisStore = new Map();
-    transactionStore = new Map();
-    operationKey(sessionId, operationId) {
-        return `${sessionId}\u0000${operationId}`;
-    }
+    /** The durable transaction capability, held rather than inherited (spec §9.1/§9.4). */
+    kernelJournal = new InMemoryKernelJournal();
     nextSeq(sessionId) {
         const seq = this.seqCounters.get(sessionId) ?? 0;
         this.seqCounters.set(sessionId, seq + 1);
@@ -39,62 +42,25 @@ export class InMemorySessionLog {
     async latestSeq(sessionId) {
         return (this.seqCounters.get(sessionId) ?? 0) - 1;
     }
-    async appendKernelGenesis(sessionId, genesis) {
-        verifyKernelOperationGenesis(genesis);
-        const operationKey = this.operationKey(sessionId, genesis.operation_id);
-        const existing = this.genesisStore.get(operationKey);
-        if (existing) {
-            if (existing.genesis.genesis_digest !== genesis.genesis_digest) {
-                throw new KernelLogConflictError("session already has a different kernel operation genesis");
-            }
-            return { log_seq: existing.log_seq, genesis_digest: genesis.genesis_digest };
-        }
-        const log_seq = this.nextSeq(sessionId);
-        this.genesisStore.set(operationKey, { log_seq, genesis });
-        return { log_seq, genesis_digest: genesis.genesis_digest };
-    }
-    async readKernelGenesis(sessionId, operationId) {
-        return this.genesisStore.get(this.operationKey(sessionId, operationId))?.genesis;
-    }
-    async compareAndAppendKernelTransaction(sessionId, expectedTransactionHead, transaction) {
-        verifyKernelTransaction(transaction);
-        const operationKey = this.operationKey(sessionId, transaction.operation_id);
-        const genesis = this.genesisStore.get(operationKey)?.genesis;
-        if (!genesis)
-            throw new KernelLogIntegrityError("kernel transaction requires a durable genesis");
-        if (transaction.operation_id !== genesis.operation_id) {
-            throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
-        }
-        const head = await this.kernelTransactionHead(sessionId, transaction.operation_id);
-        if (head !== expectedTransactionHead || transaction.previous_transaction_digest !== head) {
-            throw new KernelLogConflictError("kernel transaction head changed before compare-and-append");
-        }
-        const entries = this.transactionStore.get(operationKey) ?? [];
-        verifyKernelTransactionSuccessor(entries.at(-1)?.transaction, transaction);
-        const log_seq = this.nextSeq(sessionId);
-        entries.push({ log_seq, transaction });
-        this.transactionStore.set(operationKey, entries);
-        return { log_seq, transaction_digest: transaction.transaction_digest };
-    }
-    async readKernelTransactions(sessionId, operationId, fromStepSeq = 1) {
-        return (this.transactionStore.get(this.operationKey(sessionId, operationId)) ?? []).filter(entry => entry.transaction.step_seq >= fromStepSeq);
-    }
-    async kernelTransactionHead(sessionId, operationId) {
-        const operationKey = this.operationKey(sessionId, operationId);
-        const entries = this.transactionStore.get(operationKey) ?? [];
-        return entries.at(-1)?.transaction.transaction_digest
-            ?? this.genesisStore.get(operationKey)?.genesis.genesis_digest;
-    }
 }
-// Single-writer per session. Safe for concurrent appends within one instance.
-// Cross-instance (multi-process) safety requires an external lock.
+/**
+ * File-backed `SessionLog`. Business appends are single-writer per session: safe within one
+ * instance, **not** across processes — that limitation is confined to the projection log now.
+ *
+ * The durable transaction capability is delegated to {@link FileKernelJournal}, which *is*
+ * cross-process atomic (spec Task 8b), so the two capabilities no longer share a file, a sequence
+ * space, or a concurrency story.
+ */
 export class FileSessionLog {
     dir;
-    // Lazy-initialized per-session counter. Avoids re-reading the file on every append.
+    // Lazy-initialized per-session counter for business events only.
     seqCounters = new Map();
     appends = new KeyedSerialExecutor();
+    /** The durable transaction capability, held rather than inherited (spec §9.1/§9.4). */
+    kernelJournal;
     constructor(dir) {
         this.dir = dir;
+        this.kernelJournal = new FileKernelJournal(join(dir, "kernel-journal"));
     }
     path(sessionId) {
         return join(this.dir, `${sessionId}.jsonl`);
@@ -130,82 +96,6 @@ export class FileSessionLog {
         const records = await this.readRecords(sessionId);
         return records.reduce((latest, record) => Math.max(latest, record.seq), -1);
     }
-    async appendKernelGenesis(sessionId, genesis) {
-        return this.appends.run(sessionId, async () => {
-            verifyKernelOperationGenesis(genesis);
-            const existing = (await this.readRecords(sessionId)).find((record) => "record_type" in record
-                && record.record_type === "kernel_genesis"
-                && record.genesis.operation_id === genesis.operation_id);
-            if (existing) {
-                if (existing.genesis.genesis_digest !== genesis.genesis_digest) {
-                    throw new KernelLogConflictError("session already has a different kernel operation genesis");
-                }
-                return { log_seq: existing.seq, genesis_digest: genesis.genesis_digest };
-            }
-            const log_seq = await this.nextSeq(sessionId);
-            await this.appendRecord(sessionId, {
-                seq: log_seq,
-                record_type: "kernel_genesis",
-                genesis,
-            });
-            return { log_seq, genesis_digest: genesis.genesis_digest };
-        });
-    }
-    async readKernelGenesis(sessionId, operationId) {
-        const record = (await this.readRecords(sessionId)).find((entry) => "record_type" in entry
-            && entry.record_type === "kernel_genesis"
-            && entry.genesis.operation_id === operationId);
-        return record?.genesis;
-    }
-    async compareAndAppendKernelTransaction(sessionId, expectedTransactionHead, transaction) {
-        return this.appends.run(sessionId, async () => {
-            verifyKernelTransaction(transaction);
-            const records = await this.readRecords(sessionId);
-            const genesisRecord = records.find((record) => "record_type" in record
-                && record.record_type === "kernel_genesis"
-                && record.genesis.operation_id === transaction.operation_id);
-            if (!genesisRecord)
-                throw new KernelLogIntegrityError("kernel transaction requires a durable genesis");
-            if (transaction.operation_id !== genesisRecord.genesis.operation_id) {
-                throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
-            }
-            const transactions = records.filter((record) => "record_type" in record
-                && record.record_type === "kernel_transaction"
-                && record.transaction.operation_id === transaction.operation_id);
-            const head = transactions.at(-1)?.transaction.transaction_digest
-                ?? genesisRecord.genesis.genesis_digest;
-            if (head !== expectedTransactionHead || transaction.previous_transaction_digest !== head) {
-                throw new KernelLogConflictError("kernel transaction head changed before compare-and-append");
-            }
-            verifyKernelTransactionSuccessor(transactions.at(-1)?.transaction, transaction);
-            const log_seq = await this.nextSeq(sessionId);
-            await this.appendRecord(sessionId, {
-                seq: log_seq,
-                record_type: "kernel_transaction",
-                transaction,
-            });
-            return { log_seq, transaction_digest: transaction.transaction_digest };
-        });
-    }
-    async readKernelTransactions(sessionId, operationId, fromStepSeq = 1) {
-        return (await this.readRecords(sessionId))
-            .filter((record) => "record_type" in record
-            && record.record_type === "kernel_transaction"
-            && record.transaction.operation_id === operationId
-            && record.transaction.step_seq >= fromStepSeq)
-            .map(record => ({ log_seq: record.seq, transaction: record.transaction }));
-    }
-    async kernelTransactionHead(sessionId, operationId) {
-        const records = await this.readRecords(sessionId);
-        const transaction = records.filter((record) => "record_type" in record
-            && record.record_type === "kernel_transaction"
-            && record.transaction.operation_id === operationId).at(-1);
-        if (transaction)
-            return transaction.transaction.transaction_digest;
-        return records.find((record) => "record_type" in record
-            && record.record_type === "kernel_genesis"
-            && record.genesis.operation_id === operationId)?.genesis.genesis_digest;
-    }
     async appendRecord(sessionId, record) {
         await mkdir(this.dir, { recursive: true });
         const path = this.path(sessionId);

package/dist/runtime/session-repair.d.ts

@@ -42,8 +42,7 @@ export declare function buildRunTerminalEvent(input: {
 }): Extract<SessionEvent, {
     kind: "run_terminal";
 }>;
-/** Build workflow_node_completed for persistence after a node finishes. W-1: carries the
- *  result-borne control signals + output so resume replays control flow and re-seeds outputs. */
+/** Build the audit projection emitted after a workflow node finishes. */
 export declare function buildWorkflowNodeCompletedEvent(input: {
     turn: number;
     agentId: string;
@@ -56,29 +55,7 @@ export declare function buildWorkflowNodeCompletedEvent(input: {
 }): Extract<SessionEvent, {
     kind: "workflow_node_completed";
 }>;
-/** One recovered node completion: the agent id plus its persisted control signals and output. */
-export interface RecoveredNodeOutcome {
-    agentId: string;
-    status: WorkflowNodeStatus;
-    termination: string;
-    classifyBranch?: string;
-    tournamentWinner?: string;
-    loopContinue?: boolean;
-    output?: Message;
-}
-/**
- * Recover completed workflow node records from a session event stream. Scans for
- * workflow_node_completed events with termination "completed" and returns them WITH their
- * result-borne control signals (W-1) — resumeWorkflow lowers these to the kernel's
- * `resumed_outcomes` so a classifier re-prunes and a loop stop is honored, and re-seeds the
- * driver's outputs map from the persisted output text.
- */
-export declare function recoverWorkflowNodeOutcomes(events: Array<{
-    seq: number;
-    event: SessionEvent;
-}>): RecoveredNodeOutcome[];
-/** R3-1: build workflow_nodes_submitted for persistence after a runtime submission, so resume can
- *  re-apply it. `nodes` is the kernel-shape (snake_case) submitted node array. */
+/** Build the audit projection emitted after a runtime workflow submission. */
 export declare function buildWorkflowNodesSubmittedEvent(input: {
     turn: number;
     nodes: Record<string, unknown>[];
@@ -87,14 +64,3 @@ export declare function buildWorkflowNodesSubmittedEvent(input: {
 }): Extract<SessionEvent, {
     kind: "workflow_nodes_submitted";
 }>;
-/** R3-1: recover the runtime submission batches (in order) from a session event stream, to rebuild
- *  `resumed_submissions` for resumeWorkflow so dynamically-appended nodes are reconstructed.
- *  `submitters` is parallel to `submissions` (undefined = host/bootstrap submission). */
-export declare function recoverSubmittedWorkflowNodes(events: Array<{
-    seq: number;
-    event: SessionEvent;
-}>): {
-    submissions: Record<string, unknown>[][];
-    bases: number[];
-    submitters: Array<string | undefined>;
-};

package/dist/runtime/session-repair.js

@@ -53,8 +53,7 @@ export function buildRunTerminalEvent(input) {
         total_tokens: Math.max(0, input.totalTokens),
     };
 }
-/** Build workflow_node_completed for persistence after a node finishes. W-1: carries the
- *  result-borne control signals + output so resume replays control flow and re-seeds outputs. */
+/** Build the audit projection emitted after a workflow node finishes. */
 export function buildWorkflowNodeCompletedEvent(input) {
     return {
         kind: "workflow_node_completed",
@@ -68,32 +67,7 @@ export function buildWorkflowNodeCompletedEvent(input) {
         ...(input.output ? { output: input.output } : {}),
     };
 }
-/**
- * Recover completed workflow node records from a session event stream. Scans for
- * workflow_node_completed events with termination "completed" and returns them WITH their
- * result-borne control signals (W-1) — resumeWorkflow lowers these to the kernel's
- * `resumed_outcomes` so a classifier re-prunes and a loop stop is honored, and re-seeds the
- * driver's outputs map from the persisted output text.
- */
-export function recoverWorkflowNodeOutcomes(events) {
-    const completed = [];
-    for (const { event } of events) {
-        if (event.kind === "workflow_node_completed") {
-            completed.push({
-                agentId: event.agent_id,
-                status: event.status,
-                termination: event.termination,
-                ...(event.classify_branch !== undefined ? { classifyBranch: event.classify_branch } : {}),
-                ...(event.tournament_winner !== undefined ? { tournamentWinner: event.tournament_winner } : {}),
-                ...(event.loop_continue !== undefined ? { loopContinue: event.loop_continue } : {}),
-                ...(event.output !== undefined ? { output: event.output } : {}),
-            });
-        }
-    }
-    return completed;
-}
-/** R3-1: build workflow_nodes_submitted for persistence after a runtime submission, so resume can
- *  re-apply it. `nodes` is the kernel-shape (snake_case) submitted node array. */
+/** Build the audit projection emitted after a runtime workflow submission. */
 export function buildWorkflowNodesSubmittedEvent(input) {
     return {
         kind: "workflow_nodes_submitted",
@@ -103,22 +77,3 @@ export function buildWorkflowNodesSubmittedEvent(input) {
         ...(input.submitterAgentId !== undefined ? { submitter_agent_id: input.submitterAgentId } : {}),
     };
 }
-/** R3-1: recover the runtime submission batches (in order) from a session event stream, to rebuild
- *  `resumed_submissions` for resumeWorkflow so dynamically-appended nodes are reconstructed.
- *  `submitters` is parallel to `submissions` (undefined = host/bootstrap submission). */
-export function recoverSubmittedWorkflowNodes(events) {
-    const submissions = [];
-    const bases = [];
-    const submitters = [];
-    for (const { event } of events) {
-        if (event.kind === "workflow_nodes_submitted") {
-            submissions.push(event.nodes);
-            submitters.push(event.submitter_agent_id);
-            if (event.base_index === undefined) {
-                throw new Error("workflow_nodes_submitted is missing required base_index");
-            }
-            bases.push(event.base_index);
-        }
-    }
-    return { submissions, bases, submitters };
-}

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -46,5 +46,5 @@ export declare class SubAgentOrchestrator {
 }
 export declare const defaultSubAgentOrchestrator: SubAgentOrchestrator;
 export declare function attemptOutcomeToLoopResult(outcome: AttemptOutcome): LoopResult;
-/** Kernel spawn without an active parent run loop (harness / coordinator use). */
+/** Canonical single-node root workflow for harness / coordinator use. */
 export declare function spawnStandalone(parentOpts: RuntimeOptions, parentSessionId: string, spec: AgentRunSpec, orchestrator?: SubAgentOrchestrator, contextInput?: string): Promise<SubAgentResult>;

package/dist/runtime/sub-agent-orchestrator.js

@@ -1,7 +1,6 @@
-import { agentRunSpecToKernel, findSpawnProcessObservation, spawnObservationToManifest } from "../types/agent.js";
+import { randomUUID } from "node:crypto";
 import { FilteredExecutionPlane } from "./filtered-plane.js";
 import { WorktreeExecutionPlane } from "./worktree-plane.js";
-import { durableKernelApply } from "./kernel-step.js";
 function terminationFromStatus(status) {
     const normalized = status.toLowerCase();
     if (normalized === "completed" ||
@@ -133,8 +132,6 @@ export class SubAgentOrchestrator {
             dreamStore: metaTools.has("memory") ? ctx.parentOpts.dreamStore : undefined,
             knowledgeSource: metaTools.has("knowledge") ? ctx.parentOpts.knowledgeSource : undefined,
             enablePlanTool: metaTools.has("update_plan") ? ctx.parentOpts.enablePlanTool : undefined,
-            // M5 v2.1: a workflow node's `start_workflow` flattens to the parent kernel (no nested pivot).
-            isWorkflowNode: ctx.isWorkflowNode,
             // Nested vehicle: the child joins the inherited runGroup for lineage/settlement only — it
             // must NOT re-reserve budget axes the parent already holds (that double-reserve squeezed the
             // child's grant to 0 and the kernel stripped its first-turn tools).
@@ -258,43 +255,48 @@ export function attemptOutcomeToLoopResult(outcome) {
         },
     };
 }
-/** Kernel spawn without an active parent run loop (harness / coordinator use). */
+/** Canonical single-node root workflow for harness / coordinator use. */
 export async function spawnStandalone(parentOpts, parentSessionId, spec, orchestrator = defaultSubAgentOrchestrator, contextInput) {
-    const kernel = (await import("../kernel.js")).getKernel();
-    const runtime = new kernel.KernelRuntime({
-        maxTokens: parentOpts.maxTokens,
-        maxTurns: parentOpts.maxTurns ?? 25,
-        timeoutMs: parentOpts.timeoutMs !== undefined ? BigInt(parentOpts.timeoutMs) : undefined,
-    });
-    const pending = [];
-    await durableKernelApply(runtime, parentOpts.sessionLog, parentSessionId, pending, { kind: "start_run", task: { goal: "coordinator", criteria: [] } });
-    const observations = await durableKernelApply(runtime, parentOpts.sessionLog, parentSessionId, pending, {
-        kind: "spawn_sub_agent",
-        spec: agentRunSpecToKernel(spec),
-        parent_session_id: parentSessionId,
-    });
-    const spawned = findSpawnProcessObservation(observations);
-    if (!spawned) {
-        throw new Error("spawn_sub_agent did not emit agent_process_changed");
+    if (spec.tokenBudget !== undefined || spec.maxTurns !== undefined || spec.maxWallMs !== undefined) {
+        throw new Error("spawnStandalone cannot represent per-node resource caps under canonical ABI v3");
     }
-    const manifest = spawnObservationToManifest(spawned, spec, parentSessionId);
-    await parentOpts.sessionLog.append(parentSessionId, {
-        kind: "agent_process_changed",
-        turn: manifest.turn ?? 0,
-        agent_id: manifest.agent_id,
-        parent_session_id: manifest.parent_session_id,
-        role: manifest.role,
-        isolation: manifest.isolation,
-        context_inheritance: manifest.context_inheritance,
-        state: "running",
-        permitted_capability_ids: manifest.permitted_capability_ids ?? [],
-    });
-    return orchestrator.run({
-        parentOpts,
-        parentSessionId,
-        spec,
-        manifest,
-        sessionLog: parentOpts.sessionLog,
-        ...(contextInput ? { contextInput } : {}),
+    const { RuntimeRunner } = await import("./runner.js");
+    let captured;
+    const bridge = {
+        async run(ctx) {
+            const child = await orchestrator.run({
+                ...ctx,
+                parentSessionId,
+                spec,
+                manifest: {
+                    ...ctx.manifest,
+                    agent_id: spec.identity.agentId,
+                    parent_session_id: parentSessionId,
+                },
+                ...(contextInput ? { contextInput } : {}),
+            });
+            captured = child;
+            return { ...child, agentId: ctx.manifest.agent_id };
+        },
+    };
+    const runner = new RuntimeRunner({
+        ...parentOpts,
+        subAgentOrchestrator: bridge,
+        nestedGroupVehicle: true,
     });
+    const outcome = await runner.runWorkflow({
+        nodes: [{
+                task: spec.goal,
+                role: spec.role,
+                isolation: spec.isolation,
+                ...(spec.modelHint ? { modelHint: spec.modelHint } : {}),
+            }],
+    }, { sessionId: `${spec.identity.sessionId}:spawn-root:${randomUUID()}` });
+    if (outcome.rejection) {
+        throw new Error(`canonical standalone spawn rejected: ${outcome.rejection.reason}`);
+    }
+    if (!captured) {
+        throw new Error("canonical standalone spawn completed without a child result");
+    }
+    return captured;
 }

package/dist/types/agent.d.ts

@@ -41,6 +41,15 @@ export interface AgentRunSpec {
     /** ③ loop-agent rounds: presence makes this run ONE round of a paced loop (gates the
      *  kernel `pace` meta-tool and arms the pacing trap). */
     loopRound?: LoopRoundSpec;
+    /** Exposure baseline — the PRE-ACTIVATION tool surface *under* the `capabilityFilter` ceiling.
+     *  The ceiling bounds what this run may EVER expose; the baseline selects which of those are
+     *  advertised before any skill activates, so `exposed = meta ∪ ((baseline ∪ stableCore ∪
+     *  ⋃ activeSkills.allowed_tools) ∩ ceiling)`. That makes narrow→wide progressive disclosure
+     *  expressible: a tool can be reachable after `skill(x)` without being advertised beforehand.
+     *  Absent ⇒ legacy behavior (ceiling + errs-open skill narrowing). `[]` is meaningful and
+     *  distinct from absent: the minimal surface (meta-tools + stable-core only). Entries outside
+     *  the ceiling silently intersect away. Lowered from `RuntimeOptions.baselineToolIds`. */
+    exposureBaseline?: string[];
     /** M1/G3: per-agent model preference (e.g. "opus"/"sonnet"/"haiku"); the host resolves it to a
      *  provider via `RuntimeOptions.providerFor`. Host-side routing only — not sent to the kernel. */
     modelHint?: string;
@@ -73,12 +82,6 @@ export interface AgentProcessChangedObservation {
     permitted_capability_ids?: string[];
     result_termination?: string;
 }
-/** Map kernel spawn observation → host manifest. */
-export declare function spawnObservationToManifest(obs: AgentProcessChangedObservation | Record<string, unknown>, spec: AgentRunSpec, parentSessionId: string): AgentProcessChangedObservation;
-export declare function findSpawnProcessObservation(observations: Array<{
-    kind: string;
-    agent_id?: string;
-}>): AgentProcessChangedObservation | undefined;
 export interface LoopResult {
     termination: TerminationReason | string;
     finalMessage?: Message;
@@ -137,6 +140,18 @@ export declare function milestoneCheckResultToKernel(result: MilestoneCheckResul
 export declare function subAgentResultToKernel(result: SubAgentResult): Record<string, unknown>;
 export declare function milestoneCheckPass(phaseId: string): MilestoneCheckResult;
 export declare function milestoneCheckFail(phaseId: string, reason: string): MilestoneCheckResult;
+/**
+ * R-B27: the conservative resolution the runner feeds back when an `evaluate_milestone` effect
+ * arrives with no phase `verifier` and no host `onMilestoneEvaluate` hook. Nothing can attest the
+ * phase, but the kernel is already holding the effect in its pending table — returning without an
+ * answer leaves a dangling effect that a logical-checkpoint recovery cannot resolve. The current
+ * `MilestoneResult` wire has no error field, so "could not be verified" is expressed with the
+ * shape the wire does have: `passed: false` (the phase does not advance — fail-closed).
+ *
+ * The string is part of the cross-SDK contract: WASM (`wasm/src/runtime/types/agent.ts`),
+ * Python (`deepstrike/types/agent.py`) and Rust must feed back the byte-identical reason.
+ */
+export declare const MILESTONE_UNVERIFIED_REASON = "milestone unverified: no verifier configured and no host evaluation hook (fail-closed)";
 /** A task for a workflow node: a full object, or a bare goal string. */
 export type WorkflowTaskSpec = {
     goal: string;
@@ -247,6 +262,8 @@ export interface WorkflowSpawnInfo {
     /** The dependency agent ids for EVERY dependent node (W-N2: a DAG edge carries data). A reduce
      *  node's registered function consumes them; every other node gets its deps' outputs in context. */
     input_agent_ids?: string[];
+    /** Dependency outputs projected by canonical core so a post-crash launch keeps its data edges. */
+    dependency_outputs?: Record<string, string>;
     /** A#2: present only for a tournament *judge* spawn — the two entrant agent ids whose produced
      *  outputs this judge compares. The runner looks them up and reports the winner as `tournamentWinner`. */
     judge_match?: {
@@ -269,10 +286,10 @@ export interface WorkflowSpawnInfo {
 /** G4 budget-as-signal: the workflow's remaining headroom under the active quota, carried on the
  *  `workflow_batch_spawned` observation so a coordinator node can scale its next submission. */
 export interface WorkflowBudget {
-    nodes_used: number;
+    nodes_used?: number;
     nodes_max?: number;
     nodes_remaining?: number;
-    running_subagents: number;
+    running_subagents?: number;
     max_concurrent_subagents?: number;
     concurrency_remaining?: number;
     /** M4/G5 token headroom: cumulative tokens used, the run-level cap, and tokens remaining before the
@@ -280,25 +297,20 @@ export interface WorkflowBudget {
     tokens_used?: number;
     tokens_max?: number;
     tokens_remaining?: number;
+    /** Canonical ABI v3 publishes immutable caps rather than a host-authored remaining snapshot. */
+    max_total_tokens?: string | number;
+    max_turns?: number;
+    max_concurrency?: number;
 }
 /** G4: a concise, human-readable budget note appended to a coordinator node's goal, so its agent can
  *  size a `submit_workflow_nodes` batch to what is actually available. Returns "" when nothing is
  *  bounded (no quota ⇒ no signal). */
 export declare function workflowBudgetNote(budget: WorkflowBudget | undefined): string;
-/** Map one host `WorkflowNodeSpec` to its snake_case kernel JSON. Shared by `load_workflow` (the
+/** Map one host `WorkflowNodeSpec` to its snake_case canonical JSON. Shared by the workflow root (the
  *  whole spec) and `submit_workflow_nodes` (R3-1 runtime append) so the two encodings never drift. */
 export declare function workflowNodeSpecToKernel(n: WorkflowNodeSpec): Record<string, unknown>;
-/** Map a host `WorkflowSpec` to the snake_case kernel JSON (`load_workflow.spec`). */
+/** Map a host `WorkflowSpec` to the canonical workflow-root JSON. */
 export declare function workflowSpecToKernel(spec: WorkflowSpec): Record<string, unknown>;
-/** R3-1: map a batch of host nodes to the `submit_workflow_nodes` kernel event body. G1: pass
- *  `submitterAgentId` (the node that requested the append) so the kernel can enforce no-privilege-
- *  escalation — a quarantined submitter's nodes are coerced to quarantined. Omitted ⇒ no coercion. */
-export declare function submitWorkflowNodesToKernel(nodes: WorkflowNodeSpec[], submitterAgentId?: string): Record<string, unknown>;
-/** M5/G1: map an agent-authored spec to the `submit_workflow` kernel event body (the agent-reachable
- *  `Syscall::LoadWorkflow`). The kernel bootstraps the DAG when none is active, else flattens onto it.
- *  `parentSessionId` seeds child session ids on bootstrap; `submitterAgentId` carries G1 trust coercion
- *  on the flatten case (a quarantined author's nodes are coerced quarantined). */
-export declare function submitWorkflowToKernel(spec: WorkflowSpec, parentSessionId: string, submitterAgentId?: string): Record<string, unknown>;
 /** R3-1: the tool a workflow-coordinator node's agent calls to append work to the running DAG
  *  (true loop-until-done / dynamic fan-out). Give it to nodes meant to fan out; the runner intercepts
  *  the call and routes the nodes to the parent kernel (the child's own kernel holds no workflow). */