@deepstrike/wasm 0.2.38 → 0.2.40

package/dist/runtime/session-log.d.ts

@@ -1,5 +1,11 @@
 import type { ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
+import type { MemoryRecall, MemoryScope } from "../memory/index.js";
 import type { KernelPrimitive } from "./kernel-event-log.js";
+import type { DurableAppendReceipt, KernelGenesisReceipt, KernelOperationGenesis, KernelTransaction } from "./kernel-transaction-log.js";
+export interface KernelTransactionEntry {
+    log_seq: number;
+    transaction: KernelTransaction;
+}
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -26,6 +32,7 @@ export type SessionEvent = {
     criteria: string[];
     agent_id?: string;
     system_prompt?: string;
+    attachments?: import("../types.js").ContentPart[];
 } | {
     kind: "llm_completed";
     turn: number;
@@ -78,7 +85,6 @@ export type SessionEvent = {
     action?: "snip_compact" | "micro_compact" | "context_collapse" | "auto_compact";
     summary?: string;
     summary_tokens?: number;
-    archive_ref?: string;
     preserved_refs?: string[];
 } | {
     kind: "page_out";
@@ -87,6 +93,7 @@ export type SessionEvent = {
     summary?: string;
     tier_hint?: string;
     message_count?: number;
+    archive_ref?: string;
 } | {
     kind: "page_in";
     turn: number;
@@ -136,15 +143,34 @@ export type SessionEvent = {
     tool: string;
     reason: string;
 } | {
-    kind: "signal_disposed";
+    kind: "signal_delivery_disposed";
     turn: number;
+    operation_id: string;
+    delivery_id: string;
+    attempt: number;
     signal_id: string;
     disposition: string;
     queue_depth: number;
 } | {
     kind: "budget_exceeded";
     turn: number;
+    operation_id: string;
+    reservation_id?: string;
     budget: string;
+} | {
+    kind: "budget_usage_reported";
+    turn: number;
+    operation_id: string;
+    reservation_id: string;
+    tokens: number;
+    subagents: number;
+    rounds: number;
+} | {
+    kind: "operation_cancelled";
+    turn: number;
+    operation_id: string;
+    reason: "user" | "deadline" | "lease_lost" | "host_shutdown";
+    pending_call_ids: string[];
 } | {
     kind: "milestone_advanced";
     turn: number;
@@ -188,33 +214,38 @@ export type SessionEvent = {
 } | {
     kind: "memory_written";
     turn: number;
-    memory_id: string;
+    record_id: string;
+    scope: MemoryScope;
     memory_kind: string;
+    name: string;
     size_bytes: number;
 } | {
     kind: "memory_queried";
     turn: number;
-    query_context: string;
+    scope: MemoryScope;
+    query: string;
     requested_k: number;
     requires_async_response: boolean;
 } | {
     kind: "memory_validation_failed";
     turn: number;
-    memory_id: string;
+    record_id: string;
     error: string;
+} | {
+    kind: "memory_retrieval_result";
+    hits: MemoryRecall[];
 } | {
     kind: "workflow_node_completed";
     turn: number;
     agent_id: string;
+    status: import("./types/agent.js").WorkflowNodeStatus;
     termination: string;
     /** W-1: result-borne control signals, persisted so resume replays control flow faithfully —
      *  a classifier re-prunes its rejected branches, a recorded loop stop is honored. */
     classify_branch?: string;
     tournament_winner?: string;
     loop_continue?: boolean;
-    /** W-1: the node's final output text — resume re-seeds the driver's outputs map from it so
-     *  post-resume reduce/judge/dependent nodes still see their dependencies' outputs. */
-    output?: string;
+    output?: import("../types.js").Message;
 } | {
     kind: "workflow_nodes_submitted";
     turn: number;
@@ -234,8 +265,7 @@ export type SessionEvent = {
 } | {
     kind: "workflow_completed";
     turn: number;
-    completed: string[];
-    failed: string[];
+    node_outcomes: import("./types/agent.js").KernelWorkflowNodeOutcome[];
     total_nodes: number;
 } | {
     kind: "run_terminal";
@@ -254,13 +284,28 @@ export interface SessionLog {
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
+    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
+    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
+    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
+    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
+    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
 }
 export declare class InMemorySessionLog implements SessionLog {
     private store;
+    private seqCounters;
+    private genesisStore;
+    private transactionStore;
+    private operationKey;
+    private nextSeq;
     append(sessionId: string, event: SessionEvent): Promise<number>;
     read(sessionId: string, fromSeq?: number, primitiveFilter?: KernelPrimitive): Promise<Array<{
         seq: number;
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
+    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
+    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
+    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
+    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
+    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
 }

package/dist/runtime/session-log.js

@@ -1,11 +1,23 @@
 import { primitiveForKind } from "./kernel-event-log.js";
+import { KernelLogConflictError, KernelLogIntegrityError, verifyKernelOperationGenesis, verifyKernelTransaction, verifyKernelTransactionSuccessor, } from "./kernel-transaction-log.js";
 export class InMemorySessionLog {
     store = new Map();
+    seqCounters = new Map();
+    genesisStore = new Map();
+    transactionStore = new Map();
+    operationKey(sessionId, operationId) {
+        return `${sessionId}\u0000${operationId}`;
+    }
+    nextSeq(sessionId) {
+        const seq = this.seqCounters.get(sessionId) ?? 0;
+        this.seqCounters.set(sessionId, seq + 1);
+        return seq;
+    }
     async append(sessionId, event) {
         if (!this.store.has(sessionId))
             this.store.set(sessionId, []);
         const entries = this.store.get(sessionId);
-        const seq = entries.length;
+        const seq = this.nextSeq(sessionId);
         entries.push({ seq, event });
         return seq;
     }
@@ -20,7 +32,52 @@ export class InMemorySessionLog {
         });
     }
     async latestSeq(sessionId) {
-        const entries = this.store.get(sessionId);
-        return entries ? entries.length - 1 : -1;
+        return (this.seqCounters.get(sessionId) ?? 0) - 1;
+    }
+    async appendKernelGenesis(sessionId, genesis) {
+        await verifyKernelOperationGenesis(genesis);
+        const operationKey = this.operationKey(sessionId, genesis.operation_id);
+        const existing = this.genesisStore.get(operationKey);
+        if (existing) {
+            if (existing.genesis.genesis_digest !== genesis.genesis_digest) {
+                throw new KernelLogConflictError("session already has a different kernel operation genesis");
+            }
+            return { log_seq: existing.log_seq, genesis_digest: genesis.genesis_digest };
+        }
+        const log_seq = this.nextSeq(sessionId);
+        this.genesisStore.set(operationKey, { log_seq, genesis });
+        return { log_seq, genesis_digest: genesis.genesis_digest };
+    }
+    async readKernelGenesis(sessionId, operationId) {
+        return this.genesisStore.get(this.operationKey(sessionId, operationId))?.genesis;
+    }
+    async compareAndAppendKernelTransaction(sessionId, expectedTransactionHead, transaction) {
+        await verifyKernelTransaction(transaction);
+        const operationKey = this.operationKey(sessionId, transaction.operation_id);
+        const genesis = this.genesisStore.get(operationKey)?.genesis;
+        if (!genesis)
+            throw new KernelLogIntegrityError("kernel transaction requires a durable genesis");
+        if (transaction.operation_id !== genesis.operation_id) {
+            throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
+        }
+        const head = await this.kernelTransactionHead(sessionId, transaction.operation_id);
+        if (head !== expectedTransactionHead || transaction.previous_transaction_digest !== head) {
+            throw new KernelLogConflictError("kernel transaction head changed before compare-and-append");
+        }
+        const entries = this.transactionStore.get(operationKey) ?? [];
+        verifyKernelTransactionSuccessor(entries.at(-1)?.transaction, transaction);
+        const log_seq = this.nextSeq(sessionId);
+        entries.push({ log_seq, transaction });
+        this.transactionStore.set(operationKey, entries);
+        return { log_seq, transaction_digest: transaction.transaction_digest };
+    }
+    async readKernelTransactions(sessionId, operationId, fromStepSeq = 1) {
+        return (this.transactionStore.get(this.operationKey(sessionId, operationId)) ?? []).filter(entry => entry.transaction.step_seq >= fromStepSeq);
+    }
+    async kernelTransactionHead(sessionId, operationId) {
+        const operationKey = this.operationKey(sessionId, operationId);
+        const entries = this.transactionStore.get(operationKey) ?? [];
+        return entries.at(-1)?.transaction.transaction_digest
+            ?? this.genesisStore.get(operationKey)?.genesis.genesis_digest;
     }
 }

package/dist/runtime/session-repair.d.ts

@@ -1,5 +1,6 @@
-import type { ProviderReplay, ToolCall } from "../types.js";
+import type { Message, ProviderReplay, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
+import type { WorkflowNodeStatus } from "./types/agent.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
 /**
  * Normalize a persisted llm_completed event for recovery. Content is sanitized
@@ -41,33 +42,36 @@ export declare function buildRunTerminalEvent(input: {
 export declare function buildWorkflowNodeCompletedEvent(input: {
     turn: number;
     agentId: string;
+    status: WorkflowNodeStatus;
     termination: string;
     classifyBranch?: string;
     tournamentWinner?: string;
     loopContinue?: boolean;
-    output?: string;
+    output?: Message;
 }): Extract<SessionEvent, {
     kind: "workflow_node_completed";
 }>;
 /** One recovered node completion: the agent id plus its persisted control signals and output. */
-export interface RecoveredNodeCompletion {
+export interface RecoveredNodeOutcome {
     agentId: string;
+    status: WorkflowNodeStatus;
+    termination: string;
     classifyBranch?: string;
     tournamentWinner?: string;
     loopContinue?: boolean;
-    output?: string;
+    output?: Message;
 }
 /**
  * Recover completed workflow node records from a session event stream. Scans for
  * workflow_node_completed events with termination "completed" and returns them WITH their
  * result-borne control signals (W-1) — resumeWorkflow lowers these to the kernel's
- * `resumed_results` so a classifier re-prunes and a loop stop is honored, and re-seeds the
+ * `resumed_outcomes` so a classifier re-prunes and a loop stop is honored, and re-seeds the
  * driver's outputs map from the persisted output text.
  */
-export declare function recoverCompletedWorkflowNodes(events: Array<{
+export declare function recoverWorkflowNodeOutcomes(events: Array<{
     seq: number;
     event: SessionEvent;
-}>): RecoveredNodeCompletion[];
+}>): RecoveredNodeOutcome[];
 /** R3-1: build workflow_nodes_submitted for persistence after a runtime submission, so resume can
  *  re-apply it. `nodes` is the kernel-shape (snake_case) submitted node array. */
 export declare function buildWorkflowNodesSubmittedEvent(input: {

package/dist/runtime/session-repair.js

@@ -55,6 +55,7 @@ export function buildWorkflowNodeCompletedEvent(input) {
         kind: "workflow_node_completed",
         turn: input.turn,
         agent_id: input.agentId,
+        status: input.status,
         termination: input.termination,
         ...(input.classifyBranch !== undefined ? { classify_branch: input.classifyBranch } : {}),
         ...(input.tournamentWinner !== undefined ? { tournament_winner: input.tournamentWinner } : {}),
@@ -66,15 +67,17 @@ export function buildWorkflowNodeCompletedEvent(input) {
  * Recover completed workflow node records from a session event stream. Scans for
  * workflow_node_completed events with termination "completed" and returns them WITH their
  * result-borne control signals (W-1) — resumeWorkflow lowers these to the kernel's
- * `resumed_results` so a classifier re-prunes and a loop stop is honored, and re-seeds the
+ * `resumed_outcomes` so a classifier re-prunes and a loop stop is honored, and re-seeds the
  * driver's outputs map from the persisted output text.
  */
-export function recoverCompletedWorkflowNodes(events) {
+export function recoverWorkflowNodeOutcomes(events) {
     const completed = [];
     for (const { event } of events) {
-        if (event.kind === "workflow_node_completed" && event.termination === "completed") {
+        if (event.kind === "workflow_node_completed") {
             completed.push({
                 agentId: event.agent_id,
+                status: event.status,
+                termination: event.termination,
                 ...(event.classify_branch !== undefined ? { classifyBranch: event.classify_branch } : {}),
                 ...(event.tournament_winner !== undefined ? { tournamentWinner: event.tournament_winner } : {}),
                 ...(event.loop_continue !== undefined ? { loopContinue: event.loop_continue } : {}),
@@ -106,11 +109,11 @@ export function recoverSubmittedWorkflowNodes(events) {
         if (event.kind === "workflow_nodes_submitted") {
             submissions.push(event.nodes);
             submitters.push(event.submitter_agent_id);
-            // Absent on legacy logs → order-only replay (bases array stays parallel-short only
-            // if ALL records carry it; a mixed log degrades to order-only for safety).
-            if (event.base_index !== undefined)
-                bases.push(event.base_index);
+            if (event.base_index === undefined) {
+                throw new Error("workflow_nodes_submitted is missing required base_index");
+            }
+            bases.push(event.base_index);
         }
     }
-    return { submissions, bases: bases.length === submissions.length ? bases : [], submitters };
+    return { submissions, bases, submitters };
 }

package/dist/runtime/sub-agent-orchestrator.js

@@ -157,7 +157,7 @@ export async function spawnStandalone(parentOpts, parentSessionId, spec, orchest
     const runtime = new kernel.KernelRuntime({
         maxTokens: parentOpts.maxTokens,
         maxTurns: parentOpts.maxTurns ?? 25,
-        timeoutMs: parentOpts.timeoutMs !== undefined ? BigInt(parentOpts.timeoutMs) : undefined,
+        timeoutMs: parentOpts.timeoutMs,
     });
     const pending = [];
     kernelApply(runtime, pending, { kind: "start_run", task: { goal: "coordinator", criteria: [] } });

package/dist/runtime/types/agent.d.ts

@@ -126,6 +126,9 @@ export type WorkflowTaskSpec = {
 } | string;
 /** One node in a declarative workflow DAG (camelCase host shape). */
 export type NodeTrust = "trusted" | "quarantined";
+export type WorkflowDependencyPolicy = "all_success" | "accept_partial" | "all_terminal" | "optional";
+export type WorkflowNodeStatus = "completed" | "completed_partial" | "failed" | "skipped_upstream_failed";
+export declare function workflowNodeStatusFromTermination(termination: TerminationReason | string): WorkflowNodeStatus;
 export interface WorkflowNodeSpec {
     task: WorkflowTaskSpec;
     role: KernelAgentRole;
@@ -165,11 +168,39 @@ export interface WorkflowNodeSpec {
     maxWallMs?: number;
     /** Indices of nodes this node depends on. */
     dependsOn?: number[];
+    /** How dependency terminal states gate this node. Defaults to `all_success`. */
+    depPolicy?: WorkflowDependencyPolicy;
 }
 /** A declarative workflow DAG the kernel runs node-by-node, gating each spawn. */
 export interface WorkflowSpec {
     nodes: WorkflowNodeSpec[];
 }
+export interface KernelWorkflowNodeOutcome {
+    node_id: string;
+    status: WorkflowNodeStatus;
+    termination?: TerminationReason;
+    output?: {
+        role: Message["role"];
+        content: string;
+        tool_calls?: Array<{
+            id: string;
+            name: string;
+            arguments?: Record<string, unknown>;
+        }>;
+        token_count?: number;
+    };
+}
+export interface WorkflowNodeOutcome {
+    nodeId: string;
+    status: WorkflowNodeStatus;
+    termination?: TerminationReason;
+    output?: Message;
+}
+export interface WorkflowOutcome {
+    nodeOutcomes: WorkflowNodeOutcome[];
+    outputs: Record<string, string>;
+}
+export declare function workflowNodeOutcomeFromKernel(raw: KernelWorkflowNodeOutcome): WorkflowNodeOutcome;
 /** Per-node spawn descriptor carried in the `workflow_batch_spawned` observation. */
 export interface WorkflowSpawnInfo {
     agent_id: string;

package/dist/runtime/types/agent.js

@@ -121,6 +121,35 @@ export function milestoneCheckPass(phaseId) {
 export function milestoneCheckFail(phaseId, reason) {
     return { phaseId, passed: false, reason };
 }
+export function workflowNodeStatusFromTermination(termination) {
+    if (termination === "completed")
+        return "completed";
+    if (termination === "error" || termination === "user_abort")
+        return "failed";
+    return "completed_partial";
+}
+export function workflowNodeOutcomeFromKernel(raw) {
+    const output = raw.output;
+    return {
+        nodeId: raw.node_id,
+        status: raw.status,
+        ...(raw.termination ? { termination: raw.termination } : {}),
+        ...(output
+            ? {
+                output: {
+                    role: output.role,
+                    content: output.content,
+                    toolCalls: (output.tool_calls ?? []).map(call => ({
+                        id: call.id,
+                        name: call.name,
+                        arguments: JSON.stringify(call.arguments ?? {}),
+                    })),
+                    ...(output.token_count != null ? { tokenCount: output.token_count } : {}),
+                },
+            }
+            : {}),
+    };
+}
 /** G4: a concise budget note appended to a coordinator node's goal. "" when nothing is bounded. */
 export function workflowBudgetNote(budget) {
     if (!budget)
@@ -188,6 +217,7 @@ export function workflowNodeSpecToKernel(n) {
         ...(n.maxTurns != null ? { max_turns: n.maxTurns } : {}),
         ...(n.maxWallMs != null ? { max_wall_ms: n.maxWallMs } : {}),
         ...(n.dependsOn && n.dependsOn.length ? { depends_on: n.dependsOn } : {}),
+        dep_policy: n.depPolicy ?? "all_success",
     };
 }
 export function workflowSpecToKernel(spec) {
@@ -274,6 +304,11 @@ const workflowNodesArraySchema = {
             },
             tokenBudget: { type: "integer", description: "Cap this node's child run at this many cumulative tokens." },
             dependsOn: { type: "array", items: { type: "integer" } },
+            depPolicy: {
+                type: "string",
+                enum: ["all_success", "accept_partial", "all_terminal", "optional"],
+                description: "How dependency terminal states gate this node; defaults to all_success.",
+            },
         },
         required: ["task", "role"],
     },

package/dist/signals/index.d.ts

@@ -4,9 +4,29 @@ export interface RuntimeSignal {
     urgency: "low" | "normal" | "high" | "critical";
     payload: Record<string, unknown>;
     dedupeKey?: string;
+    /** Target a specific session loop. Omitted means a shared signal. */
+    recipient?: string;
+    /** Absolute journal-clock deadline for optional urgency escalation. */
+    deadlineMs?: number;
+    /** Merge with an unconsumed queued signal carrying the same key. */
+    coalesceKey?: string;
+    /** Number of host signals deterministically represented by this signal. */
+    coalescedCount?: number;
 }
 export interface SignalSource {
-    nextSignal(): Promise<RuntimeSignal | null>;
+    claimSignal(): Promise<SignalClaim | null>;
+    ackSignal(receipt: SignalDeliveryReceipt): Promise<boolean>;
+    nackSignal(receipt: SignalDeliveryReceipt): Promise<boolean>;
+}
+export interface SignalDeliveryReceipt {
+    deliveryId: string;
+    leaseToken: string;
+}
+export interface SignalClaim extends SignalDeliveryReceipt {
+    signalId: string;
+    deliveryAttempt: number;
+    signal: RuntimeSignal;
+    leaseExpiresAtMs: number;
 }
 export declare class ScheduledPrompt {
     readonly goal: string;

package/dist/signals/index.js

@@ -15,6 +15,7 @@ export class ScheduledPrompt {
             signalType: "job",
             urgency: "normal",
             payload: { goal: this.goal, criteria: this.criteria, runAtMs: this.runAtMs, ...this.metadata },
+            coalescedCount: 1,
             dedupeKey: `scheduled-${this.runAtMs}`,
         };
     }

package/dist/types.d.ts

@@ -54,6 +54,12 @@ export interface RenderedContext {
     /** Message count of the frozen history prefix (compaction boundary). When set,
      *  Anthropic pins a deep cache breakpoint here instead of the rolling pair. */
     frozenPrefixLen?: number;
+    budgetOverflow?: ContextBudgetOverflow;
+}
+export interface ContextBudgetOverflow {
+    kind: "fixed_context" | "protected_tail";
+    requiredTokens: number;
+    maxTokens: number;
 }
 export interface StreamEvent {
     type: string;
@@ -104,8 +110,7 @@ export interface DoneEvent extends StreamEvent {
     type: "done";
     iterations: number;
     totalTokens: number;
-    status: string;
-    dreamResult?: import("./memory/index.js").DreamResult; /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
+    status: string; /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: import("./runtime/kernel-step.js").PaceDecision;
 }
 export interface ErrorEvent extends StreamEvent {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.38",
+  "version": "0.2.40",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.38"
+    "@deepstrike/wasm-kernel": "0.2.40"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",