@deepstrike/wasm 0.2.5 → 0.2.6

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,5 +1,5 @@
-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";

package/dist/index.js

@@ -1,4 +1,4 @@
-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 { Governance } from "./governance.js";

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,13 @@ 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 ?? "",
+            });
         default:
             return null;
     }

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

@@ -91,6 +91,8 @@ export interface KernelObservation {
     query_context?: string;
     requested_k?: number;
     requires_async_response?: boolean;
+    /** memory_validation_failed (Phase 7). */
+    error?: 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/runner.d.ts

@@ -8,7 +8,37 @@ 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 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;

package/dist/runtime/runner.js

@@ -8,7 +8,7 @@ import { forceCompact, kernelAction, kernelApply, kernelMaybeAction, messageToKe
 import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, } 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);

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

@@ -225,6 +225,13 @@ 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: "run_terminal";
     reason: string;

package/package.json

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