@deepstrike/sdk 0.2.27 → 0.2.28

package/README.md

@@ -76,6 +76,51 @@ const reply = await collectText(runner.run({ sessionId: "chat-1", goal: "What is
 
 Use `InMemorySessionLog` for process-local sessions or `FileSessionLog` when replay should survive restarts. `wake(sessionId)` resumes from the event log without inserting a duplicate `run_started` event.
 
+### Recipes — the canonical entry points
+
+The package exports a large surface, but most apps need one of three shapes. Start with the facades and drop down to `RuntimeRunner` only when you need streaming, signals, memory, or governance hooks.
+
+```typescript
+import { runAgent, runFanout } from "@deepstrike/sdk"
+
+// 1) Single agent — one prompt, one model, the text back.
+const answer = await runAgent({ provider, goal: "What is 17 + 28?", tools: [add] })
+
+// 2) Parallel fan-out → synthesize — N workers, then a synthesis pass, over the kernel-gated DAG.
+//    Bootstraps and tears down its own kernel, so it's safe from a stateless request handler.
+const { synthesis } = await runFanout({
+  provider,
+  tasks: [
+    "Summarize the security posture of the auth module",
+    "Summarize the data-retention posture",
+  ],
+  synthesize: "Combine the worker findings into one risk summary.",
+})
+
+// 3) Full control — sub-agents, governance, signals, streaming, resume → use RuntimeRunner directly.
+```
+
+`runFanout` is sugar over the **standalone `runWorkflow`** path: with no active `run()`, `runner.runWorkflow(spec)` auto-bootstraps a kernel that owns the DAG (governed · resumable), drives it, and tears it down — exactly what a Vercel/Lambda handler needs. See [Dynamic workflows](#dynamic-workflows). For parallel work you can also give each worker its own `RuntimeRunner`; `RuntimeRunner` carries per-run state, so **never share one instance across concurrent runs** — use a fresh instance per worker (or the `AgentPool` primitive).
+
+### Deploying to serverless / bundlers
+
+`@deepstrike/core` is a native N-API addon; its platform binary ships via `optionalDependencies`. Bundlers (Next.js/Vercel, webpack, esbuild) don't trace `.node` files by default, so the function fails at runtime with `Cannot find module '@deepstrike/core'`. Tell your bundler to treat the package as external and trace its files:
+
+```ts
+// next.config.ts (Next.js / Vercel)
+const nextConfig = {
+  serverExternalPackages: ["@deepstrike/sdk"],
+  outputFileTracingIncludes: {
+    "/api/**": ["./node_modules/@deepstrike/**/*"],
+  },
+}
+export default nextConfig
+```
+
+- **webpack:** add `@deepstrike/core` (and `@deepstrike/sdk`) to `externals`, or use `node-loader` for `.node` files.
+- **esbuild:** `--external:@deepstrike/core --external:@deepstrike/sdk` and ensure the platform binary is copied next to the bundle.
+- **Docker/standalone:** the build host's platform binary must match the runtime's (e.g. build on `linux-x64-gnu` for Vercel). Alpine images need the `-musl` binary.
+
 Streaming:
 
 ```typescript
@@ -161,9 +206,11 @@ const outcome = await runner.runWorkflow({
     { task: "Skeptic: which flags are real violations?",  role: "verify", dependsOn: [0, 1, 2] },
   ],
 })
-// → { completed: ["wf-node0", … ], failed: [] }
+// → { completed: ["wf-node0", … ], failed: [], outputs: { "wf-node3": "…" } }
 ```
 
+`runWorkflow` works **standalone** — call it on a freshly-constructed runner (e.g. inside a stateless HTTP handler) and it auto-bootstraps a kernel that owns the DAG, drives it under the same governance/quota/attention policies a full `run()` gets, and tears it down on completion. Called *during* a `run()`, it instead drives the workflow on the active kernel. Either way every node's final text comes back in `outputs`, keyed by node agent-id. To resume an interrupted standalone run, pass the prior session id: `runner.resumeWorkflow(spec, { sessionId })`.
+
 A node's `kind` selects the control-flow shape; the same executor drives them all, every spawn passing the syscall gate:
 
 | Node `kind` | Behavior |
@@ -201,7 +248,20 @@ All providers accept `RetryConfig` for exponential backoff and share a `CircuitB
 
 `extensions` are forwarded by every provider in both `complete()` and `stream()` while SDK-owned structural fields such as `model`, `messages`, `tools`, and streaming flags remain protected.
 
-OpenAI can also be selected through the provider catalog:
+**Custom OpenAI-compatible endpoint** (MiMo, DeepSeek, Kimi, Qwen, GLM via their `/v1` base URL): use `OpenAIChatProvider` (alias `OpenAIProvider`) and pass the base URL as the **4th** argument — the 3rd is `RetryConfig`:
+
+```typescript
+import { OpenAIProvider } from "@deepstrike/sdk"
+
+const provider = new OpenAIProvider(
+  apiKey,
+  "mimo-v2.5-pro",
+  { maxRetries: 3, baseDelay: 1000 }, // RetryConfig (pass undefined for defaults)
+  "https://token-plan-cn.xiaomimimo.com/v1",
+)
+```
+
+Prefer a dedicated `*Provider` (e.g. `DeepSeekProvider`, `KimiProvider`) when one exists for your backend — they default the base URL and add backend-specific reasoning handling. OpenAI itself can also be selected through the provider catalog:
 
 ```typescript
 import { createProvider } from "@deepstrike/sdk"

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export { runAgent, runFanout } from "./runtime/facade.js";
+export type { RunAgentOptions, RunFanoutOptions } from "./runtime/facade.js";
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export type { RuntimeOptions, SchedulerBudget } from "./runtime/runner.js";
 export { builtinReducers, resolveReducer } from "./runtime/reducers.js";

package/dist/index.js

@@ -1,3 +1,12 @@
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║ START HERE — the canonical entry points for the common cases.              ║
+// ║   runAgent   → one prompt, one model, the text back.                       ║
+// ║   runFanout  → run N tasks in parallel, then synthesize (kernel-gated DAG).║
+// ║   RuntimeRunner → drop down to this for streaming, tools, signals, memory, ║
+// ║                   governance, and the standalone `runWorkflow` driver.     ║
+// ║ Everything below the providers block is advanced / opt-in surface.         ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+export { runAgent, runFanout } from "./runtime/facade.js";
 // ── Runtime (Layer 1.5) ────────────────────────────────────────────────────
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export { builtinReducers, resolveReducer } from "./runtime/reducers.js";

package/dist/runtime/facade.d.ts

@@ -0,0 +1,49 @@
+import type { ExecutionPlane } from "./execution-plane.js";
+import type { SessionLog } from "./session-log.js";
+import type { LLMProvider } from "../types.js";
+import type { RegisteredTool } from "../tools/index.js";
+import type { WorkflowTaskSpec, KernelAgentRole } from "../types/agent.js";
+/** Shared knobs for the facade entry points. */
+export interface RunAgentOptions {
+    provider: LLMProvider;
+    goal: string;
+    systemPrompt?: string;
+    tools?: RegisteredTool[];
+    sessionId?: string;
+    maxTokens?: number;
+    maxTurns?: number;
+    /** Persist the run (resume / audit). Defaults to an in-memory, throwaway log. */
+    sessionLog?: SessionLog;
+    /** Custom execution plane (tools, sandboxing). Overrides `tools` when both are given. */
+    executionPlane?: ExecutionPlane;
+}
+/**
+ * Run a single agent to completion and return its final text — `RuntimeRunner` + `run` + `collectText`
+ * in one call. Register tools by passing `tools`; everything else has a working default.
+ */
+export declare function runAgent(opts: RunAgentOptions): Promise<string>;
+export interface RunFanoutOptions {
+    provider: LLMProvider;
+    /** One parallel worker per task. A string is shorthand for `{ goal }`. */
+    tasks: WorkflowTaskSpec[];
+    /** Final synthesis prompt; runs once after every worker completes, with their outputs in context. */
+    synthesize: string;
+    /** Role for the parallel workers (default `explore`) and the synthesis node (default `plan`). */
+    workerRole?: KernelAgentRole;
+    synthesisRole?: KernelAgentRole;
+    sessionId?: string;
+    maxTokens?: number;
+    maxTurns?: number;
+    sessionLog?: SessionLog;
+    executionPlane?: ExecutionPlane;
+}
+/**
+ * Parallel fan-out → synthesize, driven by the kernel-gated DAG (the standalone `runWorkflow` path):
+ * each task becomes a fresh-context worker node, and a final synthesis node depends on all of them.
+ * Returns the synthesis text plus every node's raw output. Safe to call from a stateless handler — it
+ * bootstraps and tears down its own kernel.
+ */
+export declare function runFanout(opts: RunFanoutOptions): Promise<{
+    synthesis: string;
+    outputs: Record<string, string>;
+}>;

package/dist/runtime/facade.js

@@ -0,0 +1,63 @@
+/**
+ * High-level facades for the two bread-and-butter cases, so a caller doesn't have to assemble
+ * `RuntimeRunner` + session log + execution plane + `collectText` by hand (integration feedback #4:
+ * the package exports ~150 symbols and the canonical entry point for common work wasn't discoverable).
+ *
+ * - `runAgent`   — one prompt, one model, the text back. The 90%-case single-agent call.
+ * - `runFanout`  — run N tasks in parallel, then synthesize, from a stateless request handler. Drives
+ *                  the kernel-gated DAG via the standalone `runWorkflow` path (governed · resumable),
+ *                  instead of hand-rolling a multi-runner fan-out.
+ *
+ * Both build a throwaway `RuntimeRunner` with sensible defaults; pass `sessionLog` / `executionPlane`
+ * to opt into persistence or custom tools. Reach for the underlying `RuntimeRunner` directly when you
+ * need streaming events, signals, memory, or governance hooks.
+ */
+import { RuntimeRunner, collectText } from "./runner.js";
+import { LocalExecutionPlane } from "./execution-plane.js";
+import { InMemorySessionLog } from "./session-log.js";
+/**
+ * Run a single agent to completion and return its final text — `RuntimeRunner` + `run` + `collectText`
+ * in one call. Register tools by passing `tools`; everything else has a working default.
+ */
+export async function runAgent(opts) {
+    const plane = opts.executionPlane ??
+        (opts.tools ?? []).reduce((p, t) => p.register(t), new LocalExecutionPlane());
+    const runner = new RuntimeRunner({
+        provider: opts.provider,
+        executionPlane: plane,
+        sessionLog: opts.sessionLog ?? new InMemorySessionLog(),
+        maxTokens: opts.maxTokens ?? 32_000,
+        ...(opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}),
+        ...(opts.systemPrompt !== undefined ? { systemPrompt: opts.systemPrompt } : {}),
+    });
+    return collectText(runner.run({ sessionId: opts.sessionId ?? `agent-${crypto.randomUUID()}`, goal: opts.goal }));
+}
+/**
+ * Parallel fan-out → synthesize, driven by the kernel-gated DAG (the standalone `runWorkflow` path):
+ * each task becomes a fresh-context worker node, and a final synthesis node depends on all of them.
+ * Returns the synthesis text plus every node's raw output. Safe to call from a stateless handler — it
+ * bootstraps and tears down its own kernel.
+ */
+export async function runFanout(opts) {
+    const runner = new RuntimeRunner({
+        provider: opts.provider,
+        executionPlane: opts.executionPlane ?? new LocalExecutionPlane(),
+        sessionLog: opts.sessionLog ?? new InMemorySessionLog(),
+        maxTokens: opts.maxTokens ?? 32_000,
+        ...(opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}),
+    });
+    const workerRole = opts.workerRole ?? "explore";
+    const spec = {
+        nodes: [
+            ...opts.tasks.map(task => ({ task, role: workerRole })),
+            {
+                task: opts.synthesize,
+                role: opts.synthesisRole ?? "plan",
+                dependsOn: opts.tasks.map((_, i) => i),
+            },
+        ],
+    };
+    const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
+    const synthesisId = `wf-node${opts.tasks.length}`;
+    return { synthesis: outcome.outputs[synthesisId] ?? "", outputs: outcome.outputs };
+}

package/dist/runtime/runner.d.ts

@@ -230,6 +230,14 @@ export declare class RuntimeRunner {
     }): Promise<MemoryEntry[]>;
     private logMemoryRetrievalResult;
     private createSyscallRuntime;
+    /**
+     * Lower the declarative governance / attention / scheduler-budget / resource-quota policies into a
+     * freshly-created kernel. Shared by `execute()` (full agent run) and `bootstrapWorkflowKernel()`
+     * (standalone host-driven workflow) so a workflow's DAG-node spawns are gated, queued, and quota'd
+     * exactly as a mid-run spawn would be. Must run BEFORE `start_run` so the in-kernel gate enforces
+     * every policy from the first spawn. No config ⇒ the native-profile defaults (铁律: defaults only).
+     */
+    private applyKernelPolicies;
     private appendMemorySyscallObservations;
     /** Mount a tool capability on the currently-running kernel runtime. No-op if not running. */
     mountTool(schema: ToolSchema): void;
@@ -273,11 +281,21 @@ export declare class RuntimeRunner {
     runWorkflow(spec: WorkflowSpec, opts?: {
         resumedCompleted?: string[];
         resumedSubmissions?: Record<string, unknown>[][];
+        /** Standalone session id when bootstrapping (no active parent run). Defaults to a fresh uuid. */
+        sessionId?: string;
     }): Promise<{
         completed: string[];
         failed: string[];
         outputs: Record<string, string>;
     }>;
+    /**
+     * Bootstrap a standalone kernel for a host-driven workflow with NO active parent run — the path a
+     * stateless request handler takes when it calls `runWorkflow(spec)` directly. Mirrors `execute()`'s
+     * pre-run kernel setup (governance / attention / quota via `applyKernelPolicies`, then `start_run`)
+     * and records a `run_started` event so the standalone run is resumable from the session log. Sets
+     * `activeKernel` / `currentSessionId`; `runWorkflow` is responsible for tearing them down.
+     */
+    private bootstrapWorkflowKernel;
     /**
      * M5/G1: bootstrap an **agent-authored** workflow ("the model writes its own harness"). Unlike
      * `runWorkflow` (the host fires the privileged `load_workflow`), this routes the spec through the
@@ -325,7 +343,9 @@ export declare class RuntimeRunner {
      * 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<{
+    resumeWorkflow(spec: WorkflowSpec, opts?: {
+        sessionId?: string;
+    }): Promise<{
         completed: string[];
         failed: string[];
     }>;

package/dist/runtime/runner.js

@@ -139,6 +139,60 @@ export class RuntimeRunner {
             timeoutMs: this.opts.timeoutMs !== undefined ? BigInt(this.opts.timeoutMs) : undefined,
         });
     }
+    /**
+     * Lower the declarative governance / attention / scheduler-budget / resource-quota policies into a
+     * freshly-created kernel. Shared by `execute()` (full agent run) and `bootstrapWorkflowKernel()`
+     * (standalone host-driven workflow) so a workflow's DAG-node spawns are gated, queued, and quota'd
+     * exactly as a mid-run spawn would be. Must run BEFORE `start_run` so the in-kernel gate enforces
+     * every policy from the first spawn. No config ⇒ the native-profile defaults (铁律: defaults only).
+     */
+    applyKernelPolicies(runtime) {
+        const osProfile = assertNativeProfile(this.opts.osProfile ?? "native");
+        const attentionPolicy = this.opts.attentionPolicy ?? osProfile.attentionPolicy;
+        const governancePolicy = this.opts.governancePolicy ?? osProfile.governancePolicy;
+        // Load the declarative governance policy into the kernel before the run starts,
+        // so the in-kernel gate enforces deny/veto/rate-limit/param before any tool runs.
+        kernelApply(runtime, this.pendingObservations, governancePolicyToKernelEvent(governancePolicy));
+        // Enable in-kernel signal routing so the kernel owns disposition + queuing.
+        kernelApply(runtime, this.pendingObservations, {
+            kind: "set_attention_policy",
+            ...(attentionPolicy.maxQueueSize !== undefined
+                ? { max_queue_size: attentionPolicy.maxQueueSize }
+                : {}),
+        });
+        // Set optional wall-clock budget override.
+        if (this.opts.schedulerBudget) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_scheduler_budget",
+                ...(this.opts.schedulerBudget.maxWallMs !== undefined
+                    ? { max_wall_ms: this.opts.schedulerBudget.maxWallMs }
+                    : {}),
+            });
+        }
+        // Install optional resource quotas at the syscall trap (M2). Maps the ergonomic camelCase
+        // option onto the kernel's snake_case quota shape; the write-rate window is the serde tuple
+        // `[maxWrites, windowMs]`. Omitting the option leaves spawn / memory writes unbounded.
+        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,
+                            ],
+                        }
+                        : {}),
+                },
+            });
+        }
+    }
     async appendMemorySyscallObservations(sessionId, observations) {
         if (!sessionId)
             return;
@@ -392,21 +446,65 @@ export class RuntimeRunner {
      * Returns the completed / failed node agent-ids.
      */
     async runWorkflow(spec, opts) {
-        if (!this.activeKernel || !this.currentSessionId) {
-            throw new Error("runWorkflow requires an active parent run");
+        // Standalone entry: with no active parent run (e.g. a stateless HTTP handler), auto-bootstrap a
+        // kernel that owns the DAG — start_run + the same governance/quota/attention policies a full run
+        // gets — then tear it down on completion so the runner is reusable. Mid-run callers (activeKernel
+        // already set by an in-flight `run()`) keep the original in-place behavior with no teardown.
+        const bootstrapped = !this.activeKernel || !this.currentSessionId;
+        if (bootstrapped) {
+            this.bootstrapWorkflowKernel(opts?.sessionId ?? `wf-${crypto.randomUUID()}`, spec);
         }
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
-        const 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?.length ? { resumed_completed: opts.resumedCompleted } : {}),
-            // R3-1: re-apply recorded runtime submissions so dynamically-appended nodes are reconstructed.
-            ...(opts?.resumedSubmissions?.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
-        });
-        return this.driveWorkflow(observations, parentSessionId, runtime);
+        try {
+            const 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?.length ? { resumed_completed: opts.resumedCompleted } : {}),
+                // R3-1: re-apply recorded runtime submissions so dynamically-appended nodes are reconstructed.
+                ...(opts?.resumedSubmissions?.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
+            });
+            return await this.driveWorkflow(observations, parentSessionId, runtime);
+        }
+        finally {
+            if (bootstrapped) {
+                this.activeKernel = null;
+                this.currentSessionId = null;
+                this.pendingObservations = [];
+            }
+        }
+    }
+    /**
+     * Bootstrap a standalone kernel for a host-driven workflow with NO active parent run — the path a
+     * stateless request handler takes when it calls `runWorkflow(spec)` directly. Mirrors `execute()`'s
+     * pre-run kernel setup (governance / attention / quota via `applyKernelPolicies`, then `start_run`)
+     * and records a `run_started` event so the standalone run is resumable from the session log. Sets
+     * `activeKernel` / `currentSessionId`; `runWorkflow` is responsible for tearing them down.
+     */
+    bootstrapWorkflowKernel(sessionId, spec) {
+        this.interrupted = false;
+        this.abortController = new AbortController();
+        this.pendingObservations = [];
+        this.pendingSpoolOutputs.clear();
+        this.currentSessionId = sessionId;
+        const runtime = this.createSyscallRuntime();
+        this.activeKernel = runtime;
+        const goal = `workflow:${spec.nodes.length} nodes`;
+        // Best-effort run_started log so a standalone workflow can be resumed via `resumeWorkflow`. The
+        // session log is fire-and-forget here (the kernel state, not the log, drives the DAG); a logless
+        // store simply means no resume.
+        void this.opts.sessionLog.append(sessionId, {
+            kind: "run_started",
+            run_id: crypto.randomUUID(),
+            goal,
+            criteria: [],
+            agent_id: this.opts.agentId,
+        }).catch(() => { });
+        this.applyKernelPolicies(runtime);
+        kernelApply(runtime, this.pendingObservations, { kind: "start_run", task: { goal, criteria: [] } });
+        return runtime;
     }
     /**
      * M5/G1: bootstrap an **agent-authored** workflow ("the model writes its own harness"). Unlike
@@ -575,14 +673,17 @@ export class RuntimeRunner {
      * 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");
+    async resumeWorkflow(spec, opts) {
+        // Standalone resume: a stateless handler passes the prior `sessionId` to pick up an interrupted
+        // workflow from the session log. Mid-run callers omit it and resume the active session.
+        const sessionId = opts?.sessionId ?? this.currentSessionId;
+        if (!sessionId) {
+            throw new Error("resumeWorkflow requires an active parent run or an explicit sessionId");
         }
-        const events = await this.opts.sessionLog.read(this.currentSessionId);
+        const events = await this.opts.sessionLog.read(sessionId);
         const resumedCompleted = recoverCompletedWorkflowNodes(events);
         const resumedSubmissions = recoverSubmittedWorkflowNodes(events);
-        return this.runWorkflow(spec, { resumedCompleted, resumedSubmissions });
+        return this.runWorkflow(spec, { resumedCompleted, resumedSubmissions, sessionId });
     }
     interrupt() { this.interrupted = true; this.abortController?.abort(); }
     async *run(req) {
@@ -919,51 +1020,7 @@ export class RuntimeRunner {
                 : baseSpec;
             startPayload.run_spec = agentRunSpecToKernel(spec);
         }
-        const osProfile = assertNativeProfile(this.opts.osProfile ?? "native");
-        const attentionPolicy = this.opts.attentionPolicy ?? osProfile.attentionPolicy;
-        const governancePolicy = this.opts.governancePolicy ?? osProfile.governancePolicy;
-        // Load the declarative governance policy into the kernel before the run starts,
-        // so the in-kernel gate enforces deny/veto/rate-limit/param before any tool runs.
-        kernelApply(runtime, this.pendingObservations, governancePolicyToKernelEvent(governancePolicy));
-        // Enable in-kernel signal routing so the kernel owns disposition + queuing.
-        kernelApply(runtime, this.pendingObservations, {
-            kind: "set_attention_policy",
-            ...(attentionPolicy.maxQueueSize !== undefined
-                ? { max_queue_size: attentionPolicy.maxQueueSize }
-                : {}),
-        });
-        // Set optional wall-clock budget override.
-        if (this.opts.schedulerBudget) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_scheduler_budget",
-                ...(this.opts.schedulerBudget.maxWallMs !== undefined
-                    ? { max_wall_ms: this.opts.schedulerBudget.maxWallMs }
-                    : {}),
-            });
-        }
-        // Install optional resource quotas at the syscall trap (M2). Maps the ergonomic camelCase
-        // option onto the kernel's snake_case quota shape; the write-rate window is the serde tuple
-        // `[maxWrites, windowMs]`. Omitting the option leaves spawn / memory writes unbounded.
-        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,
-                            ],
-                        }
-                        : {}),
-                },
-            });
-        }
+        this.applyKernelPolicies(runtime);
         // Multimodal upload: seed the user's attachments (images/audio) as a history
         // message before start_run pushes the "[TASK STATE]" anchor. init_task does not
         // clear history, so order becomes [attachment user msg, "Proceed…"] — both land

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.27",
+  "version": "0.2.28",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.27",
+    "@deepstrike/core": "0.2.28",
     "@google/generative-ai": "^0.24.1",
     "openai": "^5.23.2"
   },