@deepstrike/wasm 0.2.39 → 0.2.41

package/dist/runtime/runner.js

@@ -1,12 +1,13 @@
+import { extractSessionMemories } from "../memory/extraction.js";
 import { resolvePermissionRequest } from "./execution-plane.js";
 import { governancePolicyToKernelEvent, governanceFilterSchema } from "../governance.js";
 import { getKernel } from "./kernel.js";
 import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 import { sanitizeReplayText } from "./replay-sanitize.js";
 import { formatToolError } from "../tools/errors.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 { kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
-import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, workflowBudgetNote, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.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";
@@ -14,9 +15,36 @@ import { loopInstruction, classifyInstruction, judgeGoal, dependencyOutputsNote,
 import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.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;
+    cancellationReason;
     /** #2-B-ii: aborts the in-flight provider stream on interrupt/preempt. Recreated per `execute`. */
     abortController = null;
     pendingObservations = [];
@@ -33,18 +61,28 @@ export class RuntimeRunner {
     /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
     currentGoal = "";
     nextArchiveStart = 0;
+    pendingPageOutArchives = [];
+    activePageOutArchive;
     /** 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). */
     pendingAuthoredWorkflows = [];
-    pendingSpoolOutputs = new Map();
+    workflowContinuation = 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");
+        }
     }
     get hostOptions() { return this.opts; }
-    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. `urgency` maps to
+     *  the next turn boundary, routes through the kernel attention policy, and renders once as a
+     *  `[SIGNAL] <text>` line in the volatile state turn. `urgency` maps to
      *  the kernel disposition ladder: `"normal"` queues (default), `"high"` soft-interrupts, `"critical"`
      *  preempts. */
     injectNote(text, urgency = "normal") {
@@ -60,10 +98,51 @@ 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();
+        const source = this.opts.signalSource;
+        const claim = await source.claimSignal();
+        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 = 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);
@@ -76,9 +155,10 @@ export class RuntimeRunner {
                 criteria: req.criteria ?? [],
                 agent_id: this.opts.agentId,
                 system_prompt: this.opts.systemPrompt,
+                ...(req.attachments?.length ? { attachments: req.attachments } : {}),
             });
         }
