@deepstrike/wasm 0.2.5 → 0.2.7

package/README.md

@@ -39,6 +39,11 @@ const runner = new RuntimeRunner({
   executionPlane: plane,
   maxTokens: 32_000,
   maxTurns: 10,
+  resourceQuota: {
+    maxConcurrentSubagents: 4,
+    maxSpawnDepth: 2,
+    memoryWritesPerWindow: { maxWrites: 20, windowMs: 60_000 },
+  },
 })
 
 const answer = await collectText(runner.run({ sessionId: "demo", goal: "What is 2 + 3?" }))
@@ -90,6 +95,8 @@ The kernel (`@deepstrike/wasm-kernel`, Rust/wasm-bindgen) owns:
 
 The WASM SDK ships **no `readFile` built-in**. Tools must be pure JS / serializable data. Skills use `skillContentMap` on `RuntimeOptions` (no filesystem).
 
+`resourceQuota` is supported in the runner and maps to the kernel `set_resource_quota` event during run setup. The write-rate quota is enforced for kernel memory-write syscalls; WASM does not yet expose runner-level `writeMemory` / `queryMemory` helpers.
+
 ---
 
 ## Providers

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, } from "./runtime/index.js";
-export type { RuntimeOptions, SessionEvent, SessionLog, RunContext, ExecutionPlane, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } from "./runtime/index.js";
+export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, SchedulerBudget, SessionEvent, SessionLog, RunContext, ExecutionPlane, } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
-export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, } from "./runtime/types/agent.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";

package/dist/index.js

@@ -1,6 +1,7 @@
-export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
+export { workflowSpecToKernel, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
 export { Governance } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";

package/dist/providers/anthropic.d.ts

@@ -1,10 +1,11 @@
-import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message, ProviderReplay } from "../types.js";
+import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message, ProviderDescriptor, ProviderReplay } from "../types.js";
 export declare class AnthropicProvider implements LLMProvider {
     private readonly apiKey;
     private readonly model;
     private readonly maxTokens;
     private nativeAssistantBlocks;
     constructor(apiKey: string, model?: string, maxTokens?: number);
+    descriptor(): ProviderDescriptor;
     peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;

package/dist/providers/anthropic.js

@@ -17,6 +17,22 @@ export class AnthropicProvider {
         this.model = model;
         this.maxTokens = maxTokens;
     }
+    descriptor() {
+        return {
+            provider: "anthropic",
+            protocol: "anthropic-messages",
+            model: this.model,
+            reasoning: {
+                supported: true,
+                preserveAcrossToolTurns: true,
+                requiresReplayForToolTurns: true,
+            },
+            toolCalls: {
+                supported: true,
+                requiresStrictPairing: true,
+            },
+        };
+    }
     peekProviderReplay(message) {
         const blocks = this.nativeAssistantBlocks.get(assistantReplayKey(message));
         return blocks?.length ? { native_blocks: blocks } : undefined;
@@ -24,7 +40,13 @@ export class AnthropicProvider {
     seedProviderReplay(message, replay) {
         if (replay.native_blocks?.length) {
             this.nativeAssistantBlocks.set(assistantReplayKey(message), replay.native_blocks);
+            return;
         }
+        // Legacy log without persisted native blocks: reconstruct neutral
+        // text + tool_use blocks so a tool-use turn can be replayed.
+        const blocks = reconstructAnthropicBlocks(message);
+        if (blocks.length)
+            this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
     async complete(context, tools, extensions) {
         return collectStreamMessage(this.stream(context, tools, extensions));
@@ -154,3 +176,26 @@ export class AnthropicProvider {
         this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
 }
+/**
+ * Reconstruct Anthropic assistant content blocks from a neutral transcript when
+ * no provider replay was persisted. Only meaningful for tool-use turns.
+ */
+function reconstructAnthropicBlocks(message) {
+    const toolCalls = message.toolCalls ?? [];
+    if (!toolCalls.length)
+        return [];
+    const blocks = [];
+    if (message.content)
+        blocks.push({ type: "text", text: message.content });
+    for (const tc of toolCalls) {
+        let input = {};
+        try {
+            input = JSON.parse(tc.arguments || "{}");
+        }
+        catch {
+            input = {};
+        }
+        blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input });
+    }
+    return blocks;
+}

package/dist/runtime/index.d.ts

@@ -2,6 +2,8 @@ export type { SessionEvent, SessionLog } from "./session-log.js";
 export { InMemorySessionLog } from "./session-log.js";
 export type { RunContext, ExecutionPlane } from "./execution-plane.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
-export type { RuntimeOptions } from "./runner.js";
+export type { MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, SchedulerBudget } from "./runner.js";
 export { RuntimeRunner, collectText } from "./runner.js";
 export { getKernel } from "./kernel.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";

package/dist/runtime/index.js

@@ -2,3 +2,4 @@ export { InMemorySessionLog } from "./session-log.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
 export { RuntimeRunner, collectText } from "./runner.js";
 export { getKernel } from "./kernel.js";
+export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } from "./os-profile.js";

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

@@ -12,6 +12,7 @@ export function categoryForKind(kind) {
         case "large_result_spooled":
         case "memory_written":
         case "memory_queried":
+        case "memory_validation_failed":
             return "mm";
         case "agent_process_changed":
             return "proc";
@@ -190,6 +191,33 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 requested_k: obs.requested_k ?? 0,
                 requires_async_response: obs.requires_async_response ?? false,
             });
+        case "memory_validation_failed":
+            return withCategory({
+                kind: "memory_validation_failed",
+                turn: t,
+                memory_id: obs.memory_id ?? "",
+                error: obs.error ?? "",
+            });
+        case "workflow_batch_spawned": {
+            const nodes = obs.nodes ?? [];
+            return withCategory({
+                kind: "workflow_batch_spawned",
+                turn: t,
+                node_count: nodes.length,
+                node_ids: nodes.map((n) => n.agent_id ?? ""),
+            });
+        }
+        case "workflow_completed": {
+            const completed = obs.completed ?? [];
+            const failed = obs.failed ?? [];
+            return withCategory({
+                kind: "workflow_completed",
+                turn: t,
+                completed,
+                failed,
+                total_nodes: completed.length + failed.length,
+            });
+        }
         default:
             return null;
     }

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

