@deepstrike/wasm 0.2.35 → 0.2.37

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
 export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
-export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
-export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Governance } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";

package/dist/runtime/facade.js

@@ -3,6 +3,7 @@
 import { RuntimeRunner, collectText } from "./runner.js";
 import { LocalExecutionPlane } from "./execution-plane.js";
 import { InMemorySessionLog } from "./session-log.js";
+import { fanoutSynthesize } from "./types/agent.js";
 /** Run a single agent to completion and return its final text. */
 export async function runAgent(opts) {
     const plane = opts.executionPlane ??
@@ -26,13 +27,16 @@ export async function runFanout(opts) {
         maxTokens: opts.maxTokens ?? 32_000,
         ...(opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}),
     });
-    const workerRole = opts.workerRole ?? "explore";
-    const spec = {
-        nodes: [
-            ...opts.tasks.map(task => ({ task, role: workerRole })),
-            { task: opts.synthesize, role: opts.synthesisRole ?? "plan", dependsOn: opts.tasks.map((_, i) => i) },
-        ],
-    };
+    // W-N8: build the spec via the ONE fanout template (it pins the pattern's isolation /
+    // context-inheritance choices — read-only system-only workers, full-context synthesizer — which
+    // this facade used to silently drop), then apply the caller's role overrides on top.
+    const spec = fanoutSynthesize(opts.tasks, opts.synthesize);
+    if (opts.workerRole) {
+        for (const node of spec.nodes.slice(0, opts.tasks.length))
+            node.role = opts.workerRole;
+    }
+    if (opts.synthesisRole)
+        spec.nodes[spec.nodes.length - 1].role = opts.synthesisRole;
     const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
     const synthesisId = `wf-node${opts.tasks.length}`;
     const lastCompleted = outcome.completed[outcome.completed.length - 1];

package/dist/runtime/kernel-event-log.d.ts

@@ -3,12 +3,6 @@ import type { SessionEvent } from "./session-log.js";
 /** Agent OS kernel event category (Phase 5). */
 export type KernelEventCategory = "syscall" | "sched" | "mm" | "proc" | "ipc";
 export declare function categoryForKind(kind: string): KernelEventCategory;
-export declare function withCategory<T extends {
-    kind: string;
-}>(event: T): T & {
-    category: KernelEventCategory;
-    primitive: KernelPrimitive;
-};
 type CompressionAction = Extract<SessionEvent, {
     kind: "compressed";
 }>["action"];

package/dist/runtime/kernel-event-log.js

@@ -22,33 +22,16 @@ export function categoryForKind(kind) {
             return "sched";
     }
 }
