@deepstrike/sdk 0.2.36 → 0.2.38

package/dist/runtime/loop-driver.js

@@ -0,0 +1,198 @@
+/** Fold the loop's session log into resumable pacing state — zero new storage. DW-5: the judge's
+ *  override budget folds too, so a crash/restart can't grant the verdictFn fresh overrides. */
+export function foldLoopState(events) {
+    let roundsCompleted = 0;
+    let pendingWakeAtMs;
+    let lastPace;
+    let overridesUsed = 0;
+    for (const { event } of events) {
+        if (event.kind === "round_paced") {
+            roundsCompleted = Math.max(roundsCompleted, event.round);
+            lastPace = { action: event.action, reason: event.reason };
+            pendingWakeAtMs = event.action === "sleep" ? event.wake_at_ms : undefined;
+            if (event.reason.startsWith("verdict override"))
+                overridesUsed += 1;
+        }
+    }
+    return { roundsCompleted, pendingWakeAtMs, lastPace, overridesUsed };
+}
+/**
+ * DW-6 completion→wake bridge, composed from two existing seams (zero new mechanism): a `sleeper`
+ * that races the timer against an L0 recipient-addressed signal on the shared gateway. Ingest a
+ * signal with `recipient: loopId` (a subagent/workflow completion, a webhook) and the sleeping loop
+ * wakes into its next round immediately — where the SAME queued signal then reaches the model
+ * through the kernel's normal signal path, so the wake reason is visible in-round.
+ */
+export function signalAwareSleeper(gateway, loopId) {
+    return (delayMs) => new Promise(resolve => {
+        let settled = false;
+        const settle = (v) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            unsubscribe();
+            resolve(v);
+        };
+        const unsubscribe = gateway.onSignal(sig => {
+            if (sig.recipient === loopId)
+                settle(true);
+        });
+        const timer = setTimeout(() => settle(true), Math.max(0, delayMs));
+    });
+}
+export class LoopDriver {
+    runner;
+    spec;
+    overridesUsed = 0;
+    constructor(runner, spec) {
+        this.runner = runner;
+        this.spec = spec;
+    }
+    /**
+     * Drive rounds until the loop stops or goes dormant. Resumable by construction:
+     * the round count and any pending wake are folded from the session log, so
+     * calling `run()` again after a crash / on a stateless host continues in place.
+     */
+    async run() {
+        const { loopId } = this.spec;
+        const log = this.runner.hostOptions.sessionLog;
+        // Resume: fold prior rounds + pending wake + the judge's used overrides from the transcript
+        // (DW-5: a crash/restart must not refill the verdictFn's override budget).
+        const prior = foldLoopState(await log.read(loopId));
+        let round = prior.roundsCompleted;
+        this.overridesUsed = Math.max(this.overridesUsed, prior.overridesUsed);
+        if (prior.pendingWakeAtMs !== undefined) {
+            const remaining = prior.pendingWakeAtMs - Date.now();
+            if (remaining > 0) {
+                const slept = await this.sleep(remaining, prior.pendingWakeAtMs);
+                if (!slept) {
+                    return {
+                        loopId, roundsCompleted: round, stopped: false,
+                        state: "dormant", wakeAtMs: prior.pendingWakeAtMs,
+                    };
+                }
+            }
+        }
+        let feedback;
+        for (;;) {
+            round += 1;
+            // Driver-side round-cap backstop: with a RunGroup, the kernel trap coerces via the
+            // seeded ledger; without one, this is the only max_rounds enforcement point.
+            if (this.spec.maxRounds !== undefined && round > this.spec.maxRounds) {
+                return {
+                    loopId, roundsCompleted: round - 1, stopped: true, state: "stopped",
+                    lastPace: { action: "stop", reason: `max_rounds=${this.spec.maxRounds} exhausted` },
+                };
+            }
+            await log.append(loopId, { kind: "round_started", round, goal: this.spec.goal });
+            const goal = feedback
+                ? `${this.spec.goal}\n\n[LOOP FEEDBACK round ${round - 1}] ${feedback}`
+                : this.spec.goal;
+            feedback = undefined;
+            let pace;
+            let status;
+            // ONE round = one bounded kernel run under the stable loop session id. The
+            // kernel's pacing trap adjudicates the model's pace proposal; we consume it
+            // from the done event. runSpec.loopRound arms the trap + the pace tool.
+            const priorRunSpec = this.runner.hostOptions.runSpec;
+            this.runner.hostOptions.runSpec = {
+                identity: { agentId: this.runner.hostOptions.agentId ?? "loop", sessionId: loopId, isSubAgent: false },
+                role: "custom",
+                goal,
+                ...(priorRunSpec ?? {}),
+                loopRound: {
+                    maxRounds: this.spec.maxRounds,
+                    minSleepMs: this.spec.minSleepMs,
+                    maxSleepMs: this.spec.maxSleepMs,
+                    defaultAction: this.spec.defaultAction,
+                },
+            };
+            // With a RunGroup configured, run() seeds the kernel trap's round base from the
+            // group ledger (the driver charges rounds:1 per round below) — max_rounds coercion
+            // then happens IN-KERNEL; the check above is the ungrouped backstop.
+            try {
+                for await (const evt of this.runner.run({
+                    sessionId: loopId,
+                    goal,
+                    criteria: this.spec.criteria,
+                })) {
+                    this.spec.onEvent?.(round, evt);
+                    if (evt.type === "done") {
+                        const d = evt;
+                        status = d.status;
+                        pace = d.paceDecision;
+                    }
+                }
+            }
+            finally {
+                this.runner.hostOptions.runSpec = priorRunSpec;
+            }
+            // Missing pace (old kernel / hard failure): stop and surface — nothing nags.
+            const decision = pace ?? {
+                action: "stop",
+                reason: `round ended without a pace decision (status: ${status ?? "unknown"})`,
+            };
+            // Cross-round done-gate: a stop proposal may be overridden K times by the judge.
+            let finalDecision = decision;
+            if (finalDecision.action === "stop"
+                && this.spec.verdictFn
+                && this.overridesUsed < (this.spec.maxVerdictOverrides ?? 2)) {
+                try {
+                    const verdict = await this.spec.verdictFn({ loopId, round, reason: finalDecision.reason });
+                    if (!verdict.pass) {
+                        this.overridesUsed += 1;
+                        feedback = verdict.feedback ?? "verdict failed — keep iterating on the goal";
+                        finalDecision = {
+                            action: "continue",
+                            reason: `verdict override ${this.overridesUsed}: ${verdict.feedback ?? "not done yet"}`,
+                            coercedFrom: `stop (${finalDecision.reason})`,
+                        };
+                    }
+                }
+                catch { /* judge errs-open: the stop stands */ }
+            }
+            const wakeAtMs = finalDecision.action === "sleep"
+                ? Date.now() + (finalDecision.delayMs ?? 60_000)
+                : undefined;
+            await log.append(loopId, {
+                kind: "round_paced",
+                round,
+                action: finalDecision.action,
+                ...(finalDecision.delayMs !== undefined ? { delay_ms: finalDecision.delayMs } : {}),
+                ...(wakeAtMs !== undefined ? { wake_at_ms: wakeAtMs } : {}),
+                reason: finalDecision.reason,
+                ...(finalDecision.coercedFrom ? { coerced_from: finalDecision.coercedFrom } : {}),
+            });
+            // Lifetime governance: one round = one group charge on the rounds axis.
+            const group = this.runner.hostOptions.runGroup;
+            if (group)
+                await group.budgetStore.charge(group.id, { rounds: 1 });
+            if (finalDecision.action === "stop") {
+                return {
+                    loopId, roundsCompleted: round, stopped: true, state: "stopped",
+                    lastPace: finalDecision, lastStatus: status,
+                };
+            }
+            if (finalDecision.action === "sleep" && wakeAtMs !== undefined) {
+                const slept = await this.sleep(wakeAtMs - Date.now(), wakeAtMs);
+                if (!slept) {
+                    return {
+                        loopId, roundsCompleted: round, stopped: false, state: "dormant",
+                        lastPace: finalDecision, lastStatus: status, wakeAtMs,
+                    };
+                }
+            }
+            // continue → next round immediately
+        }
+    }
+    sleep(delayMs, wakeAtMs) {
+        if (this.spec.sleeper)
+            return Promise.resolve(this.spec.sleeper(delayMs, wakeAtMs));
+        return new Promise(resolve => setTimeout(() => resolve(true), Math.max(0, delayMs)));
+    }
+}
+/** Facade: run a self-pacing loop agent (joins runAgent/runFanout as an entry point). */
+export async function runLoop(runner, spec) {
+    return new LoopDriver(runner, spec).run();
+}