-        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun);
+        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun, req.attachments);
     }
     async *wake(sessionId, extensions) {
         const events = await this.opts.sessionLog.read(sessionId);
@@ -88,7 +168,47 @@ 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);
+        yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true, start.attachments);
+    }
+    async writeMemory(memory, sessionId) {
+        if (!this.opts.dreamStore || !this.opts.agentId)
+            return;
+        const kernel = await getKernel();
+        const runtime = new kernel.KernelRuntime({ maxTokens: this.opts.maxTokens, maxTurns: this.opts.maxTurns ?? 25 });
+        const observations = [];
+        const action = kernelMaybeAction(runtime, observations, { kind: "write_memory", memory });
+        if (!action) {
+            await this.appendMemorySyscallObservations(sessionId, observations);
+            return;
+        }
+        if (action.kind !== "persist_memory")
+            throw new Error(`write_memory returned unexpected kernel effect: ${action.kind}`);
+        let error;
+        try {
+            await this.opts.dreamStore.upsert(this.opts.agentId, action.memory);
+        }
+        catch (cause) {
+            error = formatToolError(cause);
+        }
+        kernelApply(runtime, observations, {
+            kind: "memory_persist_result",
+            effect_id: action.effectId,
+            ...(error ? { error } : {}),
+        });
+        await this.appendMemorySyscallObservations(sessionId, observations);
+        if (error)
+            throw new Error(error);
+    }
+    async appendMemorySyscallObservations(sessionId, observations) {
+        if (!sessionId)
+            return;
+        for (const observation of observations) {
+            if (!["memory_written", "memory_queried", "memory_validation_failed"].includes(observation.kind))
+                continue;
+            const event = kernelObservationToSessionEvent(observation, 0);
+            if (event)
+                await this.opts.sessionLog.append(sessionId, event);
+        }
     }
     /** Push content into Slot 2 (system_knowledge) via add_knowledge_message.
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
@@ -120,26 +240,25 @@ export class RuntimeRunner {
         kernelApply(this.activeKernel, this.pendingObservations, { kind: "skill_deactivated", name });
         this.knowledgePushedSkills.delete(name);
     }
-    async resolveKernelSuspend(runtime, sessionId) {
-        const gated = this.pendingObservations.filter((o) => o.kind === "tool_gated" && typeof o.call_id === "string" && typeof o.tool === "string");
+    async resolveKernelSuspend(requests, runtime, sessionId) {
         const approved = [];
         const denied = [];
         const events = [];
         const runCtx = { onPermissionRequest: this.opts.onPermissionRequest };
-        for (const g of gated) {
+        for (const requestAction of requests) {
             const request = {
                 type: "permission_request",
-                callId: g.call_id,
-                toolName: g.tool,
-                arguments: "{}",
-                reason: typeof g.reason === "string" ? g.reason : "",
+                callId: requestAction.callId,
+                toolName: requestAction.tool,
+                arguments: requestAction.arguments,
+                reason: requestAction.reason,
             };
             events.push(request);
             const decision = await resolvePermissionRequest(request, runCtx);
             events.push({
                 type: "permission_resolved",
-                callId: g.call_id,
-                toolName: g.tool,
+                callId: requestAction.callId,
+                toolName: requestAction.tool,
                 approved: decision.approved,
                 responder: decision.responder ?? "host",
                 ...(decision.reason ? { reason: decision.reason } : {}),
@@ -147,8 +266,8 @@ export class RuntimeRunner {
             await this.opts.sessionLog.append(sessionId, {
                 kind: "permission_requested",
                 turn: runtime.turn(),
-                tool: g.tool,
-                arguments: "{}",
+                tool: requestAction.tool,
+                arguments: requestAction.arguments,
                 reason: request.reason,
             });
             await this.opts.sessionLog.append(sessionId, {
@@ -158,21 +277,21 @@ export class RuntimeRunner {
                 responder: decision.responder ?? "host",
             });
             if (decision.approved) {
-                approved.push(g.call_id);
+                approved.push(requestAction.callId);
             }
             else {
-                denied.push(g.call_id);
+                denied.push(requestAction.callId);
                 const denyReason = decision.reason ?? "permission denied";
                 events.push({
                     type: "tool_denied",
-                    callId: g.call_id,
-                    toolName: g.tool,
+                    callId: requestAction.callId,
+                    toolName: requestAction.tool,
                     reason: denyReason,
                 });
                 events.push({
                     type: "tool_result",
-                    callId: g.call_id,
-                    name: g.tool,
+                    callId: requestAction.callId,
+                    name: requestAction.tool,
                     content: `permission denied: ${denyReason}`,
                     isError: true,
                     errorKind: "governance_denied",
@@ -180,15 +299,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: requestAction.callId,
+                    tool_name: requestAction.tool,
                     reason: denyReason,
                 });
                 await this.opts.sessionLog.append(sessionId, {
                     kind: "tool_completed",
                     turn: runtime.turn(),
                     results: [{
-                            call_id: g.call_id,
+                            call_id: requestAction.callId,
                             output: `permission denied: ${denyReason}`,
                             is_error: true,
                             error_kind: "governance_denied",
@@ -200,10 +319,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, (b) the 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
-     * resolved text by `[offset, offset + maxBytes)` (plain string slice — "bytes-ish").
+     * output. Resolution order: (a) the result spool committed by `large_result_spool_result`,
+     * (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) {
         let callId = "";
@@ -220,7 +338,7 @@ export class RuntimeRunner {
         catch {
             // malformed arguments — callId stays empty, falls through to "not found" below
         }
-        let full = this.pendingSpoolOutputs.get(callId)?.output;
+        let full;
         if (full === undefined && this.opts.resultSpool) {
             try {
                 full = await this.opts.resultSpool.findByCallId(callId);
@@ -255,71 +373,13 @@ export class RuntimeRunner {
             isError: false,
         };
     }
-    async dream(agentId, nowMs = Date.now()) {
-        if (!this.opts.dreamStore)
-            throw new Error("dreamStore not configured");
-        const kernel = await getKernel();
-        const sessions = await this.opts.dreamStore.loadSessions(agentId);
-        const existingMemories = await this.opts.dreamStore.loadMemories(agentId);
-        if (!sessions.length)
-            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
-        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") {
-            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
-        }
-        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 synthContext = {
-            systemText: synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n"),
-            turns: synthMsgs.filter(m => m.role !== "system"),
-        };
-        for await (const evt of dreamProvider.stream(synthContext, [], undefined, providerState)) {
-            if (evt.type === "text_delta")
-                synthesisText += evt.delta;
-        }
-        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);
-        return {
-            sessionsProcessed: rr.sessionsProcessed,
-            insightsExtracted: rr.insightsExtracted,
-            entriesAdded: cr.stats?.entriesAdded ?? 0,
-            entriesRemoved: (cr.toRemoveIndices ?? []).length,
-        };
-    }
-    async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
+    async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false, attachments) {
         this.interrupted = false;
+        this.cancellationReason = undefined;
         this.abortController = new AbortController();
         this.pendingObservations = [];
-        this.pendingSpoolOutputs.clear();
+        this.pendingPageOutArchives = [];
+        this.activePageOutArchive = undefined;
         this.currentSessionId = sessionId;
         const kernel = await getKernel();
         const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
@@ -333,7 +393,7 @@ export class RuntimeRunner {
             maxTurns: effectiveMaxTurns,
             // M4/G5: per-node token cap → child run's cumulative token budget (wasm LoopPolicy.maxTotalTokens is f64).
             ...(this.opts.maxTotalTokens !== undefined ? { maxTotalTokens: this.opts.maxTotalTokens } : {}),
-            timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
+            timeoutMs: effectiveTimeoutMs,
         });
         this.activeKernel = runtime;
         if (this.opts.tokenizer) {
@@ -410,7 +470,7 @@ export class RuntimeRunner {
         if (priorEvents && priorEvents.length > 0) {
             const repaired = repairEventsForRecovery(priorEvents, maxBytes);
             seedProviderReplayFromEvents(this.opts.provider, repaired);
-            const replayed = replayMessages(repaired, maxBytes);
+            const replayed = await replayMessages(repaired, maxBytes, this.opts.compressionStore);
             kernelApply(runtime, this.pendingObservations, {
                 kind: "preload_history",
                 messages: replayed.map(messageToKernelMessage),
@@ -450,6 +510,13 @@ export class RuntimeRunner {
                 }
             }
         }
+        // Multimodal upload: seed attachments before start_run (parity with Node/Python).
+        if (!resumeMidRun && attachments?.length) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "add_history_message",
+                message: attachmentsToKernelMessage(attachments),
+            });
+        }
         const sessionStart = Date.now();
         const startPayload = {
             kind: "start_run",
@@ -490,18 +557,20 @@ export class RuntimeRunner {
             while (!runtime.isTerminal()) {
                 nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
                 if (this.interrupted) {
-                    action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "cancel_operation",
+                        reason: this.cancellationReason ?? "user",
+                        pending_call_ids: pendingCallIds(action),
+                    });
                     break;
                 }
                 if (this.opts.signalSource || this.injectedSignals.length > 0) {
-                    const sig = await this.nextInboundSignal();
-                    if (sig) {
-                        const sigAction = kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig));
+                    const delivery = await this.nextInboundSignal();
+                    if (delivery) {
+                        const sigAction = await this.consumeInboundSignal(delivery, claimed => kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(claimed)));
                         if (sigAction)
                             action = sigAction;
-                        // I0a: Critical signal carries user_abort intent; see Node runner for full rationale.
-                        if (sig.urgency === "critical")
-                            this.interrupted = true;
+                        // Critical attention/preemption is distinct from operation cancellation.
                     }
                 }
                 if (runtime.isTerminal())
@@ -513,6 +582,7 @@ export class RuntimeRunner {
                     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 — see Node runner for full rationale.
@@ -574,6 +644,7 @@ export class RuntimeRunner {
                             // interrupt (the post-stream `aborted` check below converts it to a clean
                             // timeout/UserAbort), not a crash or a provider error.
                             this.interrupted = true;
+                            this.cancellationReason ??= "user";
                         }
                         else {
                             // Reactive recovery is now a kernel decision. Forward the raw provider error and
@@ -583,6 +654,7 @@ export class RuntimeRunner {
                             // duplicated across the four SDK runners.
                             action = kernelAction(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
@@ -598,7 +670,11 @@ export class RuntimeRunner {
                     }
                     // #2-B-ii: stream aborted (preempt/interrupt) via the break path — end the turn now.
                     if (abortSignal?.aborted) {
-                        action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
+                        action = kernelAction(runtime, this.pendingObservations, {
+                            kind: "cancel_operation",
+                            reason: this.cancellationReason ?? "user",
+                            pending_call_ids: [providerEffectId],
+                        });
                         break;
                     }
                     const assistantMessage = {
@@ -609,25 +685,14 @@ export class RuntimeRunner {
                     };
                     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 } : {}),
                     };
-                    let nextAction = kernelMaybeAction(runtime, this.pendingObservations, providerEvent);
-                    const hasSuspended = this.pendingObservations.some(o => o.kind === "suspended");
-                    if (!nextAction && hasSuspended) {
-                        const resolved = await this.resolveKernelSuspend(runtime, sessionId);
-                        for (const evt of resolved.events)
-                            yield evt;
-                        nextAction = kernelAction(runtime, this.pendingObservations, {
-                            kind: "resume",
-                            approved_calls: resolved.approved,
-                            denied_calls: resolved.denied,
-                        });
-                    }
-                    action = nextAction ?? kernelAction(runtime, this.pendingObservations, providerEvent);
+                    action = kernelAction(runtime, this.pendingObservations, providerEvent);
                     const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
                     await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
                         turn: runtime.turn(),
@@ -663,11 +728,117 @@ export class RuntimeRunner {
                         catch { /* malformed skill args — leave activeSkill unchanged */ }
                     }
                 }
