@deepstrike/wasm 0.2.39 → 0.2.41

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 } from "../memory/index.js";
+import type { DreamStore, MemoryScope } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
 import { LargeResultSpool } from "./large-result-spool.js";
 export interface ToolSuspendEvent {
@@ -12,6 +12,7 @@ export interface ToolSuspendEvent {
 }
 export interface RunContext {
     agentId?: string;
+    memoryScope?: MemoryScope;
     skillContentMap?: Map<string, string>;
     dreamStore?: DreamStore;
     knowledgeSource?: KnowledgeSource;

package/dist/runtime/execution-plane.js

@@ -44,11 +44,11 @@ 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)
-                ? await ctx.dreamStore.search(ctx.agentId, String(args?.query ?? ""), topK)
+            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 content = entries.length
-                ? entries.map((e) => `[score=${e.score.toFixed(3)}] ${e.text}`).join("\n---\n")
+                ? entries.map(e => `[memory record_id=${e.record.record_id} score=${e.score.toFixed(3)}] ${e.record.content}`).join("\n---\n")
                 : "No relevant memories found.";
             yield { type: "tool_result", callId: c.id, name: c.name, content, isError: false };
         }

package/dist/runtime/facade.js

@@ -39,7 +39,8 @@ export async function runFanout(opts) {
         spec.nodes[spec.nodes.length - 1].role = opts.synthesisRole;
     const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
     const synthesisId = `wf-node${opts.tasks.length}`;
-    const lastCompleted = outcome.completed[outcome.completed.length - 1];
+    const completed = outcome.nodeOutcomes.filter(node => node.status === "completed" || node.status === "completed_partial");
+    const lastCompleted = completed[completed.length - 1]?.nodeId;
     const synthesis = outcome.outputs[synthesisId] ?? (lastCompleted ? outcome.outputs[lastCompleted] : undefined) ?? "";
     return { synthesis, outputs: outcome.outputs };
 }

package/dist/runtime/index.d.ts

@@ -1,9 +1,16 @@
-export type { SessionEvent, SessionLog } from "./session-log.js";
+export type { KernelTransactionEntry, SessionEvent, SessionLog } from "./session-log.js";
 export { InMemorySessionLog } from "./session-log.js";
+export * from "./kernel-transaction-log.js";
+export { rebuildKernelRuntime } from "./kernel-rebuild.js";
+export type { KernelRebuildResult } from "./kernel-rebuild.js";
+export * from "./context-policy.js";
 export type { RunContext, ExecutionPlane } from "./execution-plane.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
-export type { MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, SchedulerBudget } from "./runner.js";
+export type { MemoryPolicy, MemoryWriteRateLimit, OperationCancellationReason, PromptBudget, ResourceQuota, RuntimeOptions, SchedulerPolicy } from "./runner.js";
 export { RuntimeRunner, collectText } from "./runner.js";
+export { readKernelDiagnostics, restoreKernelRuntime, snapshotKernelRuntime } from "./kernel-step.js";
+export type { KernelDiagnostics } from "./kernel-step.js";
+export type { KernelSnapshot } from "./kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
@@ -14,5 +21,7 @@ export type { ReplayProviderOpts } from "./replay-provider.js";
 export { extractRecordedMessages } from "./replay-fixture.js";
 export { judge, buildEvalMessages, parseVerdict, verdictOutputSchema } from "./eval.js";
 export type { Criterion, Verdict, VerdictDetail, JudgeArgs } from "./eval.js";
-export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } from "./os-profile.js";
-export type { NativeOsProfile, OsProfileId } from "./os-profile.js";
+export { DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } from "./os-profile.js";
+export type { NativeOsProfile, OsProfileId, SignalPolicy } from "./os-profile.js";
+export type { KernelEventCategory, KernelPrimitive } from "./kernel-event-log.js";
+export { primitiveForCategory, primitiveForKind } from "./kernel-event-log.js";

package/dist/runtime/index.js

@@ -1,10 +1,15 @@
 export { InMemorySessionLog } from "./session-log.js";
