@deepstrike/wasm 0.2.74 → 0.2.76

package/dist/runtime/execution-plane.d.ts

@@ -27,6 +27,8 @@ export interface ExecutionPlane {
     schemas(): ToolSchema[];
     executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
 }
+/** A skill file's body without its YAML frontmatter. */
+export declare function stripSkillFrontmatter(content: string): string;
 export declare class LocalExecutionPlane implements ExecutionPlane {
     private tools;
     register(...tools: RegisteredTool[]): this;

package/dist/runtime/execution-plane.js

@@ -1,5 +1,7 @@
 import { formatToolError } from "../tools/errors.js";
-function stripFrontmatter(content) {
+import { parseToolCallArguments } from "./tool-arguments.js";
+/** A skill file's body without its YAML frontmatter. */
+export function stripSkillFrontmatter(content) {
     const s = content.trimStart();
     if (!s.startsWith("---"))
         return s;
@@ -31,7 +33,7 @@ export class LocalExecutionPlane {
             const args = tryParseJson(c.arguments);
             const name = String(args?.name ?? "");
             const raw = ctx.skillContentMap?.get(name);
-            const content = raw != null ? stripFrontmatter(raw) : null;
+            const content = raw != null ? stripSkillFrontmatter(raw) : null;
             yield {
                 type: "tool_result",
                 callId: c.id,
@@ -81,7 +83,12 @@ export class LocalExecutionPlane {
                 },
             };
             try {
-                const args = JSON.parse(call.arguments || "{}");
+                const parsedArgs = parseToolCallArguments(call.arguments);
+                if (!parsedArgs.ok) {
+                    yield { type: "tool_result", callId: call.id, name: call.name, content: `invalid arguments: ${parsedArgs.error}`, isError: true };
+                    continue;
+                }
+                const args = parsedArgs.args;
                 // M3/G4: pass the run context (incl. `cwd`, `audit`) for tool-ABI parity with Node/Python.
                 const output = await registered.execute(args, callCtx);
                 for (const f of auditFailures) {

package/dist/runtime/kernel-step.js

@@ -1,3 +1,4 @@
+import { toolArgumentsFromWire, toolArgumentsToWire } from "./tool-arguments.js";
 export const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
 /**
  * Browser/worker-safe transport for typed content. `btoa` and `atob` operate on
@@ -82,7 +83,7 @@ export function messageToKernelMessage(message) {
         tool_calls: (message.toolCalls ?? []).map(tc => ({
             id: tc.id,
             name: tc.name,
-            arguments: tryParseJson(tc.arguments) ?? {},
+            arguments: toolArgumentsToWire(tc.arguments),
         })),
     };
     // Multimodal: serialize typed content parts to the kernel `Content::Parts` shape when present
@@ -164,10 +165,11 @@ export function kernelMessageToSdk(raw) {
                     .map(part => String(part.text ?? ""))
                     .join("")
                 : "",
+        // The canonical ProviderMessage names a call `call_id`; `id` is the legacy SDK spelling.
         toolCalls: (raw.tool_calls ?? []).map(tc => ({
-            id: String(tc.id ?? ""),
+            id: String(tc.call_id ?? tc.id ?? ""),
             name: String(tc.name ?? ""),
-            arguments: JSON.stringify(tc.arguments ?? {}),
+            arguments: toolArgumentsFromWire(tc.arguments),
         })),
     };
     if (typeof content === "string") {
@@ -209,6 +211,15 @@ export function kernelMessageToSdk(raw) {
             message.contentParts = contentParts;
         }
     }
+    // A tool message the kernel paired through `tool_call_id` is a structural tool result.
+    if (!message.contentParts && typeof raw.tool_call_id === "string") {
+        message.contentParts = [{
+                type: "tool_result",
+                callId: raw.tool_call_id,
+                output: message.content,
+                isError: raw.is_error === true,
+            }];
+    }
     return message;
 }
 export function renderedContextToSdk(raw) {

package/dist/runtime/replay-provider.js

@@ -23,6 +23,7 @@
  * Tokenizer: by default a `chars/4` estimator (±20% for English; worse for code/JSON). For tighter
  * numbers plug `opts.tokenizer = tiktokenEncoder` or similar.
  */
+import { malformedToolArguments } from "./tool-arguments.js";
 const DEFAULT_DESCRIPTOR = {
     provider: "replay",
     protocol: "openai-chat",
@@ -92,10 +93,10 @@ export class ReplayProvider {
                 args = JSON.parse(tc.arguments || "{}");
             }
             catch {
-                // Malformed recorded arguments — pass an empty object. The runner's downstream tool
-                // execution will surface the error if the tool needs them.
+                // Malformed recorded arguments: `rawArguments` carries the text so the replayed call
+                // fails as invalid, exactly as the recorded one did.
             }
-            const call = { type: "tool_call", id: tc.id, name: tc.name, arguments: args };
+            const call = { type: "tool_call", id: tc.id, name: tc.name, arguments: args, ...malformedToolArguments(tc.arguments) };
             yield call;
         }
     }

package/dist/runtime/runner.d.ts

@@ -5,7 +5,7 @@ import type { KnowledgeSource } from "../knowledge/index.js";
 import type { SignalSource, RuntimeSignal } from "../signals/index.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { ExecutionPlane } from "./execution-plane.js";
-import { type GovernancePolicy } from "../governance.js";
+import { type GovernancePolicy, type LivePolicyPatch } from "../governance.js";
 import type { KernelJournal } from "./kernel-journal.js";
 import type { AgentRunSpec, MilestonePolicy, MilestoneContract, MilestoneCheckResult, WorkflowSpec, WorkflowOutcome } from "./types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
@@ -57,6 +57,8 @@ export interface MemoryPolicy {
     validationEnabled?: boolean;
     maxContentBytes?: number;
     maxNameLength?: number;
+    /** M4: recall count at which the kernel suggests promoting a record. Omitted = no suggestions. */
+    promotionRecallThreshold?: number;
 }
 export interface KernelReliabilityOptions {
     providerRecoveryAttempts?: number;
@@ -64,6 +66,16 @@ export interface KernelReliabilityOptions {
     /** Max canonical JSON bytes accepted for one kernel input, 256..64MiB. */
     maxInputBytes?: number;
 }
+interface InboundSignalDelivery {
+    signalId: string;
+    deliveryId: string;
+    deliveryAttempt: number;
+    signal: RuntimeSignal;
+    /** A host note (`injectNote`): delivered as a plain-text payload the model reads verbatim. */
+    note?: string;
+    ack(): Promise<boolean>;
+    nack(): Promise<boolean>;
+}
 export interface ArchiveStore {
     write(sessionId: string, startSeq: number, messages: ModelMessage[]): Promise<string | undefined>;
     read?(archiveRef: string): Promise<ModelMessage[]>;
@@ -275,6 +287,9 @@ export declare class RuntimeRunner {
     private fallbackPayloadStore;
     /** O2 (system-reminder channel): host-pushed notes awaiting the next turn-boundary drain. */
     private injectedSignals;
+    /** Host control commands queued by the public control methods; the main loop applies them
+     *  between effects so a command that publishes an effect never races an in-flight one. */
+    private pendingControl;
     /** Skill names whose content has already been pushed into the durable `knowledge` slot this
      *  run — guards against re-pushing a duplicate entry if the model calls `skill(name)` again for
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
@@ -338,8 +353,22 @@ export declare class RuntimeRunner {
         }>;
     }): AsyncIterable<StreamEvent>;
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    writeMemory(memory: MemoryRecord, sessionId?: string): Promise<void>;
-    private appendMemorySyscallObservations;
+    /**
+     * §22.13 · a host-authored memory write. The kernel decides whether it may happen: a live
+     * operation answers through `admit_memory_write` (the model's validation rule and rolling write
+     * quota); with no live operation the same kernel rule answers statelessly. Resolves `true` when
+     * the record was persisted.
+     */
+    writeMemory(memory: MemoryRecord, sessionId?: string): Promise<boolean>;
+    private admitMemoryWrite;
+    /** The run's memory policy as the kernel's canonical wire carries it. */
+    private kernelMemoryPolicyWire;
+    /**
+     * M3/M4 · a host-initiated recall (prefetch). The store reports the counts it holds; the kernel
+     * derives the next counts and the promotion edge, and the host only mirrors them — the same
+     * derivation a model `query_memory` resolution journals as `memory_recalled`.
+     */
+    private recordHostMemoryRecall;
     /** Push content into Slot 2 (system_knowledge) via add_knowledge_message.
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
      *  compaction/renewal boundary) instead of appending a duplicate. `opts.pinned` exempts the
@@ -354,6 +383,22 @@ export declare class RuntimeRunner {
     removeKnowledge(key: string): Promise<void>;
     /** K3: host-driven skill deactivation — toolset re-widens at the next provider call, the
      *  skill's knowledge pin drops at the next boundary. Errs-open: not-active is a no-op. */
+    /** §13.2 live policy patch (signal / governance / resource quota / recovery), guarded by the
+     *  policy revision. Mirrors Node: the runtime tracks the committed revision; after a restore
+     *  `expectedRevision` must be given. Rejects when the kernel refuses the patch. */
+    applyPolicyPatch(patch: LivePolicyPatch, opts?: {
+        expectedRevision?: number;
+    }): Promise<void>;
+    /** Move the operation's absolute deadline (epoch ms), or clear it with `null`. */
+    updateDeadline(deadlineMs: number | null): Promise<void>;
+    /** Ask the kernel to compact context now; any archive it owes runs as a normal page-out effect. */
+    forceCompact(): Promise<void>;
+    /** Host-driven skill activation, admitted by the kernel against the operation's skill catalog. */
+    activateSkill(name: string, opts?: {
+        leaseTurns?: number;
+    }): Promise<void>;
+    private enqueueControl;
+    private rejectPendingControl;
     deactivateSkill(name: string): Promise<void>;
     private resolveKernelSuspend;
     private execute;
@@ -418,3 +463,10 @@ export declare function replayMessages(events: Array<{
     event: SessionEvent;
 }>, maxBytes?: number, archiveStore?: ArchiveStore): Promise<ModelMessage[]>;
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;
+/** Lower a claimed signal delivery straight into the kernel's `LogicalSignal` vocabulary. Shared by
+ *  the main loop's per-turn poll and #2-B-ii's workflow-batch preemption monitor (so the two never
+ *  drift). `signalType` / `coalesceKey` / `coalescedCount` are signal-source concepts the canonical
+ *  wire deliberately does not carry (§5n); the absolute `deadlineMs` becomes the duration the kernel
+ *  anchors to its own accepted time. */
+export declare function signalToKernelEvent(delivery: InboundSignalDelivery | (Omit<InboundSignalDelivery, "ack" | "nack">), nowMs?: number): Record<string, unknown>;
+export {};