@deepstrike/sdk 0.2.39 → 0.2.40

package/dist/runtime/runner.js

@@ -1,12 +1,13 @@
-import { memoriesToIndex, selectMemories } from "../memory/agent.js";
+import { extractSessionMemories } from "../memory/extraction.js";
 import { resolvePermissionRequest } from "./execution-plane.js";
+import { GroupBudgetScope } from "./run-group.js";
 import { getKernel } from "../kernel.js";
 import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 import { sanitizeReplayText } from "./replay-sanitize.js";
-import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, recoverCompletedWorkflowNodes, recoverSubmittedWorkflowNodes, repairEventsForRecovery, } from "./session-repair.js";
+import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, recoverWorkflowNodeOutcomes, recoverSubmittedWorkflowNodes, repairEventsForRecovery, } from "./session-repair.js";
 import { KernelPrimitivesDashboard } from "./kernel-primitives-dashboard.js";
-import { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, entropySampleFromObservation, kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
-import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, workflowBudgetNote, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "../types/agent.js";
+import { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, entropySampleFromObservation, durableKernelAction, durableKernelApply, durableKernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, workflowBudgetNote, workflowNodeOutcomeFromKernel, workflowNodeStatusFromTermination, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "../types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
 import { resolveReducer } from "./reducers.js";
@@ -16,13 +17,47 @@ import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
 import { formatToolError } from "../tools/errors.js";
+import { ManagedTaskScope } from "./reliability.js";
+import { contextPolicyV1, normalizeContextPolicyV1, } from "./context-policy.js";
+export function schedulerPolicyToKernel(policy) {
+    const allowed = new Set([
+        "version", "criticalPathWeight", "fanoutWeight", "ageWeight", "tokenCostWeight",
+    ]);
+    const unknown = Object.keys(policy).filter(key => !allowed.has(key));
+    if (unknown.length > 0)
+        throw new TypeError(`unknown scheduler policy field(s): ${unknown.join(", ")}`);
+    return {
+        version: policy.version,
+        critical_path_weight: policy.criticalPathWeight,
+        fanout_weight: policy.fanoutWeight,
+        age_weight: policy.ageWeight,
+        token_cost_weight: policy.tokenCostWeight,
+    };
+}
+function pendingCallIds(action) {
+    switch (action.kind) {
+        case "call_provider":
+            return [action.effectId];
+        case "execute_tool":
+            return action.calls.map(call => call.id);
+        case "request_approval":
+            return action.requests.map(request => request.callId);
+        case "spawn_workflow":
+            return action.nodes.map(node => String(node.agent_id ?? "")).filter(Boolean);
+        case "preempt_sub_agents":
+            return action.agentIds;
+        default:
+            return "effectId" in action ? [action.effectId] : [];
+    }
+}
 export class RuntimeRunner {
     opts;
     interrupted = false;
-    /** #2-B-ii: aborts the in-flight provider stream when the run is interrupted/preempted. Recreated
-     *  per `execute`; `interrupt()` fires it so a Critical `InterruptNow` cancels the live LLM call. */
+    cancellationReason;
+    /** Aborts host-owned provider I/O before `cancel_operation` commits the kernel terminal fact. */
     abortController = null;
     activeKernel = null;
+    activeGroupBudgetScope;
     pendingObservations = [];
     currentSessionId = null;
     /** O2 (system-reminder channel): host-pushed notes awaiting the next turn-boundary drain. */
@@ -32,18 +67,23 @@ export class RuntimeRunner {
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
     knowledgePushedSkills = new Set();
     nextArchiveStart = 0;
+    pendingPageOutArchives = [];
+    activePageOutArchive;
     /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
     currentGoal = "";
-    /** Full tool outputs keyed by call_id until Layer-1 spool observations are logged. */
-    pendingSpoolOutputs = new Map();
     /** M5 v2.1: sub-workflow specs a top-level agent authored via `start_workflow`, awaiting auto-drive
      *  at the next safe point (after the tool turn resolves, kernel back in Reason — not suspended). */
     pendingAuthoredWorkflows = [];
+    workflowContinuation = null;
     dashboard = null;
     /** Most recent kernel entropy sample of the active/last run (see `latestEntropy`). */
     lastEntropySample = null;
     constructor(opts) {
         this.opts = opts;
+        const schemaAttempts = opts.workflowSchemaValidationAttempts ?? 2;
+        if (!Number.isInteger(schemaAttempts) || schemaAttempts < 1 || schemaAttempts > 16) {
+            throw new RangeError("workflowSchemaValidationAttempts must be an integer between 1 and 16");
+        }
         if (opts.enableDiagnosticsDashboard) {
             const originalAppend = opts.sessionLog.append.bind(opts.sessionLog);
             opts.sessionLog.append = async (sessionId, event) => {
@@ -60,83 +100,104 @@ export class RuntimeRunner {
     get hostOptions() {
         return this.opts;
     }
+    durableSessionId(sessionId) {
+        const resolved = sessionId ?? this.currentSessionId;
+        if (!resolved)
+            throw new Error("durable kernel transitions require a session id");
+        return resolved;
+    }
+    async commitKernelApply(runtime, pending, event, sessionId) {
+        return durableKernelApply(runtime, this.opts.sessionLog, this.durableSessionId(sessionId), pending, event);
+    }
+    async commitKernelMaybeAction(runtime, pending, event, sessionId) {
+        return durableKernelMaybeAction(runtime, this.opts.sessionLog, this.durableSessionId(sessionId), pending, event);
+    }
+    async commitKernelAction(runtime, pending, event, sessionId) {
+        return durableKernelAction(runtime, this.opts.sessionLog, this.durableSessionId(sessionId), pending, event);
+    }
+    async persistMemoryToStore(memory, agentId) {
+        if (!this.opts.dreamStore)
+            throw new Error("memory persistence requires dreamStore");
+        await this.opts.dreamStore.upsert(agentId, memory);
+    }
+    async retrieveMemoryFromStore(query, requestedK, agentId) {
+        if (!this.opts.dreamStore)
+            throw new Error("memory queries require dreamStore");
+        return (await this.opts.dreamStore.search(agentId, { ...query, top_k: requestedK }))
+            .slice(0, requestedK);
+    }
     async writeMemory(memory, opts = {}) {
         const sessionId = opts.sessionId ?? this.currentSessionId;
         const agentId = opts.agentId ?? this.opts.agentId;
         if (!this.opts.dreamStore || !agentId)
             return;
+        const durableSessionId = this.durableSessionId(sessionId);
         const observations = [];
-        const runtime = this.activeKernel ?? this.createSyscallRuntime();
-        kernelApply(runtime, observations, { kind: "write_memory", memory });
-        const event = observations.find(o => o.kind === "memory_written");
-        if (!event) {
+        const runtime = this.createSyscallRuntime();
+        const action = await this.commitKernelMaybeAction(runtime, observations, { kind: "write_memory", memory }, durableSessionId);
+        if (!action) {
             await this.appendMemorySyscallObservations(sessionId, observations);
             return;
         }
-        const existing = await this.opts.dreamStore.loadMemories(agentId);
-        // Curator-style jaccard dedup at the single write path: a near-duplicate of an
-        // existing entry is dropped (the observation is still logged for audit).
-        const isDuplicate = existing.some(e => jaccardSimilarity(e.text, memory.content) >= 0.9);
-        if (!isDuplicate) {
-            const meta = memory.metadata;
-            const score = typeof meta?.score === "number" ? meta.score : 1.0;
-            await this.opts.dreamStore.commit(agentId, {
-                toAdd: [{
-                        text: memory.content,
-                        score,
-                        metadata: {
-                            ...memory.metadata,
-                            source: meta?.source ?? "write_memory_syscall",
-                        },
-                    }],
-                toRemoveIndices: [],
-                stats: {
-                    insightsProcessed: 1,
-                    duplicatesRemoved: 0,
-                    conflictsResolved: 0,
-                    entriesAdded: 1,
-                },
-            }, existing);
+        if (action.kind !== "persist_memory") {
+            throw new Error(`write_memory returned unexpected kernel effect: ${action.kind}`);
         }
-        await this.appendMemorySyscallObservations(sessionId, observations);
+        let ioError;
+        try {
+            await this.persistMemoryToStore(action.memory, agentId);
+        }
+        catch (cause) {
+            ioError = cause;
+        }
+        await this.commitKernelApply(runtime, observations, {
+            kind: "memory_persist_result",
+            effect_id: action.effectId,
+            ...(ioError ? { error: formatToolError(ioError) } : {}),
+        }, durableSessionId);
+        await this.appendMemorySyscallObservations(durableSessionId, observations);
+        if (ioError)
+            throw ioError;
     }
     async queryMemory(query, opts = {}) {
         const sessionId = opts.sessionId ?? this.currentSessionId;
         const agentId = opts.agentId ?? this.opts.agentId;
         if (!this.opts.dreamStore || !agentId)
             return [];
+        const durableSessionId = this.durableSessionId(sessionId);
         const observations = [];
-        const runtime = this.activeKernel ?? this.createSyscallRuntime();
-        kernelApply(runtime, observations, { kind: "query_memory", query });
-        const allMemories = await this.opts.dreamStore.loadMemories(agentId);
-        const retrieval = await selectMemories(query, memoriesToIndex(allMemories));
-        let hits;
-        if (retrieval.selected_memory_ids.length > 0) {
-            const selected = new Set(retrieval.selected_memory_ids);
-            hits = allMemories
-                .filter(m => selected.has(String(m.metadata?.name ?? "")))
-                .slice(0, query.top_k);
-        }
-        else {
-            hits = await this.opts.dreamStore.search(agentId, query.current_context, query.top_k);
-            if (hits.length > 0 && retrieval.selection_rationale === "No candidates after filtering") {
-                retrieval.selected_memory_ids = hits.map(h => String(h.metadata?.name ?? h.text.slice(0, 32)));
-                retrieval.selection_rationale = `DreamStore.search returned ${hits.length} hit(s)`;
-            }
+        const runtime = this.createSyscallRuntime();
+        const action = await this.commitKernelAction(runtime, observations, { kind: "query_memory", query }, durableSessionId);
+        if (action.kind !== "query_memory") {
+            throw new Error(`query_memory returned unexpected kernel effect: ${action.kind}`);
         }
-        await this.appendMemorySyscallObservations(sessionId, observations);
-        await this.logMemoryRetrievalResult(sessionId, retrieval);
+        let hits = [];
+        let ioError;
+        try {
+            hits = await this.retrieveMemoryFromStore(query, action.requestedK, agentId);
+        }
+        catch (cause) {
+            ioError = cause;
+        }
+        await this.commitKernelApply(runtime, observations, {
+            kind: "memory_query_result",
+            effect_id: action.effectId,
+            hits,
+            ...(ioError ? { error: formatToolError(ioError) } : {}),
+        }, durableSessionId);
+        await this.appendMemorySyscallObservations(durableSessionId, observations);
+        if (ioError)
+            throw ioError;
+        await this.logMemoryRetrievalResult(durableSessionId, hits);
         return hits;
     }
-    async logMemoryRetrievalResult(sessionId, retrieval) {
+    async logMemoryRetrievalResult(sessionId, hits) {
         if (!sessionId)
             return;
         // The session-log record is the durable audit artifact; the kernel needs no
         // acknowledgment (the former kernel event was a no-op and was removed).
         await this.opts.sessionLog.append(sessionId, {
             kind: "memory_retrieval_result",
-            selected_memory_ids: retrieval.selected_memory_ids,
-            selection_rationale: retrieval.selection_rationale,
+            hits,
         });
     }
     createSyscallRuntime() {
@@ -149,6 +210,37 @@ export class RuntimeRunner {
             timeoutMs: this.opts.timeoutMs !== undefined ? BigInt(this.opts.timeoutMs) : undefined,
         });
     }
+    groupBudgetRequest(includeTokens = true) {
+        const tokens = includeTokens ? this.opts.maxTotalTokens : undefined;
+        const subagents = this.opts.resourceQuota?.maxTotalSubagents;
+        const rounds = this.opts.runSpec?.loopRound ? 1 : undefined;
+        const roundLimit = this.opts.runSpec?.loopRound?.maxRounds;
+        return {
+            limits: {
+                ...(tokens !== undefined ? { tokens } : {}),
+                ...(subagents !== undefined ? { subagents } : {}),
+                ...(roundLimit !== undefined ? { rounds: roundLimit } : {}),
+            },
+            requested: {
+                ...(tokens !== undefined ? { tokens } : {}),
+                ...(subagents !== undefined ? { subagents } : {}),
+                ...(rounds !== undefined ? { rounds } : {}),
+            },
+        };
+    }
+    async settleGroupBudget(scope, actual) {
+        const retries = this.opts.kernelReliability?.hostEffectRetryAttempts ?? 3;
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                await scope.settle(actual);
+                return;
+            }
+            catch (error) {
+                if (attempt >= retries)
+                    throw error;
+            }
+        }
+    }
     /**
      * Lower the declarative governance / attention / scheduler-budget / resource-quota policies into a
      * freshly-created kernel. Shared by `execute()` (full agent run) and `bootstrapWorkflowKernel()`
@@ -156,23 +248,73 @@ export class RuntimeRunner {
      * exactly as a mid-run spawn would be. Must run BEFORE `start_run` so the in-kernel gate enforces
      * every policy from the first spawn. No config ⇒ the native-profile defaults (铁律: defaults only).
      */
-    applyKernelPolicies(runtime, groupTokensBase, groupSpawnsBase, groupRoundsBase) {
+    async applyKernelPolicies(runtime, groupBudgetScope) {
         // K2: lower governance / attention / scheduler / quota in ONE `configure_run` event instead of
         // the previous 2–4 separate `set_*` / `load_governance_policy` events. The kernel applies each
         // present field via the same path its granular event uses; absent fields are left untouched.
         // (Requires the 0.2.30 core that ships `configure_run`.)
         const osProfile = assertNativeProfile(this.opts.osProfile ?? "native");
-        const attentionPolicy = this.opts.attentionPolicy ?? osProfile.attentionPolicy;
+        const signalPolicy = this.opts.signalPolicy ?? osProfile.signalPolicy;
         const governancePolicy = this.opts.governancePolicy ?? osProfile.governancePolicy;
         // Strip the event `kind` off the governance event — `configure_run.config.governance` carries the
         // bare policy fields (default_action / rules / vetoed_tools / rate_limits / constraints).
         const { kind: _govKind, ...governance } = governancePolicyToKernelEvent(governancePolicy);
         const config = { governance };
-        if (attentionPolicy.maxQueueSize !== undefined) {
-            config.attention_max_queue_size = attentionPolicy.maxQueueSize;
+        if (this.opts.contextPolicy) {
+            config.context_policy = normalizeContextPolicyV1(contextPolicyV1(this.opts.contextPolicy));
+        }
+        if (this.opts.kernelReliability) {
+            const reliability = this.opts.kernelReliability;
+            config.reliability = {
+                ...(reliability.eventReplayCapacity !== undefined
+                    ? { event_replay_capacity: reliability.eventReplayCapacity }
+                    : {}),
+                ...(reliability.completedEffectReplayCapacity !== undefined
+                    ? { completed_effect_replay_capacity: reliability.completedEffectReplayCapacity }
+                    : {}),
+                ...(reliability.providerRecoveryAttempts !== undefined
+                    ? { provider_recovery_attempts: reliability.providerRecoveryAttempts }
+                    : {}),
+                ...(reliability.outputRecoveryAttempts !== undefined
+                    ? { output_recovery_attempts: reliability.outputRecoveryAttempts }
+                    : {}),
+                ...(reliability.hostEffectRetryAttempts !== undefined
+                    ? { host_effect_retry_attempts: reliability.hostEffectRetryAttempts }
+                    : {}),
+                ...(reliability.spoolThresholdBytes !== undefined
+                    ? { spool_threshold_bytes: reliability.spoolThresholdBytes }
+                    : {}),
+                ...(reliability.spoolPreviewBytes !== undefined
+                    ? { spool_preview_bytes: reliability.spoolPreviewBytes }
+                    : {}),
+                ...(reliability.snapshotInputLimit !== undefined
+                    ? { snapshot_input_limit: reliability.snapshotInputLimit }
+                    : {}),
+                ...(reliability.maxInputBytes !== undefined
+                    ? { max_input_bytes: reliability.maxInputBytes }
+                    : {}),
+                ...(reliability.snapshotJournalBytesLimit !== undefined
+                    ? { snapshot_journal_bytes_limit: reliability.snapshotJournalBytesLimit }
+                    : {}),
+            };
+        }
+        config.signal_policy = {
+            version: 1,
+            queue_max: signalPolicy.queueMax,
+            ...(signalPolicy.ttlMs !== undefined ? { ttl_ms: signalPolicy.ttlMs } : {}),
+            ...(signalPolicy.deadlineEscalation !== undefined
+                ? { deadline_escalation: signalPolicy.deadlineEscalation }
+                : {}),
+        };
+        if (this.opts.promptBudget) {
+            config.prompt_budget = {
+                prompt_overhead_tokens: this.opts.promptBudget.promptOverheadTokens,
+                output_reserve_tokens: this.opts.promptBudget.outputReserveTokens,
+                safety_margin_tokens: this.opts.promptBudget.safetyMarginTokens,
+            };
         }
-        if (this.opts.schedulerBudget?.maxWallMs !== undefined) {
-            config.scheduler_max_wall_ms = this.opts.schedulerBudget.maxWallMs;
+        if (this.opts.schedulerPolicy) {
+            config.scheduler_policy = schedulerPolicyToKernel(this.opts.schedulerPolicy);
         }
         if (this.opts.resourceQuota) {
             const q = this.opts.resourceQuota;
@@ -185,15 +327,19 @@ export class RuntimeRunner {
                     : {}),
             };
         }
-        if (groupTokensBase !== undefined && groupTokensBase > 0) {
-            config.group_tokens_base = groupTokensBase;
-        }
-        if (groupSpawnsBase !== undefined && groupSpawnsBase > 0) {
-            config.group_spawns_base = groupSpawnsBase;
-        }
-        if (groupRoundsBase !== undefined && groupRoundsBase > 0) {
-            // ③ loop-agent: completed-round count seeds the pacing trap's max_rounds coercion.
-            config.group_rounds_base = groupRoundsBase;
+        if (groupBudgetScope) {
+            config.budget_grant = {
+                reservation_id: groupBudgetScope.reservationId,
+                ...(groupBudgetScope.granted.tokens !== undefined
+                    ? { tokens: groupBudgetScope.granted.tokens }
+                    : {}),
+                ...(groupBudgetScope.granted.subagents !== undefined
+                    ? { subagents: groupBudgetScope.granted.subagents }
+                    : {}),
+                ...(groupBudgetScope.granted.rounds !== undefined
+                    ? { rounds: groupBudgetScope.granted.rounds }
+                    : {}),
+            };
         }
         // O6: tune/disable the in-kernel repeat fuse. `false` disables; an object overrides thresholds.
         // Absent ⇒ kernel defaults (enabled, deny_after=5, terminate_after=8).
@@ -223,7 +369,7 @@ export class RuntimeRunner {
                 ...(ew.notifyModel !== undefined ? { notify_model: ew.notifyModel } : {}),
             };
         }
-        kernelApply(runtime, this.pendingObservations, { kind: "configure_run", config });
+        await this.commitKernelApply(runtime, this.pendingObservations, { kind: "configure_run", config });
     }
     async appendMemorySyscallObservations(sessionId, observations) {
         if (!sessionId)
@@ -240,37 +386,37 @@ export class RuntimeRunner {
         }
     }
     /** Mount a tool capability on the currently-running kernel runtime. No-op if not running. */
-    mountTool(schema) {
+    async mountTool(schema) {
         if (!this.activeKernel)
             return;
-        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilityTool(schema)));
+        await this.commitKernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilityTool(schema)));
     }
     /** Mount a skill capability on the currently-running kernel runtime. No-op if not running. */
-    mountSkill(name, description) {
+    async mountSkill(name, description) {
         if (!this.activeKernel)
             return;
-        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilitySkill({ name, description, estimatedTokens: 0 })));
+        await this.commitKernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilitySkill({ name, description, estimatedTokens: 0 })));
     }
     /** Mount a generic marker capability (e.g. MCP server, agent) on the active run. No-op if not running. */
-    mountMarker(kind, id, description) {
+    async mountMarker(kind, id, description) {
         if (!this.activeKernel)
             return;
-        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilityMarker(kind, id, description)));
+        await this.commitKernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilityMarker(kind, id, description)));
     }
     /** Unmount a capability by kind + id from the active run. No-op if not running. */
-    unmountCapability(kind, id) {
+    async unmountCapability(kind, id) {
         if (!this.activeKernel)
             return;
-        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandUnmount(kind, id));
+        await this.commitKernelApply(this.activeKernel, this.pendingObservations, capabilityCommandUnmount(kind, id));
     }
     /** Push content into the Knowledge slot (memory retrievals, skill definitions, artifacts).
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
      *  compaction/renewal boundary, where the cached system[1] block is rewritten anyway) instead
      *  of appending a duplicate. `opts.pinned` exempts the entry from the knowledge-budget sweep. */
-    pushKnowledge(message, tokens, opts) {
+    async pushKnowledge(message, tokens, opts) {
         if (!this.activeKernel)
             return;
-        kernelApply(this.activeKernel, this.pendingObservations, {
+        await this.commitKernelApply(this.activeKernel, this.pendingObservations, {
             kind: "add_knowledge_message",
             content: message.content ?? "",
             tokens: tokens ?? Math.max(1, Math.ceil((message.content?.length ?? 0) / 4)),
@@ -280,19 +426,19 @@ export class RuntimeRunner {
     }
     /** K1: mark a keyed knowledge entry for removal at the next compaction/renewal boundary.
      *  Errs-open: an unknown key is a kernel-side no-op. */
-    removeKnowledge(key) {
+    async removeKnowledge(key) {
         if (!this.activeKernel)
             return;
-        kernelApply(this.activeKernel, this.pendingObservations, { kind: "remove_knowledge", key });
+        await this.commitKernelApply(this.activeKernel, this.pendingObservations, { kind: "remove_knowledge", key });
     }
     /** K3: host-driven skill deactivation (there is deliberately no model-facing unload — it
      *  invites thrash). The toolset re-widens at the next provider call; the skill's knowledge pin
      *  drops at the next compaction/renewal boundary. A later `skill(name)` call re-activates and
      *  re-pins fresh content. Errs-open: not-active is a kernel-side no-op. */
-    deactivateSkill(name) {
+    async deactivateSkill(name) {
         if (!this.activeKernel)
             return;
-        kernelApply(this.activeKernel, this.pendingObservations, { kind: "skill_deactivated", name });
+        await this.commitKernelApply(this.activeKernel, this.pendingObservations, { kind: "skill_deactivated", name });
         // Re-arm the SDK-side push guard so a re-activation re-pins the content.
         this.knowledgePushedSkills.delete(name);
     }
@@ -306,7 +452,7 @@ export class RuntimeRunner {
         }
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
-        const observations = kernelApply(runtime, this.pendingObservations, {
+        const observations = await this.commitKernelApply(runtime, this.pendingObservations, {
             kind: "spawn_sub_agent",
             spec: agentRunSpecToKernel(spec),
             parent_session_id: parentSessionId,
@@ -325,7 +471,7 @@ export class RuntimeRunner {
             sessionLog: this.opts.sessionLog,
             ...(this.opts.subAgentHarness ? { harness: this.opts.subAgentHarness } : {}),
         });
-        kernelApply(runtime, this.pendingObservations, {
+        await this.commitKernelApply(runtime, this.pendingObservations, {
             kind: "sub_agent_completed",
             result: subAgentResultToKernel(result),
         });
@@ -414,10 +560,10 @@ export class RuntimeRunner {
         const schema = node.output_schema;
         if (!schema)
             return orchestrator.run(mkCtx(baseSpec.goal));
-        const MAX_ATTEMPTS = 2;
+        const maxAttempts = this.opts.workflowSchemaValidationAttempts ?? 2;
         let last;
         let lastErrors = [];
-        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             const goal = attempt === 1
                 ? `${baseSpec.goal}\n\n${schemaInstruction(schema)}`
                 : `${baseSpec.goal}\n\n${schemaRetryInstruction(schema, lastErrors)}`;
@@ -430,7 +576,7 @@ export class RuntimeRunner {
             last = result;
             lastErrors = v.errors;
         }
-        const reason = `output_schema validation failed after ${MAX_ATTEMPTS} attempts: ${lastErrors.join("; ")}`;
+        const reason = `output_schema validation failed after ${maxAttempts} attempts: ${lastErrors.join("; ")}`;
         const fallback = last;
         return {
             ...fallback,
@@ -467,7 +613,7 @@ export class RuntimeRunner {
      * W0-ABI: run a declarative workflow DAG. The kernel owns the DAG and gates every node spawn
      * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
      * feeds their results back, and loops until the kernel reports the workflow complete.
-     * Returns the completed / failed node agent-ids.
+     * Returns one typed terminal outcome for every node in the DAG.
      */
     async runWorkflow(spec, opts) {
         // Standalone entry: with no active parent run (e.g. a stateless HTTP handler), auto-bootstrap a
@@ -475,34 +621,42 @@ export class RuntimeRunner {
         // gets — then tear it down on completion so the runner is reusable. Mid-run callers (activeKernel
         // already set by an in-flight `run()`) keep the original in-place behavior with no teardown.
         const bootstrapped = !this.activeKernel || !this.currentSessionId;
-        if (bootstrapped) {
-            const sessionId = opts?.sessionId ?? `wf-${crypto.randomUUID()}`;
-            // L1: a standalone workflow is a member of its runner's governance domain too. Seed the
-            // bootstrap kernel with the group's cumulative spend (so the cumulative spawn/token cap bites
-            // while scheduling DAG nodes) and register membership — mirroring `execute()`. Mid-run callers
-            // skip this: their parent `run()` already seeds + counts the nodes via `localSubagentsSpawned()`.
-            let groupLedger;
-            if (this.opts.runGroup) {
-                const g = this.opts.runGroup;
-                groupLedger = await g.budgetStore.read(g.id);
-                await g.budgetStore.join(g.id, { sessionId, role: this.opts.agentId, kind: "vehicle" });
-            }
-            this.bootstrapWorkflowKernel(sessionId, spec, groupLedger?.tokensSpent, groupLedger?.subagentsSpawned);
-        }
-        const parentSessionId = this.currentSessionId;
-        const runtime = this.activeKernel;
+        let groupBudgetScope;
         try {
-            const observations = kernelApply(runtime, this.pendingObservations, {
+            if (bootstrapped) {
+                const sessionId = opts?.sessionId ?? `wf-${crypto.randomUUID()}`;
+                // A standalone workflow reserves a bounded slice before its kernel schedules any node.
+                // Mid-run callers reuse their parent run's already-active reservation.
+                if (this.opts.runGroup) {
+                    const g = this.opts.runGroup;
+                    groupBudgetScope = await GroupBudgetScope.open(g, { sessionId, role: this.opts.agentId, kind: "vehicle" }, this.groupBudgetRequest(false));
+                    this.activeGroupBudgetScope = groupBudgetScope;
+                }
+                // Resume depends on this fact. Do not dispatch any node until it is durable.
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "run_started",
+                    run_id: crypto.randomUUID(),
+                    goal: `workflow:${spec.nodes.length} nodes`,
+                    criteria: [],
+                    agent_id: this.opts.agentId,
+                });
+                await this.bootstrapWorkflowKernel(sessionId, groupBudgetScope);
+            }
+            const parentSessionId = this.currentSessionId;
+            const runtime = this.activeKernel;
+            const observationStart = this.pendingObservations.length;
+            const initialAction = await this.commitKernelMaybeAction(runtime, this.pendingObservations, {
                 kind: "load_workflow",
                 spec: workflowSpecToKernel(spec),
                 parent_session_id: parentSessionId,
-                // W0-ABI resume: skip nodes already completed before an interruption.
-                ...(opts?.resumedCompleted?.length ? { resumed_completed: opts.resumedCompleted } : {}),
-                // W-1: signal-carrying completion records (classify branch / loop stop replay).
-                ...(opts?.resumedResults?.length
+                // Exact typed terminal outcomes plus control-flow signals recovered from the journal.
+                ...(opts?.resumedOutcomes?.length
                     ? {
-                        resumed_results: opts.resumedResults.map(r => ({
+                        resumed_outcomes: opts.resumedOutcomes.map(r => ({
                             agent_id: r.agentId,
+                            status: r.status,
+                            termination: r.termination,
+                            ...(r.output ? { output: messageToKernelMessage(r.output) } : {}),
                             ...(r.classifyBranch !== undefined ? { classify_branch: r.classifyBranch } : {}),
                             ...(r.tournamentWinner !== undefined ? { tournament_winner: r.tournamentWinner } : {}),
                             ...(r.loopContinue !== undefined ? { loop_continue: r.loopContinue } : {}),
@@ -513,24 +667,30 @@ export class RuntimeRunner {
                 ...(opts?.resumedSubmissions?.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
                 ...(opts?.resumedSubmissionBases?.length ? { resumed_submission_bases: opts.resumedSubmissionBases } : {}),
             });
-            return await this.driveWorkflow(observations, parentSessionId, runtime, opts?.resumedOutputs);
+            const observations = this.pendingObservations.slice(observationStart);
+            const outcome = await this.driveWorkflow(initialAction, observations, parentSessionId, runtime, recoveredOutputs(opts?.resumedOutcomes));
+            if (bootstrapped) {
+                const terminal = await this.commitKernelAction(runtime, this.pendingObservations, { kind: "complete_run" });
+                if (terminal.kind !== "done") {
+                    throw new Error("complete_run did not produce a terminal kernel action");
+                }
+                await this.appendObservations(parentSessionId, runtime, 0);
+            }
+            return outcome;
         }
         finally {
             if (bootstrapped) {
-                // L1: charge the standalone workflow's node spawns back to the group so the cumulative spawn
-                // cap (`maxTotalSubagents`) counts workflow nodes — they are member runs whose own
-                // `execute()` charge contributes 0 spawns, so without this the node count is invisible to the
-                // group. The envelope kernel's TaskTable holds one proc per scheduled node, so
-                // `localSubagentsSpawned()` is exactly that node count (the envelope itself burns no tokens).
-                if (this.opts.runGroup) {
-                    const subagents = runtime.localSubagentsSpawned?.() ?? 0;
-                    if (subagents > 0) {
-                        await this.opts.runGroup.budgetStore.charge(this.opts.runGroup.id, { subagents });
+                try {
+                    if (groupBudgetScope && !groupBudgetScope.isClosed) {
+                        await groupBudgetScope.release();
                     }
                 }
-                this.activeKernel = null;
-                this.currentSessionId = null;
-                this.pendingObservations = [];
+                finally {
+                    this.activeKernel = null;
+                    this.currentSessionId = null;
+                    this.pendingObservations = [];
+                    this.activeGroupBudgetScope = undefined;
+                }
             }
         }
     }
@@ -538,31 +698,25 @@ export class RuntimeRunner {
      * Bootstrap a standalone kernel for a host-driven workflow with NO active parent run — the path a
      * stateless request handler takes when it calls `runWorkflow(spec)` directly. Mirrors `execute()`'s
      * pre-run kernel setup (governance / attention / quota via `applyKernelPolicies`, then `start_run`)
-     * and records a `run_started` event so the standalone run is resumable from the session log. Sets
-     * `activeKernel` / `currentSessionId`; `runWorkflow` is responsible for tearing them down.
+     * after `runWorkflow` has durably recorded `run_started`. Sets `activeKernel` / `currentSessionId`;
+     * `runWorkflow` is responsible for tearing them down.
      */
-    bootstrapWorkflowKernel(sessionId, spec, groupTokensBase, groupSpawnsBase) {
+    async bootstrapWorkflowKernel(sessionId, groupBudgetScope) {
         this.interrupted = false;
         this.abortController = new AbortController();
         this.pendingObservations = [];
-        this.pendingSpoolOutputs.clear();
+        this.pendingPageOutArchives = [];
+        this.activePageOutArchive = undefined;
         this.currentSessionId = sessionId;
         const runtime = this.createSyscallRuntime();
         this.activeKernel = runtime;
-        const goal = `workflow:${spec.nodes.length} nodes`;
-        // Best-effort run_started log so a standalone workflow can be resumed via `resumeWorkflow`. The
-        // session log is fire-and-forget here (the kernel state, not the log, drives the DAG); a logless
-        // store simply means no resume.
-        void this.opts.sessionLog.append(sessionId, {
-            kind: "run_started",
-            run_id: crypto.randomUUID(),
-            goal,
-            criteria: [],
-            agent_id: this.opts.agentId,
-        }).catch(() => { });
-        this.applyKernelPolicies(runtime, groupTokensBase, groupSpawnsBase);
-        // K1: no explicit `start_run` — the host `load_workflow` (fired next by `runWorkflow`) self-bootstraps
-        // the run on the 0.2.30 core, matching the agent-reachable `submit_workflow` path.
+        await this.applyKernelPolicies(runtime, groupBudgetScope);
+        // ABI v2 has one lifecycle: standalone workflows start a real run before loading their DAG.
+        // The initial provider effect is superseded by the workflow load; no self-bootstrap escape hatch.
+        await this.commitKernelAction(runtime, this.pendingObservations, {
+            kind: "start_run",
+            task: { goal: `workflow session ${sessionId}`, criteria: [] },
+        });
         return runtime;
     }
     /**
@@ -580,7 +734,9 @@ export class RuntimeRunner {
         }
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
-        const observations = kernelApply(runtime, this.pendingObservations, submitWorkflowToKernel(spec, parentSessionId, opts?.submitterAgentId));
+        const observationStart = this.pendingObservations.length;
+        const initialAction = await this.commitKernelMaybeAction(runtime, this.pendingObservations, submitWorkflowToKernel(spec, parentSessionId, opts?.submitterAgentId));
+        const observations = this.pendingObservations.slice(observationStart);
         // W-3: persist the agent-authored batch (bootstrap base 0 / flatten base N — the kernel now
         // announces BOTH) so an interrupted authored workflow reconstructs on resume; the host never
         // had this spec, unlike the `runWorkflow` path.
@@ -593,7 +749,7 @@ export class RuntimeRunner {
                 submitterAgentId: opts?.submitterAgentId,
             }));
         }
-        return this.driveWorkflow(observations, parentSessionId, runtime);
+        return this.driveWorkflow(initialAction, observations, parentSessionId, runtime);
     }
     /**
      * M5 v2.1: drive the sub-workflow(s) a top-level agent authored via `start_workflow`. Called at the
@@ -607,14 +763,14 @@ export class RuntimeRunner {
     async driveAuthoredWorkflows(runtime, action) {
         const specs = this.pendingAuthoredWorkflows;
         this.pendingAuthoredWorkflows = [];
+        this.workflowContinuation = null;
         for (const spec of specs) {
-            const outcome = await this.bootstrapWorkflow(spec);
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "add_history_message",
-                message: messageToKernelMessage({ role: "user", content: authoredWorkflowOutcomeNote(outcome) }),
-            });
+            await this.bootstrapWorkflow(spec);
         }
-        return { kind: "call_provider", context: runtime.render(), tools: action.tools };
+        const continuation = this.workflowContinuation;
+        if (!continuation)
+            throw new Error("authored workflow completed without a provider continuation");
+        return continuation;
     }
     /**
      * #2-B-ii: while a workflow batch is in flight, poll the signal source. A Critical `InterruptNow`
@@ -631,21 +787,40 @@ export class RuntimeRunner {
         while (!batchState.settled) {
             // O2: injected notes participate in the monitor too, so a host `injectNote` mid-batch is not
             // stranded until the batch settles (the drain order matches `nextInboundSignal`).
-            const sig = this.injectedSignals.shift()
-                ?? await source.nextSignal(this.currentSessionId ?? undefined);
-            if (batchState.settled)
+            const delivery = await this.nextInboundSignal();
+            if (batchState.settled) {
+                await delivery?.nack();
                 break;
-            if (!sig) {
+            }
+            if (!delivery) {
                 await new Promise(resolve => setTimeout(resolve, 5));
                 continue;
             }
-            const obs = kernelApply(runtime, this.pendingObservations, signalToKernelEvent(sig));
-            const preempted = obs.find(o => o.kind === "agent_preempted");
+            const observationStart = this.pendingObservations.length;
+            const signalAction = await this.consumeInboundSignal(delivery, sig => this.commitKernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig)));
+            let observations = this.pendingObservations.slice(observationStart);
+            if (signalAction?.kind === "preempt_sub_agents") {
+                for (const id of signalAction.agentIds)
+                    controllers.get(id)?.abort();
+                const resultStart = this.pendingObservations.length;
+                const continuation = await this.commitKernelMaybeAction(runtime, this.pendingObservations, {
+                    kind: "preempt_result",
+                    effect_id: signalAction.effectId,
+                });
+                if (continuation && continuation.kind !== "call_provider" && continuation.kind !== "done") {
+                    throw new Error(`workflow preemption returned unexpected effect: ${continuation.kind}`);
+                }
+                observations = [...observations, ...this.pendingObservations.slice(resultStart)];
+            }
+            else if (signalAction) {
+                throw new Error(`workflow signal returned unexpected effect: ${signalAction.kind}`);
+            }
+            const preempted = observations.find(o => o.kind === "agent_preempted");
             if (preempted) {
                 for (const id of preempted.agent_ids ?? [])
                     controllers.get(id)?.abort();
-                const wc = obs.find(o => o.kind === "workflow_completed");
-                return { completed: wc?.completed ?? [], failed: wc?.failed ?? [] };
+                const wc = observations.find(o => o.kind === "workflow_completed");
+                return (wc?.node_outcomes ?? []).map(workflowNodeOutcomeFromKernel);
             }
         }
         return null;
@@ -654,22 +829,40 @@ export class RuntimeRunner {
      * Shared workflow driver for `runWorkflow` (host `load_workflow`) and `bootstrapWorkflow` (agent
      * `submit_workflow`): given the observations from the initial load/bootstrap, run each kernel-emitted
      * batch in parallel, feed completions back (appending any agent-submitted nodes first), and loop
-     * until the kernel reports the workflow complete. Returns the completed / failed node agent-ids.
+     * until the kernel reports the workflow complete. Returns typed terminal node outcomes.
      */
-    async driveWorkflow(initial, parentSessionId, runtime, seedOutputs) {
+    async driveWorkflow(initialAction, initial, parentSessionId, runtime, seedOutputs) {
         let observations = initial;
         const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
-        const collectNodes = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")
-            ?.nodes ?? [];
-        // G4: the batch observation also carries the workflow's remaining budget; track the latest so a
-        // coordinator node's prompt reflects current headroom when it decides how much to submit.
-        const collectBudget = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")?.budget;
         const findDone = (obs) => obs.find(o => o.kind === "workflow_completed");
+        const acceptSpawn = async (spawn) => {
+            const observationStart = this.pendingObservations.length;
+            const continuation = await this.commitKernelMaybeAction(runtime, this.pendingObservations, {
+                kind: "workflow_spawn_result",
+                effect_id: spawn.effectId,
+                started_agent_ids: spawn.nodes.map(node => String(node.agent_id ?? "")),
+                failures: [],
+            });
+            if (continuation) {
+                throw new Error(`workflow spawn acknowledgement returned unexpected effect: ${continuation.kind}`);
+            }
+            return this.pendingObservations.slice(observationStart);
+        };
         let done = findDone(observations);
-        if (done)
-            return { completed: done.completed ?? [], failed: done.failed ?? [], outputs: {} };
-        let nodes = collectNodes(observations);
-        let budget = collectBudget(observations);
+        if (done) {
+            if (initialAction?.kind === "call_provider")
+                this.workflowContinuation = initialAction;
+            return { nodeOutcomes: (done.node_outcomes ?? []).map(workflowNodeOutcomeFromKernel), outputs: {} };
+        }
+        if (!initialAction)
+            return { nodeOutcomes: [], outputs: {} };
+        if (initialAction.kind !== "spawn_workflow") {
+            throw new Error(`workflow load returned unexpected kernel effect: ${initialAction.kind}`);
+        }
+        let nodes = initialAction.nodes;
+        let budget = initialAction.budget;
+        observations = await acceptSpawn(initialAction);
+        done = findDone(observations);
         // G2: each completed node's output, keyed by agent id — a reduce node reads its dependencies'
         // outputs from here. Deps always complete in an earlier round than the reduce node that needs
         // them (the kernel keeps the reduce node un-ready until its deps finish), so this is populated.
@@ -678,7 +871,7 @@ export class RuntimeRunner {
         const outputs = new Map(seedOutputs ?? []);
         for (;;) {
             if (nodes.length === 0)
-                return { completed: [], failed: [], outputs: Object.fromEntries(outputs) }; // nothing to run (e.g. all gated)
+                return { nodeOutcomes: [], outputs: Object.fromEntries(outputs) }; // nothing to run (e.g. all gated)
             // Run the currently-runnable nodes in parallel — each is independent within a round.
             const roundBudget = budget;
             // #2-B-ii: per-node abort controllers + a concurrent preemption monitor. While the batch is in
@@ -692,7 +885,7 @@ export class RuntimeRunner {
             batchState.settled = true;
             const preempted = await monitor;
             if (preempted)
-                return { ...preempted, outputs: Object.fromEntries(outputs) };
+                return { nodeOutcomes: preempted, outputs: Object.fromEntries(outputs) };
             // Feed completions back one at a time. The kernel's run-queue executor may spawn a node's
             // dependents the moment *that* node completes (per-node unblock), so each feed can emit its
             // own `workflow_batch_spawned`; ACCUMULATE them across the round rather than keeping only the
@@ -719,26 +912,50 @@ export class RuntimeRunner {
                     // G1: stamp the submitting node's agent id so the kernel can coerce a quarantined
                     // submitter's nodes to quarantined (no topological privilege escalation).
                     const submitEvent = submitWorkflowNodesToKernel(result.submittedNodes, result.agentId);
-                    const subObs = kernelApply(runtime, this.pendingObservations, submitEvent);
-                    nextNodes.push(...collectNodes(subObs));
-                    budget = collectBudget(subObs) ?? budget;
+                    const observationStart = this.pendingObservations.length;
+                    const submitAction = await this.commitKernelMaybeAction(runtime, this.pendingObservations, submitEvent);
+                    const subObs = this.pendingObservations.slice(observationStart);
+                    if (submitAction?.kind === "spawn_workflow") {
+                        nextNodes.push(...submitAction.nodes);
+                        budget = submitAction.budget ?? budget;
+                        const accepted = await acceptSpawn(submitAction);
+                        const submittedDone = findDone([...subObs, ...accepted]);
+                        if (submittedDone)
+                            done = submittedDone;
+                    }
+                    else if (submitAction) {
+                        throw new Error(`workflow node submission returned unexpected effect: ${submitAction.kind}`);
+                    }
                     // R3-1: persist the submission (kernel-shape nodes) + its kernel-reported base index
                     // so resume can re-apply the batch at the exact original graph position. W-N3: also the
                     // submitter, so resume drops batches whose submitter re-runs (it will re-submit).
                     const submitted = subObs.find(o => o.kind === "workflow_nodes_submitted");
-                    await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodesSubmittedEvent({
-                        turn: runtime.turn(),
-                        nodes: submitEvent.nodes ?? [],
-                        baseIndex: submitted?.base,
-                        submitterAgentId: result.agentId,
-                    }));
+                    if (submitted) {
+                        await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodesSubmittedEvent({
+                            turn: runtime.turn(),
+                            nodes: submitEvent.nodes ?? [],
+                            baseIndex: submitted.base,
+                            submitterAgentId: result.agentId,
+                        }));
+                    }
                 }
-                const obs = kernelApply(runtime, this.pendingObservations, {
+                const observationStart = this.pendingObservations.length;
+                const completionAction = await this.commitKernelMaybeAction(runtime, this.pendingObservations, {
                     kind: "sub_agent_completed",
                     result: subAgentResultToKernel(result),
                 });
-                nextNodes.push(...collectNodes(obs));
-                budget = collectBudget(obs) ?? budget;
+                let obs = this.pendingObservations.slice(observationStart);
+                if (completionAction?.kind === "spawn_workflow") {
+                    nextNodes.push(...completionAction.nodes);
+                    budget = completionAction.budget ?? budget;
+                    obs = [...obs, ...await acceptSpawn(completionAction)];
+                }
+                else if (completionAction?.kind === "call_provider") {
+                    this.workflowContinuation = completionAction;
+                }
+                else if (completionAction) {
+                    throw new Error(`workflow completion returned unexpected effect: ${completionAction.kind}`);
+                }
                 const d = findDone(obs);
                 if (d)
                     done = d;
@@ -748,15 +965,19 @@ export class RuntimeRunner {
                 await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodeCompletedEvent({
                     turn: runtime.turn(),
                     agentId: result.agentId,
+                    status: workflowNodeStatusFromTermination(result.result.termination),
                     termination: result.result.termination,
                     classifyBranch: result.result.classifyBranch,
                     tournamentWinner: result.result.tournamentWinner,
                     loopContinue: result.result.loopContinue,
-                    ...(result.result.termination === "completed" && outText ? { output: outText } : {}),
+                    ...(result.result.finalMessage ? { output: result.result.finalMessage } : {}),
                 }));
             }
             if (done && nextNodes.length === 0) {
-                return { completed: done.completed ?? [], failed: done.failed ?? [], outputs: Object.fromEntries(outputs) };
+                return {
+                    nodeOutcomes: (done.node_outcomes ?? []).map(workflowNodeOutcomeFromKernel),
+                    outputs: Object.fromEntries(outputs),
+                };
             }
             nodes = nextNodes;
         }
@@ -775,39 +996,33 @@ export class RuntimeRunner {
             throw new Error("resumeWorkflow requires an active parent run or an explicit sessionId");
         }
         const events = await this.opts.sessionLog.read(sessionId);
-        const resumedResults = recoverCompletedWorkflowNodes(events);
-        const completedIds = new Set(resumedResults.map(r => r.agentId));
+        const resumedOutcomes = recoverWorkflowNodeOutcomes(events);
+        const completedIds = new Set(resumedOutcomes.map(r => r.agentId));
         const recovered = recoverSubmittedWorkflowNodes(events);
         // W-N3: DROP batches whose submitter did NOT complete — that node re-runs on resume and will
         // re-submit its batch; replaying the logged copy too would duplicate its nodes in the DAG.
-        // Only safe with exact bases (the dropped batch's slots become inert placeholders); a legacy
-        // order-only log keeps every batch, since dropping would shift all later indices.
+        // Exact bases keep later graph indices stable while dropped slots remain inert placeholders.
         let { submissions, bases } = recovered;
-        if (bases.length === submissions.length && submissions.length > 0) {
+        if (submissions.length > 0) {
             const keep = recovered.submitters.map(s => s === undefined || completedIds.has(s));
             submissions = submissions.filter((_, i) => keep[i]);
             bases = bases.filter((_, i) => keep[i]);
         }
-        const resumedOutputs = new Map(resumedResults.filter(r => r.output).map(r => [r.agentId, r.output]));
-        // Alias loop iterations onto their stable node id (last iteration wins) — dependents consume
-        // `wf-node{N}`, not `wf-node{N}-i{k}`.
-        for (const r of resumedResults) {
-            const stableId = r.agentId.replace(/-i\d+$/, "");
-            if (stableId !== r.agentId && r.output)
-                resumedOutputs.set(stableId, r.output);
-        }
         return this.runWorkflow(spec, {
-            resumedResults,
+            resumedOutcomes,
             resumedSubmissions: submissions,
             resumedSubmissionBases: bases,
-            resumedOutputs,
             sessionId,
         });
     }
-    interrupt() { this.interrupted = true; this.abortController?.abort(); }
+    interrupt(reason = "user") {
+        this.interrupted = true;
+        this.cancellationReason = reason;
+        this.abortController?.abort(reason);
+    }
     /** Push a contextual note into the run's signal stream (the system-reminder channel): it drains at
-     *  the next turn boundary, routes through the kernel attention policy, and — once acted on — renders
-     *  as a `[SIGNAL] <text>` line in the volatile state turn plus a durable directive. Use it to feed
+     *  the next turn boundary, routes through the kernel attention policy, and renders once as a
+     *  `[SIGNAL] <text>` line in the volatile state turn. Use it to feed
      *  host-detected events back to the model mid-run (e.g. "that write was a no-op — stop repeating it")
      *  without wiring a full `SignalSource`. `urgency` maps to the kernel disposition ladder: `"normal"`
      *  queues for the next boundary (default), `"high"` soft-interrupts, `"critical"` preempts. */
@@ -830,18 +1045,63 @@ export class RuntimeRunner {
     async nextInboundSignal() {
         const injected = this.injectedSignals.shift();
         if (injected)
-            return injected;
+            return {
+                signalId: crypto.randomUUID(),
+                deliveryId: `injected-${crypto.randomUUID()}`,
+                deliveryAttempt: 1,
+                signal: injected,
+                ack: async () => true,
+                nack: async () => true,
+            };
         if (!this.opts.signalSource)
             return null;
-        return this.opts.signalSource.nextSignal(this.currentSessionId ?? undefined);
+        const source = this.opts.signalSource;
+        const claim = await source.claimSignal(this.currentSessionId ?? undefined);
+        if (!claim)
+            return null;
+        const receipt = {
+            deliveryId: claim.deliveryId,
+            leaseToken: claim.leaseToken,
+        };
+        return {
+            signalId: claim.signalId,
+            deliveryId: claim.deliveryId,
+            deliveryAttempt: claim.deliveryAttempt,
+            signal: claim.signal,
+            ack: () => source.ackSignal(receipt),
+            nack: () => source.nackSignal(receipt),
+        };
+    }
+    async consumeInboundSignal(delivery, consume) {
+        try {
+            const observationStart = this.pendingObservations.length;
+            const result = await consume(delivery);
+            const dispositions = this.pendingObservations.slice(observationStart).filter(observation => observation.kind === "signal_delivery_disposed"
+                && observation.delivery_id === delivery.deliveryId
+                && observation.attempt === delivery.deliveryAttempt);
+            if (dispositions.length !== 1) {
+                throw new Error("kernel did not return the matching signal delivery disposition");
+            }
+            if (!await delivery.ack())
+                throw new Error("signal lease was lost before acknowledgement");
+            return result;
+        }
+        catch (cause) {
+            await delivery.nack();
+            throw cause;
+        }
     }
     async *run(req) {
         const prior = req.inheritEvents ?? await this.opts.sessionLog.read(req.sessionId);
         const midRun = isMidRun(prior);
+        const resumedStart = [...prior].reverse().find(entry => entry.event.kind === "run_started");
+        const runId = midRun && resumedStart?.event.kind === "run_started"
+            ? resumedStart.event.run_id
+            : crypto.randomUUID();
         if (!midRun) {
             await this.opts.sessionLog.append(req.sessionId, {
                 kind: "run_started",
-                run_id: crypto.randomUUID(),
+                run_id: runId,
                 goal: req.goal,
                 criteria: req.criteria ?? [],
                 agent_id: this.opts.agentId,
@@ -849,7 +1109,7 @@ export class RuntimeRunner {
                 ...(req.attachments?.length ? { attachments: req.attachments } : {}),
             });
         }
-        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun, req.attachments);
+        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun, req.attachments, runId);
     }
     async *wake(sessionId, extensions) {
         const events = await this.opts.sessionLog.read(sessionId);
@@ -859,101 +1119,28 @@ export class RuntimeRunner {
         if (!startEntry)
             throw new Error(`No run_started event for session: ${sessionId}`);
         const start = startEntry.event;
-        yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true, start.attachments);
+        yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true, start.attachments, start.run_id);
     }
-    async *dream(agentId, nowMs = Date.now()) {
-        if (!this.opts.dreamStore)
-            throw new Error("dreamStore not configured");
-        const kernel = getKernel();
-        const sessions = await this.opts.dreamStore.loadSessions(agentId);
-        const existingMemories = await this.opts.dreamStore.loadMemories(agentId);
-        if (!sessions.length) {
-            yield { type: "done", iterations: 0, totalTokens: 0, status: "completed", dreamResult: { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 } };
-            return;
-        }
-        const pipeline = new kernel.IdlePipeline(agentId);
-        const action1 = pipeline.feedTrigger(sessions.map(s => ({
-            sessionId: s.sessionId, agentId: s.agentId,
-            messages: s.messages.map(m => ({
-                role: m.role, content: m.content, tokenCount: m.tokenCount,
-                toolCalls: (m.toolCalls ?? []).map(tc => ({ id: tc.id, name: tc.name, arguments: tc.arguments })),
-            })),
-            metadata: JSON.stringify(s.metadata ?? null),
-            createdAtMs: s.createdAtMs, updatedAtMs: s.updatedAtMs,
-        })), existingMemories.map(e => ({ text: e.text, score: e.score, metadata: JSON.stringify(e.metadata ?? null) })), nowMs);
-        if (action1.kind === "noop" || action1.kind === "aborted") {
-            yield { type: "done", iterations: 0, totalTokens: 0, status: "completed", dreamResult: { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 } };
-            return;
-        }
-        if (action1.kind !== "synthesize_insights")
-            throw new Error(`unexpected: ${action1.kind}`);
-        let synthesisText = "";
-        const dreamProvider = this.opts.dreamProvider ?? this.opts.provider;
-        const providerState = dreamProvider.createRunState?.();
-        const synthMsgs = (action1.messages ?? []);
-        const kernelSystemText = synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const synthContext = {
-            systemText: [kernelSystemText, this.opts.dreamSystemPrompt].filter(Boolean).join("\n\n"),
-            turns: synthMsgs.filter(m => m.role !== "system"),
-        };
-        let totalTokens = 0;
-        for await (const evt of dreamProvider.stream(synthContext, [], undefined, providerState)) {
-            if (evt.type === "text_delta") {
-                synthesisText += evt.delta;
-                yield evt;
-            }
-            else if (evt.type === "usage")
-                totalTokens = evt.totalTokens;
-        }
-        const action2 = pipeline.feedSynthesisResult(synthesisText);
-        if (action2.kind !== "commit_memories")
-            throw new Error(`unexpected: ${action2.kind}`);
-        const cr = action2.curationResult;
-        const rr = action2.runResult;
-        const dsResult = {
-            toAdd: (cr.toAdd ?? []).map((e) => ({
-                text: e.text, score: e.score, metadata: tryParseJson(e.metadata),
-            })),
-            toRemoveIndices: (cr.toRemoveIndices ?? []).map(Number),
-            stats: {
-                insightsProcessed: cr.stats?.insightsProcessed ?? 0,
-                duplicatesRemoved: cr.stats?.duplicatesRemoved ?? 0,
-                conflictsResolved: cr.stats?.conflictsResolved ?? 0,
-                entriesAdded: cr.stats?.entriesAdded ?? 0,
-            },
-        };
-        await this.opts.dreamStore.commit(agentId, dsResult, existingMemories);
-        yield {
-            type: "done", iterations: 1, totalTokens, status: "completed",
-            dreamResult: {
-                sessionsProcessed: rr.sessionsProcessed,
-                insightsExtracted: rr.insightsExtracted,
-                entriesAdded: cr.stats?.entriesAdded ?? 0,
-                entriesRemoved: (cr.toRemoveIndices ?? []).length,
-            },
-        };
-    }
-    /** Resolve in-kernel AskUser suspend; returns resume lists and stream events to yield. */
-    async resolveKernelSuspend(runtime, sessionId) {
-        const gated = this.pendingObservations.filter((o) => o.kind === "tool_gated" && typeof o.call_id === "string" && typeof o.tool === "string");
+    /** Execute a kernel-owned approval effect and return the correlated decision lists. */
+    async resolveApprovalRequests(requests, runtime, sessionId) {
         const approved = [];
         const denied = [];
         const events = [];
         const runCtx = { onPermissionRequest: this.opts.onPermissionRequest };
-        for (const g of gated) {
+        for (const approval of requests) {
             const request = {
                 type: "permission_request",
-                callId: g.call_id,
-                toolName: g.tool,
-                arguments: "{}",
-                reason: typeof g.reason === "string" ? g.reason : "",
+                callId: approval.callId,
+                toolName: approval.tool,
+                arguments: approval.arguments,
+                reason: approval.reason,
             };
             events.push(request);
             const decision = await resolvePermissionRequest(request, runCtx);
             events.push({
                 type: "permission_resolved",
-                callId: g.call_id,
-                toolName: g.tool,
+                callId: approval.callId,
+                toolName: approval.tool,
                 approved: decision.approved,
                 responder: decision.responder ?? "host",
                 ...(decision.reason ? { reason: decision.reason } : {}),
@@ -961,8 +1148,8 @@ export class RuntimeRunner {
             await this.opts.sessionLog.append(sessionId, {
                 kind: "permission_requested",
                 turn: runtime.turn(),
-                tool: g.tool,
-                arguments: "{}",
+                tool: approval.tool,
+                arguments: approval.arguments,
                 reason: request.reason,
             });
             await this.opts.sessionLog.append(sessionId, {
@@ -972,21 +1159,21 @@ export class RuntimeRunner {
                 responder: decision.responder ?? "host",
             });
             if (decision.approved) {
-                approved.push(g.call_id);
+                approved.push(approval.callId);
             }
             else {
-                denied.push(g.call_id);
+                denied.push(approval.callId);
                 const denyReason = decision.reason ?? "permission denied";
                 events.push({
                     type: "tool_denied",
-                    callId: g.call_id,
-                    toolName: g.tool,
+                    callId: approval.callId,
+                    toolName: approval.tool,
                     reason: denyReason,
                 });
                 events.push({
                     type: "tool_result",
-                    callId: g.call_id,
-                    name: g.tool,
+                    callId: approval.callId,
+                    name: approval.tool,
                     content: `permission denied: ${denyReason}`,
                     isError: true,
                     errorKind: "governance_denied",
@@ -994,15 +1181,15 @@ export class RuntimeRunner {
                 await this.opts.sessionLog.append(sessionId, {
                     kind: "tool_denied",
                     turn: runtime.turn(),
-                    call_id: g.call_id,
-                    tool_name: g.tool,
+                    call_id: approval.callId,
+                    tool_name: approval.tool,
                     reason: denyReason,
                 });
                 await this.opts.sessionLog.append(sessionId, {
                     kind: "tool_completed",
                     turn: runtime.turn(),
                     results: [{
-                            call_id: g.call_id,
+                            call_id: approval.callId,
                             output: `permission denied: ${denyReason}`,
                             is_error: true,
                             error_kind: "governance_denied",
@@ -1014,10 +1201,9 @@ export class RuntimeRunner {
     }
     /**
      * O7: resolve a `read_result` meta-tool call to the full text of a previously-evicted tool
-     * output. Resolution order: (a) this turn's in-memory `pendingSpoolOutputs` map (a call spooled
-     * earlier in the SAME tool-turn, before the session-log write lands), (b) the on-disk result
-     * spool (persisted once the kernel observation `large_result_spooled` was processed), (c) a
-     * session-log scan for the original `tool_completed` event carrying that `call_id`. Slices the
+     * output. Resolution order: (a) the on-disk result spool committed by the explicit
+     * `spool_large_result` host effect, then (b) a session-log scan for the original
+     * `tool_completed` event carrying that `call_id`. Slices the
      * resolved text by `[offset, offset + maxBytes)` (plain string slice — "bytes-ish").
      */
     async resolveReadResult(sessionId, argsJson) {
@@ -1035,15 +1221,13 @@ export class RuntimeRunner {
         catch {
             // malformed arguments — callId stays empty, falls through to "not found" below
         }
-        let full = this.pendingSpoolOutputs.get(callId)?.output;
-        if (full === undefined) {
-            const spool = this.opts.resultSpool ?? new LargeResultSpool();
-            try {
-                full = await spool.findByCallId(callId);
-            }
-            catch {
-                full = undefined;
-            }
+        let full;
+        const spool = this.opts.resultSpool ?? new LargeResultSpool();
+        try {
+            full = await spool.findByCallId(callId);
+        }
+        catch {
+            full = undefined;
         }
         if (full === undefined) {
             try {
@@ -1071,11 +1255,13 @@ export class RuntimeRunner {
             isError: false,
         };
     }
-    async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false, attachments) {
+    async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false, attachments, runId = crypto.randomUUID()) {
         this.interrupted = false;
+        this.cancellationReason = undefined;
         this.abortController = new AbortController();
         this.pendingObservations = [];
-        this.pendingSpoolOutputs.clear();
+        this.pendingPageOutArchives = [];
+        this.activePageOutArchive = undefined;
         this.currentSessionId = sessionId;
         if (this.opts.enableDiagnosticsDashboard) {
             this.dashboard = new KernelPrimitivesDashboard(sessionId);
@@ -1087,795 +1273,920 @@ export class RuntimeRunner {
         const providerPolicy = this.opts.provider.runtimePolicy?.() ?? {};
         const effectiveMaxTurns = this.opts.maxTurns ?? providerPolicy.maxTurns ?? 25;
         const effectiveTimeoutMs = this.opts.timeoutMs ?? providerPolicy.timeoutMs;
-        const runtime = new kernel.KernelRuntime({
-            maxTokens: this.opts.maxTokens,
-            maxTurns: effectiveMaxTurns,
-            timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
-            maxTotalTokens: this.opts.maxTotalTokens !== undefined ? BigInt(this.opts.maxTotalTokens) : undefined,
-        });
-        this.activeKernel = runtime;
-        this.nextArchiveStart = nextCompressedArchiveStart;
-        if (this.opts.tokenizer) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_tokenizer",
-                name: this.opts.tokenizer,
-            });
-        }
-        if (this.opts.enablePlanTool !== undefined) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_plan_tool_enabled",
-                enabled: this.opts.enablePlanTool,
-            });
-        }
-        kernelApply(runtime, this.pendingObservations, {
-            kind: "set_tools",
-            tools: this.opts.executionPlane.schemas().map(toolSchemaToKernel),
-        });
-        if (this.opts.systemPrompt) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "add_system_message",
-                content: this.opts.systemPrompt,
-                tokens: Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)),
+        const operation = {
+            runId,
+            sessionId,
+            agentId: this.opts.agentId,
+            signal: this.abortController.signal,
+            ...(effectiveTimeoutMs !== undefined ? { deadlineMs: Date.now() + effectiveTimeoutMs } : {}),
+        };
+        const taskScope = new ManagedTaskScope(operation, this.opts.onBackgroundTaskError);
+        let groupBudgetScope;
+        try {
+            const runtime = new kernel.KernelRuntime({
+                maxTokens: this.opts.maxTokens,
+                maxTurns: effectiveMaxTurns,
+                timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
+                maxTotalTokens: this.opts.maxTotalTokens !== undefined ? BigInt(this.opts.maxTotalTokens) : undefined,
             });
-        }
-        if (this.opts.initialMemory) {
-            for (const mem of this.opts.initialMemory) {
-                kernelApply(runtime, this.pendingObservations, {
-                    kind: "add_knowledge_message",
-                    content: mem,
-                    tokens: Math.max(1, Math.ceil(mem.length / 4)),
+            this.activeKernel = runtime;
+            this.nextArchiveStart = nextCompressedArchiveStart;
+            if (this.opts.tokenizer) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "set_tokenizer",
+                    name: this.opts.tokenizer,
                 });
             }
-        }
-        if (this.opts.skillDir) {
-            const { scanSkillDir } = await import("../skills/loader.js");
-            const metas = await scanSkillDir(this.opts.skillDir);
-            // P1-B: pass the full SkillMetadata (incl. `allowedTools`) straight through — re-mapping it
-            // field-by-field previously dropped `allowedTools`.
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_available_skills",
-                skills: metas.map(m => skillMetadataToKernel(m)),
-            });
-        }
-        // P1-B/D: configure the stable-core tool ids (always exposed under skill gating). Empty/absent
-        // ⇒ skills narrow to exactly their declared tools + meta-tools.
-        if (this.opts.stableCoreToolIds?.length) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_stable_core_tools",
-                tool_ids: this.opts.stableCoreToolIds,
-            });
-        }
-        if (this.opts.dreamStore && this.opts.agentId) {
-            kernelApply(runtime, this.pendingObservations, { kind: "set_memory_enabled", enabled: true });
-        }
-        // Install optional memory policy. Maps the ergonomic camelCase option onto the kernel's
-        // snake_case `set_memory_policy` event; omitted fields fall back to kernel defaults.
-        if (this.opts.memoryPolicy) {
-            const m = this.opts.memoryPolicy;
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_memory_policy",
-                ...(m.memoryPath !== undefined ? { memory_path: m.memoryPath } : {}),
-                ...(m.staleWarningDays !== undefined ? { stale_warning_days: m.staleWarningDays } : {}),
-                ...(m.retrievalTopK !== undefined ? { retrieval_top_k: m.retrievalTopK } : {}),
-                ...(m.validationEnabled !== undefined ? { validation_enabled: m.validationEnabled } : {}),
-                ...(m.maxContentBytes !== undefined ? { max_content_bytes: m.maxContentBytes } : {}),
-                ...(m.maxNameLength !== undefined ? { max_name_length: m.maxNameLength } : {}),
-            });
-        }
-        if (this.opts.knowledgeSource) {
-            kernelApply(runtime, this.pendingObservations, { kind: "set_knowledge_enabled", enabled: true });
-        }
-        if (this.opts.milestoneContract) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "load_milestone_contract",
-                contract: {
-                    phases: this.opts.milestoneContract.phases.map(p => ({
-                        id: p.id,
-                        criteria: p.criteria ?? [],
-                        unlocks: p.unlocks ?? [],
-                        required_evidence: p.requiredEvidence ?? [],
-                        ...(p.verifier ? { verifier: p.verifier } : {}),
-                    })),
-                },
-            });
-        }
-        const maxBytes = runtime.recoveryContentBytes();
-        if (priorEvents && priorEvents.length > 0) {
-            const repaired = repairEventsForRecovery(priorEvents, maxBytes);
-            seedProviderReplayFromEvents(this.opts.provider, repaired);
-            const loadArchive = this.opts.compressionStore
-                ? (ref) => this.opts.compressionStore.read(ref)
-                : undefined;
-            const replayed = await replayMessagesAsync(repaired, maxBytes, loadArchive);
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "preload_history",
-                messages: replayed.map(messageToKernelMessage),
+            if (this.opts.enablePlanTool !== undefined) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "set_plan_tool_enabled",
+                    enabled: this.opts.enablePlanTool,
+                });
+            }
+            await this.commitKernelApply(runtime, this.pendingObservations, {
+                kind: "set_tools",
+                tools: this.opts.executionPlane.schemas().map(toolSchemaToKernel),
             });
-            // P1-B B3: rebuild active-skill gating after a wake by re-emitting SkillActivated for each
-            // `skill` tool call in the replayed history (active_skills is not snapshotted — graceful).
-            // The catalog (set_available_skills) was already fed above, so allowed_tools resolves.
-            // `knowledge` isn't snapshotted either (same graceful-reset philosophy) — best-effort re-push
-            // the skill's content from its replayed tool_result so the durable copy survives a wake too.
-            const toolResultByCallId = new Map();
-            for (const m of replayed) {
-                for (const part of m.contentParts ?? []) {
-                    if (part.type === "tool_result")
-                        toolResultByCallId.set(part.callId, part.output);
+            if (this.opts.systemPrompt) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "add_system_message",
+                    content: this.opts.systemPrompt,
+                    tokens: Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)),
+                });
+            }
+            if (this.opts.initialMemory) {
+                for (const mem of this.opts.initialMemory) {
+                    await this.commitKernelApply(runtime, this.pendingObservations, {
+                        kind: "add_knowledge_message",
+                        content: mem,
+                        tokens: Math.max(1, Math.ceil(mem.length / 4)),
+                    });
                 }
             }
-            for (const m of replayed) {
-                for (const tc of m.toolCalls ?? []) {
-                    if (tc.name !== "skill")
-                        continue;
-                    try {
-                        const name = JSON.parse(tc.arguments || "{}").name;
-                        if (!name)
+            if (this.opts.skillDir) {
+                const { scanSkillDir } = await import("../skills/loader.js");
+                const metas = await scanSkillDir(this.opts.skillDir);
+                // P1-B: pass the full SkillMetadata (incl. `allowedTools`) straight through — re-mapping it
+                // field-by-field previously dropped `allowedTools`.
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "set_available_skills",
+                    skills: metas.map(m => skillMetadataToKernel(m)),
+                });
+            }
+            // P1-B/D: configure the stable-core tool ids (always exposed under skill gating). Empty/absent
+            // ⇒ skills narrow to exactly their declared tools + meta-tools.
+            if (this.opts.stableCoreToolIds?.length) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "set_stable_core_tools",
+                    tool_ids: this.opts.stableCoreToolIds,
+                });
+            }
+            if (this.opts.dreamStore && this.opts.agentId) {
+                await this.commitKernelApply(runtime, this.pendingObservations, { kind: "set_memory_enabled", enabled: true });
+            }
+            // Install optional memory policy. Maps the ergonomic camelCase option onto the kernel's
+            // snake_case `set_memory_policy` event; omitted fields fall back to kernel defaults.
+            if (this.opts.memoryPolicy) {
+                const m = this.opts.memoryPolicy;
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "set_memory_policy",
+                    ...(m.memoryPath !== undefined ? { memory_path: m.memoryPath } : {}),
+                    ...(m.staleWarningDays !== undefined ? { stale_warning_days: m.staleWarningDays } : {}),
+                    ...(m.retrievalTopK !== undefined ? { retrieval_top_k: m.retrievalTopK } : {}),
+                    ...(m.validationEnabled !== undefined ? { validation_enabled: m.validationEnabled } : {}),
+                    ...(m.maxContentBytes !== undefined ? { max_content_bytes: m.maxContentBytes } : {}),
+                    ...(m.maxNameLength !== undefined ? { max_name_length: m.maxNameLength } : {}),
+                });
+            }
+            if (this.opts.knowledgeSource) {
+                await this.commitKernelApply(runtime, this.pendingObservations, { kind: "set_knowledge_enabled", enabled: true });
+            }
+            if (this.opts.milestoneContract) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "load_milestone_contract",
+                    contract: {
+                        phases: this.opts.milestoneContract.phases.map(p => ({
+                            id: p.id,
+                            criteria: p.criteria ?? [],
+                            unlocks: p.unlocks ?? [],
+                            required_evidence: p.requiredEvidence ?? [],
+                            ...(p.verifier ? { verifier: p.verifier } : {}),
+                        })),
+                    },
+                });
+            }
+            const maxBytes = runtime.recoveryContentBytes();
+            if (priorEvents && priorEvents.length > 0) {
+                const repaired = repairEventsForRecovery(priorEvents, maxBytes);
+                seedProviderReplayFromEvents(this.opts.provider, repaired);
+                const loadArchive = this.opts.compressionStore
+                    ? (ref) => this.opts.compressionStore.read(ref)
+                    : undefined;
+                const replayed = await replayMessagesAsync(repaired, maxBytes, loadArchive);
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "preload_history",
+                    messages: replayed.map(messageToKernelMessage),
+                });
+                // P1-B B3: rebuild active-skill gating after a wake by re-emitting SkillActivated for each
+                // `skill` tool call in the replayed history (active_skills is not snapshotted — graceful).
+                // The catalog (set_available_skills) was already fed above, so allowed_tools resolves.
+                // `knowledge` isn't snapshotted either (same graceful-reset philosophy) — best-effort re-push
+                // the skill's content from its replayed tool_result so the durable copy survives a wake too.
+                const toolResultByCallId = new Map();
+                for (const m of replayed) {
+                    for (const part of m.contentParts ?? []) {
+                        if (part.type === "tool_result")
+                            toolResultByCallId.set(part.callId, part.output);
+                    }
+                }
+                for (const m of replayed) {
+                    for (const tc of m.toolCalls ?? []) {
+                        if (tc.name !== "skill")
                             continue;
-                        kernelApply(runtime, this.pendingObservations, {
-                            kind: "skill_activated",
-                            name,
-                            ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
-                        });
-                        const output = toolResultByCallId.get(tc.id);
-                        if (output && !this.knowledgePushedSkills.has(name)) {
-                            this.knowledgePushedSkills.add(name);
-                            // K1: keyed — the kernel-side upsert is the authoritative dedup, so a wake re-push
-                            // of a skill already pinned live can never double-pin (the in-run Set resets with
-                            // each runner instance; the key does not).
-                            this.pushKnowledge({ role: "system", content: output, toolCalls: [] }, undefined, { key: `skill:${name}` });
+                        try {
+                            const name = JSON.parse(tc.arguments || "{}").name;
+                            if (!name)
+                                continue;
+                            await this.commitKernelApply(runtime, this.pendingObservations, {
+                                kind: "skill_activated",
+                                name,
+                                ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
+                            });
+                            const output = toolResultByCallId.get(tc.id);
+                            if (output && !this.knowledgePushedSkills.has(name)) {
+                                this.knowledgePushedSkills.add(name);
+                                // K1: keyed — the kernel-side upsert is the authoritative dedup, so a wake re-push
+                                // of a skill already pinned live can never double-pin (the in-run Set resets with
+                                // each runner instance; the key does not).
+                                await this.pushKnowledge({ role: "system", content: output, toolCalls: [] }, undefined, { key: `skill:${name}` });
+                            }
                         }
+                        catch { /* malformed skill args — skip */ }
                     }
-                    catch { /* malformed skill args — skip */ }
                 }
             }
-        }
-        const sessionStart = Date.now();
-        const startPayload = {
-            kind: "start_run",
-            task: { goal, criteria },
-        };
-        // P0-A: lower an explicit `runSpec` and/or the `allowedToolIds` profile to the kernel's
-        // `capability_filter`. `allowedToolIds` augments an explicit spec's filter, else synthesizes
-        // a minimal top-level spec carrying just the filter (reuses the existing run_spec wire — no
-        // new ABI). Unset on both ⇒ no run_spec ⇒ no gating (铁律: no config = old behavior).
-        const allowedToolIds = this.opts.allowedToolIds;
-        const hasProfile = allowedToolIds !== undefined && allowedToolIds.length > 0;
-        if (this.opts.runSpec || hasProfile) {
-            const baseSpec = this.opts.runSpec ?? {
-                identity: { agentId: this.opts.agentId ?? "root", sessionId, isSubAgent: false },
-                role: "custom",
-                goal,
+            const sessionStart = Date.now();
+            const startPayload = {
+                kind: "start_run",
+                task: { goal, criteria },
             };
-            const spec = hasProfile
-                ? { ...baseSpec, capabilityFilter: { ...baseSpec.capabilityFilter, allowedIds: allowedToolIds } }
-                : baseSpec;
-            startPayload.run_spec = agentRunSpecToKernel(spec);
-        }
-        // L1: seed the kernel with the group's cumulative spend so the run-level token cap + cumulative
-        // spawn cap span the whole governance domain (other members' prior spend). No group ⇒ per-run.
-        // Also register this session as a member so the run's lineage (R2) spans personas/invocations.
-        let groupLedger;
-        if (this.opts.runGroup) {
-            const g = this.opts.runGroup;
-            groupLedger = await g.budgetStore.read(g.id);
-            await g.budgetStore.join(g.id, { sessionId, role: this.opts.agentId, kind: "vehicle" });
-        }
-        this.applyKernelPolicies(runtime, groupLedger?.tokensSpent, groupLedger?.subagentsSpawned, groupLedger?.roundsCompleted);
-        // Multimodal upload: seed the user's attachments (images/audio) as a history
-        // message before start_run pushes the "[TASK STATE]" anchor. init_task does not
-        // clear history, so order becomes [attachment user msg, "Proceed…"] — both land
-        // in the first render. On resume the message is already in the replayed history.
-        if (!resumeMidRun && attachments?.length) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "add_history_message",
-                message: attachmentsToKernelMessage(attachments),
-            });
-        }
-        // I4: pre-fetch memory before the first LLM turn so the model sees it on turn 1 instead of
-        // discovering it via the `memory` tool on turn 3+. Skipped on resumes (already in prior
-        // context) and when dreamStore/agentId is absent.
-        //
-        // Strict dynamic context control: this is single-use retrieval content (facts relevant to
-        // THIS run's goal right now), not a stable method/skill — so it lands in `history` as an
-        // ordinary turn, exactly like a real `memory` tool result would, and decays with the
-        // compression pyramid over subsequent turns instead of pinning itself in `knowledge` forever.
-        this.currentGoal = goal;
-        if (!resumeMidRun) {
-            await this.prefetchMemoryIntoHistory(runtime, "initial");
-        }
-        let action = resumeMidRun
-            ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
-            : kernelAction(runtime, this.pendingObservations, startPayload);
-        // P0-C: the skill loaded and in effect going into the current turn (updated when the model's
-        // `skill` tool call resolves). Drives the per-turn `activeSkill` metric → dwell measurement.
-        let activeSkill;
-        // I0b: wrap the main loop so any uncaught kernel exception (typically a NAPI
-        // Status::InvalidArg from a malformed input — e.g. RuntimeSignal.source with a wrong shape,
-        // or an unrecognized event kind) is observable rather than silently propagating out of the
-        // async generator. Without this wrap the runner emits no `run_terminal` event, so downstream
-        // observability (session log, bench mechanism hooks) can't distinguish "the kernel rejected
-        // an input" from "the run is still in progress."
-        try {
-            while (!runtime.isTerminal()) {
-                nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-                this.nextArchiveStart = nextCompressedArchiveStart;
-                if (this.interrupted) {
-                    action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
-                    break;
-                }
-                if (this.opts.signalSource || this.injectedSignals.length > 0) {
-                    const sig = await this.nextInboundSignal();
-                    if (sig) {
-                        // Kernel-routed: the kernel decides disposition (dedup/queue/interrupt) and emits
-                        // `signal_disposed`. An actionable disposition yields a new action to adopt; queued/observed/
-                        // ignored yields none (kernel buffers).
-                        const sigAction = kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig));
-                        if (sigAction)
-                            action = sigAction;
-                        // I0a: a Critical-urgency signal carries user_abort intent. The kernel disposes it as
-                        // InterruptNow (forces a Reason turn) but does NOT call abortController.abort() unless
-                        // sub-agents are suspended — so the no-sub-agent path (e.g. the signal-injection bench
-                        // scenario) wouldn't otherwise set `this.interrupted`, and the eventual run_terminal would
-                        // report `reason: "error"` indistinguishable from a crash. Mark it here so the final
-                        // classification in the run_terminal emit picks `user_abort`.
-                        if (sig.urgency === "critical")
-                            this.interrupted = true;
-                    }
-                }
-                if (runtime.isTerminal())
-                    break;
-                if (action.kind === "call_provider") {
-                    // M5 v2.1: top-level auto-pivot at the safe point. If the agent authored sub-workflow(s) via
-                    // `start_workflow`, drive each in THIS kernel now (the kernel is in Reason / `call_provider`,
-                    // NOT suspended — driving mid-suspend would clobber the single-slot suspend state), inject the
-                    // outcome into context, and re-render. Loop-top placement (vs only after `tool_results`) catches
-                    // EVERY path to `call_provider` — including resuming after an approval gate — so a queued spec
-                    // is never stranded. Drains the queue; fires once per authored batch.
-                    if (this.pendingAuthoredWorkflows.length > 0) {
-                        action = await this.driveAuthoredWorkflows(runtime, action);
+            // P0-A: lower an explicit `runSpec` and/or the `allowedToolIds` profile to the kernel's
+            // `capability_filter`. `allowedToolIds` augments an explicit spec's filter, else synthesizes
+            // a minimal top-level spec carrying just the filter (reuses the existing run_spec wire — no
+            // new ABI). Unset on both ⇒ no run_spec ⇒ no gating (铁律: no config = old behavior).
+            const allowedToolIds = this.opts.allowedToolIds;
+            const hasProfile = allowedToolIds !== undefined && allowedToolIds.length > 0;
+            if (this.opts.runSpec || hasProfile) {
+                const baseSpec = this.opts.runSpec ?? {
+                    identity: { agentId: this.opts.agentId ?? "root", sessionId, isSubAgent: false },
+                    role: "custom",
+                    goal,
+                };
+                const spec = hasProfile
+                    ? { ...baseSpec, capabilityFilter: { ...baseSpec.capabilityFilter, allowedIds: allowedToolIds } }
+                    : baseSpec;
+                startPayload.run_spec = agentRunSpecToKernel(spec);
+            }
+            // Reserve capacity before start_run. The kernel enforces only this vehicle's grant and reports
+            // exact terminal usage against the same opaque reservation identity.
+            if (this.opts.runGroup) {
+                const g = this.opts.runGroup;
+                groupBudgetScope = await GroupBudgetScope.open(g, { sessionId, role: this.opts.agentId, kind: "vehicle" }, this.groupBudgetRequest());
+                this.activeGroupBudgetScope = groupBudgetScope;
+            }
+            await this.applyKernelPolicies(runtime, groupBudgetScope);
+            // Multimodal upload: seed the user's attachments (images/audio) as a history
+            // message before start_run pushes the "[TASK STATE]" anchor. init_task does not
+            // clear history, so order becomes [attachment user msg, "Proceed…"] — both land
+            // in the first render. On resume the message is already in the replayed history.
+            if (!resumeMidRun && attachments?.length) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "add_history_message",
+                    message: attachmentsToKernelMessage(attachments),
+                });
+            }
+            // I4: pre-fetch memory before the first LLM turn so the model sees it on turn 1 instead of
+            // discovering it via the `memory` tool on turn 3+. Skipped on resumes (already in prior
+            // context) and when dreamStore/agentId is absent.
+            //
+            // Strict dynamic context control: this is single-use retrieval content (facts relevant to
+            // THIS run's goal right now), not a stable method/skill — so it lands in `history` as an
+            // ordinary turn, exactly like a real `memory` tool result would, and decays with the
+            // compression pyramid over subsequent turns instead of pinning itself in `knowledge` forever.
+            this.currentGoal = goal;
+            if (!resumeMidRun) {
+                await this.prefetchMemoryIntoHistory(runtime, "initial");
+            }
+            let action = resumeMidRun
+                ? await this.commitKernelAction(runtime, this.pendingObservations, { kind: "resume" })
+                : await this.commitKernelAction(runtime, this.pendingObservations, startPayload);
+            // P0-C: the skill loaded and in effect going into the current turn (updated when the model's
+            // `skill` tool call resolves). Drives the per-turn `activeSkill` metric → dwell measurement.
+            let activeSkill;
+            // I0b: wrap the main loop so any uncaught kernel exception (typically a NAPI
+            // Status::InvalidArg from a malformed input — e.g. RuntimeSignal.source with a wrong shape,
+            // or an unrecognized event kind) is observable rather than silently propagating out of the
+            // async generator. Without this wrap the runner emits no `run_terminal` event, so downstream
+            // observability (session log, bench mechanism hooks) can't distinguish "the kernel rejected
+            // an input" from "the run is still in progress."
+            try {
+                while (!runtime.isTerminal()) {
+                    nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart, taskScope);
+                    this.nextArchiveStart = nextCompressedArchiveStart;
+                    if (this.interrupted) {
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "cancel_operation",
+                            reason: this.cancellationReason ?? "user",
+                            pending_call_ids: pendingCallIds(action),
+                        });
+                        break;
                     }
-                    const finalToolCalls = [];
-                    let finalText = "";
-                    // I5: governance schema-level pre-filter. When a declarative GovernancePolicy is loaded
-                    // and `surfaceDeniedInSystem !== false`, drop denied tools from the schema BEFORE the
-                    // model sees them — the model can't plan a call it doesn't know about, so the rollback
-                    // overhead disappears. The list of denied names is appended to systemKnowledge so the
-                    // model knows not to plan around them.
-                    let context = action.context;
-                    let tools = action.tools;
-                    if (this.opts.governancePolicy && this.opts.governancePolicy.surfaceDeniedInSystem !== false) {
-                        const { allowed, denied } = governanceFilterSchema(tools, this.opts.governancePolicy);
-                        if (denied.length > 0) {
-                            tools = allowed;
-                            const note = `[governance] the following tools are denied for this run and will fail if called: ${denied.join(", ")}.`;
-                            context = {
-                                ...context,
-                                systemKnowledge: context.systemKnowledge
-                                    ? `${context.systemKnowledge}\n\n${note}`
-                                    : note,
-                            };
+                    if (this.opts.signalSource || this.injectedSignals.length > 0) {
+                        const delivery = await this.nextInboundSignal();
+                        if (delivery) {
+                            // Kernel-routed: the kernel decides disposition (dedup/queue/interrupt) and emits
+                            // `signal_delivery_disposed`. An actionable disposition yields a new action to adopt; queued/observed/
+                            // ignored yields none (kernel buffers).
+                            const sigAction = await this.consumeInboundSignal(delivery, sig => this.commitKernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig)));
+                            if (sigAction)
+                                action = sigAction;
+                            // A critical signal is a kernel attention/preemption decision, not operation cancellation.
                         }
                     }
-                    let turnTokens = 0;
-                    let turnInputTokens = 0;
-                    let turnOutputTokens = 0;
-                    let turnCacheReadTokens = 0;
-                    let turnCacheCreationTokens = 0;
-                    let turnCacheReadBySlot;
-                    let turnStopReason;
-                    const abortSignal = this.abortController?.signal;
-                    try {
-                        for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
-                            // #2-B-ii: a preempting `interrupt()` fires `abortController` — stop consuming the live
-                            // stream immediately (providers that forward `signal` also abort the socket; the rest at
-                            // least stop here at the next event). The loop-top `interrupted` check then ends the run.
-                            if (abortSignal?.aborted)
-                                break;
-                            if (evt.type === "usage") {
-                                const usageEvt = evt;
-                                turnTokens = usageEvt.totalTokens;
-                                turnInputTokens = usageEvt.inputTokens ?? 0;
-                                turnOutputTokens = usageEvt.outputTokens ?? 0;
-                                // P0-C: capture the prompt-cache split for the tool-gating hit-rate baseline.
-                                turnCacheReadTokens = usageEvt.cacheReadInputTokens ?? 0;
-                                turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
-                                // I1: per-slot attribution forwarded into TurnMetrics. Undefined when the provider
-                                // doesn't honor cache_control (OpenAI-family auto-cache).
-                                turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
-                                // Phase 4: stop_reason drives the kernel's max-output-tokens recovery. The closing
-                                // usage frame carries it; keep the last non-empty value seen this turn.
-                                if (usageEvt.stopReason)
-                                    turnStopReason = usageEvt.stopReason;
-                                continue;
+                    if (runtime.isTerminal())
+                        break;
+                    if (action.kind === "call_provider") {
+                        // M5 v2.1: top-level auto-pivot at the safe point. If the agent authored sub-workflow(s) via
+                        // `start_workflow`, drive each in THIS kernel now (the kernel is in Reason / `call_provider`,
+                        // NOT suspended — driving mid-suspend would clobber the single-slot suspend state), inject the
+                        // outcome into context, and re-render. Loop-top placement (vs only after `tool_results`) catches
+                        // EVERY path to `call_provider` — including resuming after an approval gate — so a queued spec
+                        // is never stranded. Drains the queue; fires once per authored batch.
+                        if (this.pendingAuthoredWorkflows.length > 0) {
+                            action = await this.driveAuthoredWorkflows(runtime, action);
+                        }
+                        const providerEffectId = action.effectId;
+                        const finalToolCalls = [];
+                        let finalText = "";
+                        // I5: governance schema-level pre-filter. When a declarative GovernancePolicy is loaded
+                        // and `surfaceDeniedInSystem !== false`, drop denied tools from the schema BEFORE the
+                        // model sees them — the model can't plan a call it doesn't know about, so the rollback
+                        // overhead disappears. The list of denied names is appended to systemKnowledge so the
+                        // model knows not to plan around them.
+                        let context = action.context;
+                        let tools = action.tools;
+                        if (this.opts.governancePolicy && this.opts.governancePolicy.surfaceDeniedInSystem !== false) {
+                            const { allowed, denied } = governanceFilterSchema(tools, this.opts.governancePolicy);
+                            if (denied.length > 0) {
+                                tools = allowed;
+                                const note = `[governance] the following tools are denied for this run and will fail if called: ${denied.join(", ")}.`;
+                                context = {
+                                    ...context,
+                                    systemKnowledge: context.systemKnowledge
+                                        ? `${context.systemKnowledge}\n\n${note}`
+                                        : note,
+                                };
                             }
-                            yield evt;
-                            if (evt.type === "text_delta")
-                                finalText += evt.delta;
-                            else if (evt.type === "tool_call") {
-                                const tc = evt;
-                                finalToolCalls.push({ id: tc.id, name: tc.name, arguments: JSON.stringify(tc.arguments) });
+                        }
+                        let turnTokens = 0;
+                        let turnInputTokens = 0;
+                        let turnOutputTokens = 0;
+                        let turnCacheReadTokens = 0;
+                        let turnCacheCreationTokens = 0;
+                        let turnCacheReadBySlot;
+                        let turnStopReason;
+                        const abortSignal = this.abortController?.signal;
+                        try {
+                            for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
+                                // #2-B-ii: a preempting `interrupt()` fires `abortController` — stop consuming the live
+                                // stream immediately (providers that forward `signal` also abort the socket; the rest at
+                                // least stop here at the next event). The loop-top `interrupted` check then ends the run.
+                                if (abortSignal?.aborted)
+                                    break;
+                                if (evt.type === "usage") {
+                                    const usageEvt = evt;
+                                    turnTokens = usageEvt.totalTokens;
+                                    turnInputTokens = usageEvt.inputTokens ?? 0;
+                                    turnOutputTokens = usageEvt.outputTokens ?? 0;
+                                    // P0-C: capture the prompt-cache split for the tool-gating hit-rate baseline.
+                                    turnCacheReadTokens = usageEvt.cacheReadInputTokens ?? 0;
+                                    turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
+                                    // I1: per-slot attribution forwarded into TurnMetrics. Undefined when the provider
+                                    // doesn't honor cache_control (OpenAI-family auto-cache).
+                                    turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                    // Phase 4: stop_reason drives the kernel's max-output-tokens recovery. The closing
+                                    // usage frame carries it; keep the last non-empty value seen this turn.
+                                    if (usageEvt.stopReason)
+                                        turnStopReason = usageEvt.stopReason;
+                                    continue;
+                                }
+                                yield evt;
+                                if (evt.type === "text_delta")
+                                    finalText += evt.delta;
+                                else if (evt.type === "tool_call") {
+                                    const tc = evt;
+                                    finalToolCalls.push({ id: tc.id, name: tc.name, arguments: JSON.stringify(tc.arguments) });
+                                }
                             }
                         }
-                    }
-                    catch (err) {
-                        if (abortSignal?.aborted) {
-                            // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat it as an
-                            // interrupt (the post-stream `aborted` check below converts it to a clean
-                            // timeout/UserAbort), not a crash or a provider error.
-                            this.interrupted = true;
+                        catch (err) {
+                            if (abortSignal?.aborted) {
+                                // External I/O is already stopped; the post-stream branch commits cancellation.
+                                this.interrupted = true;
+                                this.cancellationReason ??= "user";
+                            }
+                            else {
+                                // Reactive recovery is now a kernel decision. Forward the raw provider error and
+                                // dispatch whatever the kernel returns: `call_provider` to retry with a freshly
+                                // compacted context, or `done` to terminate with an honest `ContextOverflow`. The
+                                // classify + compact + retry + give-up policy lives in the kernel (one place), not
+                                // duplicated across the four SDK runners. `continue` re-enters the loop: a recovered
+                                // turn persists its compaction archive via the loop-top appendObservations, and a
+                                // terminal `done` exits through `isTerminal()` into the run_terminal emit below.
+                                action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                                    kind: "provider_error",
+                                    effect_id: providerEffectId,
+                                    message: formatToolError(err),
+                                });
+                                // Withholding (query.ts parity): surface the raw provider error only when the kernel
+                                // could NOT recover (it returned a terminal). On a recovered retry (`call_provider`)
+                                // the error stays hidden, so embedders that terminate on `error` events don't see a
+                                // phantom failure mid-recovery.
+                                if (action.kind === "done") {
+                                    yield { type: "error", message: formatToolError(err) };
+                                }
+                                continue;
+                            }
                         }
-                        else {
-                            // Reactive recovery is now a kernel decision. Forward the raw provider error and
-                            // dispatch whatever the kernel returns: `call_provider` to retry with a freshly
-                            // compacted context, or `done` to terminate with an honest `ContextOverflow`. The
-                            // classify + compact + retry + give-up policy lives in the kernel (one place), not
-                            // duplicated across the four SDK runners. `continue` re-enters the loop: a recovered
-                            // turn persists its compaction archive via the loop-top appendObservations, and a
-                            // terminal `done` exits through `isTerminal()` into the run_terminal emit below.
-                            action = kernelAction(runtime, this.pendingObservations, {
-                                kind: "provider_error",
-                                message: formatToolError(err),
+                        // Do not commit partial provider output after host cancellation.
+                        if (abortSignal?.aborted) {
+                            action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                                kind: "cancel_operation",
+                                reason: this.cancellationReason ?? "user",
+                                pending_call_ids: [providerEffectId],
                             });
-                            // Withholding (query.ts parity): surface the raw provider error only when the kernel
-                            // could NOT recover (it returned a terminal). On a recovered retry (`call_provider`)
-                            // the error stays hidden, so embedders that terminate on `error` events don't see a
-                            // phantom failure mid-recovery.
-                            if (action.kind === "done") {
-                                yield { type: "error", message: formatToolError(err) };
+                            break;
+                        }
+                        const assistantMessage = {
+                            role: "assistant",
+                            content: finalText,
+                            toolCalls: finalToolCalls,
+                            tokenCount: turnOutputTokens || turnTokens || undefined,
+                        };
+                        const providerEvent = {
+                            kind: "provider_result",
+                            effect_id: providerEffectId,
+                            message: messageToKernelMessage(assistantMessage),
+                            ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
+                            ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
+                            now_ms: Date.now(),
+                            ...(turnStopReason ? { stop_reason: turnStopReason } : {}),
+                        };
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, providerEvent);
+                        const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
+                        await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
+                            turn: runtime.turn(),
+                            content: finalText,
+                            tokenCount: turnOutputTokens || turnTokens || undefined,
+                            toolCalls: finalToolCalls,
+                            providerReplay,
+                        }));
+                        // P0-C: emit per-turn tool-gating telemetry. `activeSkill` reflects the skill in effect
+                        // GOING INTO this turn; a `skill` call here only takes effect next turn, so emit first, then
+                        // advance. Wrapped so a faulty sink can never break the run (pure observation).
+                        if (this.opts.onTurnMetrics) {
+                            try {
+                                this.opts.onTurnMetrics({
+                                    turn: runtime.turn(),
+                                    toolsExposed: tools.length,
+                                    toolsCalled: finalToolCalls.length,
+                                    activeSkill,
+                                    inputTokens: turnInputTokens,
+                                    cacheReadTokens: turnCacheReadTokens,
+                                    cacheCreationTokens: turnCacheCreationTokens,
+                                    ...(turnCacheReadBySlot ? { cacheReadTokensBySlot: turnCacheReadBySlot } : {}),
+                                });
                             }
-                            continue;
+                            catch { /* metrics must never break the run */ }
+                        }
+                        const skillCall = finalToolCalls.find(c => c.name === "skill");
+                        if (skillCall) {
+                            try {
+                                const name = JSON.parse(skillCall.arguments || "{}").name;
+                                if (name)
+                                    activeSkill = name;
+                            }
+                            catch { /* malformed skill args — leave activeSkill unchanged */ }
                         }
                     }
-                    // #2-B-ii: stream aborted (preempt/interrupt) via the break path (provider yielded no error) —
-                    // end the turn now with a timeout so the kernel terminates the run, rather than feeding the
-                    // partial assistant output as a normal turn.
-                    if (abortSignal?.aborted) {
-                        action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
-                        break;
-                    }
-                    const assistantMessage = {
-                        role: "assistant",
-                        content: finalText,
-                        toolCalls: finalToolCalls,
-                        tokenCount: turnOutputTokens || turnTokens || undefined,
-                    };
-                    const providerEvent = {
-                        kind: "provider_result",
-                        message: messageToKernelMessage(assistantMessage),
-                        ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
-                        ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
-                        now_ms: Date.now(),
-                        ...(turnStopReason ? { stop_reason: turnStopReason } : {}),
-                    };
-                    let nextAction = kernelMaybeAction(runtime, this.pendingObservations, providerEvent);
-                    if (!nextAction && this.pendingObservations.some(o => o.kind === "suspended")) {
-                        const resolved = await this.resolveKernelSuspend(runtime, sessionId);
-                        for (const evt of resolved.events)
-                            yield evt;
-                        nextAction = kernelAction(runtime, this.pendingObservations, {
-                            kind: "resume",
+                    else if (action.kind === "request_approval") {
+                        const resolved = await this.resolveApprovalRequests(action.requests, runtime, sessionId);
+                        for (const event of resolved.events)
+                            yield event;
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "approval_result",
+                            effect_id: action.effectId,
                             approved_calls: resolved.approved,
                             denied_calls: resolved.denied,
                         });
                     }
-                    action = nextAction ?? kernelAction(runtime, this.pendingObservations, providerEvent);
-                    const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
-                    await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
-                        turn: runtime.turn(),
-                        content: finalText,
-                        tokenCount: turnOutputTokens || turnTokens || undefined,
-                        toolCalls: finalToolCalls,
-                        providerReplay,
-                    }));
-                    // P0-C: emit per-turn tool-gating telemetry. `activeSkill` reflects the skill in effect
-                    // GOING INTO this turn; a `skill` call here only takes effect next turn, so emit first, then
-                    // advance. Wrapped so a faulty sink can never break the run (pure observation).
-                    if (this.opts.onTurnMetrics) {
+                    else if (action.kind === "persist_memory") {
+                        let error;
+                        const agentId = this.opts.agentId;
                         try {
-                            this.opts.onTurnMetrics({
-                                turn: runtime.turn(),
-                                toolsExposed: tools.length,
-                                toolsCalled: finalToolCalls.length,
-                                activeSkill,
-                                inputTokens: turnInputTokens,
-                                cacheReadTokens: turnCacheReadTokens,
-                                cacheCreationTokens: turnCacheCreationTokens,
-                                ...(turnCacheReadBySlot ? { cacheReadTokensBySlot: turnCacheReadBySlot } : {}),
-                            });
+                            if (!agentId)
+                                throw new Error("memory persistence requires RuntimeOptions.agentId");
+                            await this.persistMemoryToStore(action.memory, agentId);
+                        }
+                        catch (cause) {
+                            error = formatToolError(cause);
                         }
-                        catch { /* metrics must never break the run */ }
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "memory_persist_result",
+                            effect_id: action.effectId,
+                            ...(error ? { error } : {}),
+                        });
                     }
-                    const skillCall = finalToolCalls.find(c => c.name === "skill");
-                    if (skillCall) {
+                    else if (action.kind === "query_memory") {
+                        const query = action.query;
+                        let hits = [];
+                        let error;
+                        const agentId = this.opts.agentId;
                         try {
-                            const name = JSON.parse(skillCall.arguments || "{}").name;
-                            if (name)
-                                activeSkill = name;
+                            if (!agentId)
+                                throw new Error("memory queries require RuntimeOptions.agentId");
+                            hits = await this.retrieveMemoryFromStore(query, action.requestedK, agentId);
                         }
-                        catch { /* malformed skill args — leave activeSkill unchanged */ }
-                    }
-                }
-                else if (action.kind === "execute_tool") {
-                    const allCalls = action.calls;
-                    await this.opts.sessionLog.append(sessionId, { kind: "tool_requested", turn: runtime.turn(), calls: allCalls });
-                    const runCtx = {
-                        agentId: this.opts.agentId,
-                        skillDir: this.opts.skillDir,
-                        dreamStore: this.opts.dreamStore,
-                        knowledgeSource: this.opts.knowledgeSource,
-                        onToolSuspend: this.opts.onToolSuspend,
-                        onPermissionRequest: this.opts.onPermissionRequest,
-                        resultSpool: this.opts.resultSpool ?? new LargeResultSpool(),
-                    };
-                    const toolResults = [];
-                    const normalCalls = allCalls.filter(c => c.name !== "update_plan" && c.name !== "submit_workflow_nodes" && c.name !== "start_workflow"
-                        && c.name !== "read_result");
-                    const planCalls = allCalls.filter(c => c.name === "update_plan");
-                    // M5 v1: `start_workflow` (author a sub-workflow) flattens to the same append path as
-                    // `submit_workflow_nodes` — a `WorkflowSpec` is a node batch. (v2 adds top-level bootstrap.)
-                    const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes" || c.name === "start_workflow");
-                    // O7: `read_result` re-fetches a tool output the kernel evicted from context. Content is
-                    // host-resolved: (a) this turn's in-memory pending spool map, (b) the on-disk result spool
-                    // (persisted once the kernel observes `large_result_spooled`), (c) a session-log scan for
-                    // the original `tool_completed` event. The kernel only advertises the capability.
-                    const readResultCalls = allCalls.filter(c => c.name === "read_result");
-                    for (const call of planCalls) {
-                        const update = parseUpdatePlanArgs(call.arguments);
-                        kernelApply(runtime, this.pendingObservations, {
-                            kind: "update_task",
-                            update: taskUpdateToKernel(update),
+                        catch (cause) {
+                            error = formatToolError(cause);
+                        }
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "memory_query_result",
+                            effect_id: action.effectId,
+                            hits,
+                            ...(error ? { error } : {}),
                         });
-                        const result = { callId: call.id, output: "success", isError: false };
-                        toolResults.push(result);
-                        yield { type: "tool_result", callId: call.id, content: "success", isError: false };
+                        if (!error)
+                            await this.logMemoryRetrievalResult(sessionId, hits);
                     }
-                    for (const call of readResultCalls) {
-                        const out = await this.resolveReadResult(sessionId, call.arguments);
-                        toolResults.push({ callId: call.id, output: out.text, isError: out.isError });
-                        yield { type: "tool_result", callId: call.id, content: out.text, isError: out.isError };
-                    }
-                    // R3-1: `submit_workflow_nodes` cannot be applied to this runner's kernel — when this runner
-                    // is a workflow node, the workflow lives in the *parent* kernel. Surface the requested nodes
-                    // as a stream event; the orchestrator collects them onto the node's result and `runWorkflow`
-                    // sends `submit_workflow_nodes` to the parent kernel. (When not a workflow node, the event is
-                    // simply unconsumed — a no-op.)
-                    for (const call of submitCalls) {
-                        // M5 v2.1: a TOP-LEVEL agent authoring a whole sub-workflow via `start_workflow` — record the
-                        // full spec and AUTO-PIVOT once this tool turn resolves (the loop drives it in this kernel and
-                        // injects the outcome). A workflow-NODE's `start_workflow` (and every `submit_workflow_nodes`)
-                        // instead FLATTENS: the batch is surfaced for the parent `runWorkflow` to append.
-                        if (call.name === "start_workflow" && !this.opts.isWorkflowNode) {
-                            const spec = parseStartWorkflowSpec(call.arguments);
-                            if (spec) {
-                                this.pendingAuthoredWorkflows.push(spec);
-                                const out = "workflow authored; executing now";
-                                toolResults.push({ callId: call.id, output: out, isError: false });
-                                yield { type: "tool_result", callId: call.id, content: out, isError: false };
-                                continue;
-                            }
+                    else if (action.kind === "spool_large_result") {
+                        const spool = this.opts.resultSpool ?? new LargeResultSpool();
+                        let spoolRef;
+                        let error;
+                        try {
+                            spoolRef = await spool.persistOutput(action.callId, action.output);
+                        }
+                        catch (cause) {
+                            error = formatToolError(cause);
                         }
-                        // `start_workflow` wraps the batch as `{ spec: { nodes } }`; `submit_workflow_nodes` is `{ nodes }`.
-                        const nodes = call.name === "start_workflow"
-                            ? parseStartWorkflowArgs(call.arguments)
-                            : parseSubmitWorkflowNodesArgs(call.arguments);
-                        yield { type: "workflow_nodes_submitted", nodes };
-                        const result = { callId: call.id, output: "submitted", isError: false };
-                        toolResults.push(result);
-                        yield { type: "tool_result", callId: call.id, content: "submitted", isError: false };
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "large_result_spool_result",
+                            effect_id: action.effectId,
+                            ...(spoolRef ? { spool_ref: spoolRef } : {}),
+                            ...(error ? { error } : {}),
+                        });
                     }
-                    // O5 (PreToolUse-hook analog): give the host a STATEFUL veto over each kernel-approved
-                    // call. A blocked call never executes; its reason reaches the model as a governance-denied
-                    // tool result (the kernel rolls the turn back with the note). Errs-open on hook throw.
-                    let executableCalls = normalCalls;
-                    if (this.opts.onToolCall) {
-                        const allowed = [];
-                        for (const call of normalCalls) {
-                            let decision;
-                            try {
-                                decision = await this.opts.onToolCall({ callId: call.id, name: call.name, arguments: call.arguments });
+                    else if (action.kind === "archive_page_out") {
+                        const archiveMeta = this.activePageOutArchive
+                            ?? this.pendingPageOutArchives.shift()
+                            ?? {
+                                archiveStart: this.nextArchiveStart,
+                                compressedSeq: await this.opts.sessionLog.latestSeq(sessionId),
+                            };
+                        this.activePageOutArchive = archiveMeta;
+                        let archiveRef;
+                        let error;
+                        try {
+                            if (this.opts.compressionStore) {
+                                const ref = await this.opts.compressionStore.write(sessionId, archiveMeta.archiveStart, action.archived);
+                                if (ref)
+                                    archiveRef = ref;
                             }
-                            catch {
-                                decision = undefined;
+                        }
+                        catch (cause) {
+                            error = formatToolError(cause);
+                        }
+                        const archived = action.archived;
+                        const archiveAction = compressionAction(action.action) ?? "auto_compact";
+                        const archiveTier = action.tier;
+                        const compressedSeq = archiveMeta.compressedSeq;
+                        if (!error)
+                            this.activePageOutArchive = undefined;
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "page_out_archive_result",
+                            effect_id: action.effectId,
+                            ...(archiveRef ? { archive_ref: archiveRef } : {}),
+                            ...(error ? { error } : {}),
+                        });
+                        if (!error) {
+                            if (this.opts.asyncSummarizer && archived.length > 0) {
+                                const upgrade = () => this.upgradeCompressedSummary(sessionId, compressedSeq, archived, archiveAction);
+                                taskScope.spawn("compressed-summary-upgrade", upgrade);
                             }
-                            if (decision?.block) {
-                                const reason = decision.reason ?? "blocked by host onToolCall hook";
-                                yield { type: "tool_denied", callId: call.id, toolName: call.name, reason };
-                                await this.opts.sessionLog.append(sessionId, {
-                                    kind: "tool_denied", turn: runtime.turn(), call_id: call.id, tool_name: call.name, reason,
-                                });
-                                const out = `blocked by host hook: ${reason}`;
-                                toolResults.push({ callId: call.id, output: out, isError: true, errorKind: "governance_denied" });
-                                yield { type: "tool_result", callId: call.id, name: call.name, content: out, isError: true };
-                                continue;
+                            if (archiveTier === "semantic" && archived.length > 0) {
+                                taskScope.spawn("semantic-page-out", () => this.archiveSemanticPageOut(archived, archiveAction, sessionId));
                             }
-                            allowed.push(call);
                         }
-                        executableCalls = allowed;
                     }
-                    if (executableCalls.length > 0) {
-                        for await (const evt of this.opts.executionPlane.executeAll(executableCalls, runCtx)) {
-                            yield evt;
-                            if (evt.type === "tool_result") {
-                                const tre = evt;
-                                toolResults.push({
-                                    callId: tre.callId,
-                                    output: tre.content,
-                                    isError: tre.isError,
-                                    isFatal: tre.isFatal,
-                                    errorKind: tre.errorKind,
-                                });
-                            }
-                            else if (evt.type === "tool_argument_repaired") {
-                                const tare = evt;
-                                await this.opts.sessionLog.append(sessionId, {
-                                    kind: "tool_argument_repaired",
-                                    turn: runtime.turn(),
-                                    tool: tare.name,
-                                    original_arguments: tare.originalArguments,
-                                    repaired_arguments: tare.repairedArguments,
-                                });
+                    else if (action.kind === "execute_tool") {
+                        const toolEffectId = action.effectId;
+                        const allCalls = action.calls;
+                        await this.opts.sessionLog.append(sessionId, { kind: "tool_requested", turn: runtime.turn(), calls: allCalls });
+                        const runCtx = {
+                            operation,
+                            agentId: this.opts.agentId,
+                            memoryScope: this.opts.memoryScope,
+                            skillDir: this.opts.skillDir,
+                            dreamStore: this.opts.dreamStore,
+                            knowledgeSource: this.opts.knowledgeSource,
+                            onToolSuspend: this.opts.onToolSuspend,
+                            onPermissionRequest: this.opts.onPermissionRequest,
+                            resultSpool: this.opts.resultSpool ?? new LargeResultSpool(),
+                        };
+                        const toolResults = [];
+                        const normalCalls = allCalls.filter(c => c.name !== "update_plan" && c.name !== "submit_workflow_nodes" && c.name !== "start_workflow"
+                            && c.name !== "read_result");
+                        const planCalls = allCalls.filter(c => c.name === "update_plan");
+                        // M5 v1: `start_workflow` (author a sub-workflow) flattens to the same append path as
+                        // `submit_workflow_nodes` — a `WorkflowSpec` is a node batch. (v2 adds top-level bootstrap.)
+                        const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes" || c.name === "start_workflow");
+                        // O7: `read_result` re-fetches a tool output the kernel evicted from context. Content is
+                        // host-resolved from the effect-committed spool, then from the durable session log.
+                        const readResultCalls = allCalls.filter(c => c.name === "read_result");
+                        for (const call of planCalls) {
+                            const update = parseUpdatePlanArgs(call.arguments);
+                            await this.commitKernelApply(runtime, this.pendingObservations, {
+                                kind: "update_task",
+                                update: taskUpdateToKernel(update),
+                            });
+                            const result = { callId: call.id, output: "success", isError: false };
+                            toolResults.push(result);
+                            yield { type: "tool_result", callId: call.id, content: "success", isError: false };
+                        }
+                        for (const call of readResultCalls) {
+                            const out = await this.resolveReadResult(sessionId, call.arguments);
+                            toolResults.push({ callId: call.id, output: out.text, isError: out.isError });
+                            yield { type: "tool_result", callId: call.id, content: out.text, isError: out.isError };
+                        }
+                        // R3-1: `submit_workflow_nodes` cannot be applied to this runner's kernel — when this runner
+                        // is a workflow node, the workflow lives in the *parent* kernel. Surface the requested nodes
+                        // as a stream event; the orchestrator collects them onto the node's result and `runWorkflow`
+                        // sends `submit_workflow_nodes` to the parent kernel. (When not a workflow node, the event is
+                        // simply unconsumed — a no-op.)
+                        for (const call of submitCalls) {
+                            // M5 v2.1: a TOP-LEVEL agent authoring a whole sub-workflow via `start_workflow` — record the
+                            // full spec and AUTO-PIVOT once this tool turn resolves (the loop drives it in this kernel and
+                            // injects the outcome). A workflow-NODE's `start_workflow` (and every `submit_workflow_nodes`)
+                            // instead FLATTENS: the batch is surfaced for the parent `runWorkflow` to append.
+                            if (call.name === "start_workflow" && !this.opts.isWorkflowNode) {
+                                const spec = parseStartWorkflowSpec(call.arguments);
+                                if (spec) {
+                                    this.pendingAuthoredWorkflows.push(spec);
+                                    const out = "workflow authored; executing now";
+                                    toolResults.push({ callId: call.id, output: out, isError: false });
+                                    yield { type: "tool_result", callId: call.id, content: out, isError: false };
+                                    continue;
+                                }
                             }
-                            else if (evt.type === "tool_denied") {
-                                const tde = evt;
-                                await this.opts.sessionLog.append(sessionId, {
-                                    kind: "tool_denied",
-                                    turn: runtime.turn(),
-                                    call_id: tde.callId,
-                                    tool_name: tde.toolName,
-                                    reason: tde.reason,
-                                });
+                            // `start_workflow` wraps the batch as `{ spec: { nodes } }`; `submit_workflow_nodes` is `{ nodes }`.
+                            const nodes = call.name === "start_workflow"
+                                ? parseStartWorkflowArgs(call.arguments)
+                                : parseSubmitWorkflowNodesArgs(call.arguments);
+                            yield { type: "workflow_nodes_submitted", nodes };
+                            const result = { callId: call.id, output: "submitted", isError: false };
+                            toolResults.push(result);
+                            yield { type: "tool_result", callId: call.id, content: "submitted", isError: false };
+                        }
+                        // O5 (PreToolUse-hook analog): give the host a STATEFUL veto over each kernel-approved
+                        // call. A blocked call never executes; its reason reaches the model as a governance-denied
+                        // tool result (the kernel rolls the turn back with the note). Decision failures are closed
+                        // unless the host explicitly marks this hook advisory with `onToolCallFailure: "open"`.
+                        let executableCalls = normalCalls;
+                        if (this.opts.onToolCall) {
+                            const allowed = [];
+                            for (const call of normalCalls) {
+                                let decision;
+                                try {
+                                    decision = await this.opts.onToolCall({ callId: call.id, name: call.name, arguments: call.arguments });
+                                }
+                                catch (cause) {
+                                    decision = this.opts.onToolCallFailure === "open"
+                                        ? undefined
+                                        : { block: true, reason: `onToolCall hook failed: ${formatToolError(cause)}` };
+                                }
+                                if (decision?.block) {
+                                    const reason = decision.reason ?? "blocked by host onToolCall hook";
+                                    yield { type: "tool_denied", callId: call.id, toolName: call.name, reason };
+                                    await this.opts.sessionLog.append(sessionId, {
+                                        kind: "tool_denied", turn: runtime.turn(), call_id: call.id, tool_name: call.name, reason,
+                                    });
+                                    const out = `blocked by host hook: ${reason}`;
+                                    toolResults.push({ callId: call.id, output: out, isError: true, errorKind: "governance_denied" });
+                                    yield { type: "tool_result", callId: call.id, name: call.name, content: out, isError: true };
+                                    continue;
+                                }
+                                allowed.push(call);
                             }
-                            else if (evt.type === "permission_request") {
-                                const pre = evt;
-                                const turn = runtime.turn();
-                                await this.opts.sessionLog.append(sessionId, {
-                                    kind: "permission_requested",
-                                    turn,
-                                    tool: pre.toolName,
-                                    arguments: pre.arguments,
-                                    reason: pre.reason,
-                                });
+                            executableCalls = allowed;
+                        }
+                        if (executableCalls.length > 0) {
+                            for await (const evt of this.opts.executionPlane.executeAll(executableCalls, runCtx)) {
+                                yield evt;
+                                if (evt.type === "tool_result") {
+                                    const tre = evt;
+                                    toolResults.push({
+                                        callId: tre.callId,
+                                        output: tre.content,
+                                        isError: tre.isError,
+                                        isFatal: tre.isFatal,
+                                        errorKind: tre.errorKind,
+                                    });
+                                }
+                                else if (evt.type === "tool_argument_repaired") {
+                                    const tare = evt;
+                                    await this.opts.sessionLog.append(sessionId, {
+                                        kind: "tool_argument_repaired",
+                                        turn: runtime.turn(),
+                                        tool: tare.name,
+                                        original_arguments: tare.originalArguments,
+                                        repaired_arguments: tare.repairedArguments,
+                                    });
+                                }
+                                else if (evt.type === "tool_denied") {
+                                    const tde = evt;
+                                    await this.opts.sessionLog.append(sessionId, {
+                                        kind: "tool_denied",
+                                        turn: runtime.turn(),
+                                        call_id: tde.callId,
+                                        tool_name: tde.toolName,
+                                        reason: tde.reason,
+                                    });
+                                }
+                                else if (evt.type === "permission_request") {
+                                    const pre = evt;
+                                    const turn = runtime.turn();
+                                    await this.opts.sessionLog.append(sessionId, {
+                                        kind: "permission_requested",
+                                        turn,
+                                        tool: pre.toolName,
+                                        arguments: pre.arguments,
+                                        reason: pre.reason,
+                                    });
+                                }
+                                else if (evt.type === "permission_resolved") {
+                                    const resolved = evt;
+                                    const turn = runtime.turn();
+                                    await this.opts.sessionLog.append(sessionId, {
+                                        kind: "permission_resolved",
+                                        turn,
+                                        approved: resolved.approved,
+                                        responder: resolved.responder,
+                                    });
+                                }
                             }
-                            else if (evt.type === "permission_resolved") {
-                                const resolved = evt;
-                                const turn = runtime.turn();
-                                await this.opts.sessionLog.append(sessionId, {
-                                    kind: "permission_resolved",
-                                    turn,
-                                    approved: resolved.approved,
-                                    responder: resolved.responder,
-                                });
+                            const names = executableCalls.map(c => c.name).join(", ");
+                            await this.commitKernelApply(runtime, this.pendingObservations, {
+                                kind: "update_task",
+                                update: taskUpdateToKernel({ progress: `Executed tools: ${names}` }),
+                            });
+                        }
+                        // O5 (PostToolUse-hook analog): let the host inspect each executed result BEFORE it
+                        // reaches the kernel/session-log — replace the output (redact/annotate) and/or push a
+                        // contextual note into the signal stream. Errs-open on hook throw.
+                        if (this.opts.onToolResult) {
+                            for (const r of toolResults) {
+                                const call = executableCalls.find(c => c.id === r.callId);
+                                if (!call)
+                                    continue; // plan/submit synthetics and hook-blocked calls are not host results
+                                let decision;
+                                try {
+                                    decision = await this.opts.onToolResult({
+                                        callId: r.callId, name: call.name, arguments: call.arguments,
+                                        output: r.output, isError: r.isError,
+                                    });
+                                }
+                                catch {
+                                    decision = undefined;
+                                }
+                                if (!decision)
+                                    continue;
+                                if (typeof decision.replaceOutput === "string")
+                                    r.output = decision.replaceOutput;
+                                if (decision.note)
+                                    this.injectNote(decision.note);
                             }
                         }
-                        const names = executableCalls.map(c => c.name).join(", ");
-                        kernelApply(runtime, this.pendingObservations, {
-                            kind: "update_task",
-                            update: taskUpdateToKernel({ progress: `Executed tools: ${names}` }),
+                        await this.opts.sessionLog.append(sessionId, {
+                            kind: "tool_completed",
+                            turn: runtime.turn(),
+                            results: toolResults.map(r => ({
+                                call_id: r.callId,
+                                output: r.output,
+                                is_error: r.isError,
+                                token_count: r.tokenCount,
+                            })),
                         });
-                    }
-                    // O5 (PostToolUse-hook analog): let the host inspect each executed result BEFORE it
-                    // reaches the kernel/session-log — replace the output (redact/annotate) and/or push a
-                    // contextual note into the signal stream. Errs-open on hook throw.
-                    if (this.opts.onToolResult) {
-                        for (const r of toolResults) {
-                            const call = executableCalls.find(c => c.id === r.callId);
-                            if (!call)
-                                continue; // plan/submit synthetics and hook-blocked calls are not host results
-                            let decision;
+                        // P1-B B3: a `skill` call that resolved successfully activates that skill in the kernel, so
+                        // the next `call_provider` narrows the toolset to its declared tools. Fed before `tool_results`
+                        // (which computes the next action). Errs-open: a failed/missing skill load doesn't activate.
+                        //
+                        // Strict dynamic context control: a skill is METHOD content — how to do something — reused
+                        // for the rest of the run, unlike a one-off memory/knowledge lookup (fact content, relevant
+                        // for the moment it's used). So its text ALSO goes into the durable `knowledge` slot here
+                        // (in addition to the ordinary tool_result already headed for `history`, where it will decay
+                        // with the compression pyramid like any other tool output — that's fine, the permanent copy
+                        // now lives in `knowledge`). First activation only (see `knowledgePushedSkills`).
+                        for (const call of allCalls) {
+                            if (call.name !== "skill")
+                                continue;
+                            const res = toolResults.find(r => r.callId === call.id);
+                            if (!res || res.isError)
+                                continue;
                             try {
-                                decision = await this.opts.onToolResult({
-                                    callId: r.callId, name: call.name, arguments: call.arguments,
-                                    output: r.output, isError: r.isError,
+                                const name = JSON.parse(call.arguments || "{}").name;
+                                if (!name)
+                                    continue;
+                                await this.commitKernelApply(runtime, this.pendingObservations, {
+                                    kind: "skill_activated",
+                                    name,
+                                    ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
                                 });
+                                // K1: keyed `skill:<name>` — the kernel-side upsert dedupes across runner instances
+                                // (wake re-push of an already-pinned skill upserts instead of duplicating). With a
+                                // lease configured, the Set optimization is skipped: an expired-then-reloaded skill
+                                // must re-pin, and only the kernel knows the lease state — its upsert dedupes anyway.
+                                if (this.opts.skillLeaseTurns !== undefined || !this.knowledgePushedSkills.has(name)) {
+                                    this.knowledgePushedSkills.add(name);
+                                    await this.pushKnowledge({ role: "system", content: res.output, toolCalls: [] }, undefined, { key: `skill:${name}` });
+                                }
                             }
-                            catch {
-                                decision = undefined;
-                            }
-                            if (!decision)
-                                continue;
-                            if (typeof decision.replaceOutput === "string")
-                                r.output = decision.replaceOutput;
-                            if (decision.note)
-                                this.injectNote(decision.note);
+                            catch { /* malformed skill args — skip activation */ }
                         }
-                    }
-                    await this.opts.sessionLog.append(sessionId, {
-                        kind: "tool_completed",
-                        turn: runtime.turn(),
-                        results: toolResults.map(r => ({
-                            call_id: r.callId,
-                            output: r.output,
-                            is_error: r.isError,
-                            token_count: r.tokenCount,
-                        })),
-                    });
-                    for (const call of normalCalls) {
-                        const result = toolResults.find(r => r.callId === call.id);
-                        if (result) {
-                            this.pendingSpoolOutputs.set(call.id, { tool: call.name, output: result.output });
+                        const entropyObsStart = this.pendingObservations.length;
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "tool_results",
+                            effect_id: toolEffectId,
+                            results: toolResults.map(toolResultToKernel),
+                        });
+                        // Surface the boundary's entropy measurement live (the heartbeat watch source) —
+                        // the session-log record lands via the normal appendObservations path.
+                        for (const obs of this.pendingObservations.slice(entropyObsStart)) {
+                            if (obs.kind === "entropy_sample") {
+                                this.lastEntropySample = entropySampleFromObservation(obs);
+                                yield { type: "entropy_sample", sample: this.lastEntropySample };
+                            }
+                            else if (obs.kind === "entropy_alert") {
+                                yield {
+                                    type: "entropy_alert",
+                                    turn: obs.turn ?? 0,
+                                    score: obs.score ?? 0,
+                                    threshold: obs.threshold ?? 0,
+                                };
+                            }
                         }
                     }
-                    // P1-B B3: a `skill` call that resolved successfully activates that skill in the kernel, so
-                    // the next `call_provider` narrows the toolset to its declared tools. Fed before `tool_results`
-                    // (which computes the next action). Errs-open: a failed/missing skill load doesn't activate.
-                    //
-                    // Strict dynamic context control: a skill is METHOD content — how to do something — reused
-                    // for the rest of the run, unlike a one-off memory/knowledge lookup (fact content, relevant
-                    // for the moment it's used). So its text ALSO goes into the durable `knowledge` slot here
-                    // (in addition to the ordinary tool_result already headed for `history`, where it will decay
-                    // with the compression pyramid like any other tool output — that's fine, the permanent copy
-                    // now lives in `knowledge`). First activation only (see `knowledgePushedSkills`).
-                    for (const call of allCalls) {
-                        if (call.name !== "skill")
-                            continue;
-                        const res = toolResults.find(r => r.callId === call.id);
-                        if (!res || res.isError)
-                            continue;
-                        try {
-                            const name = JSON.parse(call.arguments || "{}").name;
-                            if (!name)
-                                continue;
-                            kernelApply(runtime, this.pendingObservations, {
-                                kind: "skill_activated",
-                                name,
-                                ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
+                    else if (action.kind === "evaluate_milestone") {
+                        const milestoneEffectId = action.effectId;
+                        const milestonePolicy = this.opts.milestonePolicy ?? "require_verifier";
+                        if (milestonePolicy === "auto_pass") {
+                            action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                                kind: "milestone_result",
+                                effect_id: milestoneEffectId,
+                                result: milestoneCheckResultToKernel(milestoneCheckPass(action.phaseId)),
                             });
-                            // K1: keyed `skill:<name>` — the kernel-side upsert dedupes across runner instances
-                            // (wake re-push of an already-pinned skill upserts instead of duplicating). With a
-                            // lease configured, the Set optimization is skipped: an expired-then-reloaded skill
-                            // must re-pin, and only the kernel knows the lease state — its upsert dedupes anyway.
-                            if (this.opts.skillLeaseTurns !== undefined || !this.knowledgePushedSkills.has(name)) {
-                                this.knowledgePushedSkills.add(name);
-                                this.pushKnowledge({ role: "system", content: res.output, toolCalls: [] }, undefined, { key: `skill:${name}` });
-                            }
+                            this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart, taskScope);
                         }
-                        catch { /* malformed skill args — skip activation */ }
-                    }
-                    const entropyObsStart = this.pendingObservations.length;
-                    action = kernelAction(runtime, this.pendingObservations, {
-                        kind: "tool_results",
-                        results: toolResults.map(toolResultToKernel),
-                    });
-                    // Surface the boundary's entropy measurement live (the heartbeat watch source) —
-                    // the session-log record lands via the normal appendObservations path.
-                    for (const obs of this.pendingObservations.slice(entropyObsStart)) {
-                        if (obs.kind === "entropy_sample") {
-                            this.lastEntropySample = entropySampleFromObservation(obs);
-                            yield { type: "entropy_sample", sample: this.lastEntropySample };
+                        else if (this.opts.onMilestoneEvaluate) {
+                            const check = await this.opts.onMilestoneEvaluate({
+                                phaseId: action.phaseId,
+                                criteria: action.criteria,
+                                requiredEvidence: action.requiredEvidence,
+                            });
+                            action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                                kind: "milestone_result",
+                                effect_id: milestoneEffectId,
+                                result: milestoneCheckResultToKernel(check),
+                            });
+                            this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart, taskScope);
                         }
-                        else if (obs.kind === "entropy_alert") {
-                            yield {
-                                type: "entropy_alert",
-                                turn: obs.turn ?? 0,
-                                score: obs.score ?? 0,
-                                threshold: obs.threshold ?? 0,
-                            };
+                        else {
+                            this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart, taskScope);
+                            const turnsUsed = Math.max(1, runtime.turn());
+                            await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
+                                reason: "milestone_pending",
+                                turnsUsed,
+                                totalTokens: 0,
+                            }));
+                            await groupBudgetScope?.release();
+                            await taskScope.drain();
+                            yield { type: "done", iterations: turnsUsed, totalTokens: 0, status: "milestone_pending" };
+                            this.activeKernel = null;
+                            this.currentSessionId = null;
+                            return;
                         }
                     }
-                }
-                else if (action.kind === "evaluate_milestone") {
-                    const milestonePolicy = this.opts.milestonePolicy ?? "require_verifier";
-                    if (milestonePolicy === "auto_pass") {
-                        action = kernelAction(runtime, this.pendingObservations, {
-                            kind: "milestone_result",
-                            result: milestoneCheckResultToKernel(milestoneCheckPass(action.phaseId)),
-                        });
-                        this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart);
-                    }
-                    else if (this.opts.onMilestoneEvaluate) {
-                        const check = await this.opts.onMilestoneEvaluate({
-                            phaseId: action.phaseId,
-                            criteria: action.criteria,
-                            requiredEvidence: action.requiredEvidence,
-                        });
-                        action = kernelAction(runtime, this.pendingObservations, {
-                            kind: "milestone_result",
-                            result: milestoneCheckResultToKernel(check),
-                        });
-                        this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart);
-                    }
-                    else {
-                        this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart);
-                        const turnsUsed = Math.max(1, runtime.turn());
-                        await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
-                            reason: "milestone_pending",
-                            turnsUsed,
-                            totalTokens: 0,
-                        }));
-                        yield { type: "done", iterations: turnsUsed, totalTokens: 0, status: "milestone_pending" };
-                        this.activeKernel = null;
-                        this.currentSessionId = null;
-                        return;
+                    else if (action.kind === "done") {
+                        break;
                     }
                 }
-                else if (action.kind === "done") {
-                    break;
+            }
+            catch (err) {
+                // I0b: kernel rejection (or any other thrown error inside the loop) reaches us here.
+                // Classify by NAPI status code or message pattern — `invalid_arg` for surface-shape rejects,
+                // `error` for everything else — then emit run_terminal so observability sees a clean end.
+                // The yield-error path mirrors what the in-flight provider-stream catch does.
+                const errMsg = formatToolError(err);
+                const code = err.code;
+                const isInvalidArg = code === "InvalidArg" ||
+                    errMsg.toLowerCase().includes("invalidarg") ||
+                    errMsg.toLowerCase().includes("invalid argument");
+                const reason = isInvalidArg ? "invalid_arg" : "error";
+                yield { type: "error", message: errMsg };
+                try {
+                    await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
+                        reason,
+                        turnsUsed: runtime.turn() || 0,
+                        totalTokens: 0,
+                    }));
                 }
+                catch { /* session log failure must not mask the original error */ }
+                await groupBudgetScope?.release();
+                await taskScope.drain();
+                yield { type: "done", iterations: runtime.turn() || 0, totalTokens: 0, status: reason };
+                this.activeKernel = null;
+                this.currentSessionId = null;
+                this.dashboard = null;
+                return;
             }
-        }
-        catch (err) {
-            // I0b: kernel rejection (or any other thrown error inside the loop) reaches us here.
-            // Classify by NAPI status code or message pattern — `invalid_arg` for surface-shape rejects,
-            // `error` for everything else — then emit run_terminal so observability sees a clean end.
-            // The yield-error path mirrors what the in-flight provider-stream catch does.
-            const errMsg = formatToolError(err);
-            const code = err.code;
-            const isInvalidArg = code === "InvalidArg" ||
-                errMsg.toLowerCase().includes("invalidarg") ||
-                errMsg.toLowerCase().includes("invalid argument");
-            const reason = isInvalidArg ? "invalid_arg" : "error";
-            yield { type: "error", message: errMsg };
-            try {
-                await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
-                    reason,
-                    turnsUsed: runtime.turn() || 0,
-                    totalTokens: 0,
+            const result = action.kind === "done" ? action.result : undefined;
+            // I0a: when the loop exits without a clean kernel-done — typically because a hard interrupt
+            // aborted the in-flight LLM stream and the catch path sent `timeout` (which the kernel handles
+            // by injecting a rollback note and continuing, not by terminating) — preserve the preempt
+            // intent in the run_terminal reason. Without this, every interrupt-curtailed run reports
+            // `reason: "error"` and the bench / observability layer can't distinguish preemption from a
+            // genuine crash. Mirrors WASM/Python/Rust.
+            const status = result?.termination ?? "error";
+            const turnsUsed = result ? Math.max(1, result.turnsUsed) : runtime.turn() || 0;
+            const totalTokens = result?.totalTokensUsed ?? 0;
+            nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart, taskScope);
+            await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
+                reason: status,
+                turnsUsed,
+                totalTokens,
+            }));
+            if (groupBudgetScope && !groupBudgetScope.isClosed) {
+                throw new Error("kernel terminated without a correlated budget_usage_reported observation");
+            }
+            if (this.opts.dreamStore && this.opts.agentId) {
+                const newMsgs = runtime.drainNewMessages().map(m => ({
+                    role: m.role,
+                    content: m.content,
+                    contentParts: m.contentParts,
+                    tokenCount: m.tokenCount,
+                    toolCalls: m.toolCalls?.length ? m.toolCalls : undefined,
                 }));
+                if (newMsgs.length > 0) {
+                    try {
+                        const completedSession = {
+                            sessionId,
+                            agentId: this.opts.agentId,
+                            messages: newMsgs,
+                            metadata: null,
+                            createdAtMs: sessionStart,
+                            updatedAtMs: Date.now(),
+                        };
+                        await this.opts.dreamStore.saveSession(completedSession);
+                        if (this.opts.memoryScope) {
+                            const extracted = await extractSessionMemories(this.opts.dreamProvider ?? this.opts.provider, completedSession, this.opts.memoryScope, this.opts.dreamSystemPrompt);
+                            for (const memory of extracted) {
+                                await this.writeMemory(memory, { sessionId, agentId: this.opts.agentId });
+                            }
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                }
             }
-            catch { /* session log failure must not mask the original error */ }
-            yield { type: "done", iterations: runtime.turn() || 0, totalTokens: 0, status: reason };
+            await taskScope.drain();
+            yield {
+                type: "done",
+                iterations: turnsUsed,
+                totalTokens,
+                status,
+                // ③ loop-agent: surface the kernel-adjudicated after-round decision to the driver.
+                ...(result?.paceDecision ? { paceDecision: result.paceDecision } : {}),
+            };
             this.activeKernel = null;
             this.currentSessionId = null;
             this.dashboard = null;
-            return;
-        }
-        const result = action.kind === "done" ? action.result : undefined;
-        // I0a: when the loop exits without a clean kernel-done — typically because a hard interrupt
-        // aborted the in-flight LLM stream and the catch path sent `timeout` (which the kernel handles
-        // by injecting a rollback note and continuing, not by terminating) — preserve the preempt
-        // intent in the run_terminal reason. Without this, every interrupt-curtailed run reports
-        // `reason: "error"` and the bench / observability layer can't distinguish preemption from a
-        // genuine crash. Mirrors WASM/Python/Rust.
-        const status = result?.termination ?? (this.interrupted ? "user_abort" : "error");
-        const turnsUsed = result ? Math.max(1, result.turnsUsed) : runtime.turn() || 0;
-        const totalTokens = result?.totalTokensUsed ?? 0;
-        nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-        await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
-            reason: status,
-            turnsUsed,
-            totalTokens,
-        }));
-        // L1: charge this vehicle's local spend (tokens + sub-agent spawns) back to the governance domain
-        // so the next member is seeded with the updated cumulative totals.
-        if (this.opts.runGroup) {
-            const subagents = runtime.localSubagentsSpawned?.() ?? 0;
-            if (totalTokens > 0 || subagents > 0) {
-                await this.opts.runGroup.budgetStore.charge(this.opts.runGroup.id, { tokens: totalTokens, subagents });
-            }
         }
-        if (this.opts.dreamStore && this.opts.agentId) {
-            const newMsgs = runtime.drainNewMessages().map(m => ({
-                role: m.role,
-                content: m.content,
-                contentParts: m.contentParts,
-                tokenCount: m.tokenCount,
-                toolCalls: m.toolCalls?.length ? m.toolCalls : undefined,
-            }));
-            if (newMsgs.length > 0) {
-                try {
-                    await this.opts.dreamStore.saveSession({
-                        sessionId: crypto.randomUUID(),
-                        agentId: this.opts.agentId,
-                        messages: newMsgs,
-                        metadata: null,
-                        createdAtMs: sessionStart,
-                        updatedAtMs: Date.now(),
-                    });
-                }
-                catch { /* non-fatal */ }
-            }
+        finally {
+            await groupBudgetScope?.release();
+            if (taskScope.pending > 0)
+                await taskScope.cancel("run scope closed");
+            this.activeKernel = null;
+            this.currentSessionId = null;
+            this.dashboard = null;
         }
-        yield {
-            type: "done",
-            iterations: turnsUsed,
-            totalTokens,
-            status,
-            // ③ loop-agent: surface the kernel-adjudicated after-round decision to the driver.
-            ...(result?.paceDecision ? { paceDecision: result.paceDecision } : {}),
-        };
-        this.activeKernel = null;
-        this.currentSessionId = null;
-        this.dashboard = null;
     }
     /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
      *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
@@ -1883,12 +2194,17 @@ export class RuntimeRunner {
      *  after each sprint renewal (`phase: "renewal"`): renewal drops the old history INCLUDING the
      *  earlier memory hits, so the new sprint gets a fresh recall pass. Errs-open throughout. */
     async prefetchMemoryIntoHistory(runtime, phase) {
-        if (!this.opts.dreamStore || !this.opts.agentId)
+        if (!this.opts.dreamStore || !this.opts.agentId || !this.opts.memoryScope)
             return;
         // P10: recall is default-on (CC session-start recall) — with no hook configured,
         // the goal itself is the query. preQueryMemory stays as the targeting override.
         const preQuery = this.opts.preQueryMemory
-            ?? ((ctx) => [ctx.goal]);
+            ?? ((ctx) => [{
+                    scope: this.opts.memoryScope,
+                    query: ctx.goal,
+                    top_k: 5,
+                    kinds: [],
+                }]);
         try {
             const queries = await preQuery({
                 goal: this.currentGoal,
@@ -1897,15 +2213,15 @@ export class RuntimeRunner {
             });
             const lines = [];
             for (const q of queries ?? []) {
-                if (typeof q !== "string" || !q.trim())
+                if (!q.query.trim())
                     continue;
-                const hits = await this.opts.dreamStore.search(this.opts.agentId, q, 5);
+                const hits = await this.opts.dreamStore.search(this.opts.agentId, q);
                 for (const hit of hits) {
-                    lines.push(`[memory score=${hit.score.toFixed(3)}] ${hit.text}`);
+                    lines.push(`[memory record_id=${hit.record.record_id} trust=${hit.record.provenance.trust} score=${hit.score.toFixed(3)}] ${hit.record.content}`);
                 }
             }
             if (lines.length > 0) {
-                kernelApply(runtime, this.pendingObservations, {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
                     kind: "add_history_message",
                     message: { role: "user", content: lines.join("\n") },
                 });
@@ -1913,50 +2229,45 @@ export class RuntimeRunner {
         }
         catch { /* errs-open — a faulty pre-fetch never breaks the run */ }
     }
-    async appendObservations(sessionId, runtime, nextArchiveStart) {
+    async appendObservations(sessionId, runtime, nextArchiveStart, _taskScope) {
         const turn = runtime.turn();
         const preservedRefs = runtime.preservedRefs();
         const observations = this.pendingObservations.splice(0);
-        for (let obs of observations) {
+        for (const obs of observations) {
             if (obs.kind === "page_in_requested")
                 continue;
-            let archiveRef;
-            let spoolRef;
-            if (obs.kind === "compressed") {
-                const archived = obs.archived;
-                if (this.opts.compressionStore && archived && archived.length > 0) {
-                    try {
-                        const pathRef = await this.opts.compressionStore.write(sessionId, nextArchiveStart, archived);
-                        if (pathRef)
-                            archiveRef = pathRef;
-                    }
-                    catch {
-                        // non-fatal
-                    }
+            if (obs.kind === "budget_usage_reported") {
+                const scope = this.activeGroupBudgetScope;
+                if (!scope || obs.reservation_id !== scope.reservationId) {
+                    throw new Error("budget usage report does not match the active reservation");
                 }
+                await this.settleGroupBudget(scope, {
+                    tokens: obs.tokens ?? 0,
+                    subagents: obs.subagents ?? 0,
+                    rounds: obs.rounds ?? 0,
+                });
+                this.activeGroupBudgetScope = undefined;
             }
-            if (obs.kind === "large_result_spooled") {
-                const pending = this.pendingSpoolOutputs.get(obs.call_id ?? "");
-                if (pending) {
-                    const spool = this.opts.resultSpool ?? new LargeResultSpool();
-                    try {
-                        spoolRef = await spool.persistOutput(obs.call_id ?? "", pending.output);
-                    }
-                    catch {
-                        // non-fatal: preview remains in kernel context; full output still in tool_completed log
-                    }
-                    if (!obs.tool && pending.tool) {
-                        obs = { ...obs, tool: pending.tool };
-                    }
-                    this.pendingSpoolOutputs.delete(obs.call_id ?? "");
+            // M3: mirror the kernel's journaled recall lifecycle into the durable store so recall
+            // history (count + last-recalled turn) survives across sessions.
+            if (obs.kind === "memory_recalled" && obs.recalls?.length) {
+                const agentId = this.opts.agentId;
+                if (agentId && this.opts.dreamStore?.recordRecall) {
+                    await this.opts.dreamStore.recordRecall(agentId, obs.recalls);
                 }
             }
+            // M4: a recall crossed the promotion threshold. Advisory — surface it for the host/model to
+            // act on (pin or promote to knowledge); the runner does not auto-pin.
+            if (obs.kind === "promotion_suggested" && obs.record_id) {
+                this.opts.onPromotionSuggested?.({
+                    recordId: obs.record_id,
+                    recallCount: obs.recall_count ?? 0,
+                });
+            }
             const latest = obs.kind === "compressed" ? await this.opts.sessionLog.latestSeq(sessionId) : undefined;
             const event = kernelObservationToSessionEvent(obs, turn, {
                 nextArchiveStart,
                 latestSeq: latest,
-                archiveRef,
-                spoolRef,
                 preservedRefs,
                 compressionAction,
             });
@@ -1964,27 +2275,10 @@ export class RuntimeRunner {
                 continue;
             const compressedSeq = await this.opts.sessionLog.append(sessionId, event);
             if (event.kind === "compressed") {
-                nextArchiveStart = compressedSeq + 1;
-                const archived = obs.kind === "compressed" ? obs.archived : undefined;
-                if (this.opts.asyncSummarizer && archived && archived.length > 0) {
-                    void this.upgradeCompressedSummary(sessionId, compressedSeq, archived, compressionAction(obs.action) ?? "auto_compact", runtime);
-                }
-                // One compaction = one kernel observation: the page_out session record (and the
-                // semantic-archive branch) is DERIVED here from Compressed.tier_hint, preserving the
-                // session-log format and OsSnapshot page_out_count.
-                if (obs.tier_hint && Array.isArray(archived) && archived.length > 0) {
-                    await this.opts.sessionLog.append(sessionId, {
-                        kind: "page_out",
-                        turn: obs.turn ?? turn,
-                        action: compressionAction(obs.action),
-                        summary: obs.summary,
-                        tier_hint: obs.tier_hint ?? "durable",
-                        message_count: archived.length,
-                    });
-                    if (obs.tier_hint === "semantic") {
-                        void this.archiveSemanticPageOut(archived, compressionAction(obs.action));
-                    }
+                if ((obs.archived_count ?? 0) > 0) {
+                    this.pendingPageOutArchives.push({ archiveStart: nextArchiveStart, compressedSeq });
                 }
+                nextArchiveStart = compressedSeq + 1;
             }
             // K4: a sprint renewal dropped the old history — including any earlier memory hits — so
             // re-run the preQueryMemory prefetch for the new sprint (live observations only: this
@@ -1995,56 +2289,58 @@ export class RuntimeRunner {
         }
         return nextArchiveStart;
     }
-    async archiveSemanticPageOut(archived, action) {
-        if (!this.opts.dreamStore || !this.opts.agentId)
+    async archiveSemanticPageOut(archived, action, sessionId) {
+        if (!this.opts.dreamStore || !this.opts.agentId || !this.opts.memoryScope)
             return;
-        try {
-            const summary = this.opts.dreamSummarizer
-                ? await this.opts.dreamSummarizer.summarize(archived, { action })
-                : await summarizeForLongTermMemory(this.opts.dreamProvider ?? this.opts.provider, archived, this.opts.dreamSystemPrompt);
-            // P2 write-funnel: route through the ONE gated WriteMemory syscall so validation,
-            // the rolling write quota, dedup, and the memory_written audit all apply. Score is
-            // advisory (0.6) — an automatic summary must never outrank curated content.
-            await this.writeMemory({
-                content: summary,
-                metadata: {
-                    name: `page-out-${Date.now()}`,
-                    description: `auto summary of ${action ?? "compaction"} archive`,
-                    source: "semantic_page_out",
-                    action,
-                    score: 0.6,
-                },
-            });
-        }
-        catch {
-            // non-fatal: in-context compression summary remains; long-term layer is best-effort
-        }
+        const summary = this.opts.dreamSummarizer
+            ? await this.opts.dreamSummarizer.summarize(archived, { action })
+            : await summarizeForLongTermMemory(this.opts.dreamProvider ?? this.opts.provider, archived, this.opts.dreamSystemPrompt);
+        // P2 write-funnel: route through the ONE gated WriteMemory syscall so validation,
+        // the rolling write quota, dedup, and the memory_written audit all apply. Score is
+        // advisory (0.6) — an automatic summary must never outrank curated content.
+        const now = Date.now();
+        const name = `page-out-${now}`;
+        await this.writeMemory({
+            record_id: `${this.opts.memoryScope.tenant_id}:${this.opts.memoryScope.namespace}:project:${name}`,
+            scope: this.opts.memoryScope,
+            name,
+            kind: "project",
+            content: summary,
+            description: `auto summary of ${action ?? "compaction"} archive`,
+            provenance: {
+                session_id: sessionId,
+                author: "extraction",
+                trust: "untrusted",
+                evidence_refs: [],
+            },
+            created_at: now,
+            updated_at: now,
+            recall_count: 0,
+            confidence: 0.6,
+            links: [],
+            pinned: false,
+        }, { sessionId, agentId: this.opts.agentId });
     }
     async upgradeCompressedSummary(sessionId, compressedSeq, archived, action, runtime) {
-        try {
-            const summary = await this.opts.asyncSummarizer.summarize(archived, action);
-            await this.opts.sessionLog.append(sessionId, {
-                kind: "summary_upgraded",
-                compressed_seq: compressedSeq,
-                summary,
+        const summary = await this.opts.asyncSummarizer.summarize(archived, action);
+        await this.opts.sessionLog.append(sessionId, {
+            kind: "summary_upgraded",
+            compressed_seq: compressedSeq,
+            summary,
+        });
+        // P4: the LLM summary also re-enters the LIVE session as a keyed page-in entry —
+        // K1 boundary-deferred upsert lands it with zero mid-generation cache churn and the
+        // K2 budget governs its size. The RuleSummarizer text remains the synchronous label.
+        if (runtime) {
+            await this.commitKernelApply(runtime, this.pendingObservations, {
+                kind: "page_in",
+                entries: [{
+                        content: `[ARCHIVE SUMMARY] ${summary}`,
+                        key: `summary:seq-${compressedSeq}`,
+                        pinned: false,
+                        source: "async_summarizer",
+                    }],
             });
-            // P4: the LLM summary also re-enters the LIVE session as a keyed page-in entry —
-            // K1 boundary-deferred upsert lands it with zero mid-generation cache churn and the
-            // K2 budget governs its size. The RuleSummarizer text remains the synchronous label.
-            if (runtime) {
-                kernelApply(runtime, this.pendingObservations, {
-                    kind: "page_in",
-                    entries: [{
-                            content: `[ARCHIVE SUMMARY] ${summary}`,
-                            key: `summary:seq-${compressedSeq}`,
-                            pinned: false,
-                            source: "async_summarizer",
-                        }],
-                });
-            }
-        }
-        catch {
-            // non-fatal: rule-based summary stays in place
         }
     }
 }
@@ -2169,14 +2465,22 @@ export function replayMessages(events, maxBytes) {
             upgradedSummaries.set(e.compressed_seq, e.summary);
     }
     const messages = [];
-    for (const { seq, event: e } of events) {
+    for (let eventIndex = 0; eventIndex < events.length; eventIndex++) {
+        const { seq, event: e } = events[eventIndex];
         if (e.kind === "run_started") {
             const userText = e.criteria.length
                 ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
                 : e.goal;
+            // Multimodal parity: the live seed of `attachments` is gated behind `!resumeMidRun`, so on
+            // resume the image/audio must be recovered from the persisted run_started event or it is lost.
+            const attachments = (e.attachments ?? []);
+            const contentParts = attachments.length
+                ? [...(userText ? [{ type: "text", text: userText }] : []), ...attachments]
+                : undefined;
             messages.push({
                 role: "user",
                 content: userText,
+                ...(contentParts ? { contentParts } : {}),
                 toolCalls: [],
                 tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
             });
@@ -2229,38 +2533,32 @@ export async function replayMessagesAsync(events, maxBytes, loadArchive) {
             upgradedSummaries.set(e.compressed_seq, e.summary);
     }
     const messages = [];
-    for (const { seq, event: e } of events) {
+    for (let eventIndex = 0; eventIndex < events.length; eventIndex++) {
+        const { seq, event: e } = events[eventIndex];
         if (e.kind === "run_started") {
             const userText = e.criteria.length
                 ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
                 : e.goal;
+            // Multimodal parity: the live seed of `attachments` is gated behind `!resumeMidRun`, so on
+            // resume the image/audio must be recovered from the persisted run_started event or it is lost.
+            const attachments = (e.attachments ?? []);
+            const contentParts = attachments.length
+                ? [...(userText ? [{ type: "text", text: userText }] : []), ...attachments]
+                : undefined;
             messages.push({
                 role: "user",
                 content: userText,
+                ...(contentParts ? { contentParts } : {}),
                 toolCalls: [],
                 tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
             });
         }
         else if (e.kind === "compressed") {
-            let loadedSuccessfully = false;
-            if (e.archive_ref && loadArchive) {
-                try {
-                    const archivedMsgs = await loadArchive(e.archive_ref);
-                    for (const msg of archivedMsgs) {
-                        messages.push({
-                            role: msg.role,
-                            content: sanitizeReplayText(msg.content, maxBytes),
-                            toolCalls: msg.toolCalls ?? [],
-                            tokenCount: msg.tokenCount,
-                        });
-                    }
-                    loadedSuccessfully = true;
-                }
-                catch (err) {
-                    // Loader failed (e.g. MissingArchive). We degrade and fallback.
-                }
-            }
-            if (!loadedSuccessfully) {
+            const pageOutWillSupplyArchive = events.slice(eventIndex + 1).some(({ event }) => event.kind === "page_out"
+                && event.turn === e.turn
+                && typeof event.archive_ref === "string"
+                && event.archive_ref.length > 0);
+            if (!pageOutWillSupplyArchive) {
                 const summary = upgradedSummaries.get(seq) ?? e.summary;
                 if (summary) {
                     const systemText = `[Compressed context: turn ${e.turn}]\n${summary}`;
@@ -2273,6 +2571,30 @@ export async function replayMessagesAsync(events, maxBytes, loadArchive) {
                 }
             }
         }
+        else if (e.kind === "page_out" && e.archive_ref && loadArchive) {
+            try {
+                const archivedMsgs = await loadArchive(e.archive_ref);
+                for (const msg of archivedMsgs) {
+                    messages.push({
+                        role: msg.role,
+                        content: sanitizeReplayText(msg.content, maxBytes),
+                        toolCalls: msg.toolCalls ?? [],
+                        tokenCount: msg.tokenCount,
+                    });
+                }
+            }
+            catch {
+                if (e.summary) {
+                    const systemText = `[Compressed context: turn ${e.turn}]\n${e.summary}`;
+                    messages.push({
+                        role: "system",
+                        content: systemText,
+                        toolCalls: [],
+                        tokenCount: Math.max(1, Math.ceil(systemText.length / 4)),
+                    });
+                }
+            }
+        }
         else if (e.kind === "llm_completed") {
             messages.push({
                 role: "assistant",
@@ -2309,14 +2631,6 @@ function nextArchivedSeqStart(events) {
     }
     return next;
 }
-function tryParseJson(s) {
-    try {
-        return JSON.parse(s);
-    }
-    catch {
-        return null;
-    }
-}
 /** Collect all text_delta events from a run into a single string. */
 export async function collectText(stream) {
     let text = "";
@@ -2388,46 +2702,51 @@ function parseStartWorkflowSpec(argsStr) {
 }
 /** M5 v2.1: render an authored-workflow outcome into a user-message note injected back into the
  *  agent's context, so the agent's next turn continues with the sub-workflow's results in view. */
+function recoveredOutputs(outcomes) {
+    const outputs = new Map();
+    for (const outcome of outcomes ?? []) {
+        if (!outcome.output)
+            continue;
+        outputs.set(outcome.agentId, outcome.output.content);
+        outputs.set(outcome.agentId.replace(/-i\d+$/, ""), outcome.output.content);
+    }
+    return outputs;
+}
 function authoredWorkflowOutcomeNote(outcome) {
+    const counts = new Map();
+    for (const node of outcome.nodeOutcomes)
+        counts.set(node.status, (counts.get(node.status) ?? 0) + 1);
     const lines = [
-        `[authored workflow result] ${outcome.completed.length} node(s) completed` +
-            (outcome.failed.length ? `, ${outcome.failed.length} failed` : "") + ".",
+        `[authored workflow result] ${outcome.nodeOutcomes.length} terminal node(s): ` +
+            [...counts.entries()].map(([status, count]) => `${count} ${status}`).join(", ") + ".",
     ];
-    for (const id of outcome.completed) {
-        const out = outcome.outputs[id];
+    for (const node of outcome.nodeOutcomes) {
+        const out = outcome.outputs[node.nodeId] ?? node.output?.content;
         if (out)
-            lines.push(`- ${id}: ${out.length > 500 ? out.slice(0, 500) + "…" : out}`);
+            lines.push(`- ${node.nodeId} (${node.status}): ${out.length > 500 ? out.slice(0, 500) + "…" : out}`);
     }
     return lines.join("\n");
 }
 /** Lower a host `RuntimeSignal` to the kernel's snake_case `signal` input event. Shared by the main
  *  loop's per-turn poll and #2-B-ii's workflow-batch preemption monitor (so the two never drift). */
-/** Word-set jaccard similarity — the curator's dedup rule as a pure helper at the write funnel. */
-function jaccardSimilarity(a, b) {
-    const sa = new Set(a.split(/\s+/).filter(Boolean));
-    const sb = new Set(b.split(/\s+/).filter(Boolean));
-    if (sa.size === 0 && sb.size === 0)
-        return 1;
-    let inter = 0;
-    for (const w of sa)
-        if (sb.has(w))
-            inter++;
-    const union = sa.size + sb.size - inter;
-    return union === 0 ? 0 : inter / union;
-}
-function signalToKernelEvent(sig) {
+function signalToKernelEvent(delivery) {
+    const sig = delivery.signal;
     return {
-        kind: "signal",
+        kind: "deliver_signal",
+        delivery_id: delivery.deliveryId,
+        attempt: delivery.deliveryAttempt,
         signal: {
-            id: crypto.randomUUID(),
+            id: delivery.signalId,
             source: sig.source ?? "custom",
             signal_type: sig.signalType ?? "event",
             urgency: sig.urgency ?? "normal",
-            summary: String(sig.payload?.goal ?? sig.kind ?? "signal"),
+            summary: String(sig.payload?.goal ?? "signal"),
             payload: sig.payload ?? {},
             ...(sig.dedupeKey ? { dedupe_key: sig.dedupeKey } : {}),
             ...(sig.recipient ? { recipient: sig.recipient } : {}),
-            ...(sig.topic ? { topic: sig.topic } : {}),
+            ...(sig.deadlineMs !== undefined ? { deadline_ms: sig.deadlineMs } : {}),
+            ...(sig.coalesceKey ? { coalesce_key: sig.coalesceKey } : {}),
+            coalesced_count: Math.max(1, sig.coalescedCount ?? 1),
             timestamp_ms: Date.now(),
         },
     };