+export * from "./kernel-transaction-log.js";
+export { rebuildKernelRuntime } from "./kernel-rebuild.js";
+export * from "./context-policy.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
 export { RuntimeRunner, collectText } from "./runner.js";
+export { readKernelDiagnostics, restoreKernelRuntime, snapshotKernelRuntime } from "./kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
 export { getKernel } from "./kernel.js";
 export { ReplayProvider } from "./replay-provider.js";
 export { extractRecordedMessages } from "./replay-fixture.js";
 export { judge, buildEvalMessages, parseVerdict, verdictOutputSchema } from "./eval.js";
-export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } from "./os-profile.js";
+export { DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } from "./os-profile.js";
+export { primitiveForCategory, primitiveForKind } from "./kernel-event-log.js";

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

@@ -16,7 +16,7 @@ export function categoryForKind(kind) {
             return "mm";
         case "agent_process_changed":
             return "proc";
-        case "signal_disposed":
+        case "signal_delivery_disposed":
             return "ipc";
         default:
             return "sched";
@@ -38,7 +38,6 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 action: compressionAction(obs.action),
                 summary: obs.summary,
                 summary_tokens: obs.summary ? Math.max(1, Math.ceil(obs.summary.length / 4)) : undefined,
-                archive_ref: opts.archiveRef,
                 preserved_refs: opts.preservedRefs ?? [],
             };
         }
@@ -130,10 +129,13 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 tool: obs.tool ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
             };
-        case "signal_disposed":
+        case "signal_delivery_disposed":
             return {
-                kind: "signal_disposed",
+                kind: "signal_delivery_disposed",
                 turn: t,
+                operation_id: obs.operation_id ?? "",
+                delivery_id: obs.delivery_id ?? "",
+                attempt: obs.attempt ?? 0,
                 signal_id: obs.signal_id ?? "",
                 disposition: obs.disposition ?? "",
                 queue_depth: obs.queue_depth ?? 0,
@@ -142,8 +144,28 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             return {
                 kind: "budget_exceeded",
                 turn: t,
+                operation_id: obs.operation_id ?? "",
+                ...(obs.reservation_id ? { reservation_id: obs.reservation_id } : {}),
                 budget: obs.budget ?? "",
             };
+        case "budget_usage_reported":
+            return {
+                kind: "budget_usage_reported",
+                turn: t,
+                operation_id: obs.operation_id ?? "",
+                reservation_id: obs.reservation_id ?? "",
+                tokens: obs.tokens ?? 0,
+                subagents: obs.subagents ?? 0,
+                rounds: obs.rounds ?? 0,
+            };
+        case "operation_cancelled":
+            return {
+                kind: "operation_cancelled",
+                turn: t,
+                operation_id: obs.operation_id ?? "",
+                reason: (obs.reason ?? "user"),
+                pending_call_ids: obs.pending_call_ids ?? [],
+            };
         case "suspended":
             return {
                 kind: "suspended",
@@ -168,21 +190,34 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 tool: obs.tool ?? "",
                 original_size: obs.original_size ?? 0,
                 preview_size: obs.preview_size ?? 0,
-                spool_ref: opts.spoolRef,
+                spool_ref: obs.spool_ref,
+            };
+        case "page_out_archived":
+            return {
+                kind: "page_out",
+                turn: t,
+                action: compressionAction(obs.action),
+                summary: obs.summary,
+                tier_hint: obs.tier,
+                message_count: obs.message_count ?? 0,
+                archive_ref: obs.archive_ref,
             };
         case "memory_written":
             return {
                 kind: "memory_written",
                 turn: t,
-                memory_id: obs.memory_id ?? "",
+                record_id: obs.record_id ?? "",
+                scope: obs.scope ?? { tenant_id: "", namespace: "" },
                 memory_kind: obs.memory_kind ?? "",
+                name: obs.name ?? "",
                 size_bytes: obs.size_bytes ?? 0,
             };
         case "memory_queried":
             return {
                 kind: "memory_queried",
                 turn: t,
-                query_context: obs.query_context ?? "",
+                scope: obs.scope ?? { tenant_id: "", namespace: "" },
+                query: obs.query ?? "",
                 requested_k: obs.requested_k ?? 0,
                 requires_async_response: obs.requires_async_response ?? false,
             };
@@ -190,7 +225,7 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             return {
                 kind: "memory_validation_failed",
                 turn: t,
-                memory_id: obs.memory_id ?? "",
+                record_id: obs.record_id ?? "",
                 error: obs.error ?? "",
             };
         case "workflow_batch_spawned": {
@@ -203,14 +238,12 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             };
         }
         case "workflow_completed": {
-            const completed = obs.completed ?? [];
-            const failed = obs.failed ?? [];
+            const nodeOutcomes = obs.node_outcomes ?? [];
             return {
                 kind: "workflow_completed",
                 turn: t,
-                completed,
-                failed,
-                total_nodes: completed.length + failed.length,
+                node_outcomes: nodeOutcomes,
+                total_nodes: nodeOutcomes.length,
             };
         }
         default:

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