package/dist/runtime/os-snapshot.d.ts

@@ -32,4 +32,3 @@ export interface OsSnapshot {
     memoryRetrievalResultCount: number;
 }
 export declare function rebuildOsSnapshotFromSessionEvents(events: SessionEvent[]): OsSnapshot;
-export declare function sessionLogHasRequiredCategories(events: SessionEvent[]): boolean;

package/dist/runtime/os-snapshot.js

@@ -1,4 +1,3 @@
-import { categoryForKind, primitiveForKind } from "./kernel-event-log.js";
 const KERNEL_KINDS = new Set([
     "compressed",
     "page_out",
@@ -16,7 +15,6 @@ const KERNEL_KINDS = new Set([
     "agent_process_changed",
     "milestone_advanced",
     "milestone_blocked",
-    "milestone_evidence",
     "memory_written",
     "memory_queried",
     "memory_validation_failed",
@@ -109,20 +107,3 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
     }
     return snap;
 }
-export function sessionLogHasRequiredCategories(events) {
-    for (const event of events) {
-        if (!KERNEL_KINDS.has(event.kind))
-            continue;
-        const cat = event.category;
-        if (!cat)
-            return false;
-        if (cat !== categoryForKind(event.kind))
-            return false;
-        const prim = event.primitive;
-        if (prim !== undefined) {
-            if (prim !== primitiveForKind(event.kind))
-                return false;
-        }
-    }
-    return true;
-}

package/dist/runtime/reactive-session.d.ts

@@ -111,8 +111,11 @@ export declare class ReactiveSession {
     private getRunner;
     private driveTurn;
     /**
-     * Rebuild a session from a persisted `RunGroup`: load its members (lineage) as peers. The blackboard
-     * continuity comes from the (persistent) `EventStream`. Turn-policy cursor state is not restored.
+     * Rebuild a session from a persisted `RunGroup`: load its PEER members (lineage) as peers. The
+     * blackboard continuity comes from the (persistent) `EventStream`. Turn-policy cursor state is not
+     * restored. W-N5: vehicle members (workflow envelopes, `wf-node*` children, loop iterations) share
+     * the governance domain but are NOT personas — resuming them as peers would resurrect phantoms.
+     * A legacy membership with no kind tags falls back to resuming every member.
      */
     static resume(opts: ReactiveSessionOptions & {
         peerSpecs?: Record<string, ReactivePeerSpec>;

package/dist/runtime/reactive-session.js

@@ -17,7 +17,13 @@ export class ReactiveSession {
     /** Register a peer persona and record it in the group membership (lineage). */
     addPeer(personaId, spec = {}) {
         this.peerSpecs.set(personaId, spec);
-        void this.opts.runGroup.budgetStore.join(this.opts.runGroup.id, { sessionId: personaId, role: spec.role });
+        // W-N5: tagged "peer" so resume() can tell personas apart from vehicle sessions (workflow
+        // envelopes / wf-node children / loop iterations) that share the same governance domain.
+        void this.opts.runGroup.budgetStore.join(this.opts.runGroup.id, {
+            sessionId: personaId,
+            role: spec.role,
+            kind: "peer",
+        });
     }
     peers() {
         return [...this.peerSpecs.keys()];
@@ -95,12 +101,19 @@ export class ReactiveSession {
         return collectText(runner.run({ sessionId: personaId, goal }));
     }
     /**
-     * Rebuild a session from a persisted `RunGroup`: load its members (lineage) as peers. The blackboard
-     * continuity comes from the (persistent) `EventStream`. Turn-policy cursor state is not restored.
+     * Rebuild a session from a persisted `RunGroup`: load its PEER members (lineage) as peers. The
+     * blackboard continuity comes from the (persistent) `EventStream`. Turn-policy cursor state is not
+     * restored. W-N5: vehicle members (workflow envelopes, `wf-node*` children, loop iterations) share
+     * the governance domain but are NOT personas — resuming them as peers would resurrect phantoms.
+     * A legacy membership with no kind tags falls back to resuming every member.
      */
     static async resume(opts) {
         const session = new ReactiveSession(opts);
-        for (const member of await opts.runGroup.budgetStore.members(opts.runGroup.id)) {
+        const members = await opts.runGroup.budgetStore.members(opts.runGroup.id);
+        const anyTagged = members.some(m => m.kind !== undefined);
+        for (const member of members) {
+            if (anyTagged && member.kind !== "peer")
+                continue;
             session.peerSpecs.set(member.sessionId, opts.peerSpecs?.[member.sessionId] ?? { role: member.role });
         }
         return session;

package/dist/runtime/run-group.d.ts

@@ -18,6 +18,8 @@
 import type { SessionLog } from "./session-log.js";
 /** Cumulative resources spent across a run group. */
 export interface GroupLedger {
+    /** ③ loop-agent rounds completed across the group (seeds the pacing trap's max_rounds). */
+    roundsCompleted?: number;
     /** Total tokens spent by all members. */
     tokensSpent: number;
     /** Total sub-agents spawned by all members (running + completed). */
@@ -27,11 +29,18 @@ export interface GroupLedger {
 export interface GroupCharge {
     tokens?: number;
     subagents?: number;
+    /** ③ loop-agent: completed rounds to add to the group's round count. */
+    rounds?: number;
 }
 /** A persona session that participated in the logical run (process-table lineage). */
 export interface GroupMember {
     sessionId: string;
     role?: string;
+    /** W-N5: what this member IS in the lineage — a `"peer"` persona (ReactiveSession.addPeer) vs a
+     *  `"vehicle"` session (run()/runWorkflow envelopes, workflow-node children, loop iterations).
+     *  `ReactiveSession.resume()` rebuilds the peer set from `"peer"` members only, so DAG-in-Peer
+     *  usage can't resurrect phantom `wf-node*` personas. Absent (legacy) = unknown. */
+    kind?: "peer" | "vehicle";
 }
 export interface GroupBudgetStore {
     /** Cumulative spend across the group so far. */

package/dist/runtime/run-group.js

@@ -3,19 +3,25 @@ export class InMemoryGroupBudgetStore {
     ledgers = new Map();
     memberships = new Map();
     read(groupId) {
-        return this.ledgers.get(groupId) ?? { tokensSpent: 0, subagentsSpawned: 0 };
+        return this.ledgers.get(groupId) ?? { tokensSpent: 0, subagentsSpawned: 0, roundsCompleted: 0 };
     }
     charge(groupId, delta) {
         const cur = this.read(groupId);
         this.ledgers.set(groupId, {
             tokensSpent: cur.tokensSpent + Math.max(0, delta.tokens ?? 0),
             subagentsSpawned: cur.subagentsSpawned + Math.max(0, delta.subagents ?? 0),
+            roundsCompleted: (cur.roundsCompleted ?? 0) + Math.max(0, delta.rounds ?? 0),
         });
     }
     join(groupId, member) {
         if (!this.memberships.has(groupId))
             this.memberships.set(groupId, new Map());
-        this.memberships.get(groupId).set(member.sessionId, member);
+        // First join wins (idempotent by sessionId) — the same contract as SessionLogGroupBudgetStore.
+        // A persona registered as "peer" then re-joining through its own run() as "vehicle" must not
+        // lose its peer tag (W-N5), and the two stores must agree on which record survives.
+        const members = this.memberships.get(groupId);
+        if (!members.has(member.sessionId))
+            members.set(member.sessionId, member);
     }
     members(groupId) {
         return [...(this.memberships.get(groupId)?.values() ?? [])];
@@ -34,17 +40,20 @@ export class SessionLogGroupBudgetStore {
     async read(groupId) {
         let tokensSpent = 0;
         let subagentsSpawned = 0;
+        let roundsCompleted = 0;
         for (const { event } of await this.log.read(groupId)) {
             if (event.kind === "group_budget_charged") {
+                roundsCompleted += event.rounds ?? 0;
                 tokensSpent += event.tokens;
                 subagentsSpawned += event.subagents;
             }
         }
-        return { tokensSpent, subagentsSpawned };
+        return { tokensSpent, subagentsSpawned, roundsCompleted };
     }
     async charge(groupId, delta) {
         await this.log.append(groupId, {
             kind: "group_budget_charged",
+            ...(delta.rounds !== undefined ? { rounds: delta.rounds } : {}),
             tokens: Math.max(0, delta.tokens ?? 0),
             subagents: Math.max(0, delta.subagents ?? 0),
         });
@@ -58,13 +67,18 @@ export class SessionLogGroupBudgetStore {
             kind: "group_member_joined",
             session_id: member.sessionId,
             ...(member.role ? { role: member.role } : {}),
+            ...(member.kind ? { member_kind: member.kind } : {}),
         });
     }
     async members(groupId) {
         const seen = new Map();
         for (const { event } of await this.log.read(groupId)) {
             if (event.kind === "group_member_joined") {
-                seen.set(event.session_id, { sessionId: event.session_id, role: event.role });
+                seen.set(event.session_id, {
+                    sessionId: event.session_id,
+                    role: event.role,
+                    ...(event.member_kind ? { kind: event.member_kind } : {}),
+                });
             }
         }
         return [...seen.values()];

package/dist/runtime/runner.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, DreamSummarizer } from "../types.js";
+import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, DreamSummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
 import type { DreamStore, MemoryEntry, MemoryQuery, MemoryWriteRequest } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { SignalSource, RuntimeSignalUrgency } from "../signals/types.js";
@@ -7,6 +7,7 @@ import type { ArchiveStore } from "./archive.js";
 import type { ExecutionPlane } from "./execution-plane.js";
 import type { RunGroup } from "./run-group.js";
 import { type MemoryPolicy, type ResourceQuota } from "../kernel.js";
+import { type RecoveredNodeCompletion } from "./session-repair.js";
 import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy, WorkflowSpec } from "../types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
@@ -85,10 +86,11 @@ export interface RuntimeOptions {
     agentId?: string;
     /** I4: optional run-start memory pre-fetch hook. The runner calls this ONCE per run, before the
      *  first LLM turn, with the request's goal and (optional) run-spec. Each returned query string
-     *  becomes a `dreamStore.search(agentId, q, 5)` and the resulting hits are paged into the
-     *  context's knowledge partition before turn 1, so the model sees them on first call. Returning
+     *  becomes a `dreamStore.search(agentId, q, 5)` and the resulting hits land in decaying
+     *  HISTORY as an ordinary user turn before turn 1 (single-use retrieval content — never a
+     *  permanent knowledge pin; `initialMemory` is the curated CLAUDE.md-analog seed). Returning
      *  `undefined` / empty array is a no-op. Requires `dreamStore` + `agentId`; missing either ⇒
-     *  silently skipped (errs-open). Bench memory-recall shows -57% turns / -55% dollars when
+     *  silently skipped (errs-open). Default when unset: one query = the run goal (P10). Bench memory-recall shows -57% turns / -55% dollars when
      *  relevant memories land on turn 1 instead of being discovered via the meta-tool on turn 3+. */
     preQueryMemory?: (ctx: {
         goal: string;
@@ -159,6 +161,14 @@ export interface RuntimeOptions {
      * entries and skill pins are never budget-evicted. `0` disables. Default: kernel's 0.25.
      */
     knowledgeBudgetRatio?: number;
+    /**
+     * Opt-in kernel entropy watch: threshold alerting over the per-turn session-entropy score
+     * (`entropy_sample` events stream unconditionally regardless). When the score crosses
+     * `threshold` — armed via hysteresis and past the cooldown — the run emits an `entropy_alert`
+     * stream event (and session-log record); with `notifyModel` the kernel also feeds the model a
+     * durable `[SIGNAL]` directive. Absent ⇒ disabled (kernel default).
+     */
+    entropyWatch?: EntropyWatchOptions;
     /**
      * K3: default lease (in turns) for every skill activation. After that many turns the kernel
      * auto-deactivates the skill — toolset re-widens, knowledge pin boundary-swept — exactly like
@@ -305,6 +315,8 @@ export declare class RuntimeRunner {
      *  at the next safe point (after the tool turn resolves, kernel back in Reason — not suspended). */
     private pendingAuthoredWorkflows;
     private dashboard;
+    /** Most recent kernel entropy sample of the active/last run (see `latestEntropy`). */
+    private lastEntropySample;
     constructor(opts: RuntimeOptions);
     /** Host configuration (for coordinator / sub-agent spawn). */
     get hostOptions(): RuntimeOptions;
@@ -380,7 +392,15 @@ export declare class RuntimeRunner {
      */
     runWorkflow(spec: WorkflowSpec, opts?: {
         resumedCompleted?: string[];
+        /** W-1: recovered completions WITH control signals (classify branch / loop stop) — lowered to
+         *  the kernel's `resumed_results` so control flow replays faithfully. Supersedes
+         *  `resumedCompleted` for ids present in both. */
+        resumedResults?: RecoveredNodeCompletion[];
         resumedSubmissions?: Record<string, unknown>[][];
+        /** R3-1: original base index per submission batch (parallel to resumedSubmissions). */
+        resumedSubmissionBases?: number[];
+        /** W-1: recovered node outputs (agent id → output text) to pre-seed the driver's outputs map. */
+        resumedOutputs?: Map<string, string>;
         /** Standalone session id when bootstrapping (no active parent run). Defaults to a fresh uuid. */
         sessionId?: string;
     }): Promise<{
@@ -440,8 +460,9 @@ export declare class RuntimeRunner {
     private driveWorkflow;
     /**
      * 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.
      */
     resumeWorkflow(spec: WorkflowSpec, opts?: {
         sessionId?: string;
@@ -457,6 +478,10 @@ export declare class RuntimeRunner {
      *  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: string, urgency?: RuntimeSignalUrgency): void;
+    /** The most recent kernel session-entropy sample (one per completed turn), or `null` before the
+     *  first boundary. A pull companion to the streamed `entropy_sample` events — hosts polling from
+     *  outside the stream (e.g. a heartbeat supervisor) read the latest measurement here. */
+    latestEntropy(): EntropySample | null;
     /** 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. */
     private nextInboundSignal;
@@ -497,6 +522,18 @@ export declare class RuntimeRunner {
     private archiveSemanticPageOut;
     private upgradeCompressedSummary;
 }
+/** 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 declare function pairOrphanToolCalls(messages: Message[]): Message[];
 export declare function replayMessages(events: Array<{
     seq: number;
     event: SessionEvent;