@deepstrike/sdk 0.2.35 → 0.2.37

package/dist/runtime/runner.js

@@ -10,9 +10,9 @@ 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 { loopInstruction, classifyInstruction, judgeGoal, dependencyOutputsNote, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
 import { governancePolicyToKernelEvent, governanceFilterSchema } from "../governance.js";
-import { kernelObservationToSessionEvent, withCategory } from "./kernel-event-log.js";
+import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
 import { formatToolError } from "../tools/errors.js";
@@ -25,11 +25,17 @@ export class RuntimeRunner {
     activeKernel = null;
     pendingObservations = [];
     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();
     nextArchiveStart = 0;
+    /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
+    currentGoal = "";
     /** Full tool outputs keyed by call_id until Layer-1 spool observations are logged. */
     pendingSpoolOutputs = new Map();
-    /** Local cache of paged-out/archived messages for priority memory retrieval. */
-    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 — not suspended). */
     pendingAuthoredWorkflows = [];
@@ -66,23 +72,30 @@ export class RuntimeRunner {
             return;
         }
         const existing = await this.opts.dreamStore.loadMemories(agentId);
-        await this.opts.dreamStore.commit(agentId, {
-            toAdd: [{
-                    text: memory.content,
-                    score: 1.0,
-                    metadata: {
-                        ...memory.metadata,
-                        source: "write_memory_syscall",
-                    },
-                }],
-            toRemoveIndices: [],
-            stats: {
-                insightsProcessed: 1,
-                duplicatesRemoved: 0,
-                conflictsResolved: 0,
-                entriesAdded: 1,
-            },
-        }, existing);
+        // Curator-style jaccard dedup at the single write path: a near-duplicate of an
+        // existing entry is dropped (the observation is still logged for audit).
+        const isDuplicate = existing.some(e => jaccardSimilarity(e.text, memory.content) >= 0.9);
+        if (!isDuplicate) {
+            const meta = memory.metadata;
+            const score = typeof meta?.score === "number" ? meta.score : 1.0;
+            await this.opts.dreamStore.commit(agentId, {
+                toAdd: [{
+                        text: memory.content,
+                        score,
+                        metadata: {
+                            ...memory.metadata,
+                            source: meta?.source ?? "write_memory_syscall",
+                        },
+                    }],
+                toRemoveIndices: [],
+                stats: {
+                    insightsProcessed: 1,
+                    duplicatesRemoved: 0,
+                    conflictsResolved: 0,
+                    entriesAdded: 1,
+                },
+            }, existing);
+        }
         await this.appendMemorySyscallObservations(sessionId, observations);
     }
     async queryMemory(query, opts = {}) {
@@ -110,24 +123,19 @@ export class RuntimeRunner {
             }
         }
         await this.appendMemorySyscallObservations(sessionId, observations);
-        await this.logMemoryRetrievalResult(sessionId, runtime, retrieval);
+        await this.logMemoryRetrievalResult(sessionId, retrieval);
         return hits;
     }