@@ -0,0 +1,8 @@
+import type { KernelRuntimeHandle } from "./kernel-step.js";
+import { type KernelOperationCursor, type KernelOperationGenesis, type KernelTransaction } from "./kernel-transaction-log.js";
+export interface KernelRebuildResult {
+    runtime: KernelRuntimeHandle;
+    cursor: KernelOperationCursor;
+}
+/** Deterministically fold an authoritative stream into a fresh WASM runtime. */
+export declare function rebuildKernelRuntime(runtime: KernelRuntimeHandle, genesis: KernelOperationGenesis, transactions: readonly KernelTransaction[]): Promise<KernelRebuildResult>;

package/dist/runtime/kernel-rebuild.js

@@ -0,0 +1,65 @@
+import { KernelLogIntegrityError, kernelRecordDigest, verifyKernelTransactionStream, } from "./kernel-transaction-log.js";
+/** Deterministically fold an authoritative stream into a fresh WASM runtime. */
+export async function rebuildKernelRuntime(runtime, genesis, transactions) {
+    const cursor = await verifyKernelTransactionStream(genesis, transactions);
+    await assertFreshRuntimeMatchesGenesis(runtime, genesis);
+    for (const transaction of transactions) {
+        const prepared = JSON.parse(runtime.prepareStep(JSON.stringify(transaction.input)));
+        const token = prepared.prepare_token;
+        try {
+            if (prepared.status !== "prepared" || !token) {
+                throw new KernelLogIntegrityError(`kernel rebuild step ${transaction.step_seq} was not accepted as a new transition`);
+            }
+            if (prepared.base_generation !== transaction.base_generation) {
+                throw new KernelLogIntegrityError(`kernel rebuild generation diverged at step ${transaction.step_seq}`);
+            }
+            if (prepared.step.step_seq !== transaction.step_seq) {
+                throw new KernelLogIntegrityError(`kernel rebuild step_seq diverged at step ${transaction.step_seq}`);
+            }
+            if (await kernelRecordDigest(prepared.input) !== transaction.input_digest) {
+                throw new KernelLogIntegrityError(`kernel rebuild normalized input diverged at step ${transaction.step_seq}`);
+            }
+            if (await kernelRecordDigest(prepared.step) !== transaction.step_digest) {
+                throw new KernelLogIntegrityError(`kernel rebuild planned step diverged at step ${transaction.step_seq}`);
+            }
+            const committed = JSON.parse(runtime.commitPrepared(token));
+            if (await kernelRecordDigest(committed) !== transaction.step_digest) {
+                throw new KernelLogIntegrityError(`kernel rebuild committed step diverged at step ${transaction.step_seq}`);
+            }
+        }
+        catch (error) {
+            if (token && prepared.status === "prepared") {
+                try {
+                    runtime.abortPrepared(token);
+                }
+                catch { /* discard failed runtime */ }
+            }
+            throw error;
+        }
+    }
+    return { runtime, cursor };
+}
+async function assertFreshRuntimeMatchesGenesis(runtime, genesis) {
+    const snapshot = JSON.parse(runtime.snapshot());
+    if (snapshot.abi_version !== genesis.abi_version) {
+        throw new KernelLogIntegrityError("kernel runtime ABI version does not match operation genesis");
+    }
+    if (genesis.default_policy_version !== 1) {
+        throw new KernelLogIntegrityError("kernel operation uses an unsupported default policy version");
+    }
+    if (snapshot.operation_id || snapshot.next_step_seq !== 1 || snapshot.accepted_inputs.length !== 0) {
+        throw new KernelLogIntegrityError("kernel rebuild requires a fresh runtime");
+    }
+    if (await kernelRecordDigest(snapshot.initial_policy) !== await kernelRecordDigest(genesis.initial_scheduler_policy)) {
+        throw new KernelLogIntegrityError("kernel runtime initial policy does not match operation genesis");
+    }
+    const defaults = {
+        snapshot_version: snapshot.snapshot_version,
+        snapshot_input_limit: snapshot.snapshot_input_limit,
+        max_input_bytes: snapshot.max_input_bytes,
+        snapshot_journal_bytes_limit: snapshot.snapshot_journal_bytes_limit,
+    };
+    if (await kernelRecordDigest(defaults) !== await kernelRecordDigest(genesis.resolved_runtime_defaults)) {
+        throw new KernelLogIntegrityError("kernel runtime defaults do not match operation genesis");
+    }
+}

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

