@deepstrike/wasm 0.2.35 → 0.2.37

package/dist/runtime/runner.js

@@ -10,8 +10,8 @@ import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass,
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
 import { resolveReducer } from "./reducers.js";
-import { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
-import { kernelObservationToSessionEvent, withCategory } from "./kernel-event-log.js";
+import { loopInstruction, classifyInstruction, judgeGoal, dependencyOutputsNote, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
+import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
 export class RuntimeRunner {
@@ -22,8 +22,15 @@ export class RuntimeRunner {
     pendingObservations = [];
     activeKernel = null;
     currentSessionId = null;
+    /** O2 (system-reminder channel): host-pushed notes awaiting the next turn-boundary drain. */
+    injectedSignals = [];
+    /** Skill names whose content has already been pushed into the durable `knowledge` slot this
+     *  run — guards against re-pushing a duplicate entry if the model calls `skill(name)` again for
+     *  an already-active skill (loading is idempotent; the knowledge push should be too). */
+    knowledgePushedSkills = new Set();
+    /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
+    currentGoal = "";
     nextArchiveStart = 0;
-    localPageOutCache = [];
     /** 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 = [];
@@ -33,6 +40,24 @@ export class RuntimeRunner {
     }
     get hostOptions() { return this.opts; }
     interrupt() { this.interrupted = true; this.abortController?.abort(); }
+    /** 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 kernel disposition ladder: `"normal"` queues (default), `"high"` soft-interrupts, `"critical"`
+     *  preempts. */
+    injectNote(text, urgency = "normal") {
+        this.injectedSignals.push({ source: "custom", signalType: "event", urgency, payload: { goal: text } });
+    }
+    /** Injected-note drain shared with the main loop's per-turn poll: injected notes first (FIFO), then
+     *  the configured `signalSource` — one code path so the two inbound channels never drift. */
+    async nextInboundSignal() {
+        const injected = this.injectedSignals.shift();
+        if (injected)
+            return injected;
+        if (!this.opts.signalSource)
+            return null;
+        return this.opts.signalSource.nextSignal();
+    }
     async *run(req) {
         const prior = req.inheritEvents ?? await this.opts.sessionLog.read(req.sessionId);
         const midRun = isMidRun(prior);
@@ -58,59 +83,35 @@ export class RuntimeRunner {
         const start = startEntry.event;
         yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true);
     }
-    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message. */
-    pushKnowledge(message, tokens) {
+    /** 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
+     *  compaction/renewal boundary) instead of appending a duplicate. `opts.pinned` exempts the
+     *  entry from the knowledge-budget sweep. */
+    pushKnowledge(message, tokens, opts) {
         if (!this.activeKernel)
             return;
         kernelApply(this.activeKernel, this.pendingObservations, {
             kind: "add_knowledge_message",
             content: message.content ?? "",
             tokens: tokens ?? Math.max(1, Math.ceil((message.content?.length ?? 0) / 4)),
+            ...(opts?.key !== undefined ? { key: opts.key } : {}),
+            ...(opts?.pinned ? { pinned: true } : {}),
         });
     }
-    /** Phase 4: satisfy kernel page-in requests before meta-tool execution. */
-    async applyKernelPageIn(runtime, sessionId) {
-        const requests = this.pendingObservations.filter((o) => o.kind === "page_in_requested" && typeof o.tool === "string");
-        if (requests.length === 0)
+    /** K1: mark a keyed knowledge entry for removal at the next compaction/renewal boundary.
+     *  Errs-open: an unknown key is a kernel-side no-op. */
+    removeKnowledge(key) {
+        if (!this.activeKernel)
             return;
-        const entries = [];
-        for (const req of requests) {
-            const query = typeof req.query === "string" ? req.query : "";
-            const topK = typeof req.top_k === "number" ? req.top_k : 5;
-            if (req.tool === "memory") {
-                const localHits = this.localPageOutCache.filter(m => typeof m.content === "string" && m.content.toLowerCase().includes(query.toLowerCase())).slice(0, topK);
-                for (const hit of localHits) {
-                    entries.push({
-                        content: `[local semantic cache] ${hit.role}: ${hit.content}`,
-                        source: "semantic_cache",
-                    });
-                }
-                const remainingK = topK - entries.length;
-                if (remainingK > 0 && this.opts.dreamStore && this.opts.agentId) {
-                    const hits = await this.opts.dreamStore.search(this.opts.agentId, query, remainingK);
-                    for (const hit of hits) {
-                        entries.push({
-                            content: `[memory score=${hit.score.toFixed(3)}] ${hit.text}`,
-                            source: "memory",
-                        });
-                    }
-                }
-            }
-            else if (req.tool === "knowledge" && this.opts.knowledgeSource) {
-                const snippets = await this.opts.knowledgeSource.retrieve(query, topK);
-                for (const snippet of snippets) {
-                    entries.push({ content: snippet, source: "knowledge" });
-                }
-            }
-        }
-        if (entries.length === 0)
+        kernelApply(this.activeKernel, this.pendingObservations, { kind: "remove_knowledge", key });
+    }
+    /** K3: host-driven skill deactivation — toolset re-widens at the next provider call, the
+     *  skill's knowledge pin drops at the next boundary. Errs-open: not-active is a no-op. */
+    deactivateSkill(name) {
+        if (!this.activeKernel)
             return;
-        kernelApply(runtime, this.pendingObservations, { kind: "page_in", entries });
-        await this.opts.sessionLog.append(sessionId, withCategory({
-            kind: "page_in",
-            turn: runtime.turn(),
-            entry_count: entries.length,
-        }));
+        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");
@@ -190,6 +191,63 @@ export class RuntimeRunner {
         }
         return { approved, denied, events };
     }
+    /**
+     * 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").
+     */
+    async resolveReadResult(sessionId, argsJson) {
+        let callId = "";
+        let offset = 0;
+        let maxBytes = 4000;
+        try {
+            const args = JSON.parse(argsJson || "{}");
+            callId = typeof args.call_id === "string" ? args.call_id : "";
+            if (typeof args.offset === "number" && Number.isFinite(args.offset))
+                offset = args.offset;
+            if (typeof args.max_bytes === "number" && Number.isFinite(args.max_bytes))
+                maxBytes = args.max_bytes;
+        }
+        catch {
+            // malformed arguments — callId stays empty, falls through to "not found" below
+        }
+        let full = this.pendingSpoolOutputs.get(callId)?.output;
+        if (full === undefined && this.opts.resultSpool) {
+            try {
+                full = await this.opts.resultSpool.findByCallId(callId);
+            }
+            catch {
+                full = undefined;
+            }
+        }
+        if (full === undefined) {
+            try {
+                const events = await this.opts.sessionLog.read(sessionId);
+                for (const { event } of events) {
+                    if (event.kind !== "tool_completed")
+                        continue;
+                    const match = event.results.find(r => r.call_id === callId);
+                    if (match)
+                        full = match.output;
+                }
+            }
+            catch {
+                full = undefined;
+            }
+        }
+        if (full === undefined) {
+            return { text: `no stored output for call_id "${callId}"`, isError: true };
+        }
+        const start = Math.max(0, offset);
+        const end = Math.min(full.length, start + Math.max(0, maxBytes));
+        const slice = full.slice(start, end);
+        return {
+            text: `[read_result ${callId}: chars ${start}–${end} of ${full.length}]\n${slice}`,
+            isError: false,
+        };
+    }
     async dream(agentId, nowMs = Date.now()) {
         if (!this.opts.dreamStore)
             throw new Error("dreamStore not configured");
@@ -351,14 +409,35 @@ export class RuntimeRunner {
                 messages: replayed.map(messageToKernelMessage),
             });
             // P1-B B3: rebuild active-skill gating after a wake (active_skills is not snapshotted).
+            // `knowledge` isn't snapshotted either (same graceful-reset philosophy) — best-effort re-push
+            // the skill's content from its replayed tool_result so the durable copy survives a wake too.
+            const toolResultByCallId = new Map();
+            for (const m of replayed) {
+                for (const part of m.contentParts ?? []) {
+                    if (part.type === "tool_result" && part.callId && part.output !== undefined) {
+                        toolResultByCallId.set(part.callId, part.output);
+                    }
+                }
+            }
             for (const m of replayed) {
                 for (const tc of m.toolCalls ?? []) {
                     if (tc.name !== "skill")
                         continue;
                     try {
                         const name = JSON.parse(tc.arguments || "{}").name;
-                        if (name)
-                            kernelApply(runtime, this.pendingObservations, { kind: "skill_activated", name });
+                        if (!name)
+                            continue;
+                        kernelApply(runtime, this.pendingObservations, {
+                            kind: "skill_activated",
+                            name,
+                            ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
+                        });
+                        const output = toolResultByCallId.get(tc.id);
+                        if (output && !this.knowledgePushedSkills.has(name)) {
+                            this.knowledgePushedSkills.add(name);
+                            // K1: keyed — the kernel-side upsert is the authoritative dedup across wake replays.
+                            this.pushKnowledge({ role: "system", content: output }, undefined, { key: `skill:${name}` });
+                        }
                     }
                     catch { /* skip */ }
                 }
@@ -386,24 +465,13 @@ export class RuntimeRunner {
             startPayload.run_spec = agentRunSpecToKernel(spec);
         }
         this.applyKernelPolicies(runtime);
-        // 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 */ }
+        // I4: pre-fetch memory before the first LLM turn (mirrors Node). Strict dynamic context
+        // control: single-use retrieval content, not a stable skill — lands in `history` like an
+        // ordinary `memory` tool result, so it decays with the compression pyramid instead of
+        // pinning itself in `knowledge` forever.
+        this.currentGoal = goal;
+        if (!resumeMidRun) {
+            await this.prefetchMemoryIntoHistory(runtime, "initial");
         }
         let action = resumeMidRun
             ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
@@ -413,16 +481,13 @@ export class RuntimeRunner {
         // 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);
-                }
                 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 (this.opts.signalSource || this.injectedSignals.length > 0) {
+                    const sig = await this.nextInboundSignal();
                     if (sig) {
                         const sigAction = kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig));
                         if (sigAction)
@@ -608,7 +673,16 @@ export class RuntimeRunner {
                     // 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");
+                    // O7: `read_result` re-fetches a tool output the kernel evicted from context. Content is
+                    // host-resolved: (a) this turn's in-memory pending spool map, (b) the on-disk result spool,
+                    // (c) a session-log scan for the original `tool_completed` event.
+                    const readResultCalls = allCalls.filter(c => c.name === "read_result");
+                    const normalCalls = allCalls.filter(c => c.name !== "submit_workflow_nodes" && c.name !== "start_workflow" && c.name !== "read_result");
+                    for (const call of readResultCalls) {
+                        const out = await this.resolveReadResult(sessionId, call.arguments);
+                        toolResults.push({ callId: call.id, output: out.text, isError: out.isError });
+                        yield { type: "tool_result", callId: call.id, content: out.text, isError: out.isError };
+                    }
                     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
@@ -630,7 +704,35 @@ export class RuntimeRunner {
                         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)) {
+                    // O5 (PreToolUse-hook analog): stateful host veto over each kernel-approved call.
+                    // A blocked call never executes; its reason reaches the model as a denied result.
+                    let executableCalls = normalCalls;
+                    if (this.opts.onToolCall) {
+                        const allowed = [];
+                        for (const call of normalCalls) {
+                            let decision;
+                            try {
+                                decision = await this.opts.onToolCall({ callId: call.id, name: call.name, arguments: call.arguments });
+                            }
+                            catch {
+                                decision = undefined;
+                            }
+                            if (decision?.block) {
+                                const reason = decision.reason ?? "blocked by host onToolCall hook";
+                                yield { type: "tool_denied", callId: call.id, toolName: call.name, reason };
+                                await this.opts.sessionLog.append(sessionId, {
+                                    kind: "tool_denied", turn: runtime.turn(), call_id: call.id, tool_name: call.name, reason,
+                                });
+                                const out = `blocked by host hook: ${reason}`;
+                                toolResults.push({ callId: call.id, output: out, isError: true, errorKind: "governance_denied" });
+                                yield { type: "tool_result", callId: call.id, name: call.name, content: out, isError: true };
+                                continue;
+                            }
+                            allowed.push(call);
+                        }
+                        executableCalls = allowed;
+                    }
+                    for await (const evt of this.opts.executionPlane.executeAll(executableCalls, runCtx)) {
                         yield evt;
                         if (evt.type === "tool_result") {
                             const tre = evt;
@@ -684,6 +786,31 @@ export class RuntimeRunner {
                             });
                         }
                     }
+                    // O5 (PostToolUse-hook analog): host inspection of each executed result before it reaches
+                    // the kernel/session-log — replace the output and/or inject a signal note. Errs-open.
+                    if (this.opts.onToolResult) {
+                        for (const r of toolResults) {
+                            const call = executableCalls.find(c => c.id === r.callId);
+                            if (!call)
+                                continue;
+                            let decision;
+                            try {
+                                decision = await this.opts.onToolResult({
+                                    callId: r.callId, name: call.name, arguments: call.arguments,
+                                    output: r.output, isError: r.isError,
+                                });
+                            }
+                            catch {
+                                decision = undefined;
+                            }
+                            if (!decision)
+                                continue;
+                            if (typeof decision.replaceOutput === "string")
+                                r.output = decision.replaceOutput;
+                            if (decision.note)
+                                this.injectNote(decision.note);
+                        }
+                    }
                     await this.opts.sessionLog.append(sessionId, {
                         kind: "tool_completed",
                         turn: runtime.turn(),
@@ -701,6 +828,12 @@ export class RuntimeRunner {
                         }
                     }
                     // 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
+                    // for the rest of the run, unlike a one-off memory/knowledge lookup (fact content, relevant
+                    // for the moment it's used). So its text ALSO goes into the durable `knowledge` slot here
+                    // (in addition to the ordinary tool_result already headed for `history`, where it will decay
+                    // with the compression pyramid like any other tool output). First activation only.
                     for (const call of allCalls) {
                         if (call.name !== "skill")
                             continue;
@@ -709,8 +842,20 @@ export class RuntimeRunner {
                             continue;
                         try {
                             const name = JSON.parse(call.arguments || "{}").name;
-                            if (name)
-                                kernelApply(runtime, this.pendingObservations, { kind: "skill_activated", name });
+                            if (!name)
+                                continue;
+                            kernelApply(runtime, this.pendingObservations, {
+                                kind: "skill_activated",
+                                name,
+                                ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
+                            });
+                            // With a lease configured, skip the Set optimization: an expired-then-reloaded skill
+                            // must re-pin — only the kernel knows the lease state; its upsert dedupes anyway.
+                            if (this.opts.skillLeaseTurns !== undefined || !this.knowledgePushedSkills.has(name)) {
+                                this.knowledgePushedSkills.add(name);
+                                // K1: keyed `skill:<name>` — the kernel-side upsert dedupes across runner instances.
+                                this.pushKnowledge({ role: "system", content: res.output }, undefined, { key: `skill:${name}` });
+                            }
                         }
                         catch { /* skip */ }
                     }
@@ -814,7 +959,14 @@ export class RuntimeRunner {
                 catch { /* non-fatal */ }
             }
         }
-        yield { type: "done", iterations: turnsUsed, totalTokens, status };
+        yield {
+            type: "done",
+            iterations: turnsUsed,
+            totalTokens,
+            status,
+            // ③ loop-agent: surface the kernel-adjudicated after-round decision to the driver.
+            ...(result?.paceDecision ? { paceDecision: result.paceDecision } : {}),
+        };
         this.activeKernel = null;
         this.currentSessionId = null;
     }
@@ -864,7 +1016,10 @@ export class RuntimeRunner {
         const manifest = workflowNodeToManifest(node, parentSessionId);
         // G4: surface remaining workflow budget so a coordinator node can size its submission.
         const budgetNote = workflowBudgetNote(budget);
-        const withBudget = (goal) => (budgetNote ? `${goal}\n\n${budgetNote}` : goal);
+        // W-N2: a DAG edge carries data — every dependent node sees its dependencies' outputs (the
+        // kernel sends `input_agent_ids` for all dependents; judges/reduce keep their special paths).
+        const depsNote = dependencyOutputsNote(node.input_agent_ids, outputs);
+        const withBudget = (goal) => [goal, depsNote, budgetNote].filter(Boolean).join("\n\n");
         const mkCtx = (goal) => ({
             parentOpts: this.opts,
             parentSessionId,
@@ -873,6 +1028,10 @@ export class RuntimeRunner {
             sessionLog: this.opts.sessionLog,
             // M5 v2.1: this child IS a workflow node — its `start_workflow` flattens to this kernel.
             isWorkflowNode: true,
+            // W-N1: trusted workflow nodes run on the parent's execution plane (they carry no grant list
+            // by design — filtering on the missing list ran every DAG node TOOL-LESS); quarantined nodes
+            // stay deny-all filtered (they read untrusted content).
+            toolAccess: (node.trust === "quarantined" ? "filtered" : "inherit"),
             // #2-B-ii: the per-node abort signal the driver fires when the kernel preempts this node.
             ...(abortSignal ? { abortSignal } : {}),
         });
@@ -892,9 +1051,18 @@ export class RuntimeRunner {
             const winnerId = winner === "right" ? node.judge_match.right : node.judge_match.left;
             return withSignal(result, { tournamentWinner: winnerId });
         }
-        // A#2 v2 loop iteration: run the increment, then extract a stop signal. No signal ⇒ run to cap.
+        // A#2 v2 loop iteration: run the increment under the armed pacing trap (workflowNodeToSpec set
+        // `loopRound`, and the iteration resumes the loop's stable session — transcript-as-carry).
+        // DW-3 one vocabulary: the kernel-adjudicated `pace` verb IS the continuation signal
+        // (stop → loopContinue=false); the legacy text-sniffed JSON blob survives only as the fallback
+        // when no pace decision arrives (stub orchestrators, harness children), where no signal still
+        // means "run to max_iters" (v1).
         if (node.loop_max_iters != null) {
-            const result = await orchestrator.run(mkCtx(`${baseSpec.goal}\n\n${loopInstruction(node.loop_max_iters)}`));
+            const iteration = Number(/-i(\d+)$/.exec(node.agent_id)?.[1] ?? "0");
+            const result = await orchestrator.run(mkCtx(`${baseSpec.goal}\n\n${loopInstruction(node.loop_max_iters, iteration)}`));
+            const pace = result.result.paceDecision;
+            if (pace)
+                return withSignal(result, { loopContinue: pace.action !== "stop" });
             const cont = extractLoopContinue(textOf(result));
             return cont === undefined ? result : withSignal(result, { loopContinue: cont });
         }
@@ -991,6 +1159,21 @@ export class RuntimeRunner {
                     : {}),
             };
         }
+        // O6: tune/disable the in-kernel repeat fuse (absent ⇒ kernel defaults: enabled, 5/8).
+        if (this.opts.repeatFuse !== undefined) {
+            const rf = this.opts.repeatFuse;
+            config.repeat_fuse = rf === false
+                ? { enabled: false, deny_after: 0, terminate_after: 0 }
+                : { enabled: true, deny_after: rf.denyAfter ?? 5, terminate_after: rf.terminateAfter ?? 8 };
+        }
+        // O4: turn-end criteria gate toggle (absent ⇒ kernel default: enabled).
+        if (this.opts.criteriaGate !== undefined) {
+            config.criteria_gate = this.opts.criteriaGate;
+        }
+        // K2: knowledge budget ratio (absent ⇒ kernel default 0.25; 0 disables).
+        if (this.opts.knowledgeBudgetRatio !== undefined) {
+            config.knowledge_budget_ratio = this.opts.knowledgeBudgetRatio;
+        }
         kernelApply(runtime, this.pendingObservations, { kind: "configure_run", config });
         if (this.opts.memoryPolicy) {
             const m = this.opts.memoryPolicy;
@@ -1055,10 +1238,22 @@ export class RuntimeRunner {
                 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
+                    ? {
+                        resumed_results: opts.resumedResults.map(r => ({
+                            agent_id: r.agentId,
+                            ...(r.classifyBranch !== undefined ? { classify_branch: r.classifyBranch } : {}),
+                            ...(r.tournamentWinner !== undefined ? { tournament_winner: r.tournamentWinner } : {}),
+                            ...(r.loopContinue !== undefined ? { loop_continue: r.loopContinue } : {}),
+                        })),
+                    }
+                    : {}),
                 // R3-1: re-apply recorded runtime submissions so dynamically-appended nodes are reconstructed.
                 ...(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);
+            return await this.driveWorkflow(observations, parentSessionId, runtime, opts?.resumedOutputs);
         }
         finally {
             if (bootstrapped) {
@@ -1081,6 +1276,18 @@ export class RuntimeRunner {
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
         const observations = kernelApply(runtime, this.pendingObservations, submitWorkflowToKernel(spec, parentSessionId, opts?.submitterAgentId));
+        // 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.
+        const submitted = observations.find(o => o.kind === "workflow_nodes_submitted");
+        if (submitted) {
+            await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodesSubmittedEvent({
+                turn: runtime.turn(),
+                nodes: workflowSpecToKernel(spec).nodes ?? [],
+                baseIndex: submitted.base,
+                submitterAgentId: opts?.submitterAgentId,
+            }));
+        }
         return this.driveWorkflow(observations, parentSessionId, runtime);
     }
     /**
@@ -1113,7 +1320,8 @@ export class RuntimeRunner {
         if (!source)
             return null;
         while (!batchState.settled) {
-            const sig = await source.nextSignal();
+            // O2: injected notes participate in the monitor too (drain order matches nextInboundSignal).
+            const sig = this.injectedSignals.shift() ?? await source.nextSignal();
             if (batchState.settled)
                 break;
             if (!sig) {
@@ -1136,7 +1344,7 @@ 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) {
+    async driveWorkflow(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 ?? [];
@@ -1149,7 +1357,9 @@ export class RuntimeRunner {
         let nodes = collectNodes(observations);
         let budget = collectBudget(observations);
         // G2: each completed node's output, keyed by agent id — a reduce node reads its deps' outputs.
-        const outputs = new Map();
+        // 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) };
@@ -1169,7 +1379,13 @@ export class RuntimeRunner {
             for (const result of results) {
                 // G2: record this node's output so a downstream reduce node can consume it.
                 const outContent = result.result.finalMessage?.content;
-                outputs.set(result.agentId, typeof outContent === "string" ? outContent : outContent != null ? JSON.stringify(outContent) : "");
+                const outText = typeof outContent === "string" ? outContent : outContent != null ? JSON.stringify(outContent) : "";
+                outputs.set(result.agentId, outText);
+                // A loop iteration completes under `wf-node{N}-i{k}` but its dependents consume the STABLE
+                // node id `wf-node{N}` — alias it so the LAST iteration's output is what dependents see.
+                const stableId = result.agentId.replace(/-i\d+$/, "");
+                if (stableId !== result.agentId)
+                    outputs.set(stableId, outText);
                 // R3-1: if this node's agent submitted more nodes, append them to the parent DAG BEFORE
                 // reporting the node's completion — the workflow is still active, so even a last-node
                 // submission keeps the DAG alive.
@@ -1180,10 +1396,15 @@ export class RuntimeRunner {
                     const subObs = kernelApply(runtime, this.pendingObservations, submitEvent);
                     nextNodes.push(...collectNodes(subObs));
                     budget = collectBudget(subObs) ?? budget;
-                    // R3-1: persist the submission (kernel-shape nodes) so resume can re-apply it.
+                    // 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,
                     }));
                 }
                 const obs = kernelApply(runtime, this.pendingObservations, {
@@ -1195,11 +1416,17 @@ export class RuntimeRunner {
                 const d = findDone(obs);
                 if (d)
                     done = d;
-                // Persist node completion for resume recovery.
+                // Persist node completion for resume recovery. W-1: the result-borne control signals ride
+                // along (a resumed classifier re-prunes; a recorded loop stop is honored) plus the output
+                // text (post-resume dependents/reduce still see this node's output).
                 await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodeCompletedEvent({
                     turn: runtime.turn(),
                     agentId: result.agentId,
                     termination: result.result.termination,
+                    classifyBranch: result.result.classifyBranch,
+                    tournamentWinner: result.result.tournamentWinner,
+                    loopContinue: result.result.loopContinue,
+                    ...(result.result.termination === "completed" && outText ? { output: outText } : {}),
                 }));
             }
             if (done && nextNodes.length === 0) {
@@ -1210,8 +1437,9 @@ export class RuntimeRunner {
     }
     /**
      * Resume a workflow from the parent session's completed nodes.
-     * Reads the session log, extracts completed workflow node agent_ids, and
-     * calls runWorkflow with resumedCompleted so the kernel skips those nodes.
+     * Reads the session log, extracts completed workflow node records (with their W-1 control
+     * signals + outputs), and calls runWorkflow so the kernel skips those nodes, replays control
+     * flow (classify prune / loop stop), and the driver re-seeds its outputs map.
      */
     async resumeWorkflow(spec, opts) {
         // Standalone resume: a stateless handler passes the prior `sessionId`; mid-run callers omit it.
@@ -1220,9 +1448,34 @@ 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 resumedCompleted = recoverCompletedWorkflowNodes(events);
-        const resumedSubmissions = recoverSubmittedWorkflowNodes(events);
-        return this.runWorkflow(spec, { resumedCompleted, resumedSubmissions, sessionId });
+        const resumedResults = recoverCompletedWorkflowNodes(events);
+        const completedIds = new Set(resumedResults.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.
+        let { submissions, bases } = recovered;
+        if (bases.length === submissions.length && 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,
+            resumedSubmissions: submissions,
+            resumedSubmissionBases: bases,
+            resumedOutputs,
+            sessionId,
+        });
     }
     async appendObservations(sessionId, runtime, nextArchiveStart) {
         const turn = runtime.turn();
@@ -1258,22 +1511,67 @@ export class RuntimeRunner {
             });
             if (!event)
                 continue;
-            if (obs.kind === "page_out" && obs.archived) {
-                this.localPageOutCache.push(...obs.archived);
-            }
             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.kind === "page_out"
-                && obs.tier_hint === "semantic"
-                && Array.isArray(obs.archived)
-                && obs.archived.length > 0) {
-                void this.archiveSemanticPageOut(obs.archived, compressionAction(obs.action));
+            // 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).
+            if (obs.kind === "renewed") {
+                await this.prefetchMemoryIntoHistory(runtime, "renewal");
             }
         }
         return nextArchiveStart;
     }
+    /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
+     *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
+     *  never pinned into `knowledge`. `phase: "initial"` = once before turn 1; `phase: "renewal"` =
+     *  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)
+            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]);
+        try {
+            const queries = await preQuery({ goal: this.currentGoal, phase });
+            const lines = [];
+            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) {
+                    lines.push(`[memory score=${hit.score.toFixed(3)}] ${hit.text}`);
+                }
+            }
+            if (lines.length > 0) {
+                kernelApply(runtime, this.pendingObservations, {
+                    kind: "add_history_message",
+                    message: { role: "user", content: lines.join("\n") },
+                });
+            }
+        }
+        catch { /* errs-open */ }
+    }
     async archiveSemanticPageOut(archived, action) {
         if (!this.opts.dreamStore || !this.opts.agentId)
             return;
@@ -1282,8 +1580,12 @@ export class RuntimeRunner {
                 ? 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: 1.0, metadata: { source: "semantic_page_out", action } }],
+                toAdd: [{ text: summary, score: 0.6, metadata: { source: "semantic_page_out", action } }],
                 toRemoveIndices: [],
                 stats: {
                     insightsProcessed: 1,
@@ -1298,6 +1600,19 @@ export class RuntimeRunner {
         }
     }
 }
+/** 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}`)