+                else if (action.kind === "request_approval") {
+                    const resolved = await this.resolveKernelSuspend(action.requests, runtime, sessionId);
+                    for (const evt of resolved.events)
+                        yield evt;
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "approval_result",
+                        effect_id: action.effectId,
+                        approved_calls: resolved.approved,
+                        denied_calls: resolved.denied,
+                    });
+                }
+                else if (action.kind === "persist_memory") {
+                    let error;
+                    try {
+                        if (!this.opts.dreamStore || !this.opts.agentId)
+                            throw new Error("WASM memory persistence requires dreamStore and agentId");
+                        await this.opts.dreamStore.upsert(this.opts.agentId, action.memory);
+                    }
+                    catch (cause) {
+                        error = formatToolError(cause);
+                    }
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "memory_persist_result",
+                        effect_id: action.effectId,
+                        ...(error ? { error } : {}),
+                    });
+                }
+                else if (action.kind === "query_memory") {
+                    let hits = [];
+                    let error;
+                    try {
+                        if (!this.opts.dreamStore || !this.opts.agentId)
+                            throw new Error("WASM memory queries require dreamStore and agentId");
+                        hits = await this.opts.dreamStore.search(this.opts.agentId, {
+                            ...action.query, top_k: action.requestedK,
+                        });
+                    }
+                    catch (cause) {
+                        error = formatToolError(cause);
+                    }
+                    const obsStart = this.pendingObservations.length;
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "memory_query_result",
+                        effect_id: action.effectId,
+                        hits,
+                        ...(error ? { error } : {}),
+                    });
+                    // M3/M4: mirror the kernel's journaled recall lifecycle + surface promotion suggestions.
+                    for (const obs of this.pendingObservations.slice(obsStart)) {
+                        if (obs.kind === "memory_recalled" && obs.recalls?.length && this.opts.agentId) {
+                            await this.opts.dreamStore?.recordRecall?.(this.opts.agentId, obs.recalls);
+                        }
+                        if (obs.kind === "promotion_suggested" && obs.record_id) {
+                            this.opts.onPromotionSuggested?.({ recordId: obs.record_id, recallCount: obs.recall_count ?? 0 });
+                        }
+                    }
+                }
+                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);
+                    }
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "large_result_spool_result",
+                        effect_id: action.effectId,
+                        ...(spoolRef ? { spool_ref: spoolRef } : {}),
+                        ...(error ? { error } : {}),
+                    });
+                }
+                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) {
+                            archiveRef = await this.opts.compressionStore.write(sessionId, archiveMeta.archiveStart, action.archived);
+                        }
+                    }
+                    catch (cause) {
+                        error = formatToolError(cause);
+                    }
+                    const archived = action.archived;
+                    const archiveAction = compressionAction(action.action) ?? "auto_compact";
+                    const archiveTier = action.tier;
+                    if (!error)
+                        this.activePageOutArchive = undefined;
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "page_out_archive_result",
+                        effect_id: action.effectId,
+                        ...(archiveRef ? { archive_ref: archiveRef } : {}),
+                        ...(error ? { error } : {}),
+                    });
+                    if (!error && archiveTier === "semantic" && archived.length > 0) {
+                        void this.archiveSemanticPageOut(archived, archiveAction);
+                    }
+                }
                 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 = {
                         agentId: this.opts.agentId,
+                        memoryScope: this.opts.memoryScope,
                         skillContentMap: this.opts.skillContentMap,
                         dreamStore: this.opts.dreamStore,
                         knowledgeSource: this.opts.knowledgeSource,
@@ -828,12 +999,6 @@ export class RuntimeRunner {
                             token_count: r.tokenCount,
                         })),
                     });