@@ -18,9 +18,15 @@ interface SkillMetadata {
      *  `stable-core ∪ allowedTools`. Absent ⇒ no narrowing (back-compat). */
     allowedTools?: string[];
 }
-export declare const KERNEL_ABI_VERSION = 1;
+export declare const KERNEL_ABI_VERSION = 2;
 export interface KernelRuntimeHandle {
     step(inputJson: string): string;
+    prepareStep(inputJson: string): string;
+    commitPrepared(prepareToken: string): string;
+    abortPrepared(prepareToken: string): void;
+    snapshot(): string;
+    restore(snapshotJson: string): void;
+    diagnostics(): string;
     isTerminal(): boolean;
     turn(): number;
     recoveryContentBytes(): number;
@@ -28,6 +34,52 @@ export interface KernelRuntimeHandle {
     drainNewMessages(): Message[];
     preservedRefs(): string[];
 }
+export type KernelPreparationStatus = "prepared" | "replayed" | "rejected";
+export interface KernelPreparedStep {
+    status: KernelPreparationStatus;
+    base_generation: number;
+    prepare_token?: string;
+    input: Record<string, unknown>;
+    step: KernelStepJson;
+}
+export interface KernelDiagnostics {
+    lifecycle: string;
+    next_step_seq: number;
+    accepted_input_count: number;
+    accepted_input_bytes: number;
+    snapshot_input_limit: number;
+    snapshot_journal_bytes_limit: number;
+    max_input_bytes: number;
+    snapshot_overflowed: boolean;
+    recorded_event_count: number;
+    completed_effect_count: number;
+    pending_effect_count: number;
+}
+export declare function readKernelDiagnostics(runtime: KernelRuntimeHandle): KernelDiagnostics;
+export interface KernelSnapshot {
+    snapshot_version: 2;
+    abi_version: 2;
+    initial_policy: {
+        max_tokens: number;
+        max_turns: number;
+        max_total_tokens: string;
+        max_wall_ms?: string;
+    };
+    lifecycle: string;
+    operation_id?: string;
+    next_step_seq: number;
+    snapshot_input_limit: number;
+    max_input_bytes: number;
+    snapshot_journal_bytes_limit: number;
+    accepted_input_bytes: number;
+    accepted_inputs: Array<{
+        event_id: string;
+        [key: string]: unknown;
+    }>;
+    last_step?: Record<string, unknown>;
+}
+export declare function snapshotKernelRuntime(runtime: KernelRuntimeHandle): KernelSnapshot;
+export declare function restoreKernelRuntime(runtime: KernelRuntimeHandle, snapshot: KernelSnapshot): void;
 export interface PaceDecision {
     action: "continue" | "sleep" | "stop";
     delayMs?: number;
@@ -44,18 +96,66 @@ export interface KernelLoopResult {
 }
 export type KernelRunnerAction = {
     kind: "call_provider";
+    effectId: string;
     context: RenderedContext;
     tools: ToolSchema[];
 } | {
     kind: "execute_tool";
+    effectId: string;
     calls: ToolCall[];
+} | {
+    kind: "request_approval";
+    effectId: string;
+    requests: Array<{
+        callId: string;
+        tool: string;
+        arguments: string;
+        reason: string;
+    }>;
+} | {
+    kind: "spawn_workflow";
+    effectId: string;
+    nodes: Array<Record<string, unknown>>;
+    budget?: Record<string, unknown>;
+} | {
+    kind: "preempt_sub_agents";
+    effectId: string;
+    agentIds: string[];
+    reason: string;
+} | {
+    kind: "persist_memory";
+    effectId: string;
+    memory: Record<string, unknown>;
+} | {
+    kind: "query_memory";
+    effectId: string;
+    query: Record<string, unknown>;
+    requestedK: number;
+} | {
+    kind: "spool_large_result";
+    effectId: string;
+    callId: string;
+    tool: string;
+    output: string;
+    originalSize: number;
+    previewSize: number;
+} | {
+    kind: "archive_page_out";
+    effectId: string;
+    turn: number;
+    action: string;
+    summary?: string;
+    archived: Message[];
+    tier: string;
 } | {
     kind: "evaluate_milestone";
+    effectId: string;
     phaseId: string;
     criteria: string[];
     requiredEvidence?: string[];
 } | {
     kind: "done";
+    effectId: string;
     result: KernelLoopResult;
 };
 export interface KernelObservation {
@@ -64,7 +164,7 @@ export interface KernelObservation {
     rho_after?: number;
     sprint?: number;
     summary?: string;
-    archived?: Message[];
+    archived_count?: number;
     turn?: number;
     checkpoint_history_len?: number;
     added?: string[];
@@ -88,21 +188,44 @@ export interface KernelObservation {
     tier_hint?: string;
     call_id?: string;
     tool?: string;
+    operation_id?: string;
+    delivery_id?: string;
+    attempt?: number;
     signal_id?: string;
     disposition?: string;
     queue_depth?: number;
     budget?: string;
+    reservation_id?: string;
+    tokens?: number;
+    subagents?: number;
+    rounds?: number;
     pending_calls?: string[];
+    pending_call_ids?: string[];
     approved?: string[];
     denied?: string[];
     original_size?: number;
     preview_size?: number;
-    memory_id?: string;
+    tier?: string;
+    message_count?: number;
+    archive_ref?: string;
+    spool_ref?: string;
+    record_id?: string;
+    scope?: {
+        tenant_id: string;
+        namespace: string;
+    };
+    name?: string;
     memory_kind?: string;
     size_bytes?: number;
-    query_context?: string;
+    query?: string;
     requested_k?: number;
     requires_async_response?: boolean;
+    recalls?: Array<{
+        record_id: string;
+        recall_count: number;
+        last_recalled_at: number;
+    }>;
+    recall_count?: number;
     /** memory_validation_failed (Phase 7). */
     error?: string;
     nodes?: Array<{
@@ -113,8 +236,8 @@ export interface KernelObservation {
         context_inheritance: string;
         model_hint?: string;
     }>;
-    completed?: string[];
-    failed?: string[];
+    node_outcomes?: import("./types/agent.js").KernelWorkflowNodeOutcome[];
+    node_index?: number;
     score?: number;
     score_version?: number;
     rho?: number;
@@ -124,6 +247,16 @@ export interface KernelObservation {
     window_turns?: number;
     threshold?: number;
 }
+interface KernelStepJson {
+    version: number;
+    actions: Array<Record<string, unknown>>;
+    observations: KernelObservation[];
+    faults?: Array<{
+        code?: string;
+        message?: string;
+        effect_id?: string;
+    }>;
+}
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
 export declare function messageToKernelMessage(message: Message): Record<string, unknown>;
@@ -136,5 +269,4 @@ export declare function kernelApply(runtime: KernelRuntimeHandle, pending: Kerne
 export declare function kernelAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction;
 /** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
 export declare function kernelMaybeAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction | null;
-export declare function forceCompact(runtime: KernelRuntimeHandle, pending: KernelObservation[]): boolean;
 export {};