@deepstrike/sdk 0.2.35 → 0.2.37

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,12 +1,13 @@
 import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, DreamSummarizer } from "../types.js";
 import type { DreamStore, MemoryEntry, MemoryQuery, MemoryWriteRequest } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
-import type { SignalSource } from "../signals/types.js";
+import type { SignalSource, RuntimeSignalUrgency } from "../signals/types.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 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";
@@ -50,6 +51,18 @@ export interface TurnMetrics {
     /** Tokens written to the prompt cache this turn (Anthropic `cache_creation_input_tokens`). */
     cacheCreationTokens: number;
 }
+/** O5: decision returned by `onToolCall` — `block: true` denies this call before it executes; the
+ *  `reason` is fed back to the model as a governance-denied tool result (so it can redirect). */
+export interface ToolCallHookDecision {
+    block?: boolean;
+    reason?: string;
+}
+/** O5: decision returned by `onToolResult` — `replaceOutput` swaps the result the model (and the
+ *  session log) sees; `note` is injected into the signal stream (see `injectNote`). */
+export interface ToolResultHookDecision {
+    replaceOutput?: string;
+    note?: string;
+}
 export interface RuntimeOptions {
     provider: LLMProvider;
     /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`). A workflow node's
@@ -73,14 +86,19 @@ 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;
         runSpec?: AgentRunSpec;
+        /** K4: `"initial"` = the once-per-run pre-turn-1 fetch; `"renewal"` = re-fired after a sprint
+         *  renewal (renewal drops the old history INCLUDING earlier memory hits, so the new sprint
+         *  gets a fresh recall pass). Hooks that ignore it keep the pre-K4 behavior. */
+        phase?: "initial" | "renewal";
     }) => Promise<string[] | undefined> | string[] | undefined;
     systemPrompt?: string;
     initialMemory?: string[];
@@ -118,6 +136,63 @@ export interface RuntimeOptions {
      * and memory-write syscalls are admitted unconditionally (pre-M2 behavior).
      */
     resourceQuota?: ResourceQuota;
+    /**
+     * O6: the in-kernel repeat fuse — the hard rungs above the soft no-progress STOP. When the model
+     * re-issues the IDENTICAL tool call (same name AND args) `denyAfter` turns in a row, the kernel
+     * denies it and feeds a directive note back; at `terminateAfter` the run ends `no_progress`.
+     * Same-tool/different-args loops never trip it. Defaults: enabled, denyAfter 5, terminateAfter 8.
+     * Pass `false` to disable (e.g. legit fixed-argument polling loops).
+     */
+    repeatFuse?: {
+        denyAfter?: number;
+        terminateAfter?: number;
+    } | false;
+    /**
+     * O4: the turn-end criteria gate (the Stop-hook analog). When the model tries to finish while the
+     * run's `criteria` stand, the kernel injects ONE self-check turn ("verify each criterion; continue
+     * if any is unmet") before accepting completion. Fires at most once per run; runs without criteria
+     * are untouched. Default enabled — set `false` to accept the first finish unconditionally.
+     */
+    criteriaGate?: boolean;
+    /**
+     * K2: max share of `maxTokens` the durable knowledge partition may occupy. Exceeding it emits a
+     * `knowledge_budget_exceeded` observation (once per cache generation) and evicts the OLDEST
+     * unpinned, non-skill entries at the next compaction/renewal boundary until usage fits. Pinned
+     * entries and skill pins are never budget-evicted. `0` disables. Default: kernel's 0.25.
+     */
+    knowledgeBudgetRatio?: number;
+    /**
+     * 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
+     * an explicit `deactivateSkill()`. Absent ⇒ activations are permanent (default). A repeat
+     * `skill(name)` call refreshes the lease.
+     */
+    skillLeaseTurns?: number;
+    /**
+     * O5 (the PreToolUse-hook analog): called for each kernel-APPROVED tool call just before it
+     * executes. Return `{ block: true, reason }` to veto — the call never runs and the reason is fed
+     * back to the model as a denied tool result. This is the seam for STATEFUL host policy (count
+     * repeats, budget writes per resource, project-specific rules); keep static allow/deny in
+     * `governancePolicy`. Errs-open: a throwing hook never blocks the run.
+     */
+    onToolCall?: (call: {
+        callId: string;
+        name: string;
+        arguments: string;
+    }) => Promise<ToolCallHookDecision | undefined | void> | ToolCallHookDecision | undefined | void;
+    /**
+     * O5 (the PostToolUse-hook analog): called for each executed tool result before it reaches the
+     * kernel. Return `{ replaceOutput }` to swap the result the model sees (redact / annotate), and/or
+     * `{ note }` to push a contextual note into the signal stream (same channel as `injectNote` —
+     * e.g. "that write was a no-op, stop repeating it"). Errs-open: a throwing hook changes nothing.
+     */
+    onToolResult?: (result: {
+        callId: string;
+        name: string;
+        arguments: string;
+        output: string;
+        isError: boolean;
+    }) => Promise<ToolResultHookDecision | undefined | void> | ToolResultHookDecision | undefined | void;
     /**
      * L1 (RunGroup): bind this runner to a governance domain shared by N peer sessions of one logical
      * run. Members pass the same `id` + `budgetStore`; the kernel's run-level token cap is then enforced
@@ -217,11 +292,17 @@ export declare class RuntimeRunner {
     private activeKernel;
     private pendingObservations;
     private currentSessionId;
+    /** O2 (system-reminder channel): host-pushed notes awaiting the next turn-boundary drain. */
+    private 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). */
+    private knowledgePushedSkills;
     private nextArchiveStart;
+    /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
+    private currentGoal;
     /** Full tool outputs keyed by call_id until Layer-1 spool observations are logged. */
     private pendingSpoolOutputs;
-    /** Local cache of paged-out/archived messages for priority memory retrieval. */
-    private 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). */
     private pendingAuthoredWorkflows;
@@ -256,10 +337,22 @@ export declare class RuntimeRunner {
     mountMarker(kind: string, id: string, description: string): void;
     /** Unmount a capability by kind + id from the active run. No-op if not running. */
     unmountCapability(kind: string, id: string): void;
-    /** Phase 4: satisfy kernel page-in requests before meta-tool execution. */
-    private applyKernelPageIn;
-    /** Push content into the Knowledge slot (memory retrievals, skill definitions, artifacts). */
-    pushKnowledge(message: Message, tokens?: number): void;
+    /** 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: Message, tokens?: number, opts?: {
+        key?: string;
+        pinned?: boolean;
+    }): void;
+    /** 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: string): void;
+    /** 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: string): void;
     /**
      * 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).
@@ -289,7 +382,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<{
@@ -349,8 +450,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;
@@ -359,6 +461,16 @@ export declare class RuntimeRunner {
         failed: string[];
     }>;
     interrupt(): void;
+    /** 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: string, urgency?: RuntimeSignalUrgency): void;
+    /** 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;
     run(req: {
         sessionId: string;
         goal: string;
@@ -376,11 +488,38 @@ export declare class RuntimeRunner {
     dream(agentId: string, nowMs?: number): AsyncIterable<StreamEvent>;
     /** Resolve in-kernel AskUser suspend; returns resume lists and stream events to yield. */
     private resolveKernelSuspend;
+    /**
+     * 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").
+     */
+    private resolveReadResult;
     private execute;
+    /** 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. */
+    private prefetchMemoryIntoHistory;
     private appendObservations;
     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;