-    async logMemoryRetrievalResult(sessionId, runtime, retrieval) {
+    async logMemoryRetrievalResult(sessionId, retrieval) {
         if (!sessionId)
             return;
+        // The session-log record is the durable audit artifact; the kernel needs no
+        // acknowledgment (the former kernel event was a no-op and was removed).
         await this.opts.sessionLog.append(sessionId, {
             kind: "memory_retrieval_result",
             selected_memory_ids: retrieval.selected_memory_ids,
             selection_rationale: retrieval.selection_rationale,
         });
-        kernelApply(runtime, [], {
-            kind: "memory_retrieval_result",
-            retrieval: {
-                selected_memory_ids: retrieval.selected_memory_ids,
-                selection_rationale: retrieval.selection_rationale,
-            },
-        });
     }
     createSyscallRuntime() {
         const { KernelRuntime } = getKernel();
@@ -146,7 +154,7 @@ export class RuntimeRunner {
      * exactly as a mid-run spawn would be. Must run BEFORE `start_run` so the in-kernel gate enforces
      * every policy from the first spawn. No config ⇒ the native-profile defaults (铁律: defaults only).
      */
-    applyKernelPolicies(runtime, groupTokensBase, groupSpawnsBase) {
+    applyKernelPolicies(runtime, groupTokensBase, groupSpawnsBase, groupRoundsBase) {
         // K2: lower governance / attention / scheduler / quota in ONE `configure_run` event instead of
         // the previous 2–4 separate `set_*` / `load_governance_policy` events. The kernel applies each
         // present field via the same path its granular event uses; absent fields are left untouched.
@@ -181,6 +189,26 @@ export class RuntimeRunner {
         if (groupSpawnsBase !== undefined && groupSpawnsBase > 0) {
             config.group_spawns_base = groupSpawnsBase;
         }
+        if (groupRoundsBase !== undefined && groupRoundsBase > 0) {
+            // ③ loop-agent: completed-round count seeds the pacing trap's max_rounds coercion.
+            config.group_rounds_base = groupRoundsBase;
+        }
+        // O6: tune/disable the in-kernel repeat fuse. `false` disables; an object overrides thresholds.
+        // Absent ⇒ kernel defaults (enabled, deny_after=5, terminate_after=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 });
     }
     async appendMemorySyscallObservations(sessionId, observations) {
@@ -221,62 +249,39 @@ export class RuntimeRunner {
             return;
         kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandUnmount(kind, id));
     }
-    /** 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)
-            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") {
-                // Priority search: Local Page-Out Cache (lexical/keyword filter)
-                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",
-                    });
-                }
-                // Fall back to dreamStore for the remainder if needed
-                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)
-            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,
-        }));
-    }
-    /** Push content into the Knowledge slot (memory retrievals, skill definitions, artifacts). */
-    pushKnowledge(message, tokens) {
+    /** Push content into the Knowledge slot (memory retrievals, skill definitions, artifacts).
+     *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
+     *  compaction/renewal boundary, where the cached system[1] block is rewritten anyway) instead
+     *  of appending a duplicate. `opts.pinned` exempts the entry from the knowledge-budget sweep. */
+    pushKnowledge(message, tokens, opts) {
         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 } : {}),
         });
     }
+    /** 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;
+        kernelApply(this.activeKernel, this.pendingObservations, { kind: "remove_knowledge", key });
+    }
+    /** K3: host-driven skill deactivation (there is deliberately no model-facing unload — it
+     *  invites thrash). The toolset re-widens at the next provider call; the skill's knowledge pin
+     *  drops at the next compaction/renewal boundary. A later `skill(name)` call re-activates and
+     *  re-pins fresh content. Errs-open: not-active is a kernel-side no-op. */
+    deactivateSkill(name) {
+        if (!this.activeKernel)
+            return;
+        kernelApply(this.activeKernel, this.pendingObservations, { kind: "skill_deactivated", name });
+        // Re-arm the SDK-side push guard so a re-activation re-pins the content.
+        this.knowledgePushedSkills.delete(name);
+    }
     /**
      * Spawn an isolated sub-agent via the kernel, run it on the host, and feed the result back.
      * Requires an active parent run (`run()` / `wake()` in progress or paused at milestone).
@@ -331,7 +336,10 @@ export class RuntimeRunner {
         // G4: surface the workflow's remaining budget to the node's agent so a coordinator can size its
         // `submit_workflow_nodes` batch to what is available (empty string ⇒ unbounded, no note).
         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,
@@ -341,6 +349,10 @@ export class RuntimeRunner {
             // M5 v2.1: this child IS a workflow node — its `start_workflow` flattens to this kernel (the
             // workflow it would author joins the running DAG) rather than bootstrapping a nested pivot.
             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 } : {}),
             ...(this.opts.subAgentHarness ? { harness: this.opts.subAgentHarness } : {}),
@@ -362,10 +374,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 so the kernel can end the
-        // loop early (`loopContinue: false`). No signal ⇒ run to `max_iters`.
+        // 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 });
         }
@@ -451,7 +471,7 @@ export class RuntimeRunner {
             if (this.opts.runGroup) {
                 const g = this.opts.runGroup;
                 groupLedger = await g.budgetStore.read(g.id);
-                await g.budgetStore.join(g.id, { sessionId, role: this.opts.agentId });
+                await g.budgetStore.join(g.id, { sessionId, role: this.opts.agentId, kind: "vehicle" });
             }
             this.bootstrapWorkflowKernel(sessionId, spec, groupLedger?.tokensSpent, groupLedger?.subagentsSpawned);
         }
@@ -464,10 +484,22 @@ export class RuntimeRunner {
                 parent_session_id: parentSessionId,
                 // W0-ABI resume: skip nodes already completed before an interruption.
                 ...(opts?.resumedCompleted?.length ? { resumed_completed: opts.resumedCompleted } : {}),
+                // W-1: signal-carrying completion records (classify branch / loop stop replay).
+                ...(opts?.resumedResults?.length
+                    ? {
+                        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?.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
+                ...(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) {
@@ -535,6 +567,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);
     }
     /**
@@ -571,7 +615,10 @@ export class RuntimeRunner {
         if (!source)
             return null;
         while (!batchState.settled) {
-            const sig = await source.nextSignal(this.currentSessionId ?? undefined);
+            // O2: injected notes participate in the monitor too, so a host `injectNote` mid-batch is not
+            // stranded until the batch settles (the drain order matches `nextInboundSignal`).
+            const sig = this.injectedSignals.shift()
+                ?? await source.nextSignal(this.currentSessionId ?? undefined);
             if (batchState.settled)
                 break;
             if (!sig) {
@@ -595,7 +642,7 @@ export class RuntimeRunner {
      * batch in parallel, feed completions back (appending any agent-submitted nodes first), and loop
      * until the kernel reports the workflow complete. Returns the completed / failed node agent-ids.
      */
-    async driveWorkflow(initial, parentSessionId, runtime) {
+    async driveWorkflow(initial, parentSessionId, runtime, seedOutputs) {
         let observations = initial;
         const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
         const collectNodes = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")
@@ -612,7 +659,9 @@ export class RuntimeRunner {
         // G2: each completed node's output, keyed by agent id — a reduce node reads its dependencies'
         // outputs from here. Deps always complete in an earlier round than the reduce node that needs
         // them (the kernel keeps the reduce node un-ready until its deps finish), so this is populated.
-        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) }; // nothing to run (e.g. all gated)
@@ -641,7 +690,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 (the kernel hasn't seen this
                 // node finish), so even a submission from the last running node keeps the DAG alive. The
@@ -653,10 +708,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, {
@@ -668,11 +728,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) {
@@ -683,8 +749,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` to pick up an interrupted
@@ -694,11 +761,60 @@ 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,
+        });
     }
     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. Use it to feed
+     *  host-detected events back to the model mid-run (e.g. "that write was a no-op — stop repeating it")
+     *  without wiring a full `SignalSource`. `urgency` maps to the kernel disposition ladder: `"normal"`
+     *  queues for the next boundary (default), `"high"` soft-interrupts, `"critical"` preempts. */
+    injectNote(text, urgency = "normal") {
+        this.injectedSignals.push({
+            source: "custom",
+            signalType: "event",
+            urgency,
+            payload: { goal: text },
+        });
+    }
+    /** Injected-note drain shared by the main loop's per-turn poll: injected notes first (FIFO), then
+     *  the configured `signalSource`. Keeps the two inbound channels on one code path so they never drift. */
+    async nextInboundSignal() {
+        const injected = this.injectedSignals.shift();
+        if (injected)
+            return injected;
+        if (!this.opts.signalSource)
+            return null;
+        return this.opts.signalSource.nextSignal(this.currentSessionId ?? undefined);
+    }
     async *run(req) {
         const prior = req.inheritEvents ?? await this.opts.sessionLog.read(req.sessionId);
         const midRun = isMidRun(prior);
@@ -876,6 +992,65 @@ 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 (a call spooled
+     * earlier in the SAME tool-turn, before the session-log write lands), (b) the on-disk result
+     * spool (persisted once the kernel observation `large_result_spooled` was processed), (c) a
+     * session-log scan for the original `tool_completed` event carrying that `call_id`. Slices the
+     * 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) {
+            const spool = this.opts.resultSpool ?? new LargeResultSpool();
+            try {
+                full = await spool.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 *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false, attachments) {
         this.interrupted = false;
         this.abortController = new AbortController();
@@ -999,14 +1174,36 @@ export class RuntimeRunner {
             // P1-B B3: rebuild active-skill gating after a wake by re-emitting SkillActivated for each
             // `skill` tool call in the replayed history (active_skills is not snapshotted — graceful).
             // The catalog (set_available_skills) was already fed above, so allowed_tools resolves.
+            // `knowledge` isn't snapshotted either (same graceful-reset philosophy) — best-effort re-push
+            // the skill's content from its replayed tool_result so the durable copy survives a wake too.
+            const toolResultByCallId = new Map();
+            for (const m of replayed) {
+                for (const part of m.contentParts ?? []) {
+                    if (part.type === "tool_result")
+                        toolResultByCallId.set(part.callId, part.output);
+                }
+            }
             for (const m of replayed) {
                 for (const tc of m.toolCalls ?? []) {
                     if (tc.name !== "skill")
                         continue;
                     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, so a wake re-push
+                            // of a skill already pinned live can never double-pin (the in-run Set resets with
+                            // each runner instance; the key does not).
+                            this.pushKnowledge({ role: "system", content: output, toolCalls: [] }, undefined, { key: `skill:${name}` });
+                        }
                     }
                     catch { /* malformed skill args — skip */ }
                 }
@@ -1041,9 +1238,9 @@ export class RuntimeRunner {
         if (this.opts.runGroup) {
             const g = this.opts.runGroup;
             groupLedger = await g.budgetStore.read(g.id);
-            await g.budgetStore.join(g.id, { sessionId, role: this.opts.agentId });
+            await g.budgetStore.join(g.id, { sessionId, role: this.opts.agentId, kind: "vehicle" });
         }
-        this.applyKernelPolicies(runtime, groupLedger?.tokensSpent, groupLedger?.subagentsSpawned);
+        this.applyKernelPolicies(runtime, groupLedger?.tokensSpent, groupLedger?.subagentsSpawned, groupLedger?.roundsCompleted);
         // Multimodal upload: seed the user's attachments (images/audio) as a history
         // message before start_run pushes the "[TASK STATE]" anchor. init_task does not
         // clear history, so order becomes [attachment user msg, "Proceed…"] — both land
@@ -1054,25 +1251,17 @@ export class RuntimeRunner {
                 message: attachmentsToKernelMessage(attachments),
             });
         }
-        // I4: pre-fetch memory into the knowledge partition before the first LLM turn. Skipped on
-        // resumes (memory was already on the prior context) and when dreamStore/agentId is absent.
-        if (!resumeMidRun && this.opts.preQueryMemory && this.opts.dreamStore && this.opts.agentId) {
-            try {
-                const queries = await this.opts.preQueryMemory({ goal, runSpec: this.opts.runSpec });
-                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 — a faulty pre-fetch never breaks the run */ }
+        // I4: pre-fetch memory before the first LLM turn so the model sees it on turn 1 instead of
+        // discovering it via the `memory` tool on turn 3+. Skipped on resumes (already in prior
+        // context) and when dreamStore/agentId is absent.
+        //
+        // Strict dynamic context control: this is single-use retrieval content (facts relevant to
+        // THIS run's goal right now), not a stable method/skill — so it lands in `history` as an
+        // ordinary turn, exactly like a real `memory` tool result would, and decays with the
+        // compression pyramid over subsequent turns instead of pinning itself in `knowledge` forever.
+        this.currentGoal = goal;
+        if (!resumeMidRun) {
+            await this.prefetchMemoryIntoHistory(runtime, "initial");
         }
         let action = resumeMidRun
             ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
@@ -1088,18 +1277,14 @@ export class RuntimeRunner {
         // an input" from "the run is still in progress."
         try {
             while (!runtime.isTerminal()) {
-                // Page-in must run before appendObservations drains pending kernel observations.
-                if (action.kind === "execute_tool") {
-                    await this.applyKernelPageIn(runtime, sessionId);
-                }
                 nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
                 this.nextArchiveStart = nextCompressedArchiveStart;
                 if (this.interrupted) {
                     action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                     break;
                 }
-                if (this.opts.signalSource) {
-                    const sig = await this.opts.signalSource.nextSignal(this.currentSessionId ?? undefined);
+                if (this.opts.signalSource || this.injectedSignals.length > 0) {
+                    const sig = await this.nextInboundSignal();
                     if (sig) {
                         // Kernel-routed: the kernel decides disposition (dedup/queue/interrupt) and emits
                         // `signal_disposed`. An actionable disposition yields a new action to adopt; queued/observed/
@@ -1303,11 +1488,17 @@ export class RuntimeRunner {
                         resultSpool: this.opts.resultSpool ?? new LargeResultSpool(),
                     };
                     const toolResults = [];
-                    const normalCalls = allCalls.filter(c => c.name !== "update_plan" && c.name !== "submit_workflow_nodes" && c.name !== "start_workflow");
+                    const normalCalls = allCalls.filter(c => c.name !== "update_plan" && c.name !== "submit_workflow_nodes" && c.name !== "start_workflow"
+                        && c.name !== "read_result");
                     const planCalls = allCalls.filter(c => c.name === "update_plan");
                     // M5 v1: `start_workflow` (author a sub-workflow) flattens to the same append path as
                     // `submit_workflow_nodes` — a `WorkflowSpec` is a node batch. (v2 adds top-level bootstrap.)
                     const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes" || c.name === "start_workflow");
+                    // O7: `read_result` re-fetches a tool output the kernel evicted from context. Content is
+                    // host-resolved: (a) this turn's in-memory pending spool map, (b) the on-disk result spool
+                    // (persisted once the kernel observes `large_result_spooled`), (c) a session-log scan for
+                    // the original `tool_completed` event. The kernel only advertises the capability.
+                    const readResultCalls = allCalls.filter(c => c.name === "read_result");
                     for (const call of planCalls) {
                         const update = parseUpdatePlanArgs(call.arguments);
                         kernelApply(runtime, this.pendingObservations, {
@@ -1318,6 +1509,11 @@ export class RuntimeRunner {
                         toolResults.push(result);
                         yield { type: "tool_result", callId: call.id, content: "success", isError: false };
                     }
+                    for (const call of readResultCalls) {
+                        const out = await this.resolveReadResult(sessionId, call.arguments);
+                        toolResults.push({ callId: call.id, output: out.text, isError: out.isError });
+                        yield { type: "tool_result", callId: call.id, content: out.text, isError: out.isError };
+                    }
                     // R3-1: `submit_workflow_nodes` cannot be applied to this runner's kernel — when this runner
                     // is a workflow node, the workflow lives in the *parent* kernel. Surface the requested nodes
                     // as a stream event; the orchestrator collects them onto the node's result and `runWorkflow`
@@ -1347,8 +1543,37 @@ export class RuntimeRunner {
                         toolResults.push(result);
                         yield { type: "tool_result", callId: call.id, content: "submitted", isError: false };
                     }
-                    if (normalCalls.length > 0) {
-                        for await (const evt of this.opts.executionPlane.executeAll(normalCalls, runCtx)) {
+                    // O5 (PreToolUse-hook analog): give the host a STATEFUL veto over each kernel-approved
+                    // call. A blocked call never executes; its reason reaches the model as a governance-denied
+                    // tool result (the kernel rolls the turn back with the note). Errs-open on hook throw.
+                    let executableCalls = normalCalls;
+                    if (this.opts.onToolCall) {
+                        const allowed = [];
+                        for (const call of normalCalls) {
+                            let decision;
+                            try {
+                                decision = await this.opts.onToolCall({ callId: call.id, name: call.name, arguments: call.arguments });
+                            }
+                            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;
+                    }
+                    if (executableCalls.length > 0) {
+                        for await (const evt of this.opts.executionPlane.executeAll(executableCalls, runCtx)) {
                             yield evt;
                             if (evt.type === "tool_result") {
                                 const tre = evt;
@@ -1402,12 +1627,38 @@ export class RuntimeRunner {
                                 });
                             }
                         }
-                        const names = normalCalls.map(c => c.name).join(", ");
+                        const names = executableCalls.map(c => c.name).join(", ");
                         kernelApply(runtime, this.pendingObservations, {
                             kind: "update_task",
                             update: taskUpdateToKernel({ progress: `Executed tools: ${names}` }),
                         });
                     }
+                    // O5 (PostToolUse-hook analog): let the host inspect each executed result BEFORE it
+                    // reaches the kernel/session-log — replace the output (redact/annotate) and/or push a
+                    // contextual note into the signal stream. Errs-open on hook throw.
+                    if (this.opts.onToolResult) {
+                        for (const r of toolResults) {
+                            const call = executableCalls.find(c => c.id === r.callId);
+                            if (!call)
+                                continue; // plan/submit synthetics and hook-blocked calls are not host results
+                            let decision;
+                            try {
+                                decision = await this.opts.onToolResult({
+                                    callId: r.callId, name: call.name, arguments: call.arguments,
+                                    output: r.output, isError: r.isError,
+                                });
+                            }
+                            catch {
+                                decision = undefined;
+                            }
+                            if (!decision)
+                                continue;
+                            if (typeof decision.replaceOutput === "string")
+                                r.output = decision.replaceOutput;
+                            if (decision.note)
+                                this.injectNote(decision.note);
+                        }
+                    }
                     await this.opts.sessionLog.append(sessionId, {
                         kind: "tool_completed",
                         turn: runtime.turn(),
@@ -1427,6 +1678,13 @@ export class RuntimeRunner {
                     // P1-B B3: a `skill` call that resolved successfully activates that skill in the kernel, so
                     // the next `call_provider` narrows the toolset to its declared tools. Fed before `tool_results`
                     // (which computes the next action). Errs-open: a failed/missing skill load doesn't activate.
+                    //
+                    // Strict dynamic context control: a skill is METHOD content — how to do something — reused
+                    // for the rest of the run, unlike a one-off memory/knowledge lookup (fact content, relevant
+                    // for the moment it's used). So its text ALSO goes into the durable `knowledge` slot here
+                    // (in addition to the ordinary tool_result already headed for `history`, where it will decay
+                    // with the compression pyramid like any other tool output — that's fine, the permanent copy
+                    // now lives in `knowledge`). First activation only (see `knowledgePushedSkills`).
                     for (const call of allCalls) {
                         if (call.name !== "skill")
                             continue;
@@ -1435,8 +1693,21 @@ 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 } : {}),
+                            });
+                            // K1: keyed `skill:<name>` — the kernel-side upsert dedupes across runner instances
+                            // (wake re-push of an already-pinned skill upserts instead of duplicating). With a
+                            // lease configured, the Set optimization is skipped: an expired-then-reloaded skill
+                            // must re-pin, and only the kernel knows the lease state — its upsert dedupes anyway.
+                            if (this.opts.skillLeaseTurns !== undefined || !this.knowledgePushedSkills.has(name)) {
+                                this.knowledgePushedSkills.add(name);
+                                this.pushKnowledge({ role: "system", content: res.output, toolCalls: [] }, undefined, { key: `skill:${name}` });
+                            }
                         }
                         catch { /* malformed skill args — skip activation */ }
                     }
@@ -1557,11 +1828,54 @@ 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;
         this.dashboard = null;
     }
+    /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
+     *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
+     *  never pinned into `knowledge`. Called once before turn 1 (`phase: "initial"`) and re-fired
+     *  after each sprint renewal (`phase: "renewal"`): renewal drops the old history INCLUDING the
+     *  earlier memory hits, so the new sprint gets a fresh recall pass. Errs-open throughout. */
+    async prefetchMemoryIntoHistory(runtime, phase) {
+        if (!this.opts.dreamStore || !this.opts.agentId)
+            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,
+                runSpec: this.opts.runSpec,
+                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 — a faulty pre-fetch never breaks the run */ }
+    }
     async appendObservations(sessionId, runtime, nextArchiveStart) {
         const turn = runtime.turn();
         const preservedRefs = runtime.preservedRefs();
@@ -1584,9 +1898,6 @@ export class RuntimeRunner {
                     }
                 }
             }
-            if (obs.kind === "page_out" && obs.archived) {
-                this.localPageOutCache.push(...obs.archived);
-            }
             if (obs.kind === "large_result_spooled") {
                 const pending = this.pendingSpoolOutputs.get(obs.call_id ?? "");
                 if (pending) {
@@ -1619,14 +1930,30 @@ export class RuntimeRunner {
                 nextArchiveStart = compressedSeq + 1;
                 const archived = obs.kind === "compressed" ? obs.archived : undefined;
                 if (this.opts.asyncSummarizer && archived && archived.length > 0) {
-                    void this.upgradeCompressedSummary(sessionId, compressedSeq, archived, compressionAction(obs.action) ?? "auto_compact");
+                    void this.upgradeCompressedSummary(sessionId, compressedSeq, archived, compressionAction(obs.action) ?? "auto_compact", runtime);
+                }
+                // One compaction = one kernel observation: the page_out session record (and the
+                // semantic-archive branch) is DERIVED here from Compressed.tier_hint, preserving the
+                // session-log format and OsSnapshot page_out_count.
+                if (obs.tier_hint && Array.isArray(archived) && archived.length > 0) {
+                    await this.opts.sessionLog.append(sessionId, {
+                        kind: "page_out",
+                        turn: obs.turn ?? turn,
+                        action: compressionAction(obs.action),
+                        summary: obs.summary,
+                        tier_hint: obs.tier_hint ?? "durable",
+                        message_count: archived.length,
+                    });
+                    if (obs.tier_hint === "semantic") {
+                        void this.archiveSemanticPageOut(archived, compressionAction(obs.action));
+                    }
                 }
             }
-            if (obs.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: this
+            // consumer sits on the live drain path, same placement as the semantic page-out archival).
+            if (obs.kind === "renewed") {
+                await this.prefetchMemoryIntoHistory(runtime, "renewal");
             }
         }
         return nextArchiveStart;
@@ -1638,23 +1965,25 @@ export class RuntimeRunner {
             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);
-            await this.opts.dreamStore.commit(this.opts.agentId, {
-                toAdd: [{ text: summary, score: 1.0, metadata: { source: "semantic_page_out", action } }],
-                toRemoveIndices: [],
-                stats: {
-                    insightsProcessed: 1,
-                    duplicatesRemoved: 0,
-                    conflictsResolved: 0,
-                    entriesAdded: 1,
+            // P2 write-funnel: route through the ONE gated WriteMemory syscall so validation,
+            // the rolling write quota, dedup, and the memory_written audit all apply. Score is
+            // advisory (0.6) — an automatic summary must never outrank curated content.
+            await this.writeMemory({
+                content: summary,
+                metadata: {
+                    name: `page-out-${Date.now()}`,
+                    description: `auto summary of ${action ?? "compaction"} archive`,
+                    source: "semantic_page_out",
+                    action,
+                    score: 0.6,
                 },
-            }, existing);
+            });
         }
         catch {
             // non-fatal: in-context compression summary remains; long-term layer is best-effort
         }
     }
-    async upgradeCompressedSummary(sessionId, compressedSeq, archived, action) {
+    async upgradeCompressedSummary(sessionId, compressedSeq, archived, action, runtime) {
         try {
             const summary = await this.opts.asyncSummarizer.summarize(archived, action);
             await this.opts.sessionLog.append(sessionId, {
@@ -1662,6 +1991,20 @@ export class RuntimeRunner {
                 compressed_seq: compressedSeq,
                 summary,
             });
+            // P4: the LLM summary also re-enters the LIVE session as a keyed page-in entry —
+            // K1 boundary-deferred upsert lands it with zero mid-generation cache churn and the
+            // K2 budget governs its size. The RuleSummarizer text remains the synchronous label.
+            if (runtime) {
+                kernelApply(runtime, this.pendingObservations, {
+                    kind: "page_in",
+                    entries: [{
+                            content: `[ARCHIVE SUMMARY] ${summary}`,
+                            key: `summary:seq-${compressedSeq}`,
+                            pinned: false,
+                            source: "async_summarizer",
+                        }],
+                });
+            }
         }
         catch {
             // non-fatal: rule-based summary stays in place
@@ -1669,7 +2012,20 @@ export class RuntimeRunner {
     }
 }
 function isMidRun(events) {
-    return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
+    // Mid-run ⇔ the LAST run_started has no run_terminal after it. Pairing (not mere
+    // presence) matters on multi-round loop sessions: round 1's terminal must not make a
+    // crashed round 2 look fresh, and driver-level round_* records must not make a fresh
+    // round look interrupted.
+    let lastStarted = -1;
+    let lastTerminal = -1;
+    for (let i = 0; i < events.length; i++) {
+        const k = events[i].event.kind;
+        if (k === "run_started")
+            lastStarted = i;
+        else if (k === "run_terminal")
+            lastTerminal = i;
+    }
+    return lastStarted >= 0 && lastStarted > lastTerminal;
 }
 /**
  * Build a kernel `add_history_message` payload from user attachments: a `user`
@@ -1724,6 +2080,50 @@ async function summarizeForLongTermMemory(provider, archived, systemPrompt) {
     }
     return text.trim() || transcript.slice(0, 2000);
 }
+/** Kernel-consumed meta-tools (e.g. `pace`) are answered by a synthetic tool result the kernel keeps
+ *  in its OWN history but never emits as a `tool_completed` session event (they never reach the
+ *  execution plane). On replay that leaves an assistant `tool_call` with no following tool result —
+ *  which strict OpenAI-compatible providers reject ("every tool_call must be answered by a tool
+ *  message"). This pass re-pairs any such orphan by inserting a synthetic tool-result message right
+ *  after its assistant message, reproducing the pair the kernel had all along.
+ *
+ *  Discriminator: only pair an orphan when the run **continued past it** — i.e. a later non-tool
+ *  message exists. A tail assistant tool_call with nothing after it is a genuinely PENDING tool the
+ *  run stopped in front of (the wake/recovery case), which must stay unpaired so wake executes it.
+ *  Pure. */
+export function pairOrphanToolCalls(messages) {
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        out.push(m);
+        if (m.role !== "assistant" || !m.toolCalls?.length)
+            continue;
+        // Collect ids answered by the immediately-following run of tool messages; note where it ends.
+        const answered = new Set();
+        let j = i + 1;
+        for (; j < messages.length && messages[j].role === "tool"; j++) {
+            for (const p of messages[j].contentParts ?? []) {
+                if (p.type === "tool_result")
+                    answered.add(p.callId);
+            }
+        }
+        // If nothing follows the tool run, this tool_call is a pending tail (wake case) — leave it.
+        if (j >= messages.length)
+            continue;
+        for (const c of m.toolCalls) {
+            if (answered.has(c.id))
+                continue;
+            out.push({
+                role: "tool",
+                content: "",
+                toolCalls: [],
+                contentParts: [{ type: "tool_result", callId: c.id, output: `[${c.name} handled by kernel]`, isError: false }],
+                tokenCount: 1,
+            });
+        }
+    }
+    return out;
+}
 export function replayMessages(events, maxBytes) {
     // Build upgraded-summary index: compressed_seq -> upgraded summary
     const upgradedSummaries = new Map();
@@ -1782,7 +2182,7 @@ export function replayMessages(events, maxBytes) {
             }
         }
     }
-    return messages;
+    return pairOrphanToolCalls(messages);
 }
 export async function replayMessagesAsync(events, maxBytes, loadArchive) {
     // Build upgraded-summary index: compressed_seq -> upgraded summary
@@ -1862,7 +2262,7 @@ export async function replayMessagesAsync(events, maxBytes, loadArchive) {
             }
         }
     }
-    return messages;
+    return pairOrphanToolCalls(messages);
 }
 function nextArchivedSeqStart(events) {
     let next = 0;
@@ -1965,6 +2365,19 @@ function authoredWorkflowOutcomeNote(outcome) {
 }
 /** Lower a host `RuntimeSignal` to the kernel's snake_case `signal` input event. Shared by the main
  *  loop's per-turn poll and #2-B-ii's workflow-batch preemption monitor (so the two never drift). */
+/** Word-set jaccard similarity — the curator's dedup rule as a pure helper at the write funnel. */
+function jaccardSimilarity(a, b) {
+    const sa = new Set(a.split(/\s+/).filter(Boolean));
+    const sb = new Set(b.split(/\s+/).filter(Boolean));
+    if (sa.size === 0 && sb.size === 0)
+        return 1;
+    let inter = 0;
+    for (const w of sa)
+        if (sb.has(w))
+            inter++;
+    const union = sa.size + sb.size - inter;
+    return union === 0 ? 0 : inter / union;
+}
 function signalToKernelEvent(sig) {
     return {
         kind: "signal",