@@ -91,6 +91,18 @@ export interface KernelObservation {
     query_context?: string;
     requested_k?: number;
     requires_async_response?: boolean;
+    /** memory_validation_failed (Phase 7). */
+    error?: string;
+    nodes?: Array<{
+        agent_id: string;
+        goal: string;
+        role: string;
+        isolation: string;
+        context_inheritance: string;
+        model_hint?: string;
+    }>;
+    completed?: string[];
+    failed?: string[];
 }
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;

package/dist/runtime/os-profile.d.ts

@@ -1,7 +1,30 @@
 import type { GovernancePolicy } from "../governance.js";
+export type OsProfileId = "native";
+export interface NativeOsProfile {
+    id: OsProfileId;
+    attentionPolicy: {
+        maxQueueSize?: number;
+    };
+    governancePolicy: GovernancePolicy;
+}
 /** Default attention policy for native profile smoke tests. */
 export declare const DEFAULT_NATIVE_ATTENTION_POLICY: {
     maxQueueSize: number;
 };
 /** Permissive governance policy for native runs that do not need AskUser. */
 export declare const DEFAULT_NATIVE_GOVERNANCE_POLICY: GovernancePolicy;
+/** Default restrictive sandbox policy template requiring confirmation for modification/execution. */
+export declare const DEFAULT_SANDBOX_POLICY: GovernancePolicy;
+/** Resolve a named OS profile into concrete kernel-owned policy defaults. */
+export declare function osProfile(profile?: OsProfileId | NativeOsProfile): NativeOsProfile;
+/** Assert that a runtime is using a valid native microkernel policy profile. */
+export declare function assertNativeProfile(profile?: OsProfileId | NativeOsProfile): NativeOsProfile;
+/**
+ * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
+ */
+export declare function validateDeclarativePolicy(govPolicy?: GovernancePolicy, attentionPolicy?: {
+    maxQueueSize?: number;
+}): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/runtime/os-profile.js

@@ -4,3 +4,68 @@ export const DEFAULT_NATIVE_ATTENTION_POLICY = { maxQueueSize: 64 };
 export const DEFAULT_NATIVE_GOVERNANCE_POLICY = {
     rules: [{ pattern: "*", action: "allow" }],
 };
