@deepstrike/sdk 0.2.49 → 0.2.51

package/dist/runtime/os-snapshot.js

@@ -2,7 +2,6 @@ const KERNEL_KINDS = new Set([
     "compressed",
     "page_out",
     "page_in",
-    "large_result_spooled",
     "capability_changed",
     "context_renewed",
     "suspended",
@@ -30,7 +29,6 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
         signals: [],
         pageOutCount: 0,
         pageInCount: 0,
-        spoolCount: 0,
         toolGatedCount: 0,
         memoryWrittenCount: 0,
         memoryQueriedCount: 0,
@@ -64,7 +62,8 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
                 const record = {
                     turn: event.turn,
                     agent_id: event.agent_id,
-                    parent_session_id: event.parent_session_id,
+                    ...(event.parent_task_id ? { parent_task_id: event.parent_task_id } : {}),
+                    ...(event.parent_session_id ? { parent_session_id: event.parent_session_id } : {}),
                     state: event.state ?? "running",
                 };
                 const idx = index.get(event.agent_id);
@@ -119,9 +118,6 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
             case "page_in":
                 snap.pageInCount += 1;
                 break;
-            case "large_result_spooled":
-                snap.spoolCount += 1;
-                break;
             case "memory_written":
                 snap.memoryWrittenCount += 1;
                 break;

package/dist/runtime/payload-store.d.ts

@@ -0,0 +1,16 @@
+export interface PayloadStoreConfig {
+    storageDir?: string;
+    maxAgeMs?: number;
+}
+/** File-backed storage for canonical opaque payload locators. */
+export declare class PayloadStore {
+    private readonly storageDir;
+    private readonly maxAgeMs?;
+    private readonly activeWrites;
+    constructor(config?: PayloadStoreConfig);
+    private payloadPath;
+    persistPayload(sessionId: string, payloadRef: string, content: string): Promise<void>;
+    loadPayload(sessionId: string, payloadRef: string): Promise<string | undefined>;
+    cleanup(maxAgeMs?: number): Promise<number>;
+    private atomicWrite;
+}

package/dist/runtime/payload-store.js

@@ -0,0 +1,80 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+/** File-backed storage for canonical opaque payload locators. */
+export class PayloadStore {
+    storageDir;
+    maxAgeMs;
+    activeWrites = new Map();
+    constructor(config = {}) {
+        this.storageDir = config.storageDir ?? ".payloads";
+        this.maxAgeMs = config.maxAgeMs;
+    }
+    payloadPath(sessionId, payloadRef) {
+        const key = crypto
+            .createHash("sha256")
+            .update(`${sessionId}\u0000${payloadRef}`)
+            .digest("hex");
+        return path.join(this.storageDir, `${key}.payload`);
+    }
+    async persistPayload(sessionId, payloadRef, content) {
+        const target = this.payloadPath(sessionId, payloadRef);
+        let write = this.activeWrites.get(target);
+        if (!write) {
+            write = this.atomicWrite(target, content).finally(() => {
+                this.activeWrites.delete(target);
+            });
+            this.activeWrites.set(target, write);
+        }
+        await write;
+    }
+    async loadPayload(sessionId, payloadRef) {
+        try {
+            return await fs.readFile(this.payloadPath(sessionId, payloadRef), "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    async cleanup(maxAgeMs = this.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000) {
+        let files;
+        try {
+            files = await fs.readdir(this.storageDir);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return 0;
+            throw error;
+        }
+        const now = Date.now();
+        let removed = 0;
+        for (const file of files) {
+            const target = path.join(this.storageDir, file);
+            const stat = await fs.stat(target);
+            if (now - stat.mtimeMs > maxAgeMs) {
+                await fs.unlink(target);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+    async atomicWrite(target, content) {
+        await fs.mkdir(this.storageDir, { recursive: true });
+        const temporary = `${target}.${process.pid}.${crypto.randomUUID()}.tmp`;
+        let handle;
+        try {
+            handle = await fs.open(temporary, "wx");
+            await handle.writeFile(content, "utf8");
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await fs.rename(temporary, target);
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+            await fs.unlink(temporary).catch(() => undefined);
+        }
+    }
+}

package/dist/runtime/runner.d.ts

@@ -3,17 +3,17 @@ import type { DreamStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery }
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { RuntimeSignalUrgency, SignalSource } from "../signals/types.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
+import type { KernelJournal } from "./kernel-journal.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 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, type SignalPolicy } from "./os-profile.js";
-import { LargeResultSpool } from "./large-result-spool.js";
+import { PayloadStore } from "./payload-store.js";
 import type { BackgroundTaskErrorHandler } from "./reliability.js";
 import { type ContextPolicyOverridesV1 } from "./context-policy.js";
 import { type InstructionProfile } from "../harness/manifest.js";
@@ -80,26 +80,12 @@ export interface ToolResultHookDecision {
 }
 /** 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 {
@@ -118,6 +104,8 @@ export interface RuntimeOptions {
      *  Undefined ⇒ worktree nodes fall back to the inherited plane (no isolation). */
     worktreeManager?: import("./worktree-plane.js").WorktreeManager;
     sessionLog: SessionLog;
+    /** ABI v3 transaction capability. Default session logs expose one; custom logs pass it explicitly. */
+    kernelJournal?: KernelJournal;
     executionPlane: ExecutionPlane;
     /** Receives failures from run-owned best-effort tasks after their semantic owner has committed. */
     onBackgroundTaskError?: BackgroundTaskErrorHandler;
@@ -194,7 +182,7 @@ export interface RuntimeOptions {
      * and memory-write syscalls are admitted unconditionally (pre-M2 behavior).
      */
     resourceQuota?: ResourceQuota;
-    /** Host-selectable bounded replay/recovery/durability policy. */
+    /** Canonical provider/output recovery and input-bound policy. */
     kernelReliability?: KernelReliabilityOptions;
     /** Attempts allowed for a workflow node to satisfy its output schema, 1..16. Default: 2. */
     workflowSchemaValidationAttempts?: number;
@@ -273,6 +261,8 @@ export interface RuntimeOptions {
      * concurrency stays vehicle-scoped (spec §2.5).
      */
     runGroup?: RunGroup;
+    /** Host-only retries for settling the run-group ledger; never enters the canonical ABI. */
+    groupBudgetSettlementRetries?: number;
     /**
      * Set by the SubAgentOrchestrator for host-derived child runs: the child still joins the
      * `runGroup` (lineage) and settles its actual terminal usage into the group ledger, but reserves
@@ -281,18 +271,14 @@ export interface RuntimeOptions {
      */
     nestedGroupVehicle?: boolean;
     /**
-     * Optional long-term memory policy (`set_memory_policy`). Tunes the kernel's memory subsystem
-     * (retrieval top-k, stale-warning age, write validation, memory path). Unset leaves the kernel
-     * defaults. Enabling memory still requires `dreamStore` + `agentId`.
+     * Optional canonical long-term memory policy. Enabling memory still requires `dreamStore` +
+     * `agentId`; storage location is configured on that host store, not in the kernel contract.
      */
     memoryPolicy?: MemoryPolicy;
     tokenizer?: string;
     enablePlanTool?: boolean;
-    /**
-     * Persist full tool outputs when the kernel emits `large_result_spooled`.
-     * Defaults to `.spool/` under the process cwd.
-     */
-    resultSpool?: LargeResultSpool;
+    /** Storage for canonical opaque external payload locators. */
+    payloadStore?: PayloadStore;
     compressionStore?: ArchiveStore;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
@@ -304,15 +290,59 @@ export interface RuntimeOptions {
         criteria: string[];
         requiredEvidence: string[];
     }) => Promise<MilestoneCheckResult> | MilestoneCheckResult;
-    /** Passed to kernel start_run for role/isolation metadata. */
+    /** Passed to the canonical agent root for role/isolation metadata. */
     runSpec?: AgentRunSpec;
-    /** P0-A tool gating: a static per-run tool profile — only these tool ids (plus the
-     *  skill/memory/knowledge/update_plan/read_result meta-tools) are exposed to the model each turn.
-     *  Sugar that lowers to the same `capability_filter` sub-agents use; byte-stable across
-     *  the run, so it never busts the prompt-cache prefix. Augments `runSpec`'s filter when
-     *  both are set; synthesizes a minimal run spec when `runSpec` is absent. Omitted/empty
-     *  ⇒ all registered tools exposed (no gating). */
+    /**
+     * The run's **exposure ceiling** — the outer bound on what this run may EVER advertise to the
+     * model. Not a static profile: it is an INTERSECTION applied on every turn (`exposed ⊆ ceiling`),
+     * so every narrowing mechanism operates *within* it and none can widen past it. Skills narrow
+     * inside the ceiling (`allowed_tools`), `baselineToolIds` selects which of the ceiling's tools are
+     * exposed before any skill activates, `stableCoreToolIds` pins tools against skill narrowing, and
+     * the self-harness manifest surface folds by intersection for exactly this reason.
+     *
+     * Exempt on the id axis: the kernel-owned meta-tools (`skill`, `memory`, `knowledge`,
+     * `update_plan`, `read_result`) stay exposed regardless of this list — a ceiling that hid `skill`
+     * would make progressive disclosure unreachable. The KIND axis
+     * (`runSpec.capabilityFilter.allowedKinds`) still applies to them.
+     *
+     * Byte-stable across the run, so it never busts the prompt-cache prefix. Lowers to the same
+     * `capability_filter` sub-agents use: augments `runSpec`'s filter when both are set, else
+     * synthesizes a minimal run spec. Omitted **or empty** ⇒ no ceiling (all registered tools) — the
+     * empty array is NOT a minimal surface here; use `baselineToolIds: []` for that.
+     *
+     * Enforcement: `toolDispatchGate` (default `"exposed"`) makes this a real boundary — a call to a
+     * tool outside the advertised set never executes.
+     */
     allowedToolIds?: string[];
+    /**
+     * The **pre-activation** exposure surface, selected from under the `allowedToolIds` ceiling.
+     * Makes the narrow→wide progressive-disclosure shape expressible: start the run advertising only
+     * these tools, and let a skill activation widen the surface by exactly its declared
+     * `allowed_tools` (still ∩ the ceiling). Per turn:
+     *
+     *   `exposed = meta ∪ ((baseline ∪ stableCore ∪ ⋃ activeSkills.allowed_tools) ∩ ceiling)`
+     *
+     * An active skill that declares no `allowed_tools` contributes nothing — with a baseline set the
+     * surface stays narrow (strict; the legacy errs-open widening is deliberately not inherited).
+     *
+     * `undefined` ⇒ legacy behavior, byte-identical (ceiling + errs-open skill narrowing). `[]` is a
+     * legitimate, distinct value: the minimal surface (meta-tools + `stableCoreToolIds` only) — the
+     * `allowedToolIds` "empty means no gating" trap does NOT recur here. Entries outside the ceiling
+     * silently intersect away (no root-start error), the same fold every id-list surface uses.
+     */
+    baselineToolIds?: string[];
+    /**
+     * Dispatch enforcement for the exposure surface. `"exposed"` (default) is fail-closed: a tool call
+     * the model was never advertised this turn never reaches the host — the kernel commits a
+     * model-visible `governance_denied` result instead ("Tool 'X' is not part of this run's toolset"),
+     * which feeds the repeat fuse like any other denial. Allowed siblings in the same batch still
+     * execute; `pace` and the meta-tool family always pass through.
+     *
+     * `"registered"` is the escape hatch restoring the pre-gate permissive behavior (any registered
+     * tool the model names executes, even if it was gated out of the tools schema). Set it only when a
+     * host deliberately relies on blind calls to unadvertised tools.
+     */
+    toolDispatchGate?: "exposed" | "registered";
     /** P0-C: optional per-turn metrics sink for tool-gating telemetry (see `TurnMetrics`). Pure
      *  observation; invoked once per LLM turn. Never throws into the run loop (errors are swallowed). */
     onTurnMetrics?: (metrics: TurnMetrics) => void;
@@ -324,13 +354,6 @@ export interface RuntimeOptions {
     milestoneContract?: MilestoneContract;
     /** Custom sub-agent host driver; defaults to SubAgentOrchestrator. */
     subAgentOrchestrator?: SubAgentOrchestrator;
-    /** M5 v2.1: marks this runner as executing AS a workflow node (a child spawned by the workflow
-     *  driver). A workflow node's `start_workflow` FLATTENS to the parent kernel (emits
-     *  `workflow_nodes_submitted` for `runWorkflow` to append). A top-level run (this flag unset)
-     *  instead AUTO-PIVOTS: it bootstraps + drives the authored workflow in its own kernel and resumes
-     *  the reason loop with the outcome. The orchestrator sets this on workflow-node children so a
-     *  nested `start_workflow` flattens rather than recursing. */
-    isWorkflowNode?: boolean;
     /**
      * 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
@@ -372,6 +395,7 @@ export declare class RuntimeRunner {
     private activeGroupBudgetScope;
     private pendingObservations;
     private currentSessionId;
+    private fallbackPayloadStore;
     /** 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
@@ -383,9 +407,6 @@ export declare class RuntimeRunner {
     private activePageOutArchive;
     /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
     private currentGoal;
-    /** 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`). */
@@ -402,25 +423,16 @@ export declare class RuntimeRunner {
     private commitKernelApply;
     private commitKernelMaybeAction;
     private commitKernelAction;
+    private startKernelAgent;
+    private payloadStore;
     private persistMemoryToStore;
     private retrieveMemoryFromStore;
     /**
-     * T5: run one memory query through the kernel's `query_memory → memory_query_result`
-     * effect lifecycle on the given runtime. The kernel injects each routed hit into history
-     * itself and derives the recall lifecycle (`memory_recalled`, edge-triggered
-     * `promotion_suggested`) from the routed hits — the store stays a pure query.
-     *
-     * `seenRecordIds` is one dedupe horizon: a record hit by several queries of the same
-     * prefetch is routed (recalled, injected) once. The kernel derives counts statelessly from
-     * each hit's payload, so host-side pre-filtering is the only place duplicates can be stopped.
-     *
-     * The recall lifecycle is consumed immediately rather than via the per-turn drain: the store
-     * must be up to date before any same-turn re-query, and a renewal prefetch fires inside the
-     * drain loop where queued observations would not be consumed until the next boundary.
-     * Non-memory observations are forwarded to `leftovers` (the run's pending queue) when given,
-     * and discarded for detached syscall runtimes (their kernel is throwaway).
+     * Route a host-originated renewal prefetch into canonical knowledge commands. This is not an
+     * agent syscall: the host selects records from its store, then the kernel owns the only mutation
+     * of live semantic context. `seenRecordIds` is the prefetch's dedupe horizon.
      */
-    private queryMemoryThroughKernel;
+    private prefetchMemoryIntoKnowledge;
     writeMemory(memory: MemoryRecord, opts?: {
         sessionId?: string;
         agentId?: string;
@@ -429,29 +441,28 @@ export declare class RuntimeRunner {
         sessionId?: string;
         agentId?: string;
     }): Promise<MemoryRecall[]>;
+    private applyHostMemoryRecallLifecycle;
     private logMemoryRetrievalResult;
-    private createSyscallRuntime;
+    private createCanonicalRuntime;
+    private resolveKernelJournal;
     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()`
+     * freshly-created kernel. Shared by `execute()` (full agent run) and `initializeWorkflowKernel()`
      * (standalone host-driven workflow) so a workflow's DAG-node spawns are gated, queued, and quota'd
-     * exactly as a mid-run spawn would be. Must run BEFORE `start_run` so the in-kernel gate enforces
+     * exactly as a mid-run spawn would be. Must run before the canonical root start so the gate enforces
      * every policy from the first spawn. No config ⇒ the native-profile defaults (铁律: defaults only).
      */
     private applyKernelPolicies;
     /**
-     * Mirror one kernel memory-lifecycle observation into the durable store / host callbacks.
-     * Shared by the main run drain, the prefetch path, and the host memory syscalls so every
-     * query route has identical recall + promotion semantics (T5).
+     * Mirror one agent-syscall memory-lifecycle observation into the durable store / host callbacks.
      *
      * M3: `memory_recalled` carries the kernel-derived count — the runner never computes
      * `recall_count + 1` itself. M4: `promotion_suggested` is advisory and already
      * edge-triggered by the kernel; the runner surfaces it and never auto-pins.
      */
     private mirrorMemoryLifecycle;
-    private consumeMemoryLifecycleObservations;
     /** Mount a tool capability on the currently-running kernel runtime. No-op if not running. */
     mountTool(schema: ToolSchema): Promise<void>;
     /** Mount a skill capability on the currently-running kernel runtime. No-op if not running. */
@@ -476,11 +487,6 @@ export declare class RuntimeRunner {
      *  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): 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).
-     */
-    spawnSubAgent(spec: AgentRunSpec): AsyncIterable<StreamEvent>;
     /**
      * G3: run one workflow node, enforcing its `output_schema` (if any). Without a schema this is a
      * plain `orchestrator.run`. With one, the node's agent is instructed to emit conforming JSON, its
@@ -504,44 +510,17 @@ export declare class RuntimeRunner {
      * Returns one typed terminal outcome for every node in the DAG.
      */
     runWorkflow(spec: WorkflowSpec, opts?: {
-        /** 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[];
         /** Standalone session id when bootstrapping (no active parent run). Defaults to a fresh uuid. */
         sessionId?: 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`)
+     * pre-run kernel setup (governance / attention / quota via `applyKernelPolicies`, then root start)
      * after `runWorkflow` has durably recorded `run_started`. Sets `activeKernel` / `currentSessionId`;
      * `runWorkflow` is responsible for tearing them down.
      */
-    private bootstrapWorkflowKernel;
-    /**
-     * M5/G1: bootstrap an **agent-authored** workflow ("the model writes its own harness"). Unlike
-     * `runWorkflow` (the host fires the privileged `load_workflow`), this routes the spec through the
-     * agent-reachable `Syscall::LoadWorkflow` (the `submit_workflow` event): with no workflow active the
-     * kernel **bootstraps** the DAG; if one is already active it **flattens** the spec's nodes onto it
-     * (bootstrap-or-flatten — one kernel, one quota, never a workflow stack). Gated by the same
-     * `max_workflow_nodes` backstop as runtime submission, so an authored harness can't overgrow the run.
-     * The resulting batches are driven by the same shared driver as `runWorkflow`.
-     */
-    bootstrapWorkflow(spec: WorkflowSpec, opts?: {
-        submitterAgentId?: 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
-     * suspended). For each authored spec: `bootstrapWorkflow` runs it in THIS kernel (the kernel resumes
-     * the agent reason loop on `workflow_completed` — `finish_workflow` sets phase=Reason), then the
-     * outcome is injected as a user message so the agent's next turn sees the result. Returns a fresh
-     * `call_provider` synthesized from the updated context (the workflow drive consumed its own kernel
-     * actions, so we re-render — the same pattern as the reactive-compact retry path).
-     */
-    private driveAuthoredWorkflows;
+    private initializeWorkflowKernel;
     /**
      * #2-B-ii: while a workflow batch is in flight, poll the signal source. A Critical `InterruptNow`
      * routes through the kernel (which, with the root suspended in `SubAgentAwait`, preempts — marks the
@@ -552,21 +531,10 @@ export declare class RuntimeRunner {
      */
     private monitorWorkflowPreemption;
     /**
-     * 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 typed terminal node outcomes.
+     * Drive a canonical root or provider-authored workflow from kernel effects only: run each
+     * emitted batch, resolve its launch/completion/preemption effects, and stop at the kernel terminal.
      */
     private driveWorkflow;
-    /**
-     * Resume a workflow from the parent session's completed 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;
-    }): 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 renders once as a
@@ -599,14 +567,6 @@ export declare class RuntimeRunner {
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     /** 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) 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;
     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,
@@ -614,6 +574,7 @@ export declare class RuntimeRunner {
      *  after each sprint renewal (`phase: "renewal"`): renewal drops the old history INCLUDING the
      *  earlier memory hits, so the new sprint gets a fresh recall pass. Errs-open throughout. */
     private prefetchMemoryIntoHistory;
+    private prefetchMemoryIntoInitialContext;
     private appendObservations;
     private archiveSemanticPageOut;
     private upgradeCompressedSummary;