@deepstrike/wasm 0.2.36 → 0.2.38

package/dist/runtime/session-repair.js

@@ -48,24 +48,38 @@ export function buildRunTerminalEvent(input) {
         total_tokens: Math.max(0, input.totalTokens),
     };
 }
+/** Build workflow_node_completed for persistence after a node finishes. W-1: carries the
+ *  result-borne control signals + output so resume replays control flow and re-seeds outputs. */
 export function buildWorkflowNodeCompletedEvent(input) {
     return {
         kind: "workflow_node_completed",
         turn: input.turn,
         agent_id: input.agentId,
         termination: input.termination,
+        ...(input.classifyBranch !== undefined ? { classify_branch: input.classifyBranch } : {}),
+        ...(input.tournamentWinner !== undefined ? { tournament_winner: input.tournamentWinner } : {}),
+        ...(input.loopContinue !== undefined ? { loop_continue: input.loopContinue } : {}),
+        ...(input.output ? { output: input.output } : {}),
     };
 }
 /**
- * Recover completed workflow node agent_ids from a session event stream.
- * Scans for workflow_node_completed events and returns the agent_ids whose
- * termination was "completed". Used to rebuild resumedCompleted for resumeWorkflow.
+ * 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
+ * driver's outputs map from the persisted output text.
  */
 export function recoverCompletedWorkflowNodes(events) {
     const completed = [];
     for (const { event } of events) {
         if (event.kind === "workflow_node_completed" && event.termination === "completed") {
-            completed.push(event.agent_id);
+            completed.push({
+                agentId: event.agent_id,
+                ...(event.classify_branch !== undefined ? { classifyBranch: event.classify_branch } : {}),
+                ...(event.tournament_winner !== undefined ? { tournamentWinner: event.tournament_winner } : {}),
+                ...(event.loop_continue !== undefined ? { loopContinue: event.loop_continue } : {}),
+                ...(event.output !== undefined ? { output: event.output } : {}),
+            });
         }
     }
     return completed;
@@ -73,15 +87,30 @@ export function recoverCompletedWorkflowNodes(events) {
 /** 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 function buildWorkflowNodesSubmittedEvent(input) {
-    return { kind: "workflow_nodes_submitted", turn: input.turn, nodes: input.nodes };
+    return {
+        kind: "workflow_nodes_submitted",
+        turn: input.turn,
+        nodes: input.nodes,
+        ...(input.baseIndex !== undefined ? { base_index: input.baseIndex } : {}),
+        ...(input.submitterAgentId !== undefined ? { submitter_agent_id: input.submitterAgentId } : {}),
+    };
 }
 /** R3-1: recover the runtime submission batches (in order) to rebuild `resumed_submissions` for
- *  resumeWorkflow, so dynamically-appended nodes are reconstructed. */
+ *  resumeWorkflow, so dynamically-appended nodes are reconstructed.
+ *  `submitters` is parallel to `submissions` (undefined = host/bootstrap submission). */
 export function recoverSubmittedWorkflowNodes(events) {
     const submissions = [];
+    const bases = [];
+    const submitters = [];
     for (const { event } of events) {
-        if (event.kind === "workflow_nodes_submitted")
+        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);
+        }
     }
-    return submissions;
+    return { submissions, bases: bases.length === submissions.length ? bases : [], submitters };
 }

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -10,6 +10,13 @@ export interface SubAgentRunContext {
     /** M5 v2.1: set when this child is a workflow node — propagated so a nested `start_workflow`
      *  FLATTENS to the parent kernel rather than auto-pivoting into its own bootstrap. */
     isWorkflowNode?: boolean;
+    /** W-N1 tool exposure. The kernel omits an EMPTY `permitted_capability_ids` on the wire, so a
+     *  grant-less workflow node is indistinguishable from a zero-cap spawn at the manifest — the
+     *  caller states intent instead: `"inherit"` = run on the parent's execution plane with its
+     *  meta-tool availability (trusted workflow nodes — they carried no grant list by design, and
+     *  filtering on the missing list ran every DAG node TOOL-LESS); `"filtered"` (default) = filter
+     *  to the manifest grants, empty ⇒ deny-all (spawn path, quarantined nodes). */
+    toolAccess?: "inherit" | "filtered";
     /** #2-B-ii: parent-controlled abort — when the kernel preempts this node (`AgentPreempted`), the
      *  orchestrator interrupts the child runner, cancelling its in-flight LLM call. */
     abortSignal?: AbortSignal;

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

@@ -49,12 +49,32 @@ function deriveMetaTools(permitted, opts) {
         metaTools.add("update_plan");
     return metaTools;
 }
+/** W-N1: meta-tools by source availability alone — a `toolAccess: "inherit"` child gets the same
+ *  meta surface a top-level run of these options would. */
+function availableMetaTools(opts) {
+    const metaTools = new Set();
+    if (opts.skillContentMap?.size)
+        metaTools.add("skill");
+    if (opts.dreamStore)
+        metaTools.add("memory");
+    if (opts.knowledgeSource)
+        metaTools.add("knowledge");
+    if (opts.enablePlanTool)
+        metaTools.add("update_plan");
+    return metaTools;
+}
 /** Host-side driver for kernel-isolated sub-agent runs. */
 export class SubAgentOrchestrator {
     async run(ctx) {
+        // W-N1: "inherit" runs the child on the parent's plane with availability-derived meta-tools
+        // (trusted workflow nodes); "filtered" (default) filters to the manifest grants, empty ⇒
+        // deny-all (spawn path, quarantined nodes).
+        const inherit = ctx.toolAccess === "inherit";
         const permitted = new Set(ctx.manifest.permitted_capability_ids ?? []);
-        const metaTools = deriveMetaTools(permitted, ctx.parentOpts);
-        const filteredPlane = new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted, metaTools);
+        const metaTools = inherit ? availableMetaTools(ctx.parentOpts) : deriveMetaTools(permitted, ctx.parentOpts);
+        const execPlane = inherit
+            ? ctx.parentOpts.executionPlane
+            : new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted, metaTools);
         let systemPrompt = ctx.parentOpts.systemPrompt;
         let inheritEvents;
         if (ctx.manifest.context_inheritance === "full") {
@@ -77,7 +97,7 @@ export class SubAgentOrchestrator {
             // O3: per-child turn / wall-clock caps (fall back to the inherited limits).
             maxTurns: ctx.spec.maxTurns ?? ctx.parentOpts.maxTurns,
             timeoutMs: ctx.spec.maxWallMs ?? ctx.parentOpts.timeoutMs,
-            executionPlane: filteredPlane,
+            executionPlane: execPlane,
             agentId: ctx.spec.identity.agentId,
             systemPrompt,
             sessionLog: ctx.sessionLog,
@@ -87,6 +107,13 @@ export class SubAgentOrchestrator {
             enablePlanTool: metaTools.has("update_plan") ? ctx.parentOpts.enablePlanTool : undefined,
             // M5 v2.1: a workflow node's `start_workflow` flattens to the parent kernel (no nested pivot).
             isWorkflowNode: ctx.isWorkflowNode,
+            // The child runs under ITS OWN spec, never the parent's: the spread above would otherwise
+            // leak the parent's `runSpec` (identity, capability filter — and an armed `loopRound`,
+            // giving every child a phantom pace tool). A loop-node iteration carries its own minimal
+            // spec to arm the pacing trap (DW-3); everything else runs spec-less as before.
+            runSpec: ctx.spec.loopRound
+                ? { identity: ctx.spec.identity, role: ctx.spec.role, goal: ctx.spec.goal, loopRound: ctx.spec.loopRound }
+                : undefined,
         });
         // #2-B-ii: parent preempt → interrupt the child (cancels its in-flight LLM call).
         linkAbort(ctx.abortSignal, childRunner);
@@ -112,6 +139,9 @@ export class SubAgentOrchestrator {
             ...(finalText
                 ? { finalMessage: { role: "assistant", content: finalText, toolCalls: [] } }
                 : {}),
+            // DW-3: surface the kernel-adjudicated pace decision (loop-node iterations consume it as the
+            // continuation vocabulary). SDK-internal; stripped by subAgentResultToKernel.
+            ...(done?.paceDecision ? { paceDecision: done.paceDecision } : {}),
         };
         return {
             agentId: ctx.spec.identity.agentId,

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

@@ -19,6 +19,16 @@ export interface AgentCapabilityFilter {
     allowedKinds?: string[];
     allowedIds?: string[];
 }
+export interface LoopRoundSpec {
+    /** Hard round cap across the loop's lifetime; continue/sleep at the cap is coerced to stop. */
+    maxRounds?: number;
+    /** Sleep clamp floor (ms). */
+    minSleepMs?: number;
+    /** Sleep clamp ceiling (ms). */
+    maxSleepMs?: number;
+    /** Fallback when a round ends without a pace call: "stop" (goal loops, default) | "sleep" (cron loops). */
+    defaultAction?: "stop" | "sleep";
+}
 export interface AgentRunSpec {
     identity: AgentIdentity;
     role: KernelAgentRole;
@@ -28,6 +38,9 @@ export interface AgentRunSpec {
     capabilityFilter?: AgentCapabilityFilter;
     milestones?: MilestoneContract;
     metadata?: Record<string, unknown>;
+    /** ③ loop-agent rounds: presence makes this run ONE round of a paced loop (gates the
+     *  kernel `pace` meta-tool and arms the pacing trap). */
+    loopRound?: LoopRoundSpec;
     /** M1/G3: per-agent model preference; the host resolves it via `RuntimeOptions.providerFor`.
      *  Host-side routing only — not sent to the kernel. */
     modelHint?: string;
@@ -70,6 +83,11 @@ export interface LoopResult {
     classifyBranch?: string;
     /** A#2 tournament verdict: a judge reports the winning entrant's agent id here. Sent only when set. */
     tournamentWinner?: string;
+    /** ③ loop-agent pacing: the kernel-adjudicated after-round decision, surfaced by the orchestrator
+     *  from the child's done event. For a loop-node iteration this is the PRIMARY continuation
+     *  vocabulary (stop → loopContinue=false); the legacy text-sniffed signal is the fallback.
+     *  SDK-internal — stripped by `subAgentResultToKernel`. */
+    paceDecision?: import("../kernel-step.js").PaceDecision;
 }
 export interface SubAgentResult {
     agentId: string;
@@ -141,6 +159,10 @@ export interface WorkflowNodeSpec {
     };
     /** M4/G5: cap this node's child run at `tokenBudget` cumulative tokens (the per-node "use N tokens"). */
     tokenBudget?: number;
+    /** O3: cap this node's child run at `maxTurns` provider turns (falls back to the parent's). */
+    maxTurns?: number;
+    /** O3: cap this node's child run at `maxWallMs` wall-clock milliseconds. */
+    maxWallMs?: number;
     /** Indices of nodes this node depends on. */
     dependsOn?: number[];
 }
@@ -156,11 +178,14 @@ export interface WorkflowSpawnInfo {
     isolation: string;
     context_inheritance: string;
     model_hint?: string;
+    /** W3 trust level: `"trusted"` | `"quarantined"`. */
+    trust?: string;
     /** G3: JSON Schema the node's output must conform to (carried verbatim from the spec). */
     output_schema?: Record<string, unknown>;
     /** G2: for a reduce node, the registered reducer name to run (no LLM). */
     reducer?: string;
-    /** G2: the dependency agent ids whose outputs a reduce node consumes. */
+    /** The dependency agent ids for EVERY dependent node (W-N2: a DAG edge carries data). A reduce
+     *  node's registered function consumes them; every other node gets its deps' outputs in context. */
     input_agent_ids?: string[];
     /** A#2: present only for a tournament *judge* spawn — the two entrant agent ids whose produced
      *  outputs this judge compares. The runner looks them up and reports the winner as `tournamentWinner`. */
@@ -176,6 +201,10 @@ export interface WorkflowSpawnInfo {
     classify_labels?: string[];
     /** M4/G5: the node's per-node cumulative token cap, if set — the runner caps the child run here. */
     token_budget?: number;
+    /** O3: per-node turn cap → the child run's `maxTurns`. */
+    max_turns?: number;
+    /** O3: per-node wall-clock cap (ms) → the child run's timeout. */
+    max_wall_ms?: number;
 }
 /** G4 budget-as-signal: the workflow's remaining headroom under the active quota, carried on the
  *  `workflow_batch_spawned` observation so a coordinator node can scale its next submission. */
@@ -225,3 +254,9 @@ export declare function generateAndFilter(generators: WorkflowTaskSpec[], filter
  * re-checks flags. Verifiers run read-only with no inherited author context (bias-resistant).
  */
 export declare function verifyRules(rules: WorkflowTaskSpec[], skeptic?: WorkflowTaskSpec): WorkflowSpec;
+/**
+ * Generate → evaluate loop template (parity with node/python `genEval`): a worker Loop node
+ * (worktree isolation, full context) feeding a fresh-context verifier whose output is pinned
+ * to the kernel's verdict schema. Async because the wasm kernel module loads lazily.
+ */
+export declare function genEval(worker: WorkflowTaskSpec, evaluate: WorkflowTaskSpec, maxIters?: number, extractSkillOnPass?: boolean): Promise<WorkflowSpec>;

package/dist/runtime/types/agent.js

@@ -1,3 +1,4 @@
+import { getKernel } from "../kernel.js";
 /** Map kernel spawn observation → host manifest. */
 export function spawnObservationToManifest(obs, spec, parentSessionId) {
     const o = obs;
@@ -45,6 +46,14 @@ export function agentRunSpecToKernel(spec) {
         out.verification_contract_id = spec.verificationContractId;
     if (spec.milestones)
         out.milestones = milestoneContractToKernel(spec.milestones);
+    if (spec.loopRound) {
+        out.loop_round = {
+            ...(spec.loopRound.maxRounds !== undefined ? { max_rounds: spec.loopRound.maxRounds } : {}),
+            ...(spec.loopRound.minSleepMs !== undefined ? { min_sleep_ms: spec.loopRound.minSleepMs } : {}),
+            ...(spec.loopRound.maxSleepMs !== undefined ? { max_sleep_ms: spec.loopRound.maxSleepMs } : {}),
+            ...(spec.loopRound.defaultAction !== undefined ? { default_action: spec.loopRound.defaultAction } : {}),
+        };
+    }
     return out;
 }
 export function milestoneContractToKernel(contract) {
@@ -175,6 +184,9 @@ export function workflowNodeSpecToKernel(n) {
         ...(kind ? { kind } : {}),
         // M4/G5: per-node token cap (additive; omitted when unset).
         ...(n.tokenBudget != null ? { token_budget: n.tokenBudget } : {}),
+        // O3: per-node turn / wall-clock caps (additive; omitted when unset).
+        ...(n.maxTurns != null ? { max_turns: n.maxTurns } : {}),
+        ...(n.maxWallMs != null ? { max_wall_ms: n.maxWallMs } : {}),
         ...(n.dependsOn && n.dependsOn.length ? { depends_on: n.dependsOn } : {}),
     };
 }
@@ -302,10 +314,15 @@ export const startWorkflowTool = {
 };
 /** Build a sub-agent run spec for a kernel-generated workflow node. */
 export function workflowNodeToSpec(node, parentSessionId) {
+    // W-N6 transcript-as-carry: a loop node's iterations share ONE stable session id (the `-i{k}`
+    // suffix names the spawn, not the session), so iteration k replays the transcript of 0..k-1 —
+    // "do the next increment" actually sees the previous increments. The agent_id keeps the
+    // per-iteration suffix (kernel completion routing).
+    const sessionNodeId = node.loop_max_iters != null ? node.agent_id.replace(/-i\d+$/, "") : node.agent_id;
     return {
         identity: {
             agentId: node.agent_id,
-            sessionId: `${parentSessionId}-${node.agent_id}`,
+            sessionId: `${parentSessionId}-${sessionNodeId}`,
             isSubAgent: true,
             parentSessionId,
         },
@@ -316,6 +333,14 @@ export function workflowNodeToSpec(node, parentSessionId) {
         ...(node.model_hint ? { modelHint: node.model_hint } : {}),
         // M4/G5: carry the node's token cap so the orchestrator can bound the child run.
         ...(node.token_budget != null ? { tokenBudget: node.token_budget } : {}),
+        // O3: carry the node's turn / wall-clock caps (the orchestrator already honors these).
+        ...(node.max_turns != null ? { maxTurns: node.max_turns } : {}),
+        ...(node.max_wall_ms != null ? { maxWallMs: node.max_wall_ms } : {}),
+        // DW-3 one continuation vocabulary: a loop ITERATION runs with the pacing trap armed, so the
+        // agent signals continue/stop through the kernel-adjudicated `pace` meta-tool instead of a
+        // text-sniffed JSON blob. One iteration = one round; the DAG (not max_rounds) caps iterations,
+        // and default stop means "ended without pacing" = done — the CC silence-is-completion contract.
+        ...(node.loop_max_iters != null ? { loopRound: { defaultAction: "stop" } } : {}),
     };
 }
 /** Build the host manifest for a kernel-generated workflow node. */
@@ -391,3 +416,31 @@ export function verifyRules(rules, skeptic) {
     }
     return { nodes };
 }
+/**
+ * Generate → evaluate loop template (parity with node/python `genEval`): a worker Loop node
+ * (worktree isolation, full context) feeding a fresh-context verifier whose output is pinned
+ * to the kernel's verdict schema. Async because the wasm kernel module loads lazily.
+ */
+export async function genEval(worker, evaluate, maxIters = 3, extractSkillOnPass = true) {
+    const kernel = await getKernel();
+    const schema = JSON.parse(kernel.verdictOutputSchema(extractSkillOnPass));
+    return {
+        nodes: [
+            {
+                task: asTask(worker),
+                role: "implement",
+                isolation: "worktree",
+                contextInheritance: "full",
+                loop: { maxIters: Math.max(1, maxIters) },
+            },
+            {
+                task: asTask(evaluate),
+                role: "verify",
+                isolation: "read_only",
+                contextInheritance: "none",
+                dependsOn: [0],
+                outputSchema: schema,
+            },
+        ],
+    };
+}

package/dist/runtime/workflow-control-flow.d.ts

@@ -1,5 +1,13 @@
-/** Instruction appended to a loop node's goal: do the next increment, and signal when done. */
-export declare function loopInstruction(maxIters: number): string;
+/** Instruction appended to a loop iteration's goal. DW-3: the continuation verb is the
+ *  kernel-adjudicated `pace` meta-tool (armed on every iteration run), not a text blob — one
+ *  vocabulary shared with the round-level loop agent. Iterations share one session, so "the work
+ *  so far" is simply the visible transcript. */
+export declare function loopInstruction(maxIters: number, iteration?: number): string;
+/** W-N2: dependency outputs appended to a dependent node's goal — a DAG edge carries data, not
+ *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
+ *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
+ *  outputs are skipped. Returns "" when the node has no dependencies. */
+export declare function dependencyOutputsNote(inputAgentIds: string[] | undefined, outputs: Map<string, string> | undefined, maxPerDep?: number): string;
 /** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
 export declare function classifyInstruction(labels: string[]): string;
 /** Build a tournament judge's goal: the controller's criterion + the two candidates to compare. */

package/dist/runtime/workflow-control-flow.js

@@ -6,12 +6,33 @@
 //! decision from the node's agent and extracts the matching result signal (`loopContinue` /
 //! `classifyBranch` / `tournamentWinner`) the kernel reads back.
 import { extractJsonValue } from "./output-schema.js";
-/** Instruction appended to a loop node's goal: do the next increment, and signal when done. */
-export function loopInstruction(maxIters) {
-    return (`This task runs as a LOOP (up to ${maxIters} iterations total). Do the next increment of work now. ` +
-        `When you judge the overall task COMPLETE and no further iterations are needed, end your response ` +
-        `with a JSON object {"loop_continue": false}. To request another iteration, omit it or return ` +
-        `{"loop_continue": true}.`);
+/** Instruction appended to a loop iteration's goal. DW-3: the continuation verb is the
+ *  kernel-adjudicated `pace` meta-tool (armed on every iteration run), not a text blob — one
+ *  vocabulary shared with the round-level loop agent. Iterations share one session, so "the work
+ *  so far" is simply the visible transcript. */
+export function loopInstruction(maxIters, iteration = 0) {
+    return (`This task runs as a LOOP — this is iteration ${iteration + 1} of up to ${maxIters}. Your prior ` +
+        `iterations' work (if any) is visible above; do the NEXT increment now. Then call the \`pace\` tool: ` +
+        `\`{"next": "continue"}\` to request another iteration, or \`{"next": "stop"}\` when the overall ` +
+        `task is complete. Ending without calling \`pace\` also completes the loop.`);
+}
+/** W-N2: dependency outputs appended to a dependent node's goal — a DAG edge carries data, not
+ *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
+ *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
+ *  outputs are skipped. Returns "" when the node has no dependencies. */
+export function dependencyOutputsNote(inputAgentIds, outputs, maxPerDep = 8_000) {
+    if (!inputAgentIds?.length || !outputs)
+        return "";
+    const blocks = inputAgentIds
+        .map(id => {
+        const out = outputs.get(id) ?? "";
+        if (!out)
+            return "";
+        const clipped = out.length > maxPerDep ? `${out.slice(0, maxPerDep)}\n…[truncated]` : out;
+        return `[dependency ${id} output]\n${clipped}`;
+    })
+        .filter(Boolean);
+    return blocks.join("\n\n");
 }
 /** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
 export function classifyInstruction(labels) {

package/dist/types.d.ts

@@ -105,7 +105,8 @@ export interface DoneEvent extends StreamEvent {
     iterations: number;
     totalTokens: number;
     status: string;
-    dreamResult?: import("./memory/index.js").DreamResult;
+    dreamResult?: import("./memory/index.js").DreamResult; /** ③ 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 {
     type: "error";
@@ -154,6 +155,38 @@ export interface ToolArgumentRepairedEvent extends StreamEvent {
     originalArguments: string;
     repairedArguments: string;
 }
+/** Kernel session-entropy measurement at a completed turn boundary (see the Node SDK's
+ *  `EntropySample` for the canonical documentation; this is the WASM mirror). */
+export interface EntropySample {
+    turn: number;
+    score: number;
+    scoreVersion: number;
+    rho: number;
+    repeatPressure: number;
+    failureRate: number;
+    rollbacksInWindow: number;
+    windowTurns: number;
+}
+/** One kernel entropy sample, emitted once per completed turn (a heartbeat watch source). */
+export interface EntropySampleEvent extends StreamEvent {
+    type: "entropy_sample";
+    sample: EntropySample;
+}
+/** The opt-in kernel entropy watch tripped (see `RunnerOptions.entropyWatch`). */
+export interface EntropyAlertEvent extends StreamEvent {
+    type: "entropy_alert";
+    turn: number;
+    score: number;
+    threshold: number;
+}
+/** Opt-in kernel-side threshold watch over the per-turn entropy score (Node SDK mirror). */
+export interface EntropyWatchOptions {
+    enabled?: boolean;
+    threshold?: number;
+    hysteresis?: number;
+    cooldownTurns?: number;
+    notifyModel?: boolean;
+}
 /**
  * Opaque per-run state owned by the provider (e.g. OpenAI Responses continuation).
  * The framework creates and threads this object; providers may read/write it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.36",
+  "version": "0.2.38",
   "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.36"
+    "@deepstrike/wasm-kernel": "0.2.38"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",