@deepstrike/wasm 0.2.22 → 0.2.25

package/dist/runtime/runner.js

@@ -1,8 +1,9 @@
 import { resolvePermissionRequest } from "./execution-plane.js";
-import { governancePolicyToKernelEvent } from "../governance.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 { forceCompact, 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";
@@ -434,335 +435,402 @@ export class RuntimeRunner {
                 ...(m.maxNameLength !== undefined ? { max_name_length: m.maxNameLength } : {}),
             });
         }
+        // I4: pre-fetch memory into the knowledge partition before the first LLM turn (mirrors Node).
+        if (!resumeMidRun && this.opts.preQueryMemory && this.opts.dreamStore && this.opts.agentId) {
+            try {
+                const queries = await this.opts.preQueryMemory({ goal });
+                const entries = [];
+                for (const q of queries ?? []) {
+                    if (typeof q !== "string" || !q.trim())
+                        continue;
+                    const hits = await this.opts.dreamStore.search(this.opts.agentId, q, 5);
+                    for (const hit of hits) {
+                        entries.push({ content: `[memory score=${hit.score.toFixed(3)}] ${hit.text}`, source: "memory" });
+                    }
+                }
+                if (entries.length > 0) {
+                    kernelApply(runtime, this.pendingObservations, { kind: "page_in", entries });
+                }
+            }
+            catch { /* errs-open */ }
+        }
         let action = resumeMidRun
             ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
             : kernelAction(runtime, this.pendingObservations, startPayload);
         let hasAttemptedReactiveCompact = false;
         // P0-C: the skill loaded and in effect going into the current turn → per-turn `activeSkill` metric.
         let activeSkill;
-        while (!runtime.isTerminal()) {
-            if (action.kind === "execute_tool") {
-                await this.applyKernelPageIn(runtime, sessionId);
-            }
-            nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-            if (this.interrupted) {
-                action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
-                break;
-            }
-            if (this.opts.signalSource) {
-                const sig = await this.opts.signalSource.nextSignal();
-                if (sig) {
-                    const sigAction = kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig));
-                    if (sigAction)
-                        action = sigAction;
+        // I0b: kernel-throw safety net — see Node runner for full rationale.
+        try {
+            while (!runtime.isTerminal()) {
+                if (action.kind === "execute_tool") {
+                    await this.applyKernelPageIn(runtime, sessionId);
                 }
-            }
-            if (runtime.isTerminal())
-                break;
-            if (action.kind === "call_provider") {
-                // M5 v2.1: top-level auto-pivot at the safe point (kernel in Reason, not suspended). Loop-top
-                // placement catches every path to `call_provider` (incl. post-approval-resume), so a queued
-                // authored spec is never stranded. Drains the queue; fires once per authored batch.
-                if (this.pendingAuthoredWorkflows.length > 0) {
-                    action = await this.driveAuthoredWorkflows(runtime, action);
+                nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+                if (this.interrupted) {
+                    action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
+                    break;
                 }
-                const finalToolCalls = [];
-                let finalText = "";
-                const context = action.context;
-                const tools = action.tools;
-                let turnTokens = 0;
-                let turnInputTokens = 0;
-                let turnOutputTokens = 0;
-                let turnCacheReadTokens = 0;
-                let turnCacheCreationTokens = 0;
-                let shouldRetry = false;
-                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.
-                        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;
-                            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) });
-                        }
+                if (this.opts.signalSource) {
+                    const sig = await this.opts.signalSource.nextSignal();
+                    if (sig) {
+                        const sigAction = kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig));
+                        if (sigAction)
+                            action = sigAction;
+                        // I0a: Critical signal carries user_abort intent; see Node runner for full rationale.
+                        if (sig.urgency === "critical")
+                            this.interrupted = true;
                     }
                 }
-                catch (err) {
-                    // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat as an interrupt.
-                    if (abortSignal?.aborted) {
-                        this.interrupted = true;
+                if (runtime.isTerminal())
+                    break;
+                if (action.kind === "call_provider") {
+                    // M5 v2.1: top-level auto-pivot at the safe point (kernel in Reason, not suspended). Loop-top
+                    // placement catches every path to `call_provider` (incl. post-approval-resume), so a queued
+                    // authored spec is never stranded. Drains the queue; fires once per authored batch.
+                    if (this.pendingAuthoredWorkflows.length > 0) {
+                        action = await this.driveAuthoredWorkflows(runtime, action);
+                    }
+                    const finalToolCalls = [];
+                    let finalText = "";
+                    // I5: governance schema-level pre-filter — see Node runner for full rationale.
+                    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,
+                            };
+                        }
+                    }
+                    let turnTokens = 0;
+                    let turnInputTokens = 0;
+                    let turnOutputTokens = 0;
+                    let turnCacheReadTokens = 0;
+                    let turnCacheCreationTokens = 0;
+                    let turnCacheReadBySlot;
+                    let shouldRetry = false;
+                    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.
+                            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 to TurnMetrics; undefined on non-Anthropic providers.
+                                turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                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) });
+                            }
+                        }
                     }