+/** Default restrictive sandbox policy template requiring confirmation for modification/execution. */
+export const DEFAULT_SANDBOX_POLICY = {
+    rules: [
+        { pattern: "read_file", action: "allow" },
+        { pattern: "write_file", action: "ask_user" },
+        { pattern: "run_command", action: "ask_user" },
+        { pattern: "*", action: "deny" },
+    ],
+};
+/** Resolve a named OS profile into concrete kernel-owned policy defaults. */
+export function osProfile(profile = "native") {
+    if (typeof profile !== "string")
+        return profile;
+    if (profile !== "native")
+        throw new Error(`Unsupported OS profile: ${profile}`);
+    return {
+        id: "native",
+        attentionPolicy: DEFAULT_NATIVE_ATTENTION_POLICY,
+        governancePolicy: DEFAULT_NATIVE_GOVERNANCE_POLICY,
+    };
+}
+/** Assert that a runtime is using a valid native microkernel policy profile. */
+export function assertNativeProfile(profile = "native") {
+    const resolved = osProfile(profile);
+    if (resolved.id !== "native") {
+        throw new Error(`Unsupported OS profile: ${resolved.id}`);
+    }
+    const validation = validateDeclarativePolicy(resolved.governancePolicy, resolved.attentionPolicy);
+    if (!validation.valid) {
+        throw new Error(`Invalid native OS profile: ${validation.errors.join("; ")}`);
+    }
+    return resolved;
+}
+/**
+ * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
+ */
+export function validateDeclarativePolicy(govPolicy, attentionPolicy) {
+    const errors = [];
+    if (govPolicy) {
+        if (!Array.isArray(govPolicy.rules)) {
+            errors.push("GovernancePolicy rules must be an array");
+        }
+        else {
+            govPolicy.rules.forEach((rule, idx) => {
+                if (!rule.pattern || typeof rule.pattern !== "string") {
+                    errors.push(`Rule[${idx}] pattern is missing or not a string`);
+                }
+                if (!["allow", "deny", "ask_user"].includes(rule.action)) {
+                    errors.push(`Rule[${idx}] action '${rule.action}' is invalid. Allowed: allow, deny, ask_user`);
+                }
+            });
+        }
+    }
+    if (attentionPolicy) {
+        if (attentionPolicy.maxQueueSize !== undefined) {
+            if (typeof attentionPolicy.maxQueueSize !== "number" || attentionPolicy.maxQueueSize <= 0) {
+                errors.push("AttentionPolicy maxQueueSize must be a positive integer");
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/runtime/provider-replay.d.ts

@@ -1,6 +1,12 @@
-import type { LLMProvider, Message, ProviderReplay, ToolCall } from "../types.js";
+import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 export declare function assistantReplayKey(message: Pick<Message, "content" | "toolCalls">): string;
+/**
+ * A stored replay may only be seeded into a provider speaking the same wire
+ * protocol; on a cross-protocol fallback the incompatible envelope is skipped so
+ * the new provider re-serializes neutral context instead.
+ */
+export declare function isReplayCompatibleWithProvider(replay: ProviderReplay, descriptor: ProviderDescriptor | undefined): boolean;
 export declare function seedProviderReplayFromEvents(provider: LLMProvider, events: Array<{
     event: SessionEvent;
 }>): void;

package/dist/runtime/provider-replay.js

@@ -1,21 +1,46 @@
-import { effectiveProviderReplay } from "./session-repair.js";
 export function assistantReplayKey(message) {
     return JSON.stringify({
         content: message.content,
         toolCalls: message.toolCalls ?? [],
     });
 }
+/** Infer the wire protocol a stored replay envelope belongs to (explicit, or by shape for legacy logs). */
+function replayProtocol(replay) {
+    if (replay.protocol)
+        return replay.protocol;
+    if (replay.native_blocks?.length)
+        return "anthropic-messages";
+    if (replay.reasoning_content != null || replay.reasoning_details !== undefined)
+        return "openai-chat";
+    return undefined;
+}
+/**
+ * A stored replay may only be seeded into a provider speaking the same wire
+ * protocol; on a cross-protocol fallback the incompatible envelope is skipped so
+ * the new provider re-serializes neutral context instead.
+ */
+export function isReplayCompatibleWithProvider(replay, descriptor) {
+    if (!descriptor)
+        return true;
+    const protocol = replayProtocol(replay);
+    if (!protocol)
+        return true;
+    return protocol === descriptor.protocol;
+}
 export function seedProviderReplayFromEvents(provider, events) {
     if (!provider.seedProviderReplay)
         return;
+    const descriptor = provider.descriptor?.();
     for (const { event } of events) {
         if (event.kind !== "llm_completed")
             continue;
         const toolCalls = event.tool_calls ?? [];
-        const replay = effectiveProviderReplay(event.content, toolCalls, event.provider_replay);
-        if (!replay)
+        const stored = event.provider_replay;
+        if (stored && !isReplayCompatibleWithProvider(stored, descriptor))
             continue;
-        provider.seedProviderReplay({ content: event.content, toolCalls }, replay);
+        // Pass the message even with no persisted replay: a provider may reconstruct
+        // a legacy replay (e.g. Anthropic native_blocks) from the neutral transcript.
+        provider.seedProviderReplay({ content: event.content, toolCalls }, stored ?? {});
     }
 }
 export function peekProviderReplay(provider, content, toolCalls) {

package/dist/runtime/runner.d.ts

@@ -6,9 +6,39 @@ import type { SignalSource } 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 { AgentRunSpec, SubAgentResult, MilestonePolicy, MilestoneContract, MilestoneCheckResult } from "./types/agent.js";
+import type { AgentRunSpec, SubAgentResult, MilestonePolicy, MilestoneContract, MilestoneCheckResult, WorkflowSpec } from "./types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
+import { type NativeOsProfile, type OsProfileId } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
+export interface MemoryWriteRateLimit {
+    maxWrites: number;
+    windowMs: number;
+}
+export interface ResourceQuota {
+    /** Max sub-agents in the `running` state at once; further spawns are denied while at cap. */
+    maxConcurrentSubagents?: number;
+    /** Max sub-agent nesting depth (direct children of the root loop are depth 1). */
+    maxSpawnDepth?: number;
+    /** Rolling-window memory-write rate limit: at most `maxWrites` per any `windowMs` span. */
+    memoryWritesPerWindow?: MemoryWriteRateLimit;
+}
+export interface SchedulerBudget {
+    maxWallMs?: number;
+}
+/**
+ * Long-term memory policy (`set_memory_policy`) — opt-in, kernel-enforced. `validationEnabled:
+ * false` admits writes without validation, `maxContentBytes` / `maxNameLength` override the
+ * validation limits, and `retrievalTopK` caps `query_memory` breadth. `memoryPath` /
+ * `staleWarningDays` are carried for SDK recall I/O. Omitted fields keep the kernel defaults.
+ */
+export interface MemoryPolicy {
+    memoryPath?: string;
+    staleWarningDays?: number;
+    retrievalTopK?: number;
+    validationEnabled?: boolean;
+    maxContentBytes?: number;
+    maxNameLength?: number;
+}
 export interface RuntimeOptions {
     provider: LLMProvider;
     sessionLog: SessionLog;
@@ -25,10 +55,17 @@ export interface RuntimeOptions {
     knowledgeSource?: KnowledgeSource;
     signalSource?: SignalSource;
     extensions?: Record<string, unknown>;
+    /** Named or concrete OS profile. Defaults to the native microkernel profile. */
+    osProfile?: OsProfileId | NativeOsProfile;
     governancePolicy?: GovernancePolicy;
     attentionPolicy?: {
         maxQueueSize?: number;
     };
+    schedulerBudget?: SchedulerBudget;
+    resourceQuota?: ResourceQuota;
+    memoryPolicy?: MemoryPolicy;
+    tokenizer?: string;
+    enablePlanTool?: boolean;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
     subAgentOrchestrator?: SubAgentOrchestrator;
@@ -76,6 +113,26 @@ export declare class RuntimeRunner {
     dream(agentId: string, nowMs?: number): Promise<DreamResult>;
     private execute;
     spawnSubAgent(spec: AgentRunSpec): Promise<SubAgentResult>;
+    /**
+     * W0-ABI: run a declarative workflow DAG. The kernel owns the DAG and gates every node spawn
+     * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
+     * feeds their results back, and loops until the kernel reports the workflow complete.
+     */
+    runWorkflow(spec: WorkflowSpec, opts?: {
+        resumedCompleted?: string[];
+    }): Promise<{
+        completed: string[];
+        failed: string[];
+    }>;
+    /**
+     * Resume a workflow from the parent session's completed nodes.
+     * Reads the session log, extracts completed workflow node agent_ids, and
+     * calls runWorkflow with resumedCompleted so the kernel skips those nodes.
+     */
+    resumeWorkflow(spec: WorkflowSpec): Promise<{
+        completed: string[];
+        failed: string[];
+    }>;
     private appendObservations;
     private archiveSemanticPageOut;
 }

package/dist/runtime/runner.js

@@ -3,12 +3,12 @@ import { governancePolicyToKernelEvent } from "../governance.js";
 import { getKernel } from "./kernel.js";
 import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 import { sanitizeReplayText } from "./replay-sanitize.js";
-import { buildLlmCompletedEvent, buildRunTerminalEvent, repairEventsForRecovery } from "./session-repair.js";
+import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, recoverCompletedWorkflowNodes, repairEventsForRecovery, } from "./session-repair.js";
 import { forceCompact, kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
-import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, } from "./types/agent.js";
+import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { kernelObservationToSessionEvent, withCategory } from "./kernel-event-log.js";
-import { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY } from "./os-profile.js";
+import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
 export class RuntimeRunner {
     opts;
@@ -259,6 +259,18 @@ export class RuntimeRunner {
             timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
         });
         this.activeKernel = runtime;
+        if (this.opts.tokenizer) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_tokenizer",
+                name: this.opts.tokenizer,
+            });
+        }
+        if (this.opts.enablePlanTool !== undefined) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_plan_tool_enabled",
+                enabled: this.opts.enablePlanTool,
+            });
+        }
         kernelApply(runtime, this.pendingObservations, {
             kind: "set_tools",
             tools: this.opts.executionPlane.schemas().map(toolSchemaToKernel),
@@ -273,7 +285,7 @@ export class RuntimeRunner {
         if (this.opts.initialMemory) {
             for (const mem of this.opts.initialMemory) {
                 kernelApply(runtime, this.pendingObservations, {
-                    kind: "add_memory_message",
+                    kind: "add_knowledge_message",
                     content: mem,
                     tokens: Math.max(1, Math.ceil(mem.length / 4)),
                 });
@@ -327,8 +339,9 @@ export class RuntimeRunner {
         if (this.opts.runSpec) {
             startPayload.run_spec = agentRunSpecToKernel(this.opts.runSpec);
         }
-        const attentionPolicy = this.opts.attentionPolicy ?? DEFAULT_NATIVE_ATTENTION_POLICY;
-        const governancePolicy = this.opts.governancePolicy ?? DEFAULT_NATIVE_GOVERNANCE_POLICY;
+        const osProfile = assertNativeProfile(this.opts.osProfile ?? "native");
+        const attentionPolicy = this.opts.attentionPolicy ?? osProfile.attentionPolicy;
+        const governancePolicy = this.opts.governancePolicy ?? osProfile.governancePolicy;
         kernelApply(runtime, this.pendingObservations, governancePolicyToKernelEvent(governancePolicy));
         kernelApply(runtime, this.pendingObservations, {
             kind: "set_attention_policy",
@@ -336,6 +349,46 @@ export class RuntimeRunner {
                 ? { max_queue_size: attentionPolicy.maxQueueSize }
                 : {}),
         });
+        if (this.opts.schedulerBudget) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_scheduler_budget",
+                ...(this.opts.schedulerBudget.maxWallMs !== undefined
+                    ? { max_wall_ms: this.opts.schedulerBudget.maxWallMs }
+                    : {}),
+            });
+        }
+        if (this.opts.resourceQuota) {
+            const q = this.opts.resourceQuota;
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_resource_quota",
+                quota: {
+                    ...(q.maxConcurrentSubagents !== undefined
+                        ? { max_concurrent_subagents: q.maxConcurrentSubagents }
+                        : {}),
+                    ...(q.maxSpawnDepth !== undefined ? { max_spawn_depth: q.maxSpawnDepth } : {}),
+                    ...(q.memoryWritesPerWindow !== undefined
+                        ? {
+                            memory_writes_per_window: [
+                                q.memoryWritesPerWindow.maxWrites,
+                                q.memoryWritesPerWindow.windowMs,
+                            ],
+                        }
+                        : {}),
+                },
+            });
+        }
+        if (this.opts.memoryPolicy) {
+            const m = this.opts.memoryPolicy;
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_memory_policy",
+                ...(m.memoryPath !== undefined ? { memory_path: m.memoryPath } : {}),
+                ...(m.staleWarningDays !== undefined ? { stale_warning_days: m.staleWarningDays } : {}),
+                ...(m.retrievalTopK !== undefined ? { retrieval_top_k: m.retrievalTopK } : {}),
+                ...(m.validationEnabled !== undefined ? { validation_enabled: m.validationEnabled } : {}),
+                ...(m.maxContentBytes !== undefined ? { max_content_bytes: m.maxContentBytes } : {}),
+                ...(m.maxNameLength !== undefined ? { max_name_length: m.maxNameLength } : {}),
+            });
+        }
         let action = resumeMidRun
             ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
             : kernelAction(runtime, this.pendingObservations, startPayload);
