@deepstrike/wasm 0.2.51 → 0.2.60

package/dist/runtime/context-policy.d.ts

@@ -1,35 +1,33 @@
-export declare const CONTEXT_POLICY_VERSION: 1;
 export declare const PPM_SCALE: 1000000;
-export interface ContextPressureThresholdsV1 {
+export interface ContextPressureThresholds {
     snip: number;
     micro: number;
     collapse: number;
     auto: number;
     renewal: number;
 }
-export interface ContextPolicyV1 {
-    pressureThresholds: ContextPressureThresholdsV1;
+export interface ContextPolicy {
+    pressureThresholds: ContextPressureThresholds;
     targetAfterCompress: number;
     preserveRecentTurns: number;
     renewalCarryover: number;
     collapseOldAssistantNarration: boolean;
     idleMicroCompactMinutes: number;
 }
-export interface ContextPolicyWireV1 {
-    version: typeof CONTEXT_POLICY_VERSION;
-    pressure_thresholds_ppm: ContextPressureThresholdsV1;
+export interface ContextPolicyWire {
+    pressure_thresholds_ppm: ContextPressureThresholds;
     target_after_compress_ppm: number;
     preserve_recent_turns: number;
     renewal_carryover_ppm: number;
     collapse_old_assistant_narration: boolean;
     idle_micro_compact_minutes: number;
 }
-export interface ContextPolicyOverridesV1 extends Partial<Omit<ContextPolicyV1, "pressureThresholds">> {
-    pressureThresholds?: Partial<ContextPressureThresholdsV1>;
+export interface ContextPolicyOverrides extends Partial<Omit<ContextPolicy, "pressureThresholds">> {
+    pressureThresholds?: Partial<ContextPressureThresholds>;
 }
-export declare const DEFAULT_CONTEXT_POLICY_V1: Readonly<ContextPolicyV1>;
+export declare const DEFAULT_CONTEXT_POLICY: Readonly<ContextPolicy>;
 /** Resolve ergonomic partial SDK options into one complete, atomically validated policy. */
-export declare function contextPolicyV1(overrides?: ContextPolicyOverridesV1): ContextPolicyV1;
+export declare function contextPolicy(overrides?: ContextPolicyOverrides): ContextPolicy;
 /** Convert the public ratio-based policy to the canonical integer-only ABI wire shape. */
-export declare function normalizeContextPolicyV1(policy: ContextPolicyV1): ContextPolicyWireV1;
+export declare function normalizeContextPolicy(policy: ContextPolicy): ContextPolicyWire;
 export declare function ratioToPpm(value: number, field?: string): number;

package/dist/runtime/context-policy.js

@@ -1,6 +1,5 @@
-export const CONTEXT_POLICY_VERSION = 1;
 export const PPM_SCALE = 1_000_000;
-export const DEFAULT_CONTEXT_POLICY_V1 = Object.freeze({
+export const DEFAULT_CONTEXT_POLICY = Object.freeze({
     pressureThresholds: Object.freeze({ snip: 0.70, micro: 0.80, collapse: 0.90, auto: 0.95, renewal: 0.98 }),
     targetAfterCompress: 0.65,
     preserveRecentTurns: 2,
@@ -9,20 +8,20 @@ export const DEFAULT_CONTEXT_POLICY_V1 = Object.freeze({
     idleMicroCompactMinutes: 60,
 });
 /** Resolve ergonomic partial SDK options into one complete, atomically validated policy. */
-export function contextPolicyV1(overrides = {}) {
+export function contextPolicy(overrides = {}) {
     const policy = {
-        ...DEFAULT_CONTEXT_POLICY_V1,
+        ...DEFAULT_CONTEXT_POLICY,
         ...overrides,
         pressureThresholds: {
-            ...DEFAULT_CONTEXT_POLICY_V1.pressureThresholds,
+            ...DEFAULT_CONTEXT_POLICY.pressureThresholds,
             ...overrides.pressureThresholds,
         },
     };
-    normalizeContextPolicyV1(policy);
+    normalizeContextPolicy(policy);
     return policy;
 }
 /** Convert the public ratio-based policy to the canonical integer-only ABI wire shape. */
-export function normalizeContextPolicyV1(policy) {
+export function normalizeContextPolicy(policy) {
     const pressure_thresholds_ppm = {
         snip: ratioToPpm(policy.pressureThresholds.snip, "pressureThresholds.snip"),
         micro: ratioToPpm(policy.pressureThresholds.micro, "pressureThresholds.micro"),
@@ -44,7 +43,6 @@ export function normalizeContextPolicyV1(policy) {
         throw new TypeError("collapseOldAssistantNarration must be boolean");
     }
     return {
-        version: CONTEXT_POLICY_VERSION,
         pressure_thresholds_ppm,
         target_after_compress_ppm,
         preserve_recent_turns: policy.preserveRecentTurns,

package/dist/runtime/durable-content.d.ts

@@ -0,0 +1,44 @@
+export declare class DurableContentError extends Error {
+    constructor(message: string);
+}
+export type DurableSource = {
+    kind: "url";
+    url: string;
+} | {
+    kind: "base64";
+    data: string;
+} | {
+    kind: "file_id";
+    id: string;
+    affinity: {
+        provider_id: string;
+        endpoint_id: string;
+    };
+} | {
+    kind: "object";
+    handle: string;
+    owner: string;
+    payload_ref: string;
+};
+export type DurableContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image" | "audio" | "video" | "file";
+    source: DurableSource;
+    media_type?: string;
+    provider_options?: Record<string, unknown>;
+};
+export interface DurableContent {
+    blocks: DurableContentBlock[];
+}
+export interface DurableToolResult extends DurableContent {
+    call_id: string;
+    is_error: boolean;
+}
+export declare function decodeDurableContent(value: unknown): DurableContent;
+export declare function decodeDurableToolResult(value: unknown): DurableToolResult;
+export declare function encodeDurableContent(content: DurableContent): Record<string, unknown>;
+export declare function encodeDurableToolResult(result: DurableToolResult): Record<string, unknown>;
+export declare function toolOutputBlocksToDurable(blocks: readonly import("../types.js").ToolOutputBlock[]): DurableContentBlock[];
+export declare function durableBlocksToToolOutput(blocks: readonly DurableContentBlock[]): import("../types.js").ToolOutputBlock[];

package/dist/runtime/durable-content.js

@@ -0,0 +1,119 @@
+export class DurableContentError extends Error {
+    constructor(message) { super(message); this.name = "DurableContentError"; }
+}
+function obj(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new DurableContentError(`${label} must be an object`);
+    return value;
+}
+function keys(value, allowed, label) {
+    for (const key of Object.keys(value))
+        if (!allowed.includes(key))
+            throw new DurableContentError(`${label} has unknown field ${key}`);
+}
+function string(value, label) {
+    if (typeof value !== "string" || !value)
+        throw new DurableContentError(`${label} must be a non-empty string`);
+    return value;
+}
+function boolean(value, label) {
+    if (typeof value !== "boolean")
+        throw new DurableContentError(`${label} must be a boolean`);
+    return value;
+}
+function base64(value, label) {
+    const data = string(value, label);
+    if (data.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data))
+        throw new DurableContentError(`${label} is not valid base64`);
+    return data;
+}
+function source(value, label) {
+    const raw = obj(value, `${label} source`);
+    const kind = raw.kind;
+    if (kind === "url") {
+        keys(raw, ["kind", "url"], `${label} source`);
+        return { kind, url: string(raw.url, `${label} URL`) };
+    }
+    if (kind === "base64") {
+        keys(raw, ["kind", "data"], `${label} source`);
+        return { kind, data: base64(raw.data, `${label} base64 data`) };
+    }
+    if (kind === "file_id") {
+        keys(raw, ["kind", "id", "affinity"], `${label} source`);
+        const a = obj(raw.affinity, `${label} affinity`);
+        keys(a, ["provider_id", "endpoint_id"], `${label} affinity`);
+        return { kind, id: string(raw.id, `${label} file id`), affinity: { provider_id: string(a.provider_id, `${label} affinity provider_id`), endpoint_id: string(a.endpoint_id, `${label} affinity endpoint_id`) } };
+    }
+    if (kind === "object") {
+        keys(raw, ["kind", "handle", "owner", "payload_ref"], `${label} source`);
+        return { kind, handle: string(raw.handle, `${label} object handle`), owner: string(raw.owner, `${label} object owner`), payload_ref: string(raw.payload_ref, `${label} payload_ref`) };
+    }
+    throw new DurableContentError(`${label} source kind is invalid`);
+}
+function block(value, index) {
+    const raw = obj(value, `content block ${index}`);
+    if (raw.type === "text") {
+        keys(raw, ["type", "text"], `content block ${index}`);
+        return { type: "text", text: string(raw.text, `content block ${index} text`) };
+    }
+    if (raw.type === "tool_result")
+        throw new DurableContentError("nested tool_result blocks are forbidden");
+    if (raw.type !== "image" && raw.type !== "audio" && raw.type !== "video" && raw.type !== "file")
+        throw new DurableContentError(`unknown content block type: ${String(raw.type)}`);
+    keys(raw, ["type", "source", "media_type", "provider_options"], `content block ${index}`);
+    const result = { type: raw.type, source: source(raw.source, `content block ${index}`) };
+    if (raw.media_type !== undefined)
+        result.media_type = string(raw.media_type, `content block ${index} media_type`);
+    if (raw.provider_options !== undefined)
+        result.provider_options = obj(raw.provider_options, `content block ${index} provider_options`);
+    return result;
+}
+function blocks(value) { if (!Array.isArray(value))
+    throw new DurableContentError("content blocks must be an array"); return value.map(block); }
+export function decodeDurableContent(value) {
+    const raw = obj(value, "durable content");
+    keys(raw, ["blocks"], "durable content");
+    return { blocks: blocks(raw.blocks) };
+}
+export function decodeDurableToolResult(value) {
+    const raw = obj(value, "durable tool result");
+    keys(raw, ["call_id", "is_error", "blocks"], "durable tool result");
+    return { call_id: string(raw.call_id, "tool result call_id"), is_error: boolean(raw.is_error, "tool result is_error"), blocks: blocks(raw.blocks) };
+}
+export function encodeDurableContent(content) { return decodeDurableContent(content); }
+export function encodeDurableToolResult(result) { return decodeDurableToolResult(result); }
+export function toolOutputBlocksToDurable(blocks) {
+    return blocks.map((part, index) => {
+        if (part.type === "text")
+            return { type: "text", text: part.text };
+        const source = part.source;
+        const durableSource = source.kind === "fileId"
+            ? {
+                kind: "file_id",
+                id: source.id,
+                affinity: source.affinity
+                    ? { provider_id: source.affinity.providerId, endpoint_id: source.affinity.endpointId }
+                    : (() => { throw new DurableContentError(`tool output block ${index} fileId source requires endpoint affinity`); })(),
+            }
+            : source.kind === "base64" ? { kind: "base64", data: source.data }
+                : source.kind === "url" ? { kind: "url", url: source.url }
+                    : {
+                        kind: "object",
+                        handle: source.handle,
+                        owner: source.owner ?? (() => { throw new DurableContentError(`tool output block ${index} object source requires owner`); })(),
+                        payload_ref: source.payloadRef ?? (() => { throw new DurableContentError(`tool output block ${index} object source requires payloadRef`); })(),
+                    };
+        return { type: part.type, source: durableSource, ...(part.mediaType ? { media_type: part.mediaType } : {}), ...(part.providerOptions ? { provider_options: part.providerOptions } : {}) };
+    });
+}
+export function durableBlocksToToolOutput(blocks) {
+    return blocks.map((part) => {
+        if (part.type === "text")
+            return part;
+        const source = part.source;
+        const sdkSource = source.kind === "file_id"
+            ? { kind: "fileId", id: source.id, affinity: { providerId: source.affinity.provider_id, endpointId: source.affinity.endpoint_id } }
+            : source.kind === "base64" ? source : source.kind === "url" ? source : { kind: "object", handle: source.handle, owner: source.owner, payloadRef: source.payload_ref };
+        return { type: part.type, source: sdkSource, ...(part.media_type ? { mediaType: part.media_type } : {}), ...(part.provider_options ? { providerOptions: part.provider_options } : {}) };
+    });
+}

package/dist/runtime/execution-plane.d.ts

@@ -1,6 +1,6 @@
 import type { ToolCall, ToolSchema, StreamEvent, PermissionRequestEvent, PermissionResponse } from "../types.js";
 import type { RegisteredTool } from "../tools/index.js";
-import type { DreamStore, MemoryScope } from "../memory/index.js";
+import type { MemoryStore, MemoryScope } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
 export interface ToolSuspendEvent {
     type: "tool_suspend";
@@ -13,7 +13,7 @@ export interface RunContext {
     agentId?: string;
     memoryScope?: MemoryScope;
     skillContentMap?: Map<string, string>;
-    dreamStore?: DreamStore;
+    memoryStore?: MemoryStore;
     knowledgeSource?: KnowledgeSource;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;

package/dist/runtime/execution-plane.js

@@ -43,8 +43,8 @@ export class LocalExecutionPlane {
         for (const c of memoryCalls) {
             const args = tryParseJson(c.arguments);
             const topK = typeof args?.top_k === "number" ? args.top_k : 5;
-            const entries = (ctx.dreamStore && ctx.agentId && ctx.memoryScope)
-                ? await ctx.dreamStore.search(ctx.agentId, { scope: ctx.memoryScope, query: String(args?.query ?? ""), top_k: topK, kinds: [] })
+            const entries = (ctx.memoryStore && ctx.agentId && ctx.memoryScope)
+                ? await ctx.memoryStore.search(ctx.agentId, { scope: ctx.memoryScope, query: String(args?.query ?? ""), top_k: topK, kinds: [] })
                 : [];
             const content = entries.length
                 ? entries.map(e => `[memory record_id=${e.record.record_id} score=${e.score.toFixed(3)}] ${e.record.content}`).join("\n---\n")

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

@@ -91,7 +91,6 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 kind: "entropy_sample",
                 turn: t,
                 score: obs.score ?? 0,
-                score_version: obs.score_version ?? 0,
                 rho: obs.rho ?? 0,
                 repeat_pressure: obs.repeat_pressure ?? 0,
                 failure_rate: obs.failure_rate ?? 0,

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

@@ -18,7 +18,7 @@ interface SkillMetadata {
      *  `stable-core ∪ allowedTools`. Absent ⇒ no narrowing (back-compat). */
     allowedTools?: string[];
 }
-export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts:v1]]";
+export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
 /**
  * Browser/worker-safe transport for typed content. `btoa` and `atob` operate on
  * binary strings, so explicitly bridge UTF-8 bytes rather than assuming Latin-1.
@@ -198,7 +198,6 @@ export interface KernelObservation {
     node_outcomes?: import("./types/agent.js").KernelWorkflowNodeOutcome[];
     node_index?: number;
     score?: number;
-    score_version?: number;
     rho?: number;
     repeat_pressure?: number;
     failure_rate?: number;

package/dist/runtime/kernel-step.js

@@ -1,4 +1,4 @@
-export const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts:v1]]";
+export const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
 /**
  * Browser/worker-safe transport for typed content. `btoa` and `atob` operate on
  * binary strings, so explicitly bridge UTF-8 bytes rather than assuming Latin-1.

package/dist/runtime/provider-replay.d.ts

@@ -6,7 +6,7 @@ export declare function assistantReplayKey(message: Pick<Message, "content" | "t
  * protocol; on a cross-protocol fallback the incompatible envelope is skipped so
  * the new provider re-serializes neutral context instead.
  */
-export declare function isReplayCompatibleWithProvider(replay: ProviderReplay, descriptor: ProviderDescriptor | undefined): boolean;
+export declare function isReplayCompatibleWithProvider(replay: Partial<ProviderReplay>, descriptor: ProviderDescriptor | undefined): boolean;
 export declare function seedProviderReplayFromEvents(provider: LLMProvider, events: Array<{
     event: SessionEvent;
 }>): void;

package/dist/runtime/provider-replay.js

@@ -4,28 +4,22 @@ export function assistantReplayKey(message) {
         toolCalls: message.toolCalls ?? [],
     });
 }
-/** Infer the wire protocol a stored replay envelope belongs to (explicit, or by shape for legacy logs). */
-function replayProtocol(replay) {
-    if (replay.protocol)
-        return replay.protocol;
-    if (replay.native_blocks?.length)
-        return "anthropic-messages";
-    if (replay.reasoning_content != null || replay.reasoning_details !== undefined)
-        return "openai-chat";
-    return undefined;
-}
 /**
  * A stored replay may only be seeded into a provider speaking the same wire
  * protocol; on a cross-protocol fallback the incompatible envelope is skipped so
  * the new provider re-serializes neutral context instead.
  */
 export function isReplayCompatibleWithProvider(replay, descriptor) {
-    if (!descriptor)
-        return true;
-    const protocol = replayProtocol(replay);
-    if (!protocol)
-        return true;
-    return protocol === descriptor.protocol;
+    assertCanonicalReplay(replay);
+    return !descriptor || replay.protocol === descriptor.protocol;
+}
+const REPLAY_KEYS = new Set(["protocol", "provider", "model", "native_blocks", "reasoning_content", "reasoning_details", "native_message", "tool_calls"]);
+function assertCanonicalReplay(replay) {
+    for (const key of Object.keys(replay))
+        if (!REPLAY_KEYS.has(key))
+            throw new Error(`provider replay has unknown field ${key}`);
+    if (typeof replay.protocol !== "string" || replay.protocol.length === 0)
+        throw new Error("provider replay protocol is required");
 }
 export function seedProviderReplayFromEvents(provider, events) {
     if (!provider.seedProviderReplay)
@@ -36,11 +30,9 @@ export function seedProviderReplayFromEvents(provider, events) {
             continue;
         const toolCalls = event.tool_calls ?? [];
         const stored = event.provider_replay;
-        if (stored && !isReplayCompatibleWithProvider(stored, descriptor))
+        if (!stored || !isReplayCompatibleWithProvider(stored, descriptor))
             continue;
-        // Pass the message even with no persisted replay: a provider may reconstruct
-        // a legacy replay (e.g. Anthropic native_blocks) from the neutral transcript.
-        provider.seedProviderReplay({ content: event.content, toolCalls }, stored ?? {});
+        provider.seedProviderReplay({ content: event.content, toolCalls }, stored);
     }
 }
 export function peekProviderReplay(provider, content, toolCalls) {

package/dist/runtime/runner.d.ts

@@ -1,6 +1,6 @@
-import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, DreamSummarizer } from "../types.js";
+import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, MemorySummarizer } from "../types.js";
 import type { ToolSuspendEvent } from "./execution-plane.js";
-import type { DreamStore, MemoryQuery, MemoryRecord, MemoryScope } from "../memory/index.js";
+import type { MemoryStore, MemoryQuery, MemoryRecord, MemoryScope } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
 import type { SignalSource, RuntimeSignal } from "../signals/index.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
@@ -12,7 +12,7 @@ import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
 import { type NativeOsProfile, type OsProfileId, type SignalPolicy } from "./os-profile.js";
 import { PayloadStore } from "./payload-store.js";
-import { type ContextPolicyOverridesV1 } from "./context-policy.js";
+import { type ContextPolicyOverrides } from "./context-policy.js";
 export interface MemoryWriteRateLimit {
     maxWrites: number;
     windowMs: number;
@@ -28,11 +28,14 @@ export interface ResourceQuota {
     memoryWritesPerWindow?: MemoryWriteRateLimit;
 }
 export interface SchedulerPolicy {
-    version: 1;
     criticalPathWeight: number;
     fanoutWeight: number;
     ageWeight: number;
     tokenCostWeight: number;
+    deadlineWeight?: number;
+    processPriorityWeight?: number;
+    resourcePressureWeight?: number;
+    budgetPressureWeight?: number;
 }
 export declare function schedulerPolicyToKernel(policy: SchedulerPolicy): Record<string, number>;
 /** Host-counted provider envelope and response reserves deducted from the model context window. */
@@ -45,7 +48,7 @@ export interface PromptBudget {
  * Long-term memory policy (`set_memory_policy`) — opt-in, kernel-enforced. `validationEnabled:
  * false` admits writes without validation, `maxContentBytes` / `maxNameLength` override the
  * validation limits, and `retrievalTopK` caps `query_memory` breadth. Host storage is configured
- * on the `DreamStore` and never enters this contract. Omitted fields keep the kernel defaults.
+ * on the `MemoryStore` and never enters this contract. Omitted fields keep the kernel defaults.
  */
 export interface MemoryPolicy {
     staleWarningDays?: number;
@@ -112,8 +115,8 @@ export interface RuntimeOptions {
     agentId?: string;
     memoryScope?: MemoryScope;
     /** I4: optional run-start memory pre-fetch hook (mirrors Node SDK). Called once per run before
-     *  the first LLM turn; each returned query string becomes a dreamStore search; hits page into
-     *  the knowledge partition before turn 1. Requires dreamStore + agentId. */
+     *  the first LLM turn; each returned query string becomes a memoryStore search; hits page into
+     *  the knowledge partition before turn 1. Requires memoryStore + agentId. */
     preQueryMemory?: (ctx: {
         goal: string;
         /** K4: `"initial"` = pre-turn-1 fetch; `"renewal"` = re-fired after a sprint renewal. */
@@ -123,7 +126,7 @@ export interface RuntimeOptions {
     initialMemory?: string[];
     /** Skill name → markdown body (WASM has no filesystem). */
     skillContentMap?: Map<string, string>;
-    dreamStore?: DreamStore;
+    memoryStore?: MemoryStore;
     /** M4: advisory callback when a recalled record crosses the promotion threshold. */
     onPromotionSuggested?: (info: {
         recordId: string;
@@ -138,7 +141,7 @@ export interface RuntimeOptions {
     signalPolicy?: SignalPolicy;
     promptBudget?: PromptBudget;
     /** Stable replayable context behavior; ratios are normalized to integer ppm. */
-    contextPolicy?: ContextPolicyOverridesV1;
+    contextPolicy?: ContextPolicyOverrides;
     schedulerPolicy?: SchedulerPolicy;
     kernelReliability?: KernelReliabilityOptions;
     /** Attempts allowed for a workflow node to satisfy its output schema, 1..16. Default: 2. */
@@ -214,8 +217,7 @@ export interface RuntimeOptions {
      * 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.
+     * Dispatch is always fail-closed: a call outside the advertised set never executes.
      */
     allowedToolIds?: string[];
     /**
@@ -226,10 +228,9 @@ export interface RuntimeOptions {
      *
      *   `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).
+     * An active skill that declares no `allowed_tools` contributes nothing and the surface stays narrow.
      *
-     * `undefined` ⇒ legacy behavior, byte-identical. `[]` is a legitimate, distinct value: the minimal
+     * `undefined` and `[]` both mean 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.
      */
@@ -242,7 +243,6 @@ export interface RuntimeOptions {
      * 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).
      */
-    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;
@@ -250,9 +250,9 @@ export interface RuntimeOptions {
      *  to exactly their declared tools + meta-tools. (wasm skills come from `skillContentMap`; gating
      *  engages only once that carries per-skill tool lists.) */
     stableCoreToolIds?: string[];
-    dreamProvider?: LLMProvider;
-    dreamSummarizer?: DreamSummarizer;
-    dreamSystemPrompt?: string;
+    memoryProvider?: LLMProvider;
+    memorySummarizer?: MemorySummarizer;
+    memorySystemPrompt?: string;
     payloadStore?: PayloadStore;
 }
 export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
@@ -389,4 +389,8 @@ export declare class RuntimeRunner {
     private prefetchMemoryIntoHistory;
     private archiveSemanticPageOut;
 }
+export declare function replayMessages(events: Array<{
+    seq: number;
+    event: SessionEvent;
+}>, maxBytes?: number, archiveStore?: ArchiveStore): Promise<Message[]>;
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;