@deepstrike/sdk 0.2.36 → 0.2.37

package/dist/runtime/runner.js

@@ -10,7 +10,7 @@ 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 } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
@@ -72,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 = {}) {
@@ -116,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();
@@ -152,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.
@@ -187,6 +189,10 @@ 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) {
@@ -330,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,
@@ -340,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 } : {}),
@@ -361,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 });
         }
@@ -450,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);
         }
@@ -463,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) {
@@ -534,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);
     }
     /**
@@ -597,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")
@@ -614,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)
@@ -643,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
@@ -655,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, {
@@ -670,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) {
@@ -685,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
@@ -696,9 +761,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,
+        });
     }
     interrupt() { this.interrupted = true; this.abortController?.abort(); }
     /** Push a contextual note into the run's signal stream (the system-reminder channel): it drains at
@@ -1148,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
@@ -1738,7 +1828,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;
         this.dashboard = null;
@@ -1749,10 +1846,14 @@ export class RuntimeRunner {
      *  after each sprint renewal (`phase: "renewal"`): renewal drops the old history INCLUDING the
      *  earlier memory hits, so the new sprint gets a fresh recall pass. Errs-open throughout. */
     async prefetchMemoryIntoHistory(runtime, phase) {
-        if (!this.opts.preQueryMemory || !this.opts.dreamStore || !this.opts.agentId)
+        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 this.opts.preQueryMemory({
+            const queries = await preQuery({
                 goal: this.currentGoal,
                 runSpec: this.opts.runSpec,
                 phase,
@@ -1829,14 +1930,24 @@ 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
@@ -1854,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, {
@@ -1878,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
@@ -1885,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`
@@ -1940,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();
@@ -1998,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
@@ -2078,7 +2262,7 @@ export async function replayMessagesAsync(events, maxBytes, loadArchive) {
             }
         }
     }
-    return messages;
+    return pairOrphanToolCalls(messages);
 }
 function nextArchivedSeqStart(events) {
     let next = 0;
@@ -2181,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",