-                    const errMsg = String(err).toLowerCase();
-                    if ((errMsg.includes("413") || errMsg.includes("too long") || errMsg.includes("context length exceeded") || errMsg.includes("context_length_exceeded")) &&
-                        !hasAttemptedReactiveCompact) {
-                        hasAttemptedReactiveCompact = true;
-                        if (forceCompact(runtime, this.pendingObservations)) {
-                            nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-                            shouldRetry = true;
+                    catch (err) {
+                        // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat as an interrupt.
+                        if (abortSignal?.aborted) {
+                            this.interrupted = true;
+                        }
+                        const errMsg = formatToolError(err).toLowerCase();
+                        if ((errMsg.includes("413") || errMsg.includes("too long") || errMsg.includes("context length exceeded") || errMsg.includes("context_length_exceeded")) &&
+                            !hasAttemptedReactiveCompact) {
+                            hasAttemptedReactiveCompact = true;
+                            if (forceCompact(runtime, this.pendingObservations)) {
+                                nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+                                shouldRetry = true;
+                            }
+                        }
+                        if (!shouldRetry) {
+                            yield { type: "error", message: formatToolError(err) };
+                            action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
+                            break;
                         }
                     }
-                    if (!shouldRetry) {
-                        yield { type: "error", message: String(err) };
+                    // #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" });
                         break;
                     }
-                }
-                // #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" });
-                    break;
-                }
-                if (shouldRetry) {
-                    action = {
-                        kind: "call_provider",
-                        context: runtime.render(),
-                        tools,
+                    if (shouldRetry) {
+                        action = {
+                            kind: "call_provider",
+                            context: runtime.render(),
+                            tools,
+                        };
+                        continue;
+                    }
+                    const assistantMessage = {
+                        role: "assistant",
+                        content: finalText,
+                        toolCalls: finalToolCalls,
+                        tokenCount: turnOutputTokens || turnTokens || undefined,
                     };
-                    continue;
-                }
-                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(),
-                };
-                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);
-                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: per-turn tool-gating telemetry. `activeSkill` reflects the skill in effect GOING INTO
-                // this turn; a `skill` call here only takes effect next turn — emit first, then advance.
-                if (this.opts.onTurnMetrics) {
-                    try {
-                        this.opts.onTurnMetrics({
-                            turn: runtime.turn(),
-                            toolsExposed: tools.length,
-                            toolsCalled: finalToolCalls.length,
-                            activeSkill,
-                            inputTokens: turnInputTokens,
-                            cacheReadTokens: turnCacheReadTokens,
-                            cacheCreationTokens: turnCacheCreationTokens,
+                    const providerEvent = {
+                        kind: "provider_result",
+                        message: messageToKernelMessage(assistantMessage),
+                        ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
+                        ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
+                        now_ms: Date.now(),
+                    };
+                    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,
                         });
                     }
-                    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;
+                    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: per-turn tool-gating telemetry. `activeSkill` reflects the skill in effect GOING INTO
+                    // this turn; a `skill` call here only takes effect next turn — emit first, then advance.
+                    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 } : {}),
+                            });
+                        }
+                        catch { /* metrics must never break the run */ }
                     }
-                    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,
-                    skillContentMap: this.opts.skillContentMap,
-                    dreamStore: this.opts.dreamStore,
-                    knowledgeSource: this.opts.knowledgeSource,
-                    onToolSuspend: this.opts.onToolSuspend,
-                    onPermissionRequest: this.opts.onPermissionRequest,
-                };
-                const toolResults = [];
-                // R3-1: intercept `submit_workflow_nodes` — it can't apply to this runner's kernel (when this
-                // runner is a workflow node, the workflow lives in the parent). Surface the nodes as an event;
-                // the orchestrator collects them and `runWorkflow` sends them to the parent kernel.
-                // M5 v1: `start_workflow` (author a sub-workflow) flattens to the same append path.
-                const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes" || c.name === "start_workflow");
-                const normalCalls = allCalls.filter(c => c.name !== "submit_workflow_nodes" && c.name !== "start_workflow");
-                for (const call of submitCalls) {
-                    // M5 v2.1: a TOP-LEVEL agent authoring a whole sub-workflow via `start_workflow` — record the
-                    // spec and AUTO-PIVOT once this tool turn resolves. A workflow-NODE's `start_workflow` (and
-                    // every `submit_workflow_nodes`) instead FLATTENS 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;
+                    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 */ }
                     }
-                    const nodes = call.name === "start_workflow"
-                        ? parseStartWorkflowArgs(call.arguments)
-                        : parseSubmitWorkflowNodesArgs(call.arguments);
-                    yield { type: "workflow_nodes_submitted", nodes };
-                    toolResults.push({ callId: call.id, output: "submitted", isError: false });
-                    yield { type: "tool_result", callId: call.id, content: "submitted", isError: false };
                 }