@@ -653,6 +706,68 @@ export class RuntimeRunner {
         });
         return result;
     }
+    /**
+     * W0-ABI: run a declarative workflow DAG. The kernel owns the DAG and gates every node spawn
+     * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
+     * feeds their results back, and loops until the kernel reports the workflow complete.
+     */
+    async runWorkflow(spec, opts) {
+        if (!this.activeKernel || !this.currentSessionId) {
+            throw new Error("runWorkflow requires an active parent run");
+        }
+        const parentSessionId = this.currentSessionId;
+        const runtime = this.activeKernel;
+        const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
+        let observations = kernelApply(runtime, this.pendingObservations, {
+            kind: "load_workflow",
+            spec: workflowSpecToKernel(spec),
+            parent_session_id: parentSessionId,
+            // W0-ABI resume: skip nodes already completed before an interruption.
+            ...(opts?.resumedCompleted && opts.resumedCompleted.length ? { resumed_completed: opts.resumedCompleted } : {}),
+        });
+        for (;;) {
+            const done = observations.find(o => o.kind === "workflow_completed");
+            if (done)
+                return { completed: done.completed ?? [], failed: done.failed ?? [] };
+            const batch = observations.find(o => o.kind === "workflow_batch_spawned");
+            const nodes = batch?.nodes ?? [];
+            if (nodes.length === 0)
+                return { completed: [], failed: [] };
+            const results = await Promise.all(nodes.map(node => orchestrator.run({
+                parentOpts: this.opts,
+                parentSessionId,
+                spec: workflowNodeToSpec(node, parentSessionId),
+                manifest: workflowNodeToManifest(node, parentSessionId),
+                sessionLog: this.opts.sessionLog,
+            })));
+            observations = [];
+            for (const result of results) {
+                observations = kernelApply(runtime, this.pendingObservations, {
+                    kind: "sub_agent_completed",
+                    result: subAgentResultToKernel(result),
+                });
+                // Persist node completion for resume recovery.
+                await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodeCompletedEvent({
+                    turn: runtime.turn(),
+                    agentId: result.agentId,
+                    termination: result.result.termination,
+                }));
+            }
+        }
+    }
+    /**
+     * Resume a workflow from the parent session's completed nodes.
+     * Reads the session log, extracts completed workflow node agent_ids, and
+     * calls runWorkflow with resumedCompleted so the kernel skips those nodes.
+     */
+    async resumeWorkflow(spec) {
+        if (!this.currentSessionId) {
+            throw new Error("resumeWorkflow requires an active parent run");
+        }
+        const events = await this.opts.sessionLog.read(this.currentSessionId);
+        const resumedCompleted = recoverCompletedWorkflowNodes(events);
+        return this.runWorkflow(spec, { resumedCompleted });
+    }
     async appendObservations(sessionId, runtime, nextArchiveStart) {
         const turn = runtime.turn();
         const preservedRefs = runtime.preservedRefs();

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

@@ -225,6 +225,35 @@ export type SessionEvent = {
     query_context: string;
     requested_k: number;
     requires_async_response: boolean;
+} | {
+    kind: "memory_validation_failed";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    memory_id: string;
+    error: string;
+} | {
+    kind: "workflow_node_completed";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    agent_id: string;
+    termination: string;
+} | {
+    kind: "workflow_batch_spawned";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    node_count: number;
+    node_ids: string[];
+} | {
+    kind: "workflow_completed";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    completed: string[];
+    failed: string[];
+    total_nodes: number;
 } | {
     kind: "run_terminal";
     reason: string;

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

@@ -1,8 +1,13 @@
 import type { ProviderReplay, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
-export declare function synthesizeProviderReplay(content: string, toolCalls: ToolCall[]): ProviderReplay | undefined;
-export declare function effectiveProviderReplay(content: string, toolCalls: ToolCall[], stored?: ProviderReplay): ProviderReplay | undefined;
+/**
+ * Normalize a persisted llm_completed event for recovery. Content is sanitized
+ * and token_count backfilled, but the stored `provider_replay` envelope is
+ * passed through verbatim — this layer is provider-neutral and never
+ * synthesizes protocol-specific replay shapes. Legacy reconstruction is the
+ * responsibility of the target provider's `seedProviderReplay`.
+ */
 export declare function normalizeLlmCompleted(event: Extract<SessionEvent, {
     kind: "llm_completed";
 }>, maxBytes?: number): Extract<SessionEvent, {
@@ -31,3 +36,19 @@ export declare function buildRunTerminalEvent(input: {
 }): Extract<SessionEvent, {
     kind: "run_terminal";
 }>;
+export declare function buildWorkflowNodeCompletedEvent(input: {
+    turn: number;
+    agentId: string;
+    termination: string;
+}): Extract<SessionEvent, {
+    kind: "workflow_node_completed";
+}>;
+/**
+ * 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.
+ */
+export declare function recoverCompletedWorkflowNodes(events: Array<{
+    seq: number;
+    event: SessionEvent;
+}>): string[];

package/dist/runtime/session-repair.js

@@ -3,40 +3,17 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
 function estimateTokenCount(text) {
     return Math.max(1, Math.ceil(text.length / 4));
 }
-function parseToolInput(args) {
-    try {
-        return JSON.parse(args || "{}");
-    }
-    catch {
-        return {};
-    }
-}
-export function synthesizeProviderReplay(content, toolCalls) {
-    if (!toolCalls.length)
-        return undefined;
-    const blocks = [];
-    if (content)
-        blocks.push({ type: "text", text: content });
-    for (const tc of toolCalls) {
-        blocks.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.name,
-            input: parseToolInput(tc.arguments),
-        });
-    }
-    return { native_blocks: blocks };
-}
-export function effectiveProviderReplay(content, toolCalls, stored) {
-    if (stored?.native_blocks?.length || stored?.reasoning_content != null) {
-        return stored;
-    }
-    return synthesizeProviderReplay(content, toolCalls);
-}
+/**
+ * Normalize a persisted llm_completed event for recovery. Content is sanitized
+ * and token_count backfilled, but the stored `provider_replay` envelope is
+ * passed through verbatim — this layer is provider-neutral and never
+ * synthesizes protocol-specific replay shapes. Legacy reconstruction is the
+ * responsibility of the target provider's `seedProviderReplay`.
+ */
 export function normalizeLlmCompleted(event, maxBytes) {
     const content = sanitizeReplayText(event.content ?? "", maxBytes);
     const toolCalls = event.tool_calls ?? [];
-    const providerReplay = effectiveProviderReplay(content, toolCalls, event.provider_replay);
+    const providerReplay = event.provider_replay;
     return {
         kind: "llm_completed",
         turn: event.turn,
@@ -71,3 +48,25 @@ export function buildRunTerminalEvent(input) {
         total_tokens: Math.max(0, input.totalTokens),
     };
 }
+export function buildWorkflowNodeCompletedEvent(input) {
+    return {
+        kind: "workflow_node_completed",
+        turn: input.turn,
+        agent_id: input.agentId,
+        termination: input.termination,
+    };
+}
+/**
+ * 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.
+ */
+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);
+        }
+    }
+    return completed;
+}

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

