@deepstrike/sdk 0.2.39 → 0.2.40

package/dist/runtime/run-group.js

@@ -1,11 +1,27 @@
+/**
+ * L1 (RunGroup) — a governance domain shared by N peer agent sessions of one logical run.
+ *
+ * The kernel (execution vehicle) is ephemeral and torn down between stateless turns, so the
+ * cumulative budget + membership that must span the whole group live outside any vehicle: in a
+ * `GroupBudgetStore`. Every store atomically reserves capacity and settles actual consumption.
+ * Per spec §2.5, only *cumulative* budget is shared this way; instantaneous concurrency stays
+ * vehicle-scoped.
+ *
+ * `InMemoryGroupBudgetStore` provides process-local atomic reservations for one replica / tests.
+ */
+import { randomUUID } from "node:crypto";
 /** Process-local default store. One ledger + member set per group id. */
 export class InMemoryGroupBudgetStore {
     ledgers = new Map();
     memberships = new Map();
+    reservations = new Map();
     read(groupId) {
-        return this.ledgers.get(groupId) ?? { tokensSpent: 0, subagentsSpawned: 0, roundsCompleted: 0 };
+        const ledger = this.ledgers.get(groupId);
+        return ledger
+            ? { ...ledger }
+            : { tokensSpent: 0, subagentsSpawned: 0, roundsCompleted: 0 };
     }
-    charge(groupId, delta) {
+    applyCharge(groupId, delta) {
         const cur = this.read(groupId);
         this.ledgers.set(groupId, {
             tokensSpent: cur.tokensSpent + Math.max(0, delta.tokens ?? 0),
@@ -16,8 +32,8 @@ export class InMemoryGroupBudgetStore {
     join(groupId, member) {
         if (!this.memberships.has(groupId))
             this.memberships.set(groupId, new Map());
-        // 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
+        // First join wins (idempotent by sessionId). 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))
@@ -26,61 +42,88 @@ export class InMemoryGroupBudgetStore {
     members(groupId) {
         return [...(this.memberships.get(groupId)?.values() ?? [])];
     }
-}
-/**
- * Persists the group ledger + membership to a `SessionLog`, keyed by a group-anchor session whose id
- * is the group id. Budget/membership rebuild by folding `group_budget_charged` / `group_member_joined`
- * events on read (spec §2.4). Durable + replica-spanning when the underlying `SessionLog` is.
- */
-export class SessionLogGroupBudgetStore {
-    log;
-    constructor(log) {
-        this.log = log;
+    reserve(groupId, request) {
+        const settled = this.read(groupId);
+        const held = [...(this.reservations.get(groupId)?.values() ?? [])].reduce((sum, reservation) => ({
+            tokensSpent: sum.tokensSpent + (reservation.granted.tokens ?? 0),
+            subagentsSpawned: sum.subagentsSpawned + (reservation.granted.subagents ?? 0),
+            roundsCompleted: (sum.roundsCompleted ?? 0) + (reservation.granted.rounds ?? 0),
+        }), { tokensSpent: 0, subagentsSpawned: 0, roundsCompleted: 0 });
+        const ledger = {
+            tokensSpent: settled.tokensSpent + held.tokensSpent,
+            subagentsSpawned: settled.subagentsSpawned + held.subagentsSpawned,
+            roundsCompleted: (settled.roundsCompleted ?? 0) + (held.roundsCompleted ?? 0),
+        };
+        const grant = (requested = 0, limit, used) => Math.max(0, Math.min(Math.max(0, requested), limit === undefined ? requested : limit - used));
+        const reservation = {
+            id: randomUUID(),
+            groupId,
+            memberId: request.memberId,
+            granted: {
+                ...(request.requested.tokens !== undefined
+                    ? { tokens: grant(request.requested.tokens, request.limits.tokens, ledger.tokensSpent) }
+                    : {}),
+                ...(request.requested.subagents !== undefined
+                    ? { subagents: grant(request.requested.subagents, request.limits.subagents, ledger.subagentsSpawned) }
+                    : {}),
+                ...(request.requested.rounds !== undefined
+                    ? { rounds: grant(request.requested.rounds, request.limits.rounds, ledger.roundsCompleted ?? 0) }
+                    : {}),
+            },
+        };
+        if (!this.reservations.has(groupId))
+            this.reservations.set(groupId, new Map());
+        this.reservations.get(groupId).set(reservation.id, reservation);
+        return reservation;
     }
-    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, roundsCompleted };
+    settle(groupId, reservationId, actual) {
+        const reservations = this.reservations.get(groupId);
+        if (!reservations?.delete(reservationId))
+            return;
+        if (reservations.size === 0)
+            this.reservations.delete(groupId);
+        this.applyCharge(groupId, actual);
     }
-    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),
+    release(groupId, reservationId) {
+        const reservations = this.reservations.get(groupId);
+        if (!reservations?.delete(reservationId))
+            return;
+        if (reservations.size === 0)
+            this.reservations.delete(groupId);
+    }
+}
+/** One member's reservation lifecycle. */
+export class GroupBudgetScope {
+    group;
+    granted;
+    reservationId;
+    closed = false;
+    constructor(group, granted, reservationId) {
+        this.group = group;
+        this.granted = granted;
+        this.reservationId = reservationId;
+    }
+    static async open(group, member, request) {
+        await group.budgetStore.join(group.id, member);
+        const reservation = await group.budgetStore.reserve(group.id, {
+            ...request,
+            memberId: member.sessionId,
         });
+        return new GroupBudgetScope(group, reservation.granted, reservation.id);
     }
-    async join(groupId, member) {
-        // Idempotent: don't grow the log with duplicate joins for the same session.
-        const existing = await this.members(groupId);
-        if (existing.some(m => m.sessionId === member.sessionId))
+    async settle(actual) {
+        if (this.closed)
             return;
-        await this.log.append(groupId, {
-            kind: "group_member_joined",
-            session_id: member.sessionId,
-            ...(member.role ? { role: member.role } : {}),
-            ...(member.kind ? { member_kind: member.kind } : {}),
-        });
+        await this.group.budgetStore.settle(this.group.id, this.reservationId, actual);
+        this.closed = true;
+    }
+    get isClosed() {
+        return this.closed;
     }
-    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,
-                    ...(event.member_kind ? { kind: event.member_kind } : {}),
-                });
-            }
-        }
-        return [...seen.values()];
+    async release() {
+        if (this.closed)
+            return;
+        await this.group.budgetStore.release(this.group.id, this.reservationId);
+        this.closed = true;
     }
 }

package/dist/runtime/runner.d.ts

@@ -1,21 +1,34 @@
 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 { DreamStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
-import type { SignalSource, RuntimeSignalUrgency } from "../signals/types.js";
+import type { RuntimeSignalUrgency, SignalSource } 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 RecoveredNodeOutcome } from "./session-repair.js";
+import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy, WorkflowSpec, WorkflowOutcome } from "../types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
 import { type GovernancePolicy } from "../governance.js";
-import { type NativeOsProfile, type OsProfileId } from "./os-profile.js";
+import { type NativeOsProfile, type OsProfileId, type SignalPolicy } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
-export interface SchedulerBudget {
-    maxWallMs?: number;
+import type { BackgroundTaskErrorHandler } from "./reliability.js";
+import { type ContextPolicyOverridesV1 } from "./context-policy.js";
+export interface SchedulerPolicy {
+    version: 1;
+    criticalPathWeight: number;
+    fanoutWeight: number;
+    ageWeight: number;
+    tokenCostWeight: number;
+}
+export declare function schedulerPolicyToKernel(policy: SchedulerPolicy): Record<string, number>;
+/** Host-counted provider envelope and response reserves deducted from the model context window. */
+export interface PromptBudget {
+    promptOverheadTokens: number;
+    outputReserveTokens: number;
+    safetyMarginTokens: number;
 }
 /** P0-C tool-gating telemetry: per-LLM-turn metrics, emitted via `RuntimeOptions.onTurnMetrics`.
  *  Pure observation — no behavior change. Feeds the go/no-go analysis for epoch skill gating (P1-B):
@@ -63,6 +76,30 @@ export interface ToolResultHookDecision {
     replaceOutput?: string;
     note?: string;
 }
+/** Bounded kernel reliability policy. Omitted fields retain kernel defaults. */
+export interface KernelReliabilityOptions {
+    /** Deduplicated input-event replay window, 1..65536. */
+    eventReplayCapacity?: number;
+    /** Completed effect-result replay window, 1..65536. */
+    completedEffectReplayCapacity?: number;
+    /** Provider overflow recovery retries, 0..16. */
+    providerRecoveryAttempts?: number;
+    /** Truncated-output recovery retries, 0..16. */
+    outputRecoveryAttempts?: number;
+    /** Host durability-effect retries, 0..16. */
+    hostEffectRetryAttempts?: number;
+    /** Tool-result spool threshold in bytes; must be positive. */
+    spoolThresholdBytes?: number;
+    /** Inline spool preview bytes; positive and no larger than the threshold. */
+    spoolPreviewBytes?: number;
+    /** Max accepted ABI transactions retained for a portable KernelSnapshot rebuild. */
+    snapshotInputLimit?: number;
+    /** Max canonical JSON bytes accepted for one kernel input, 256..64MiB. */
+    maxInputBytes?: number;
+    /** Max canonical JSON bytes retained by the snapshot journal, 256..1GiB. */
+    snapshotJournalBytesLimit?: number;
+}
+export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
 export interface RuntimeOptions {
     provider: LLMProvider;
     /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`). A workflow node's
@@ -80,13 +117,17 @@ export interface RuntimeOptions {
     worktreeManager?: import("./worktree-plane.js").WorktreeManager;
     sessionLog: SessionLog;
     executionPlane: ExecutionPlane;
+    /** Receives failures from run-owned best-effort tasks after their semantic owner has committed. */
+    onBackgroundTaskError?: BackgroundTaskErrorHandler;
     maxTokens: number;
     maxTurns?: number;
     timeoutMs?: number;
     agentId?: string;
+    /** Required by host-generated memory queries and page-out writes. */
+    memoryScope?: MemoryScope;
     /** 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 land in decaying
+     *  first LLM turn, with the request's goal and (optional) run-spec. Each returned scoped query
+     *  becomes a `dreamStore.search(agentId, query)` 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 ⇒
@@ -99,11 +140,17 @@ export interface RuntimeOptions {
          *  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;
+    }) => Promise<MemoryQuery[] | undefined> | MemoryQuery[] | undefined;
     systemPrompt?: string;
     initialMemory?: string[];
     skillDir?: string;
     dreamStore?: DreamStore;
+    /** M4: advisory callback when a recalled record crosses the promotion threshold. The host/model
+     *  decides whether to pin the record or promote its content into knowledge. */
+    onPromotionSuggested?: (info: {
+        recordId: string;
+        recallCount: number;
+    }) => void;
     knowledgeSource?: KnowledgeSource;
     signalSource?: SignalSource;
     extensions?: Record<string, unknown>;
@@ -115,27 +162,24 @@ export interface RuntimeOptions {
      * AskUser calls surface as `tool_gated` and run through `onPermissionRequest`.
      */
     governancePolicy?: GovernancePolicy;
-    /**
-     * Enable in-kernel signal routing (`set_attention_policy`). When set, inbound
-     * signals are dispatched through the kernel attention policy (dedup + disposition
-     * + queue) and surface as `signal_disposed` observations, instead of the legacy
-     * SDK-side router. `maxQueueSize` defaults to 64.
-     */
-    attentionPolicy?: {
-        maxQueueSize?: number;
-    };
-    /**
-     * Optional scheduler budget overrides. `maxWallMs` is the wall-clock run budget
-     * in milliseconds; when set, the kernel terminates the run when exceeded.
-     * Other axes (maxTurns, maxTokens) are set via RuntimeOptions directly.
-     */
-    schedulerBudget?: SchedulerBudget;
+    /** Version-1 in-kernel signal admission, queue, and expiry policy. */
+    signalPolicy?: SignalPolicy;
+    /** Provider-envelope overhead plus output and safety reserves journaled before start. */
+    promptBudget?: PromptBudget;
+    /** Stable replayable context behavior; SDK ratios are normalized to integer ppm on the ABI wire. */
+    contextPolicy?: ContextPolicyOverridesV1;
+    /** Versioned deterministic DAG scheduling policy installed atomically through ConfigureRun. */
+    schedulerPolicy?: SchedulerPolicy;
     /**
      * Optional declarative resource quotas (`set_resource_quota`). Bounds spawn concurrency /
      * nesting depth and memory-write rate at the kernel's single syscall trap. When unset, spawn
      * and memory-write syscalls are admitted unconditionally (pre-M2 behavior).
      */
     resourceQuota?: ResourceQuota;
+    /** Host-selectable bounded replay/recovery/durability policy. */
+    kernelReliability?: KernelReliabilityOptions;
+    /** Attempts allowed for a workflow node to satisfy its output schema, 1..16. Default: 2. */
+    workflowSchemaValidationAttempts?: number;
     /**
      * 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
@@ -181,13 +225,15 @@ export interface RuntimeOptions {
      * 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.
+     * `governancePolicy`. A throwing decision hook fails closed by default.
      */
     onToolCall?: (call: {
         callId: string;
         name: string;
         arguments: string;
     }) => Promise<ToolCallHookDecision | undefined | void> | ToolCallHookDecision | undefined | void;
+    /** Failure policy for `onToolCall`. Default `closed`; set `open` only for advisory hooks. */
+    onToolCallFailure?: "closed" | "open";
     /**
      * 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
@@ -203,9 +249,9 @@ export interface RuntimeOptions {
     }) => 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
-     * against the group's cumulative spend (seeded at boot, charged at run end) rather than per-vehicle.
-     * Unset ⇒ N=1, pre-L1 per-run budget (byte-identical). Only cumulative budget is shared; instantaneous
+     * run. Members pass the same `id` + `budgetStore`; reservable stores enforce the kernel's run-level
+     * cap against settled + in-flight usage. Stores must implement atomic reserve/settle/release.
+     * Unset ⇒ N=1. Only cumulative budget is shared; instantaneous
      * concurrency stays vehicle-scoped (spec §2.5).
      */
     runGroup?: RunGroup;
@@ -261,7 +307,7 @@ export interface RuntimeOptions {
      *  nested `start_workflow` flattens rather than recursing. */
     isWorkflowNode?: boolean;
     /**
-     * When set, sub-agents run through a HarnessLoop with this config.
+     * When set, sub-agents run through AttemptLoop with a RuntimeAttemptBody and LLM judge.
      * The eval provider evaluates the sub-agent's output against the criteria
      * from the AgentRunSpec, retrying up to maxAttempts times.
      */
@@ -294,10 +340,11 @@ export interface RuntimeOptions {
 export declare class RuntimeRunner {
     private readonly opts;
     private interrupted;
-    /** #2-B-ii: aborts the in-flight provider stream when the run is interrupted/preempted. Recreated
-     *  per `execute`; `interrupt()` fires it so a Critical `InterruptNow` cancels the live LLM call. */
+    private cancellationReason;
+    /** Aborts host-owned provider I/O before `cancel_operation` commits the kernel terminal fact. */
     private abortController;
     private activeKernel;
+    private activeGroupBudgetScope;
     private pendingObservations;
     private currentSessionId;
     /** O2 (system-reminder channel): host-pushed notes awaiting the next turn-boundary drain. */
@@ -307,29 +354,38 @@ export declare class RuntimeRunner {
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
     private knowledgePushedSkills;
     private nextArchiveStart;
+    private pendingPageOutArchives;
+    private activePageOutArchive;
     /** 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;
     /** 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;
+    private workflowContinuation;
     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;
-    writeMemory(memory: MemoryWriteRequest, opts?: {
+    private durableSessionId;
+    private commitKernelApply;
+    private commitKernelMaybeAction;
+    private commitKernelAction;
+    private persistMemoryToStore;
+    private retrieveMemoryFromStore;
+    writeMemory(memory: MemoryRecord, opts?: {
         sessionId?: string;
         agentId?: string;
     }): Promise<void>;
     queryMemory(query: MemoryQuery, opts?: {
         sessionId?: string;
         agentId?: string;
-    }): Promise<MemoryEntry[]>;
+    }): Promise<MemoryRecall[]>;
     private logMemoryRetrievalResult;
     private createSyscallRuntime;
+    private groupBudgetRequest;
+    private settleGroupBudget;
     /**
      * Lower the declarative governance / attention / scheduler-budget / resource-quota policies into a
      * freshly-created kernel. Shared by `execute()` (full agent run) and `bootstrapWorkflowKernel()`
@@ -340,13 +396,13 @@ export declare class RuntimeRunner {
     private applyKernelPolicies;
     private appendMemorySyscallObservations;
     /** Mount a tool capability on the currently-running kernel runtime. No-op if not running. */
-    mountTool(schema: ToolSchema): void;
+    mountTool(schema: ToolSchema): Promise<void>;
     /** Mount a skill capability on the currently-running kernel runtime. No-op if not running. */
-    mountSkill(name: string, description: string): void;
+    mountSkill(name: string, description: string): Promise<void>;
     /** Mount a generic marker capability (e.g. MCP server, agent) on the active run. No-op if not running. */
-    mountMarker(kind: string, id: string, description: string): void;
+    mountMarker(kind: string, id: string, description: string): Promise<void>;
     /** Unmount a capability by kind + id from the active run. No-op if not running. */
-    unmountCapability(kind: string, id: string): void;
+    unmountCapability(kind: string, id: string): Promise<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
@@ -354,15 +410,15 @@ export declare class RuntimeRunner {
     pushKnowledge(message: Message, tokens?: number, opts?: {
         key?: string;
         pinned?: boolean;
-    }): void;
+    }): Promise<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;
+    removeKnowledge(key: string): Promise<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;
+    deactivateSkill(name: string): Promise<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).
@@ -388,32 +444,23 @@ export declare class RuntimeRunner {
      * W0-ABI: run a declarative workflow DAG. The kernel owns the DAG and gates every node spawn
      * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
      * feeds their results back, and loops until the kernel reports the workflow complete.
-     * Returns the completed / failed node agent-ids.
+     * Returns one typed terminal outcome for every node in the DAG.
      */
     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[];
+        /** Typed recovered terminal outcomes, including control signals and output. */
+        resumedOutcomes?: RecoveredNodeOutcome[];
         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<{
-        completed: string[];
-        failed: string[];
-        outputs: Record<string, string>;
-    }>;
+    }): Promise<WorkflowOutcome>;
     /**
      * Bootstrap a standalone kernel for a host-driven workflow with NO active parent run — the path a
      * stateless request handler takes when it calls `runWorkflow(spec)` directly. Mirrors `execute()`'s
      * pre-run kernel setup (governance / attention / quota via `applyKernelPolicies`, then `start_run`)
-     * and records a `run_started` event so the standalone run is resumable from the session log. Sets
-     * `activeKernel` / `currentSessionId`; `runWorkflow` is responsible for tearing them down.
+     * after `runWorkflow` has durably recorded `run_started`. Sets `activeKernel` / `currentSessionId`;
+     * `runWorkflow` is responsible for tearing them down.
      */
     private bootstrapWorkflowKernel;
     /**
@@ -427,11 +474,7 @@ export declare class RuntimeRunner {
      */
     bootstrapWorkflow(spec: WorkflowSpec, opts?: {
         submitterAgentId?: string;
-    }): Promise<{
-        completed: string[];
-        failed: string[];
-        outputs: Record<string, string>;
-    }>;
+    }): Promise<WorkflowOutcome>;
     /**
      * M5 v2.1: drive the sub-workflow(s) a top-level agent authored via `start_workflow`. Called at the
      * verified-safe point (right after the tool turn resolved to `call_provider` — kernel in Reason, not
@@ -455,7 +498,7 @@ export declare class RuntimeRunner {
      * Shared workflow driver for `runWorkflow` (host `load_workflow`) and `bootstrapWorkflow` (agent
      * `submit_workflow`): given the observations from the initial load/bootstrap, run each kernel-emitted
      * 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.
+     * until the kernel reports the workflow complete. Returns typed terminal node outcomes.
      */
     private driveWorkflow;
     /**
@@ -466,14 +509,11 @@ export declare class RuntimeRunner {
      */
     resumeWorkflow(spec: WorkflowSpec, opts?: {
         sessionId?: string;
-    }): Promise<{
-        completed: string[];
-        failed: string[];
-    }>;
-    interrupt(): void;
+    }): Promise<WorkflowOutcome>;
+    interrupt(reason?: OperationCancellationReason): 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
+     *  the next turn boundary, routes through the kernel attention policy, and renders once as a
+     *  `[SIGNAL] <text>` line in the volatile state turn. 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. */
@@ -485,6 +525,7 @@ export declare class RuntimeRunner {
     /** 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;
+    private consumeInboundSignal;
     run(req: {
         sessionId: string;
         goal: string;
@@ -499,15 +540,13 @@ export declare class RuntimeRunner {
         }>;
     }): AsyncIterable<StreamEvent>;
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    dream(agentId: string, nowMs?: number): AsyncIterable<StreamEvent>;
-    /** Resolve in-kernel AskUser suspend; returns resume lists and stream events to yield. */
-    private resolveKernelSuspend;
+    /** Execute a kernel-owned approval effect and return the correlated decision lists. */
+    private resolveApprovalRequests;
     /**
      * 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
+     * output. Resolution order: (a) the on-disk result spool committed by the explicit
+     * `spool_large_result` host effect, then (b) 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;