-                for await (const evt of this.opts.executionPlane.executeAll(normalCalls, 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 (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,
+                        skillContentMap: this.opts.skillContentMap,
+                        dreamStore: this.opts.dreamStore,
+                        knowledgeSource: this.opts.knowledgeSource,
+                        onToolSuspend: this.opts.onToolSuspend,
+                        onPermissionRequest: this.opts.onPermissionRequest,
+                    };
+                    const toolResults = [];
+                    // R3-1: intercept `submit_workflow_nodes` — it can't apply to this runner's kernel (when this
+                    // runner is a workflow node, the workflow lives in the parent). Surface the nodes as an event;
+                    // the orchestrator collects them and `runWorkflow` sends them to the parent kernel.
+                    // M5 v1: `start_workflow` (author a sub-workflow) flattens to the same append path.
+                    const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes" || c.name === "start_workflow");
+                    const normalCalls = allCalls.filter(c => c.name !== "submit_workflow_nodes" && c.name !== "start_workflow");
+                    for (const call of submitCalls) {
+                        // M5 v2.1: a TOP-LEVEL agent authoring a whole sub-workflow via `start_workflow` — record the
+                        // spec and AUTO-PIVOT once this tool turn resolves. A workflow-NODE's `start_workflow` (and
+                        // every `submit_workflow_nodes`) instead FLATTENS 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;
+                            }
+                        }
+                        const nodes = call.name === "start_workflow"
+                            ? parseStartWorkflowArgs(call.arguments)
+                            : parseSubmitWorkflowNodesArgs(call.arguments);
+                        yield { type: "workflow_nodes_submitted", nodes };
+                        toolResults.push({ callId: call.id, output: "submitted", isError: false });
+                        yield { type: "tool_result", callId: call.id, content: "submitted", isError: false };
                     }
-                    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,
-                        });
+                    for await (const evt of this.opts.executionPlane.executeAll(normalCalls, 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: typeof pre.arguments === "string" ? pre.arguments : JSON.stringify(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 === "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,
-                        });
+                    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 allCalls) {
+                        const result = toolResults.find(r => r.callId === call.id);
+                        if (result) {
+                            this.pendingSpoolOutputs.set(call.id, { tool: call.name, output: result.output });
+                        }
                     }
-                    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: typeof pre.arguments === "string" ? pre.arguments : JSON.stringify(pre.arguments),
-                            reason: pre.reason,
-                        });
+                    // P1-B B3: a successfully-resolved `skill` call activates that skill for the next turn.
+                    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)
+                                kernelApply(runtime, this.pendingObservations, { kind: "skill_activated", name });
+                        }
+                        catch { /* skip */ }
                     }
-                    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,
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "tool_results",
+                        results: toolResults.map(toolResultToKernel),
+                    });
+                }
+                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)),
                         });
+                        nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
                     }
-                }
-                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 allCalls) {
-                    const result = toolResults.find(r => r.callId === call.id);
-                    if (result) {
-                        this.pendingSpoolOutputs.set(call.id, { tool: call.name, output: result.output });
+                    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),
+                        });
+                        nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
                     }
-                }
-                // P1-B B3: a successfully-resolved `skill` call activates that skill for the next turn.
-                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)
-                            kernelApply(runtime, this.pendingObservations, { kind: "skill_activated", name });
+                    else {
+                        nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+                        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;
                     }
-                    catch { /* skip */ }
                 }
-                action = kernelAction(runtime, this.pendingObservations, {
-                    kind: "tool_results",
-                    results: toolResults.map(toolResultToKernel),
-                });
-            }
-            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)),
-                    });
-                    nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-                }
-                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),
-                    });
-                    nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-                }
-                else {
-                    nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-                    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) is observable here —
+            // emit run_terminal so downstream code sees a clean end rather than mid-loop EOF.
+            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 */ }
+            yield { type: "done", iterations: runtime.turn() || 0, totalTokens: 0, status: reason };
+            this.activeKernel = null;
+            this.currentSessionId = null;
+            return;
         }
         const result = action.kind === "done" ? action.result : undefined;
-        const status = result?.termination ?? "error";
+        // 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 turnsUsed = result ? Math.max(1, result.turnsUsed) : runtime.turn() || 0;
         const totalTokens = result?.totalTokensUsed ?? 0;
         nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
@@ -931,7 +999,7 @@ export class RuntimeRunner {
             return ok(reducer(inputs), "completed");
         }
         catch (err) {
-            return ok(`reducer "${node.reducer}" threw: ${err instanceof Error ? err.message : String(err)}`, "error");
+            return ok(`reducer "${node.reducer}" threw: ${formatToolError(err)}`, "error");
         }
     }
     /**