-export function withCategory(event) {
-    const category = categoryForKind(event.kind);
-    return {
-        ...event,
-        category,
-        primitive: primitiveForCategory(category),
-    };
-}
 export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
     const t = obs.turn ?? turn;
     const compressionAction = opts.compressionAction ?? (() => undefined);
     switch (obs.kind) {
-        case "page_out":
-            return withCategory({
-                kind: "page_out",
-                turn: t,
-                action: compressionAction(obs.action),
-                summary: obs.summary,
-                tier_hint: obs.tier_hint ?? "durable",
-                message_count: Array.isArray(obs.archived) ? obs.archived.length : 0,
-            });
         case "compressed": {
             const latest = opts.latestSeq ?? -1;
             const start = opts.nextArchiveStart ?? 0;
             if (latest < start)
                 return null;
-            return withCategory({
+            return {
                 kind: "compressed",
                 turn: t,
                 archived_seq_range: [start, latest],
@@ -57,24 +40,24 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 summary_tokens: obs.summary ? Math.max(1, Math.ceil(obs.summary.length / 4)) : undefined,
                 archive_ref: opts.archiveRef,
                 preserved_refs: opts.preservedRefs ?? [],
-            });
+            };
         }
         case "renewed":
-            return withCategory({
+            return {
                 kind: "context_renewed",
                 turn: t,
                 sprint: obs.sprint ?? 0,
                 handoff_ref: "",
-            });
+            };
         case "rollbacked":
-            return withCategory({
+            return {
                 kind: "rollbacked",
                 turn: t,
                 checkpoint_history_len: obs.checkpoint_history_len ?? 0,
                 reason: obs.reason,
-            });
+            };
         case "capability_changed":
-            return withCategory({
+            return {
                 kind: "capability_changed",
                 turn: t,
                 added: obs.added ?? [],
@@ -84,36 +67,29 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 ...(obs.version != null && { version: obs.version }),
                 ...(obs.mounted_by != null && { mounted_by: obs.mounted_by }),
                 ...(obs.mount_reason != null && { mount_reason: obs.mount_reason }),
-            });
+            };
         case "milestone_advanced":
-            return withCategory({
+            return {
                 kind: "milestone_advanced",
                 turn: t,
                 phase_id: obs.phase_id ?? "",
                 capabilities_unlocked: obs.capabilities_unlocked ?? [],
-            });
+            };
         case "milestone_blocked":
-            return withCategory({
+            return {
                 kind: "milestone_blocked",
                 turn: t,
                 phase_id: obs.phase_id ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
-            });
-        case "milestone_evidence":
-            return withCategory({
-                kind: "milestone_evidence",
-                turn: t,
-                phase_id: obs.phase_id ?? "",
-                evidence: obs.evidence ?? [],
-            });
+            };
         case "checkpoint_taken":
-            return withCategory({
+            return {
                 kind: "checkpoint_taken",
                 turn: t,
                 history_len: obs.history_len ?? 0,
-            });
+            };
         case "agent_process_changed":
-            return withCategory({
+            return {
                 kind: "agent_process_changed",
                 turn: t,
                 agent_id: obs.agent_id ?? "",
@@ -126,47 +102,47 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 ...(obs.result_termination
                     ? { result_termination: obs.result_termination }
                     : {}),
-            });
+            };
         case "tool_gated":
-            return withCategory({
+            return {
                 kind: "tool_gated",
                 turn: t,
                 call_id: obs.call_id ?? "",
                 tool: obs.tool ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
-            });
+            };
         case "signal_disposed":
-            return withCategory({
+            return {
                 kind: "signal_disposed",
                 turn: t,
                 signal_id: obs.signal_id ?? "",
                 disposition: obs.disposition ?? "",
                 queue_depth: obs.queue_depth ?? 0,
-            });
+            };
         case "budget_exceeded":
-            return withCategory({
+            return {
                 kind: "budget_exceeded",
                 turn: t,
                 budget: obs.budget ?? "",
-            });
+            };
         case "suspended":
-            return withCategory({
+            return {
                 kind: "suspended",
                 turn: t,
                 reason: typeof obs.reason === "string" ? obs.reason : "",
                 pending_calls: obs.pending_calls ?? [],
-            });
+            };
         case "resumed":
-            return withCategory({
+            return {
                 kind: "resumed",
                 turn: t,
                 approved: obs.approved ?? [],
                 denied: obs.denied ?? [],
-            });
+            };
         case "page_in_requested":
             return null;
         case "large_result_spooled":
-            return withCategory({
+            return {
                 kind: "large_result_spooled",
                 turn: t,
                 call_id: obs.call_id ?? "",
@@ -174,49 +150,49 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 original_size: obs.original_size ?? 0,
                 preview_size: obs.preview_size ?? 0,
                 spool_ref: opts.spoolRef,
-            });
+            };
         case "memory_written":
-            return withCategory({
+            return {
                 kind: "memory_written",
                 turn: t,
                 memory_id: obs.memory_id ?? "",
                 memory_kind: obs.memory_kind ?? "",
                 size_bytes: obs.size_bytes ?? 0,
-            });
+            };
         case "memory_queried":
-            return withCategory({
+            return {
                 kind: "memory_queried",
                 turn: t,
                 query_context: obs.query_context ?? "",
                 requested_k: obs.requested_k ?? 0,
                 requires_async_response: obs.requires_async_response ?? false,
-            });
+            };
         case "memory_validation_failed":
-            return withCategory({
+            return {
                 kind: "memory_validation_failed",
                 turn: t,
                 memory_id: obs.memory_id ?? "",
                 error: obs.error ?? "",
-            });
+            };
         case "workflow_batch_spawned": {
             const nodes = obs.nodes ?? [];
-            return withCategory({
+            return {
                 kind: "workflow_batch_spawned",
                 turn: t,
                 node_count: nodes.length,
                 node_ids: nodes.map((n) => n.agent_id ?? ""),
-            });
+            };
         }
         case "workflow_completed": {
             const completed = obs.completed ?? [];
             const failed = obs.failed ?? [];
-            return withCategory({
+            return {
                 kind: "workflow_completed",
                 turn: t,
                 completed,
                 failed,
                 total_nodes: completed.length + failed.length,
-            });
+            };
         }
         default:
             return null;

package/dist/runtime/kernel-step.d.ts

@@ -28,10 +28,19 @@ export interface KernelRuntimeHandle {
     drainNewMessages(): Message[];
     preservedRefs(): string[];
 }
+export interface PaceDecision {
+    action: "continue" | "sleep" | "stop";
+    delayMs?: number;
+    reason: string;
+    /** Set when the kernel trap coerced the model's proposal (clamped delay / forced stop). */
+    coercedFrom?: string;
+}
 export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
+    /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
+    paceDecision?: PaceDecision;
 }
 export type KernelRunnerAction = {
     kind: "call_provider";

package/dist/runtime/kernel-step.js

@@ -159,12 +159,24 @@ function mapKernelAction(raw) {
             };
         case "done": {
             const result = raw.result ?? {};
+            const pace = result.pace_decision;
             return {
                 kind: "done",
                 result: {
                     termination: String(result.termination ?? "error"),
                     turnsUsed: Number(result.turns_used ?? 0),
                     totalTokensUsed: Number(result.total_tokens_used ?? 0),
+                    // ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs).
+                    ...(pace
+                        ? {
+                            paceDecision: {
+                                action: (pace.action ?? "stop"),
+                                delayMs: pace.delay_ms,
+                                reason: pace.reason ?? "",
+                                coercedFrom: pace.coerced_from,
+                            },
+                        }
+                        : {}),
                 },
             };
         }

package/dist/runtime/large-result-spool.d.ts

@@ -45,5 +45,12 @@ export declare class LargeResultSpool {
     processToolResult(result: ToolResult): Promise<SpooledToolResult>;
     persistOutput(callId: string, content: string): Promise<string>;
     readSpooledResult(spoolRef: string): Promise<string>;
+    /**
+     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
+     * `call_id`, not the content-hashed key `persistOutput` chose). Scans the driver's key list for
+     * the `.spool/${callId}-*.txt` naming convention; returns `undefined` if nothing was ever
+     * spooled for that call.
+     */
+    findByCallId(callId: string): Promise<string | undefined>;
     cleanup(maxAgeMs?: number): Promise<number>;
 }

package/dist/runtime/large-result-spool.js

@@ -113,6 +113,31 @@ omitted: ${omitted} chars
     async readSpooledResult(spoolRef) {
         return this.driver.read(spoolRef);
     }
+    /**
+     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
+     * `call_id`, not the content-hashed key `persistOutput` chose). Scans the driver's key list for
+     * the `.spool/${callId}-*.txt` naming convention; returns `undefined` if nothing was ever
+     * spooled for that call.
+     */
+    async findByCallId(callId) {
+        let keys;
+        try {
+            keys = await this.driver.list();
+        }
+        catch {
+            return undefined;
+        }
+        const prefix = `.spool/${callId}-`;
+        const match = keys.find(k => k.startsWith(prefix) && k.endsWith('.txt'));
+        if (!match)
+            return undefined;
+        try {
+            return await this.driver.read(match);
+        }
+        catch {
+            return undefined;
+        }
+    }
     async cleanup(maxAgeMs) {
         const limit = maxAgeMs ?? this.config.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000;
         try {

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

@@ -28,4 +28,3 @@ export interface OsSnapshot {
     toolGatedCount: 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",
 ]);
 export function rebuildOsSnapshotFromSessionEvents(events) {
     const snap = {
@@ -89,20 +87,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/runner.d.ts

@@ -2,10 +2,11 @@ import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, Permiss
 import type { ToolSuspendEvent } from "./execution-plane.js";
 import type { DreamStore, DreamResult } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
-import type { SignalSource } from "../signals/index.js";
+import type { SignalSource, RuntimeSignal } from "../signals/index.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { ExecutionPlane } from "./execution-plane.js";
 import { type GovernancePolicy } from "../governance.js";
+import { type RecoveredNodeCompletion } from "./session-repair.js";
 import type { AgentRunSpec, SubAgentResult, MilestonePolicy, MilestoneContract, MilestoneCheckResult, WorkflowSpec } from "./types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
@@ -59,6 +60,16 @@ export interface TurnMetrics {
     };
     cacheCreationTokens: number;
 }
+/** O5: decision returned by `onToolCall` — `block: true` denies this call before it executes. */
+export interface ToolCallHookDecision {
+    block?: boolean;
+    reason?: string;
+}
+/** O5: decision returned by `onToolResult` — replace the output and/or inject a signal note. */
+export interface ToolResultHookDecision {
+    replaceOutput?: string;
+    note?: string;
+}
 export interface RuntimeOptions {
     provider: LLMProvider;
     /** M1/G3 intelligence routing: resolve a per-node provider from a workflow node's `modelHint`.
@@ -78,6 +89,8 @@ export interface RuntimeOptions {
      *  the knowledge partition before turn 1. Requires dreamStore + agentId. */
     preQueryMemory?: (ctx: {
         goal: string;
+        /** K4: `"initial"` = pre-turn-1 fetch; `"renewal"` = re-fired after a sprint renewal. */
+        phase?: "initial" | "renewal";
     }) => Promise<string[] | undefined> | string[] | undefined;
     systemPrompt?: string;
     initialMemory?: string[];
@@ -95,6 +108,39 @@ export interface RuntimeOptions {
     };
     schedulerBudget?: SchedulerBudget;
     resourceQuota?: ResourceQuota;
+    /** O6: the in-kernel repeat fuse — identical tool call (same name AND args) `denyAfter` turns in a
+     *  row ⇒ deny + directive note; `terminateAfter` ⇒ run ends `no_progress`. Defaults 5/8; `false`
+     *  disables. Same-tool/different-args loops never trip it. */
+    repeatFuse?: {
+        denyAfter?: number;
+        terminateAfter?: number;
+    } | false;
+    /** O4: turn-end criteria gate — one kernel-injected self-check turn before accepting completion
+     *  while `criteria` stand. Default enabled; `false` accepts the first finish unconditionally. */
+    criteriaGate?: boolean;
+    /** K2: max share of `maxTokens` the durable knowledge partition may occupy. Over budget ⇒
+     *  warn-once observation + oldest unpinned non-skill entries evicted at the next boundary.
+     *  Pinned/skill entries are exempt. `0` disables. Default: kernel's 0.25. */
+    knowledgeBudgetRatio?: number;
+    /** K3: default lease (in turns) for every skill activation — auto-deactivates after N turns
+     *  (toolset re-widens, knowledge pin boundary-swept). Absent ⇒ permanent (default). */
+    skillLeaseTurns?: number;
+    /** O5 (PreToolUse-hook analog): stateful host veto over each kernel-approved call; return
+     *  `{ block: true, reason }` to deny — the reason reaches the model as a denied result. Errs-open. */
+    onToolCall?: (call: {
+        callId: string;
+        name: string;
+        arguments: string;
+    }) => Promise<ToolCallHookDecision | undefined | void> | ToolCallHookDecision | undefined | void;
+    /** O5 (PostToolUse-hook analog): inspect each executed result; `{ replaceOutput }` swaps what the
+     *  model sees, `{ note }` injects a signal note (the `injectNote` channel). Errs-open. */
+    onToolResult?: (result: {
+        callId: string;
+        name: string;
+        arguments: string;
+        output: string;
+        isError: boolean;
+    }) => Promise<ToolResultHookDecision | undefined | void> | ToolResultHookDecision | undefined | void;
     memoryPolicy?: MemoryPolicy;
     tokenizer?: string;
     enablePlanTool?: boolean;
@@ -140,8 +186,15 @@ export declare class RuntimeRunner {
     private pendingObservations;
     private activeKernel;
     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;
+    /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
+    private currentGoal;
     private nextArchiveStart;
-    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). */
     private pendingAuthoredWorkflows;
@@ -149,6 +202,15 @@ export declare class RuntimeRunner {
     constructor(opts: RuntimeOptions);
     get hostOptions(): RuntimeOptions;
     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. `urgency` maps to
+     *  the kernel disposition ladder: `"normal"` queues (default), `"high"` soft-interrupts, `"critical"`
+     *  preempts. */
+    injectNote(text: string, urgency?: RuntimeSignal["urgency"]): void;
+    /** Injected-note drain shared with the main loop's per-turn poll: injected notes first (FIFO), then
+     *  the configured `signalSource` — one code path so the two inbound channels never drift. */
+    private nextInboundSignal;
     run(req: {
         sessionId: string;
         goal: string;
@@ -160,11 +222,29 @@ export declare class RuntimeRunner {
         }>;
     }): AsyncIterable<StreamEvent>;
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message. */
-    pushKnowledge(message: Message, tokens?: number): void;
-    /** Phase 4: satisfy kernel page-in requests before meta-tool execution. */
-    private applyKernelPageIn;
+    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message.
+     *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
+     *  compaction/renewal boundary) instead of appending a duplicate. `opts.pinned` exempts the
+     *  entry from the knowledge-budget sweep. */
+    pushKnowledge(message: 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 — toolset re-widens at the next provider call, the
+     *  skill's knowledge pin drops at the next boundary. Errs-open: not-active is a no-op. */
+    deactivateSkill(name: string): void;
     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, (b) the result
+     * spool (persisted once the kernel observation `large_result_spooled` was processed), (c) a
+     * session-log scan for the original `tool_completed` event carrying that `call_id`. Slices the
+     * resolved text by `[offset, offset + maxBytes)` (plain string slice — "bytes-ish").
+     */
+    private resolveReadResult;
     dream(agentId: string, nowMs?: number): Promise<DreamResult>;
     private execute;
     spawnSubAgent(spec: AgentRunSpec): Promise<SubAgentResult>;
@@ -202,7 +282,15 @@ export declare class RuntimeRunner {
     private bootstrapWorkflowKernel;
     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<{
@@ -246,8 +334,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;
@@ -256,6 +345,12 @@ export declare class RuntimeRunner {
         failed: string[];
     }>;
     private appendObservations;
+    /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
+     *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
+     *  never pinned into `knowledge`. `phase: "initial"` = once before turn 1; `phase: "renewal"` =
+     *  re-fired after each sprint renewal (renewal drops the old history INCLUDING earlier memory
+     *  hits). Errs-open throughout. */
+    private prefetchMemoryIntoHistory;
     private archiveSemanticPageOut;
 }
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;