-                    for (const call of allCalls) {
-                        const result = toolResults.find(r => r.callId === call.id);
-                        if (result) {
-                            this.pendingSpoolOutputs.set(call.id, { tool: call.name, output: result.output });
-                        }
-                    }
                     // P1-B B3: a successfully-resolved `skill` call activates that skill for the next turn.
                     //
                     // Strict dynamic context control: a skill is METHOD content — how to do something — reused
@@ -869,6 +1034,7 @@ export class RuntimeRunner {
                     const entropyObsStart = this.pendingObservations.length;
                     action = kernelAction(runtime, this.pendingObservations, {
                         kind: "tool_results",
+                        effect_id: toolEffectId,
                         results: toolResults.map(toolResultToKernel),
                     });
                     // Surface the boundary's entropy measurement live (the heartbeat watch source).
@@ -901,6 +1067,7 @@ export class RuntimeRunner {
                     if (milestonePolicy === "auto_pass") {
                         action = kernelAction(runtime, this.pendingObservations, {
                             kind: "milestone_result",
+                            effect_id: action.effectId,
                             result: milestoneCheckResultToKernel(milestoneCheckPass(action.phaseId)),
                         });
                         nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
@@ -913,6 +1080,7 @@ export class RuntimeRunner {
                         });
                         action = kernelAction(runtime, this.pendingObservations, {
                             kind: "milestone_result",
+                            effect_id: action.effectId,
                             result: milestoneCheckResultToKernel(check),
                         });
                         nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
@@ -961,7 +1129,7 @@ export class RuntimeRunner {
         }
         const result = action.kind === "done" ? action.result : undefined;
         // I0a: preserve preempt intent when loop exits without clean kernel-done (see Node runner for full rationale).
-        const status = result?.termination ?? (this.interrupted ? "user_abort" : "error");
+        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);
@@ -979,14 +1147,20 @@ export class RuntimeRunner {
             }));
             if (newMsgs.length > 0) {
                 try {
-                    await this.opts.dreamStore.saveSession({
-                        sessionId: crypto.randomUUID(),
+                    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);
+                    }
                 }
                 catch { /* non-fatal */ }
             }
