@deepstrike/wasm 0.2.80 → 0.2.82

package/dist/providers/openai.js

@@ -1,6 +1,8 @@
 import { requestSnapshot } from "./prepared-request.js";
 import { collectStreamMessage, toOpenAIMessages } from "./base.js";
 import { malformedToolArguments } from "../runtime/tool-arguments.js";
+import { ProviderError } from "./provider-error.js";
+import { TEXTUAL_TOOL_CALL_CODE, TEXTUAL_TOOL_CALL_MESSAGE, markupStart, parseTextToolCalls, partialMarkupLength, textToolCallId } from "./text-tool-calls.js";
 const DEEPSEEK_REASONERS = new Set(["deepseek-reasoner", "deepseek-r1"]);
 const MINIMAX_REASONERS = new Set(["MiniMax-M1", "minimax-m1"]);
 // OpenAI-compatible provider — works for OpenAI, Qwen (DashScope), DeepSeek, MiniMax, Kimi
@@ -61,7 +63,31 @@ export class OpenAIProvider {
         // Phase 4: OpenAI signals an output-cap truncation via finish_reason="length"; the kernel
         // treats it as a truncation (== Anthropic "max_tokens") and drives output-cap recovery.
         let finishReason;
-        while (true) {
+        // Plan task 9.0 · DeepSeek may write its tool calls as DSML markup in the text: hold it out of
+        // the text and parse it into tool calls at the end of the turn.
+        const watchMarkup = this.dialect === "deepseek";
+        let held = "";
+        let markup;
+        const visible = (text) => {
+            if (!watchMarkup)
+                return text;
+            if (markup !== undefined) {
+                markup += text;
+                return "";
+            }
+            const combined = held + text;
+            held = "";
+            const at = markupStart(combined);
+            if (at >= 0) {
+                markup = combined.slice(at);
+                return combined.slice(0, at);
+            }
+            const keep = partialMarkupLength(combined);
+            held = combined.slice(combined.length - keep);
+            return combined.slice(0, combined.length - keep);
+        };
+        let streamDone = false;
+        while (!streamDone) {
             const { done, value } = await reader.read();
             if (done)
                 break;
@@ -73,11 +99,9 @@ export class OpenAIProvider {
                     continue;
                 const data = line.slice(6).trim();
                 if (data === "[DONE]") {
-                    // Surface an output-cap truncation (finish_reason="length") to the runner/kernel. Emitted
-                    // as a usage frame (the channel the runner reads stopReason from) before the early return.
-                    if (finishReason)
-                        yield { type: "usage", totalTokens: 0, stopReason: finishReason };
-                    return;
+                    // The tool calls accumulated so far are emitted below: returning here dropped them.
+                    streamDone = true;
+                    break;
                 }
                 try {
                     const chunk = JSON.parse(data);
@@ -88,8 +112,11 @@ export class OpenAIProvider {
                         continue;
                     if (exposeReasoning && typeof delta.reasoning_content === "string" && delta.reasoning_content)
                         yield { type: "thinking_delta", delta: delta.reasoning_content };
-                    if (typeof delta.content === "string" && delta.content)
-                        yield { type: "text_delta", delta: delta.content };
+                    if (typeof delta.content === "string" && delta.content) {
+                        const text = visible(delta.content);
+                        if (text)
+                            yield { type: "text_delta", delta: text };
+                    }
                     for (const tc of delta.tool_calls ?? []) {
                         const idx = tc.index;
                         if (!toolAccum[idx])
@@ -100,6 +127,25 @@ export class OpenAIProvider {
                 catch { /* skip */ }
             }
         }
+        if (held)
+            yield { type: "text_delta", delta: held };
+        if (markup !== undefined) {
+            const calls = parseTextToolCalls(markup);
+            if (!calls) {
+                throw new ProviderError({
+                    provider: this.providerId(),
+                    kind: "protocol",
+                    retryable: true,
+                    message: TEXTUAL_TOOL_CALL_MESSAGE,
+                    providerCode: TEXTUAL_TOOL_CALL_CODE,
+                });
+            }
+            let index = Math.max(-1, ...Object.keys(toolAccum).map(Number)) + 1;
+            for (const call of calls) {
+                toolAccum[index++] = { id: textToolCallId(), name: call.name, argsBuf: JSON.stringify(call.arguments) };
+            }
+            finishReason = "tool_calls";
+        }
         for (const tb of Object.values(toolAccum)) {
             let args = {};
             try {
@@ -110,6 +156,10 @@ export class OpenAIProvider {
             }
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args, ...malformedToolArguments(tb.argsBuf) };
         }
+        // Surface an output-cap truncation (finish_reason="length") to the runner/kernel as a usage
+        // frame, the channel the runner reads stopReason from.
+        if (finishReason)
+            yield { type: "usage", totalTokens: 0, stopReason: finishReason };
     }
     prepareRequest(context, tools, extensions, state) {
         let requestTools = tools;

package/dist/providers/text-tool-calls.d.ts

@@ -0,0 +1,16 @@
+export interface TextToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+/** Index of the first DSML marker in `text`, or -1. */
+export declare function markupStart(text: string): number;
+/** How many trailing characters of `text` could begin a marker and must wait for the next chunk. */
+export declare function partialMarkupLength(text: string): number;
+/** The tool calls in `markup`, or undefined when it is not a complete, well-formed set of calls. */
+export declare function parseTextToolCalls(markup: string): TextToolCall[] | undefined;
+/** A call id for a parsed call: unique, so read-backs and tool results never collide. */
+export declare function textToolCallId(): string;
+/** Markup that does not parse fails like the Anthropic adapter's textual-tool-call guard (SPC-022):
+ *  same provider code and message, retryable, and the body is never echoed. */
+export declare const TEXTUAL_TOOL_CALL_CODE = "textual_tool_call";
+export declare const TEXTUAL_TOOL_CALL_MESSAGE = "Provider emitted a tool call as text instead of a native tool block";

package/dist/providers/text-tool-calls.js

@@ -0,0 +1,96 @@
+// Plan task 9.0 · tool calls a model wrote as text.
+//
+// DeepSeek sometimes answers with its native tool-call markup (DSML) in the message text instead of
+// the API's `tool_calls` field, often in a degraded form:
+//
+//   <｜DSML｜invoke name="read_file">
+//   <｜DSML｜parameter name="path" string="true">logs/svc-13.log</｜DSML｜parameter>
+//   </｜DSML｜invoke>
+//
+// (or `｜｜DSML｜｜ parameter` with doubled bars and spaces). Left as text it enters history, the model
+// imitates it on later turns, and the run loops until its turn limit. The dialect layer therefore
+// keeps the markup out of the text: it parses it into real tool calls, or — when it cannot — fails
+// the call as a retryable protocol error so the kernel's recovery asks again.
+const MARKUP_START = /<\s*\/?\s*[｜|]+\s*DSML/i;
+const TAG = /<\s*(\/?)\s*[｜|]+\s*DSML\s*[｜|]+\s*([A-Za-z_]+)([^>]*)>/gi;
+/** A text tail that may be the start of a marker split across stream chunks. */
+const PARTIAL_START = /<\s*\/?\s*(?:[｜|]+\s*(?:D(?:S(?:M)?)?)?)?$/i;
+const PARTIAL_LOOKBACK = 24;
+/** Index of the first DSML marker in `text`, or -1. */
+export function markupStart(text) {
+    const match = MARKUP_START.exec(text);
+    return match ? match.index : -1;
+}
+/** How many trailing characters of `text` could begin a marker and must wait for the next chunk. */
+export function partialMarkupLength(text) {
+    const tail = text.slice(-PARTIAL_LOOKBACK);
+    const at = tail.lastIndexOf("<");
+    if (at < 0)
+        return 0;
+    return PARTIAL_START.test(tail.slice(at)) ? tail.length - at : 0;
+}
+function attribute(attrs, name) {
+    const match = new RegExp(`\\b${name}\\s*=\\s*"([^"]*)"`, "i").exec(attrs);
+    return match?.[1];
+}
+function parameterValue(raw, isString) {
+    if (isString)
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** The tool calls in `markup`, or undefined when it is not a complete, well-formed set of calls. */
+export function parseTextToolCalls(markup) {
+    const calls = [];
+    let current;
+    let parameter;
+    for (const match of markup.matchAll(TAG)) {
+        const [whole, close, rawTag, attrs] = match;
+        const tag = rawTag.toLowerCase();
+        const at = match.index ?? 0;
+        if (tag === "invoke") {
+            if (!close) {
+                const name = attribute(attrs, "name");
+                if (!name || current || parameter)
+                    return undefined;
+                current = { name, arguments: {} };
+            }
+            else {
+                if (!current || parameter)
+                    return undefined;
+                calls.push(current);
+                current = undefined;
+            }
+        }
+        else if (tag === "parameter") {
+            if (!close) {
+                const name = attribute(attrs, "name");
+                if (!name || !current || parameter)
+                    return undefined;
+                parameter = { name, isString: attribute(attrs, "string") !== "false", start: at + whole.length };
+            }
+            else {
+                if (!current || !parameter)
+                    return undefined;
+                current.arguments[parameter.name] = parameterValue(markup.slice(parameter.start, at), parameter.isString);
+                parameter = undefined;
+            }
+        }
+        // Wrappers (`function_calls`, `tool_calls`, a bare `calls`) carry nothing.
+    }
+    if (current || parameter || calls.length === 0)
+        return undefined;
+    return calls;
+}
+/** A call id for a parsed call: unique, so read-backs and tool results never collide. */
+export function textToolCallId() {
+    return `call_text_${Math.random().toString(36).slice(2, 12)}`;
+}
+/** Markup that does not parse fails like the Anthropic adapter's textual-tool-call guard (SPC-022):
+ *  same provider code and message, retryable, and the body is never echoed. */
+export const TEXTUAL_TOOL_CALL_CODE = "textual_tool_call";
+export const TEXTUAL_TOOL_CALL_MESSAGE = "Provider emitted a tool call as text instead of a native tool block";

package/dist/runtime/canonical-kernel-step.js

@@ -1309,6 +1309,7 @@ export class CanonicalRunnerRuntime {
                                 ...(event.key ? { key: event.key } : {}),
                                 ...(event.tokens !== undefined ? { tokens: Number(event.tokens) } : {}),
                                 ...(event.pinned ? { pinned: true } : {}),
+                                ...(event.inherited_from ? { inherited_from: event.inherited_from } : {}),
                             }],
                     },
                 };
@@ -1607,6 +1608,7 @@ export class CanonicalRunnerRuntime {
                     ...(event.key ? { key: event.key } : {}),
                     ...(event.tokens !== undefined ? { tokens: Number(event.tokens) } : {}),
                     ...(event.pinned ? { pinned: true } : {}),
+                    ...(event.inherited_from ? { inherited_from: event.inherited_from } : {}),
                 });
                 return true;
             case "set_available_skills":

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

@@ -13,6 +13,10 @@ export interface ContextPolicy {
     renewalCarryover: number;
     collapseOldAssistantNarration: boolean;
     idleMicroCompactMinutes: number;
+    /** Plan task 9.1 · tokens the model's notes may hold in the state turn (kernel default 600, on since
+     *  0.2.82); 0 turns the `note` tool off. Notes are written by the model and kept verbatim through
+     *  compaction. */
+    notesBudgetTokens?: number;
 }
 export interface ContextPolicyWire {
     pressure_thresholds_ppm: ContextPressureThresholds;
@@ -21,6 +25,7 @@ export interface ContextPolicyWire {
     renewal_carryover_ppm: number;
     collapse_old_assistant_narration: boolean;
     idle_micro_compact_minutes: number;
+    notes_budget_tokens?: number;
 }
 export interface ContextPolicyOverrides extends Partial<Omit<ContextPolicy, "pressureThresholds">> {
     pressureThresholds?: Partial<ContextPressureThresholds>;

package/dist/runtime/context-policy.js

@@ -42,6 +42,8 @@ export function normalizeContextPolicy(policy) {
     if (typeof policy.collapseOldAssistantNarration !== "boolean") {
         throw new TypeError("collapseOldAssistantNarration must be boolean");
     }
+    if (policy.notesBudgetTokens !== undefined)
+        assertIntegerAtLeast(policy.notesBudgetTokens, 0, "notesBudgetTokens");
     return {
         pressure_thresholds_ppm,
         target_after_compress_ppm,
@@ -49,6 +51,7 @@ export function normalizeContextPolicy(policy) {
         renewal_carryover_ppm: ratioToPpm(policy.renewalCarryover, "renewalCarryover"),
         collapse_old_assistant_narration: policy.collapseOldAssistantNarration,
         idle_micro_compact_minutes: policy.idleMicroCompactMinutes,
+        ...(policy.notesBudgetTokens !== undefined ? { notes_budget_tokens: policy.notesBudgetTokens } : {}),
     };
 }
 export function ratioToPpm(value, field = "ratio") {

package/dist/runtime/filtered-plane.js

@@ -1,7 +1,7 @@
 // Mirrors the kernel's EXPOSURE_EXEMPT_META_TOOLS invariant: kernel-owned meta surfaces are
 // never narrowed away by a tool allow-list. `read_result` is runner-resolved before reaching any
 // plane today, but the lists must not drift.
-const DEFAULT_META_TOOLS = new Set(["skill", "memory", "knowledge", "update_plan", "read_result"]);
+const DEFAULT_META_TOOLS = new Set(["skill", "memory", "knowledge", "update_plan", "note", "read_result"]);
 /** Wraps an execution plane, allowing only manifest-permitted tool IDs (+ meta-tools). */
 export class FilteredExecutionPlane {
     inner;

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

@@ -84,6 +84,16 @@ function projectKernelObservation(obs, turn, opts = {}) {
                 ...(obs.history && obs.history.length > 0 ? { history: obs.history } : {}),
                 ...(obs.history_items && obs.history_items.length > 0 ? { history_items: obs.history_items } : {}),
                 ...(obs.history_items_omitted ? { history_items_omitted: obs.history_items_omitted } : {}),
+                ...(obs.edges && obs.edges.length > 0 ? { edges: obs.edges } : {}),
+                ...(obs.edges_omitted ? { edges_omitted: obs.edges_omitted } : {}),
+                ...(obs.waste_items && obs.waste_items.length > 0 ? { waste_items: obs.waste_items } : {}),
+                ...(obs.external_edges && obs.external_edges.length > 0 ? { external_edges: obs.external_edges } : {}),
+                ...(obs.parent_items_used && obs.parent_items_used.length > 0 ? { parent_items_used: obs.parent_items_used } : {}),
+                ...(obs.prefix_breaks && obs.prefix_breaks.length > 0 ? { prefix_breaks: obs.prefix_breaks } : {}),
+                ...(obs.prefix_breaks_omitted ? { prefix_breaks_omitted: obs.prefix_breaks_omitted } : {}),
+                ...(obs.cache_tail_tokens ? { cache_tail_tokens: obs.cache_tail_tokens } : {}),
+                ...(obs.notes_written ? { notes_written: obs.notes_written } : {}),
+                ...(obs.notes_active ? { notes_active: obs.notes_active } : {}),
             };
         case "rollbacked":
             return {

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

@@ -1,5 +1,5 @@
 import type { ModelMessage, RenderedContext, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
-import type { ContextHistoryItemRecord, ContextItemRecord, ContextOriginTally, RollbackReason } from "./session-log.js";
+import type { ContextExternalEdge, ContextExternalItem, ContextHistoryItemRecord, ContextPrefixBreak, ContextItemEdge, ContextItemRecord, ContextOriginTally, RollbackReason } from "./session-log.js";
 interface TaskUpdate {
     plan?: string[];
     currentStep?: number;
@@ -139,6 +139,16 @@ export interface KernelObservation {
     history?: ContextOriginTally[];
     history_items?: ContextHistoryItemRecord[];
     history_items_omitted?: number;
+    edges?: ContextItemEdge[];
+    edges_omitted?: number;
+    waste_items?: number[];
+    external_edges?: ContextExternalEdge[];
+    parent_items_used?: ContextExternalItem[];
+    prefix_breaks?: ContextPrefixBreak[];
+    prefix_breaks_omitted?: number;
+    cache_tail_tokens?: number;
+    notes_written?: number;
+    notes_active?: number;
     archived_count?: number;
     turn?: number;
     checkpoint_history_len?: number;

package/dist/runtime/runner.js

@@ -766,6 +766,7 @@ export class RuntimeRunner {
                     ...(entry.key ? { key: entry.key } : {}),
                     tokens: entry.tokens ?? Math.max(1, Math.ceil(entry.content.length / 4)),
                     ...(entry.pinned ? { pinned: true } : {}),
+                    ...(entry.inherited_from ? { inherited_from: entry.inherited_from } : {}),
                 });
             }
             if (this.opts.initialMemory) {

package/dist/runtime/session-event-registry.generated.d.ts

@@ -77,7 +77,7 @@ export declare const SESSION_EVENT_REGISTRY: {
     };
     readonly context_lifecycle_reported: {
         readonly required: readonly ["cache_loss_tokens", "knowledge_entries", "knowledge_referenced", "recall_expanded", "recalled", "regret", "turn", "waste_tokens"];
-        readonly optional: readonly ["history", "history_items", "history_items_omitted", "items"];
+        readonly optional: readonly ["cache_tail_tokens", "edges", "edges_omitted", "external_edges", "history", "history_items", "history_items_omitted", "items", "notes_active", "notes_written", "parent_items_used", "prefix_breaks", "prefix_breaks_omitted", "waste_items"];
     };
     readonly suspended: {
         readonly required: readonly ["reason", "turn"];

package/dist/runtime/session-event-registry.generated.js

@@ -21,7 +21,7 @@ export const SESSION_EVENT_REGISTRY = {
     rollbacked: { required: ["checkpoint_history_len", "turn"], optional: ["reason"] },
     capability_changed: { required: ["added", "removed", "turn"], optional: ["capability_id", "change_kind", "mount_reason", "mounted_by", "version"] },
     context_renewed: { required: ["handoff_ref", "sprint", "turn"], optional: [] },
-    context_lifecycle_reported: { required: ["cache_loss_tokens", "knowledge_entries", "knowledge_referenced", "recall_expanded", "recalled", "regret", "turn", "waste_tokens"], optional: ["history", "history_items", "history_items_omitted", "items"] },
+    context_lifecycle_reported: { required: ["cache_loss_tokens", "knowledge_entries", "knowledge_referenced", "recall_expanded", "recalled", "regret", "turn", "waste_tokens"], optional: ["cache_tail_tokens", "edges", "edges_omitted", "external_edges", "history", "history_items", "history_items_omitted", "items", "notes_active", "notes_written", "parent_items_used", "prefix_breaks", "prefix_breaks_omitted", "waste_items"] },
     suspended: { required: ["reason", "turn"], optional: ["pending_calls"] },
     resumed: { required: ["turn"], optional: ["approved", "denied"] },
     tool_gated: { required: ["call_id", "reason", "tool", "turn"], optional: [] },

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

@@ -53,14 +53,18 @@ export interface ContextOriginTally {
 }
 /** One knowledge item's lifecycle in a `context_lifecycle_reported` event (plan task 4.1). */
 export interface ContextItemRecord {
+    /** The item's id, shared with history items and item-graph edges. */
+    id?: number;
     key?: string;
-    origin: "system" | "skill" | "memory_recall" | "reference" | "blackboard" | "tool_result" | "dependency_output" | "user" | "assistant" | "task_state" | "signal" | "provider_summary";
+    origin: "system" | "skill" | "memory_recall" | "reference" | "blackboard" | "tool_result" | "dependency_output" | "user" | "assistant" | "task_state" | "signal" | "provider_summary" | "note";
     tokens: number;
     value: {
         injected_turn: number;
         ref_count: number;
         last_referenced_step?: number;
         last_referenced_turn?: number;
+        strong_refs?: number;
+        lexical_refs?: number;
         expanded?: boolean;
         paged_in_after_evict?: boolean;
     };
@@ -68,6 +72,35 @@ export interface ContextItemRecord {
     end?: "evicted" | "expired" | "removed" | "compacted" | "renewed";
 }
 /** One history item's lifecycle in a `context_lifecycle_reported` event (plan task 4.1). */
+/** One directed edge of the item graph: `from` answers, references, reads back or summarizes `to`. */
+export interface ContextItemEdge {
+    from: number;
+    to: number;
+    relation: "answers" | "references_strong" | "references_lexical" | "reads_back" | "summarizes" | "expands" | "derived_from" | "links_to" | "supersedes";
+    turn: number;
+}
+/** An item of another run: a parent operation's item, or a workflow dependency's output. */
+export interface ContextExternalItem {
+    operation?: string;
+    agent?: string;
+    item?: number;
+}
+/** Plan task 8.0 · where a provider request broke the previous request's cacheable prefix. */
+export interface ContextPrefixBreak {
+    turn: number;
+    cause: "toolset" | "system" | "promotion" | "collapse" | "reprojection" | "narration" | "budget_drop" | "snip" | "micro" | "auto" | "renewal" | "provider" | "other";
+    /** Prefix tokens of the previous request still cacheable. */
+    kept_tokens: number;
+    /** Prefix tokens of the previous request after the break: sent uncached again. */
+    lost_tokens: number;
+}
+/** An edge from an item of this run to an item of another run. */
+export interface ContextExternalEdge {
+    from: number;
+    to: ContextExternalItem;
+    relation: "inherited_from" | "depends_on";
+    turn: number;
+}
 export interface ContextHistoryItemRecord {
     id: number;
     origin: ContextItemRecord["origin"];
@@ -216,6 +249,23 @@ export type SessionEvent = {
     /** The latest history items one by one (at most 128); older ones are only counted. */
     history_items?: ContextHistoryItemRecord[];
     history_items_omitted?: number;
+    /** The item graph: resident edges, then the latest edges touching an item that left. */
+    edges?: ContextItemEdge[];
+    edges_omitted?: number;
+    /** Knowledge item ids nothing referenced or read back. */
+    waste_items?: number[];
+    /** Edges to items of other runs: inherited copies and dependency reads. */
+    external_edges?: ContextExternalEdge[];
+    /** The parent run's items whose inherited copies this run used. */
+    parent_items_used?: ContextExternalItem[];
+    /** Plan task 8.0 · the latest prefix breaks between provider requests (`cache_loss_tokens` sums every break); older ones are only counted. */
+    prefix_breaks?: ContextPrefixBreak[];
+    prefix_breaks_omitted?: number;
+    /** State-turn tokens of every request a later one followed: never reusable, so not a break, but part of a provider's uncached input count. */
+    cache_tail_tokens?: number;
+    /** Plan task 9.1 · notes the model wrote (rewrites count again) and notes it holds now. */
+    notes_written?: number;
+    notes_active?: number;
 } | {
     kind: "suspended";
     turn: number;

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

@@ -214,6 +214,12 @@ export interface InheritedKnowledge {
     key?: string;
     tokens?: number;
     pinned?: boolean;
+    /** Plan task 7.4 · the parent run's item this is a copy of; reported as an `inherited_from` edge. */
+    inherited_from?: {
+        operation?: string;
+        agent?: string;
+        item?: number;
+    };
 }
 /** Per-node spawn descriptor carried in the `workflow_batch_spawned` observation. */
 export interface WorkflowSpawnInfo {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.80",
+  "version": "0.2.82",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -14,10 +14,10 @@
     "build:wasm": "wasm-pack build ../crates/deepstrike-wasm --target bundler --out-dir ../../wasm/pkg",
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
-    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs && npm run build && node tests/boundary-p0-regressions.node.mjs && node tests/boundary-p1-regressions.node.mjs && node tests/boundary-p2-regressions.node.mjs && node tests/memory-candidate-binding.node.mjs && node tests/memory-recall-renewal.node.mjs && node tests/dynamic-workflow.node.mjs"
+    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs && npm run build && node tests/boundary-p0-regressions.node.mjs && node tests/boundary-p1-regressions.node.mjs && node tests/boundary-p2-regressions.node.mjs && node tests/memory-candidate-binding.node.mjs && node tests/memory-recall-renewal.node.mjs && node tests/dynamic-workflow.node.mjs && node tests/notes.node.mjs && node tests/notes.node.mjs"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.80"
+    "@deepstrike/wasm-kernel": "0.2.82"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",