@deepstrike/wasm 0.2.38 → 0.2.40

package/dist/runtime/runner.d.ts

@@ -1,17 +1,18 @@
 import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, DreamSummarizer } from "../types.js";
 import type { ToolSuspendEvent } from "./execution-plane.js";
-import type { DreamStore, DreamResult } from "../memory/index.js";
+import type { DreamStore, 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";
 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 RecoveredNodeOutcome } from "./session-repair.js";
+import type { AgentRunSpec, SubAgentResult, MilestonePolicy, MilestoneContract, MilestoneCheckResult, WorkflowSpec, WorkflowOutcome } from "./types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.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";
+import { type ContextPolicyOverridesV1 } from "./context-policy.js";
 export interface MemoryWriteRateLimit {
     maxWrites: number;
     windowMs: number;
@@ -24,8 +25,19 @@ export interface ResourceQuota {
     /** Rolling-window memory-write rate limit: at most `maxWrites` per any `windowMs` span. */
     memoryWritesPerWindow?: MemoryWriteRateLimit;
 }
-export interface SchedulerBudget {
-    maxWallMs?: number;
+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;
 }
 /**
  * Long-term memory policy (`set_memory_policy`) — opt-in, kernel-enforced. `validationEnabled:
@@ -41,6 +53,25 @@ export interface MemoryPolicy {
     maxContentBytes?: number;
     maxNameLength?: number;
 }
+export interface KernelReliabilityOptions {
+    eventReplayCapacity?: number;
+    completedEffectReplayCapacity?: number;
+    providerRecoveryAttempts?: number;
+    outputRecoveryAttempts?: number;
+    hostEffectRetryAttempts?: number;
+    spoolThresholdBytes?: number;
+    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 interface ArchiveStore {
+    write(sessionId: string, startSeq: number, messages: Message[]): Promise<string | undefined>;
+    read?(archiveRef: string): Promise<Message[]>;
+}
 /** P0-C tool-gating telemetry: per-LLM-turn metrics, emitted via `RuntimeOptions.onTurnMetrics`.
  *  Pure observation — no behavior change. `toolsExposed` vs `toolsCalled` quantifies over-exposure;
  *  consecutive equal `activeSkill` values measure skill dwell `D`; the cache split gives the
@@ -79,11 +110,13 @@ export interface RuntimeOptions {
      *  flows here for its child run. Undefined ⇒ the kernel default. */
     maxTotalTokens?: number;
     sessionLog: SessionLog;
+    compressionStore?: ArchiveStore;
     executionPlane: ExecutionPlane;
     maxTokens: number;
     maxTurns?: number;
     timeoutMs?: number;
     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. */
@@ -91,22 +124,31 @@ export interface RuntimeOptions {
         goal: string;
         /** K4: `"initial"` = pre-turn-1 fetch; `"renewal"` = re-fired after a sprint renewal. */
         phase?: "initial" | "renewal";
-    }) => Promise<string[] | undefined> | string[] | undefined;
+    }) => Promise<MemoryQuery[] | undefined> | MemoryQuery[] | undefined;
     systemPrompt?: string;
     initialMemory?: string[];
     /** Skill name → markdown body (WASM has no filesystem). */
     skillContentMap?: Map<string, string>;
     dreamStore?: DreamStore;
+    /** M4: advisory callback when a recalled record crosses the promotion threshold. */
+    onPromotionSuggested?: (info: {
+        recordId: string;
+        recallCount: number;
+    }) => void;
     knowledgeSource?: KnowledgeSource;
     signalSource?: SignalSource;
     extensions?: Record<string, unknown>;
     /** Named or concrete OS profile. Defaults to the native microkernel profile. */
     osProfile?: OsProfileId | NativeOsProfile;
     governancePolicy?: GovernancePolicy;
-    attentionPolicy?: {
-        maxQueueSize?: number;
-    };
-    schedulerBudget?: SchedulerBudget;
+    signalPolicy?: SignalPolicy;
+    promptBudget?: PromptBudget;
+    /** Stable replayable context behavior; ratios are normalized to integer ppm. */
+    contextPolicy?: ContextPolicyOverridesV1;
+    schedulerPolicy?: SchedulerPolicy;
+    kernelReliability?: KernelReliabilityOptions;
+    /** Attempts allowed for a workflow node to satisfy its output schema, 1..16. Default: 2. */
+    workflowSchemaValidationAttempts?: number;
     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`
@@ -182,9 +224,11 @@ export interface RuntimeOptions {
     dreamSystemPrompt?: string;
     resultSpool?: LargeResultSpool;
 }
+export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
 export declare class RuntimeRunner {
     private readonly opts;
     private interrupted;
+    private cancellationReason;
     /** #2-B-ii: aborts the in-flight provider stream on interrupt/preempt. Recreated per `execute`. */
     private abortController;
     private pendingObservations;
@@ -201,16 +245,18 @@ export declare class RuntimeRunner {
     /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
     private currentGoal;
     private nextArchiveStart;
+    private pendingPageOutArchives;
+    private activePageOutArchive;
     /** 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;
-    private pendingSpoolOutputs;
+    private workflowContinuation;
     constructor(opts: RuntimeOptions);
     get hostOptions(): RuntimeOptions;
-    interrupt(): void;
+    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. `urgency` maps to
+     *  the next turn boundary, routes through the kernel attention policy, and renders once as a
+     *  `[SIGNAL] <text>` line in the volatile state turn. `urgency` maps to
      *  the kernel disposition ladder: `"normal"` queues (default), `"high"` soft-interrupts, `"critical"`
      *  preempts. */
     injectNote(text: string, urgency?: RuntimeSignal["urgency"]): void;
@@ -220,17 +266,21 @@ export declare class RuntimeRunner {
     /** 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;
+    private consumeInboundSignal;
     run(req: {
         sessionId: string;
         goal: string;
         criteria?: string[];
         extensions?: Record<string, unknown>;
+        attachments?: import("../types.js").ContentPart[];
         inheritEvents?: Array<{
             seq: number;
             event: SessionEvent;
         }>;
     }): AsyncIterable<StreamEvent>;
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    writeMemory(memory: MemoryRecord, sessionId?: string): Promise<void>;
+    private appendMemorySyscallObservations;
     /** 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
@@ -248,13 +298,11 @@ export declare class RuntimeRunner {
     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").
+     * output. Resolution order: (a) the result spool committed by `large_result_spool_result`,
+     * (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;
-    dream(agentId: string, nowMs?: number): Promise<DreamResult>;
     private execute;
     spawnSubAgent(spec: AgentRunSpec): Promise<SubAgentResult>;
     /**
@@ -290,23 +338,14 @@ 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[];
+        /** 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>;
     /**
      * M5/G1: bootstrap an **agent-authored** workflow ("the model writes its own harness"). Routes the
      * spec through the agent-reachable `Syscall::LoadWorkflow` (`submit_workflow`): with no workflow
@@ -315,11 +354,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`, at the safe
      * point (tool turn resolved → kernel in Reason). Each runs in THIS kernel (the kernel resumes the
@@ -349,10 +384,7 @@ export declare class RuntimeRunner {
      */
     resumeWorkflow(spec: WorkflowSpec, opts?: {
         sessionId?: string;
-    }): Promise<{
-        completed: string[];
-        failed: string[];
-    }>;
+    }): Promise<WorkflowOutcome>;
     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,