@@ -1108,10 +1282,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)}`;
@@ -1124,7 +1298,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,
@@ -1169,17 +1343,49 @@ export class RuntimeRunner {
      */
     applyKernelPolicies(runtime) {
         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;
         // K2: lower governance / attention / scheduler / quota in ONE `configure_run` event (the 0.2.30
         // core applies each present field via its granular path). `set_memory_policy` stays separate below.
         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));
+        }
+        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.kernelReliability) {
+            const r = this.opts.kernelReliability;
+            config.reliability = {
+                ...(r.eventReplayCapacity !== undefined ? { event_replay_capacity: r.eventReplayCapacity } : {}),
+                ...(r.completedEffectReplayCapacity !== undefined ? { completed_effect_replay_capacity: r.completedEffectReplayCapacity } : {}),
+                ...(r.providerRecoveryAttempts !== undefined ? { provider_recovery_attempts: r.providerRecoveryAttempts } : {}),
+                ...(r.outputRecoveryAttempts !== undefined ? { output_recovery_attempts: r.outputRecoveryAttempts } : {}),
+                ...(r.hostEffectRetryAttempts !== undefined ? { host_effect_retry_attempts: r.hostEffectRetryAttempts } : {}),
+                ...(r.spoolThresholdBytes !== undefined ? { spool_threshold_bytes: r.spoolThresholdBytes } : {}),
+                ...(r.spoolPreviewBytes !== undefined ? { spool_preview_bytes: r.spoolPreviewBytes } : {}),
+                ...(r.snapshotInputLimit !== undefined ? { snapshot_input_limit: r.snapshotInputLimit } : {}),
+                ...(r.maxInputBytes !== undefined ? { max_input_bytes: r.maxInputBytes } : {}),
+                ...(r.snapshotJournalBytesLimit !== undefined
+                    ? { snapshot_journal_bytes_limit: r.snapshotJournalBytesLimit }
+                    : {}),
+            };
         }
         if (this.opts.resourceQuota) {
             const q = this.opts.resourceQuota;
@@ -1239,15 +1445,17 @@ export class RuntimeRunner {
      */
     async bootstrapWorkflowKernel(sessionId, spec) {
         this.interrupted = false;
+        this.cancellationReason = undefined;
         this.pendingObservations = [];
-        this.pendingSpoolOutputs.clear();
+        this.pendingPageOutArchives = [];
+        this.activePageOutArchive = undefined;
         this.currentSessionId = sessionId;
         const kernel = await getKernel();
         const runtime = new kernel.KernelRuntime({
             maxTokens: this.opts.maxTokens,
             maxTurns: this.opts.maxTurns ?? 25,
             ...(this.opts.maxTotalTokens !== undefined ? { maxTotalTokens: this.opts.maxTotalTokens } : {}),
-            timeoutMs: this.opts.timeoutMs !== undefined ? BigInt(this.opts.timeoutMs) : undefined,
+            timeoutMs: this.opts.timeoutMs,
         });
         this.activeKernel = runtime;
         const goal = `workflow:${spec.nodes.length} nodes`;
@@ -1259,9 +1467,10 @@ export class RuntimeRunner {
             ...(this.opts.agentId ? { agent_id: this.opts.agentId } : {}),
         })).catch(() => { });
         this.applyKernelPolicies(runtime);
-        // 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.
-        void goal;
+        kernelAction(runtime, this.pendingObservations, {
+            kind: "start_run",
+            task: { goal: `workflow session ${sessionId}`, criteria: [] },
+        });
         return runtime;
     }
     async runWorkflow(spec, opts) {
@@ -1275,17 +1484,19 @@ export class RuntimeRunner {
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
         try {
-            const observations = kernelApply(runtime, this.pendingObservations, {
+            const observationStart = this.pendingObservations.length;
+            const initialAction = kernelMaybeAction(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 && 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 } : {}),
@@ -1296,7 +1507,8 @@ export class RuntimeRunner {
                 ...(opts?.resumedSubmissions && opts.resumedSubmissions.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
                 ...(opts?.resumedSubmissionBases && opts.resumedSubmissionBases.length ? { resumed_submission_bases: opts.resumedSubmissionBases } : {}),
             });
-            return await this.driveWorkflow(observations, parentSessionId, runtime, opts?.resumedOutputs);
+            const observations = this.pendingObservations.slice(observationStart);
+            return await this.driveWorkflow(initialAction, observations, parentSessionId, runtime, recoveredOutputs(opts?.resumedOutcomes));
         }
         finally {
             if (bootstrapped) {
@@ -1318,7 +1530,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 = kernelMaybeAction(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.
@@ -1331,7 +1545,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`, at the safe
@@ -1343,14 +1557,15 @@ 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);
+        }
+        const continuation = this.workflowContinuation;
+        if (!continuation) {
+            throw new Error("authored workflow completed without a provider continuation");
         }