@@ -75,3 +75,47 @@ export declare function milestoneCheckResultToKernel(result: MilestoneCheckResul
 export declare function subAgentResultToKernel(result: SubAgentResult): Record<string, unknown>;
 export declare function milestoneCheckPass(phaseId: string): MilestoneCheckResult;
 export declare function milestoneCheckFail(phaseId: string, reason: string): MilestoneCheckResult;
+/** A task for a workflow node: a full object, or a bare goal string. */
+export type WorkflowTaskSpec = {
+    goal: string;
+    criteria?: string[];
+    lane?: string;
+} | string;
+/** One node in a declarative workflow DAG (camelCase host shape). */
+export interface WorkflowNodeSpec {
+    task: WorkflowTaskSpec;
+    role: KernelAgentRole;
+    isolation?: AgentIsolation;
+    contextInheritance?: ContextInheritance;
+    modelHint?: string;
+    /** Indices of nodes this node depends on. */
+    dependsOn?: number[];
+}
+/** A declarative workflow DAG the kernel runs node-by-node, gating each spawn. */
+export interface WorkflowSpec {
+    nodes: WorkflowNodeSpec[];
+}
+/** Per-node spawn descriptor carried in the `workflow_batch_spawned` observation. */
+export interface WorkflowSpawnInfo {
+    agent_id: string;
+    goal: string;
+    role: string;
+    isolation: string;
+    context_inheritance: string;
+    model_hint?: string;
+}
+/** Map a host `WorkflowSpec` to the snake_case kernel JSON (`load_workflow.spec`). */
+export declare function workflowSpecToKernel(spec: WorkflowSpec): Record<string, unknown>;
+/** Build a sub-agent run spec for a kernel-generated workflow node. */
+export declare function workflowNodeToSpec(node: WorkflowSpawnInfo, parentSessionId: string): AgentRunSpec;
+/** Build the host manifest for a kernel-generated workflow node. */
+export declare function workflowNodeToManifest(node: WorkflowSpawnInfo, parentSessionId: string): AgentProcessChangedObservation;
+/** N parallel read-only Explore workers feeding a single Plan synthesizer (barrier). */
+export declare function fanoutSynthesize(workers: WorkflowTaskSpec[], synthesize: WorkflowTaskSpec): WorkflowSpec;
+/** N parallel Implement generators feeding a single Verify filter/dedupe step (barrier). */
+export declare function generateAndFilter(generators: WorkflowTaskSpec[], filter: WorkflowTaskSpec): WorkflowSpec;
+/**
+ * One fresh-context verifier per rule/claim (parallel) + optional skeptic that depends on all and
+ * re-checks flags. Verifiers run read-only with no inherited author context (bias-resistant).
+ */
+export declare function verifyRules(rules: WorkflowTaskSpec[], skeptic?: WorkflowTaskSpec): WorkflowSpec;

package/dist/runtime/types/agent.js

@@ -94,3 +94,111 @@ export function milestoneCheckPass(phaseId) {
 export function milestoneCheckFail(phaseId, reason) {
     return { phaseId, passed: false, reason };
 }
+/** Map a host `WorkflowSpec` to the snake_case kernel JSON (`load_workflow.spec`). */
+export function workflowSpecToKernel(spec) {
+    return {
+        nodes: spec.nodes.map(n => {
+            const task = typeof n.task === "string" ? { goal: n.task } : n.task;
+            return {
+                task: {
+                    goal: task.goal,
+                    // `criteria` is required by the kernel's RuntimeTask serde (no default).
+                    criteria: task.criteria ?? [],
+                    ...(task.lane ? { lane: task.lane } : {}),
+                },
+                role: n.role,
+                isolation: n.isolation ?? "shared",
+                context_inheritance: n.contextInheritance ?? "none",
+                ...(n.modelHint ? { model_hint: n.modelHint } : {}),
+                ...(n.dependsOn && n.dependsOn.length ? { depends_on: n.dependsOn } : {}),
+            };
+        }),
+    };
+}
+/** Build a sub-agent run spec for a kernel-generated workflow node. */
+export function workflowNodeToSpec(node, parentSessionId) {
+    return {
+        identity: {
+            agentId: node.agent_id,
+            sessionId: `${parentSessionId}-${node.agent_id}`,
+            isSubAgent: true,
+            parentSessionId,
+        },
+        role: node.role,
+        isolation: node.isolation,
+        goal: node.goal,
+    };
+}
+/** Build the host manifest for a kernel-generated workflow node. */
+export function workflowNodeToManifest(node, parentSessionId) {
+    return {
+        kind: "agent_process_changed",
+        agent_id: node.agent_id,
+        parent_session_id: parentSessionId,
+        role: node.role,
+        isolation: node.isolation,
+        context_inheritance: node.context_inheritance,
+    };
+}
+// ─── W1/W2 workflow templates (the six patterns as one-liners) ───
+// Roles carry the kernel's role_defaults isolation/inheritance so host-built specs match the
+// core `orchestration::workflow` constructors (e.g. verifiers stay bias-resistant).
+function asTask(t) {
+    return typeof t === "string" ? { goal: t } : t;
+}
+/** N parallel read-only Explore workers feeding a single Plan synthesizer (barrier). */
+export function fanoutSynthesize(workers, synthesize) {
+    const nodes = workers.map(t => ({
+        task: asTask(t),
+        role: "explore",
+        isolation: "read_only",
+        contextInheritance: "system_only",
+    }));
+    nodes.push({
+        task: asTask(synthesize),
+        role: "plan",
+        isolation: "shared",
+        contextInheritance: "full",
+        dependsOn: workers.map((_, i) => i),
+    });
+    return { nodes };
+}
+/** N parallel Implement generators feeding a single Verify filter/dedupe step (barrier). */
+export function generateAndFilter(generators, filter) {
+    const nodes = generators.map(t => ({
+        task: asTask(t),
+        role: "implement",
+        isolation: "worktree",
+        contextInheritance: "full",
+    }));
+    nodes.push({
+        task: asTask(filter),
+        role: "verify",
+        isolation: "read_only",
+        contextInheritance: "none",
+        dependsOn: generators.map((_, i) => i),
+    });
+    return { nodes };
+}
+/**
+ * One fresh-context verifier per rule/claim (parallel) + optional skeptic that depends on all and
+ * re-checks flags. Verifiers run read-only with no inherited author context (bias-resistant).
+ */
+export function verifyRules(rules, skeptic) {
+    const nodes = rules.map(t => ({
+        task: asTask(t),
+        role: "verify",
+        isolation: "read_only",
+        contextInheritance: "none",
+    }));
+    if (skeptic !== undefined) {
+        nodes.push({
+            task: asTask(skeptic),
+            role: "verify",
+            isolation: "read_only",
+            contextInheritance: "none",
+            dependsOn: rules.map((_, i) => i),
+        });
+    }
+    return { nodes };
+}

package/dist/types.d.ts

@@ -112,9 +112,31 @@ export interface ToolArgumentRepairedEvent extends StreamEvent {
  * The framework creates and threads this object; providers may read/write it.
  */
 export type ProviderRunState = Record<string, unknown>;
+export type ProviderProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini";
+export interface ProviderDescriptor {
+    provider: string;
+    protocol: ProviderProtocol;
+    model: string;
+    reasoning: {
+        supported: boolean;
+        preserveAcrossToolTurns: boolean;
+        requiresReplayForToolTurns?: boolean;
+    };
+    toolCalls: {
+        supported: boolean;
+        requiresStrictPairing: boolean;
+    };
+}
 export interface ProviderReplay {
+    schema_version?: 1 | 2;
+    provider?: string;
+    protocol?: ProviderProtocol;
+    model?: string;
     native_blocks?: Array<Record<string, unknown>>;
     reasoning_content?: string;
+    reasoning_details?: unknown;
+    native_message?: unknown;
+    tool_calls?: unknown[];
 }
 export interface LLMProvider {
     createRunState?(): ProviderRunState;
@@ -122,6 +144,7 @@ export interface LLMProvider {
         maxTurns?: number;
         timeoutMs?: number;
     };
+    descriptor?(): ProviderDescriptor;
     peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;

package/package.json

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