-        return { kind: "call_provider", context: runtime.render(), tools: action.tools };
+        return continuation;
     }
     /**
      * #2-B-ii: while a workflow batch is in flight, poll the signal source; a Critical `InterruptNow`
@@ -1360,24 +1575,39 @@ export class RuntimeRunner {
      */
     async monitorWorkflowPreemption(runtime, controllers, batchState) {
         const source = this.opts.signalSource;
-        if (!source)
+        if (!source && this.injectedSignals.length === 0)
             return null;
         while (!batchState.settled) {
             // O2: injected notes participate in the monitor too (drain order matches nextInboundSignal).
-            const sig = this.injectedSignals.shift() ?? await source.nextSignal();
+            const delivery = await this.nextInboundSignal();
             if (batchState.settled)
                 break;
-            if (!sig) {
+            if (!delivery) {
                 await new Promise(resolve => setTimeout(resolve, 5));
                 continue;
             }
-            const obs = kernelApply(runtime, this.pendingObservations, signalToKernelEvent(sig));
+            const observationStart = this.pendingObservations.length;
+            const signalAction = await this.consumeInboundSignal(delivery, claimed => kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(claimed)));
+            if (signalAction) {
+                if (signalAction.kind !== "preempt_sub_agents") {
+                    throw new Error(`workflow signal returned unexpected effect: ${signalAction.kind}`);
+                }
+                for (const id of signalAction.agentIds)
+                    controllers.get(id)?.abort();
+                const continuation = kernelMaybeAction(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}`);
+                }
+            }
+            const obs = this.pendingObservations.slice(observationStart);
             const preempted = obs.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 ?? [] };
+                return (wc?.node_outcomes ?? []).map(workflowNodeOutcomeFromKernel);
             }
         }
         return null;
@@ -1387,25 +1617,43 @@ export class RuntimeRunner {
      * `submit_workflow`): 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.
      */
-    async driveWorkflow(initial, parentSessionId, runtime, seedOutputs) {
+    async driveWorkflow(initialAction, initial, parentSessionId, runtime, seedOutputs) {
         const observations = initial;
         const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
-        const collectNodes = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")?.nodes ?? [];
-        // G4: the batch observation carries the workflow's remaining budget; track the latest.
-        const collectBudget = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")?.budget;
         const findDone = (obs) => obs.find(o => o.kind === "workflow_completed");
+        const acceptSpawn = (spawn) => {
+            const observationStart = this.pendingObservations.length;
+            const continuation = kernelMaybeAction(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;
+        acceptSpawn(initialAction);
         // G2: each completed node's output, keyed by agent id — a reduce node reads its deps' outputs.
         // W-1: on resume it is pre-seeded from the persisted node outputs, so post-resume dependents
         // still see their (pre-crash) dependencies' outputs.
         const outputs = new Map(seedOutputs ?? []);
         for (;;) {
             if (nodes.length === 0)
-                return { completed: [], failed: [], outputs: Object.fromEntries(outputs) };
+                return { nodeOutcomes: [], outputs: Object.fromEntries(outputs) };
             const roundBudget = budget;
             // #2-B-ii: per-node abort controllers + a concurrent preemption monitor (see node runner).
             const controllers = new Map(nodes.map(n => [n.agent_id, new AbortController()]));
@@ -1415,7 +1663,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) };
             // Accumulate next-batch nodes across feeds (per-node unblock can spawn dependents per feed).
             const nextNodes = [];
             done = undefined;
@@ -1436,26 +1684,47 @@ export class RuntimeRunner {
                     // G1: stamp the submitting node's agent id so the kernel coerces 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 = kernelMaybeAction(runtime, this.pendingObservations, submitEvent);
+                    const subObs = this.pendingObservations.slice(observationStart);
+                    if (submitAction?.kind === "spawn_workflow") {
+                        nextNodes.push(...submitAction.nodes);
+                        budget = submitAction.budget ?? budget;
+                        acceptSpawn(submitAction);
+                    }
+                    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 = kernelMaybeAction(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, ...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;
@@ -1465,15 +1734,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;
         }
@@ -1491,32 +1764,22 @@ 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,
         });
     }
@@ -1524,56 +1787,24 @@ export class RuntimeRunner {
         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 spoolRef;
-            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
-                    }
-                    if (!obs.tool && pending.tool) {
-                        obs = { ...obs, tool: pending.tool };
-                    }
-                    this.pendingSpoolOutputs.delete(obs.call_id ?? "");
-                }
-            }
             const latest = obs.kind === "compressed" ? await this.opts.sessionLog.latestSeq(sessionId) : undefined;
             const event = kernelObservationToSessionEvent(obs, turn, {
                 nextArchiveStart,
                 latestSeq: latest,
                 preservedRefs,
-                spoolRef,
                 compressionAction,
             });
             if (!event)
                 continue;
             const compressedSeq = await this.opts.sessionLog.append(sessionId, event);
             if (event.kind === "compressed") {
-                nextArchiveStart = compressedSeq + 1;
-                // One compaction = one kernel observation: the page_out session record (and the
-                // semantic-archive branch) is DERIVED from Compressed.tier_hint, preserving the
-                // session-log format and OsSnapshot page_out_count.
-                const archived = obs.archived;
-                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).
@@ -1589,21 +1820,21 @@ export class RuntimeRunner {
      *  re-fired after each sprint renewal (renewal drops the old history INCLUDING earlier memory
      *  hits). 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, phase });
             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) {
@@ -1616,46 +1847,27 @@ export class RuntimeRunner {
         catch { /* errs-open */ }
     }
     async archiveSemanticPageOut(archived, action) {
-        if (!this.opts.dreamStore || !this.opts.agentId)
+        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);
-            const existing = await this.opts.dreamStore.loadMemories(this.opts.agentId);
-            // P2 write-funnel (wasm surface has no kernel write gate yet): jaccard dedup +
-            // advisory 0.6 score — an automatic summary must never outrank curated content.
-            if (existing.some(e => jaccardSimilarity(e.text, summary) >= 0.9))
-                return;
-            await this.opts.dreamStore.commit(this.opts.agentId, {
-                toAdd: [{ text: summary, score: 0.6, metadata: { source: "semantic_page_out", action } }],
-                toRemoveIndices: [],
-                stats: {
-                    insightsProcessed: 1,
-                    duplicatesRemoved: 0,
-                    conflictsResolved: 0,
-                    entriesAdded: 1,
-                },
-            }, existing);
+            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: { author: "extraction", trust: "untrusted", evidence_refs: [] },
+                created_at: now, updated_at: now, recall_count: 0, confidence: 0.6, links: [], pinned: false,
+            }, this.currentSessionId ?? undefined);
         }
         catch {
             // non-fatal
         }
     }
 }
-/** Word-set jaccard similarity — the curator's dedup rule 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;
-}
 async function summarizeForLongTermMemory(provider, archived, systemPrompt) {
     const transcript = archived
         .map(m => `${m.role}: ${m.content}`)
@@ -1687,7 +1899,7 @@ function compressionAction(action) {
     }
     return undefined;
 }
-function replayMessages(events, maxBytes) {
+async function replayMessages(events, maxBytes, archiveStore) {
     // Build upgraded-summary index: compressed_seq -> upgraded summary
     const upgradedSummaries = new Map();
     for (const { event: e } of events) {
@@ -1695,19 +1907,29 @@ function replayMessages(events, maxBytes) {
             upgradedSummaries.set(e.compressed_seq, e.summary);
     }
     const messages = [];
+    const archivedTurns = new Set(events.flatMap(({ event }) => event.kind === "page_out" && event.archive_ref && archiveStore?.read ? [event.turn] : []));
     for (const { seq, event: e } of events) {
         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") {
+            if (archivedTurns.has(e.turn))
+                continue;
             const summary = upgradedSummaries.get(seq) ?? e.summary;
             if (summary) {
                 const systemText = `[Compressed context: turn ${e.turn}]\n${summary}`;
@@ -1719,6 +1941,24 @@ function replayMessages(events, maxBytes) {
                 });
             }
         }
+        else if (e.kind === "page_out" && e.archive_ref && archiveStore?.read) {
+            try {
+                const archived = await archiveStore.read(e.archive_ref);
+                messages.push(...archived.map(message => ({
+                    ...message,
+                    content: sanitizeReplayText(message.content, maxBytes),
+                })));
+            }
+            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",
@@ -1754,14 +1994,6 @@ function nextArchivedSeqStart(events) {
     }
     return next;
 }
-function tryParseJson(s) {
-    try {
-        return JSON.parse(s);
-    }
-    catch {
-        return null;
-    }
-}
 export async function collectText(stream) {
     let text = "";
     for await (const evt of stream) {
@@ -1811,32 +2043,72 @@ function parseStartWorkflowSpec(argsStr) {
 }
 /** M5 v2.1: render an authored-workflow outcome into a user-message note injected back into the
  *  agent's context, so its 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
+/** Lower a claimed signal delivery to the kernel's `deliver_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). */
-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 ?? "signal"),
             payload: sig.payload ?? {},
             ...(sig.dedupeKey ? { dedupe_key: sig.dedupeKey } : {}),
+            ...(sig.recipient ? { recipient: sig.recipient } : {}),
+            ...(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(),
         },
     };
 }
+/** Convert SDK ContentParts (camelCase mediaType) to kernel serde shape (media_type). */
+function attachmentsToKernelMessage(parts) {
+    const content = parts.map(p => {
+        if (p.type === "image") {
+            return {
+                type: "image",
+                ...(p.url ? { url: p.url } : {}),
+                ...(p.data ? { data: p.data } : {}),
+                ...(p.mediaType ? { media_type: p.mediaType } : {}),
+                ...(p.detail ? { detail: p.detail } : {}),
+            };
+        }
+        if (p.type === "audio")
+            return { type: "audio", data: p.data, media_type: p.mediaType };
+        if (p.type === "text")
+            return { type: "text", text: p.text };
+        return { type: "text", text: "" };
+    });
+    return { role: "user", content };
+}