@deepstrike/sdk 0.2.15 → 0.2.17

package/dist/index.d.ts

@@ -2,6 +2,10 @@ export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export type { RuntimeOptions, SchedulerBudget } from "./runtime/runner.js";
 export { builtinReducers, resolveReducer } from "./runtime/reducers.js";
 export type { Reducer, ReducerRegistry, ReducerInput } from "./runtime/reducers.js";
+export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
+export { WorktreeExecutionPlane, GitWorktreeManager } from "./runtime/worktree-plane.js";
+export type { WorktreeManager } from "./runtime/worktree-plane.js";
+export { FileWorkflowStore } from "./runtime/workflow-store.js";
 export type { MemoryPolicy, MemoryWriteRateLimit, ResourceQuota } from "./kernel.js";
 export { KernelPrimitivesDashboard } from "./runtime/kernel-primitives-dashboard.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
@@ -64,7 +68,7 @@ export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harne
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
 export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, ProviderReplay, RenderedContext, ReplayabilityAssessment, } from "./types.js";
 export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./types/agent.js";
-export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowNodesTool, fanoutSynthesize, generateAndFilter, verifyRules, } from "./types/agent.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules, } from "./types/agent.js";
 export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./collaboration/contract.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";

package/dist/index.js

@@ -1,6 +1,9 @@
 // ── Runtime (Layer 1.5) ────────────────────────────────────────────────────
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export { builtinReducers, resolveReducer } from "./runtime/reducers.js";
+export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
+export { WorktreeExecutionPlane, GitWorktreeManager } from "./runtime/worktree-plane.js";
+export { FileWorkflowStore } from "./runtime/workflow-store.js";
 export { KernelPrimitivesDashboard } from "./runtime/kernel-primitives-dashboard.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
@@ -43,7 +46,7 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export { Governance, governancePolicyToKernelEvent } from "./governance.js";
 // ── Harness ────────────────────────────────────────────────────────────────
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
-export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowNodesTool, fanoutSynthesize, generateAndFilter, verifyRules, } from "./types/agent.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules, } from "./types/agent.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";
 export { KERNEL_ROLE_MAP } from "./collaboration/pool.js";

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderDescriptor, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, ProviderDescriptor, ProviderReplay, ProviderRunState, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
@@ -29,7 +29,7 @@ export declare class AnthropicProvider implements LLMProvider {
      */
     private buildTools;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private requestExtensions;
     private hasBetas;
     private createMessage;

package/dist/providers/anthropic.js

@@ -128,7 +128,7 @@ export class AnthropicProvider {
         }
         throw lastErr;
     }
-    async *stream(context, tools, extensions) {
+    async *stream(context, tools, extensions, _state, signal) {
         const system = this.buildSystem(context);
         const msgs = this.buildMessages(context);
         assertCacheBudget(system, tools.length);
@@ -144,7 +144,7 @@ export class AnthropicProvider {
             ...(system ? { system } : {}),
             messages: msgs,
             ...(tools.length ? { tools: this.buildTools(tools, !Array.isArray(system)) } : {}),
-        }, extensions);
+        }, extensions, signal);
         let uncachedInput = 0;
         let cacheReadTokens = 0;
         let cacheCreationTokens = 0;
@@ -228,10 +228,12 @@ export class AnthropicProvider {
             ? this.client.beta.messages.create(params)
             : this.client.messages.create(params);
     }
-    streamMessage(params, extensions) {
+    streamMessage(params, extensions, signal) {
+        // #2-B-ii: forward the abort signal as a request option so a preempt cancels the HTTP request.
+        const opts = signal ? { signal } : undefined;
         return (this.hasBetas(extensions)
-            ? this.client.beta.messages.stream(params)
-            : this.client.messages.stream(params));
+            ? this.client.beta.messages.stream(params, opts)
+            : this.client.messages.stream(params, opts));
     }
     buildSystem(context) {
         // B3 note: the system shape is content-driven — 0 blocks (string), 1 block

package/dist/providers/openai.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { Message, ProviderDescriptor, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, ProviderDescriptor, ProviderReplay, ProviderRunState, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 import type { ReplayabilityAssessment } from "./replay-validator.js";
@@ -30,7 +30,7 @@ export declare class OpenAIChatProvider implements LLMProvider {
     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>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     /**
      * Default `prompt_cache_key` derived from the cacheable prefix (system prompt +
      * tool names) so requests for the same agent config route to the same cache.

package/dist/providers/openai.js

@@ -122,7 +122,7 @@ export class OpenAIChatProvider {
         }
         throw lastErr;
     }
-    async *stream(context, tools, extensions) {
+    async *stream(context, tools, extensions, _state, signal) {
         const msgs = this.buildChatMessages(context, extensions);
         const toolCallBufs = {};
         const emittedToolCallIndexes = new Set();
@@ -137,7 +137,8 @@ export class OpenAIChatProvider {
             ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
             stream: true,
             stream_options: { include_usage: true },
-        });
+            // #2-B-ii: forward the abort signal so a preempt cancels the in-flight HTTP request.
+        }, signal ? { signal } : undefined);
         let totalTokens = 0;
         let inputTokens = 0;
         let outputTokens = 0;

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

@@ -11,6 +11,11 @@ export interface RunContext {
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
     resultSpool?: LargeResultSpool;
+    /** M3/G4 worktree isolation: the working directory a sub-agent's tools should run in (the git
+     *  worktree created for an `isolation: "worktree"` node). Injected by `WorktreeExecutionPlane`; a
+     *  cwd-aware execution plane / tool reads it to scope filesystem + subprocess work. Undefined ⇒
+     *  the plane's own default cwd. */
+    cwd?: string;
 }
 export interface ExecutionPlane {
     register(...tools: RegisteredTool[]): this;

package/dist/runtime/execution-plane.js

@@ -117,7 +117,9 @@ export class LocalExecutionPlane {
                     repairedArguments: JSON.stringify(args),
                 };
             }
-            const output = await registered.execute(args);
+            // M3/G4: pass the run context (incl. `cwd`) so cwd-aware tools scope their work to the
+            // sub-agent's worktree. `RunContext` is structurally assignable to the tool's `ToolExecContext`.
+            const output = await registered.execute(args, ctx);
             if (isAsyncIterable(output)) {
                 let combined = "";
                 const iterator = output[Symbol.asyncIterator]();

package/dist/runtime/kernel-step.js

@@ -192,12 +192,19 @@ function kernelMessageToSdk(raw) {
     return message;
 }
 function renderedContextToSdk(raw) {
-    return {
+    const rawStateTurn = (raw.state_turn ?? raw.stateTurn);
+    const frozenLen = (raw.frozen_prefix_len ?? raw.frozenPrefixLen);
+    const ctx = {
         systemText: String(raw.system_text ?? raw.systemText ?? ""),
         systemStable: String(raw.system_stable ?? raw.systemStable ?? ""),
         systemKnowledge: String(raw.system_knowledge ?? raw.systemKnowledge ?? ""),
         turns: (raw.turns ?? []).map(kernelMessageToSdk),
     };
+    if (rawStateTurn)
+        ctx.stateTurn = kernelMessageToSdk(rawStateTurn);
+    if (typeof frozenLen === "number")
+        ctx.frozenPrefixLen = frozenLen;
+    return ctx;
 }
 function mapKernelAction(raw) {
     switch (raw.kind) {

package/dist/runtime/process-sandbox-plane.js

@@ -38,7 +38,7 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
         }
         return env;
     }
-    runSubprocess(cmd, argv) {
+    runSubprocess(cmd, argv, cwd) {
         return new Promise(resolve => {
             const chunks = [];
             let totalBytes = 0;
@@ -51,7 +51,7 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
                 resolve({ output, isError });
             };
             const child = spawn(cmd, argv, {
-                cwd: this.sandboxDir,
+                cwd,
                 env: this.buildEnv(),
                 stdio: ["ignore", "pipe", "pipe"],
             });
@@ -83,9 +83,12 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
                 command: { type: "string", description: "The bash command to execute." },
             },
             required: ["command"],
-        }, async (args) => {
-            await mkdir(this.sandboxDir, { recursive: true });
-            const { output, isError } = await this.runSubprocess("bash", ["-c", String(args.command)]);
+        }, async (args, ctx) => {
+            // M3/G4: run in the sub-agent's worktree when one was injected, else the sandbox dir.
+            const cwd = ctx?.cwd ?? this.sandboxDir;
+            if (!ctx?.cwd)
+                await mkdir(this.sandboxDir, { recursive: true });
+            const { output, isError } = await this.runSubprocess("bash", ["-c", String(args.command)], cwd);
             if (isError && !output.trim())
                 return "Process exited with non-zero status and produced no output.";
             return output || "(no output)";
@@ -98,9 +101,12 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
                 code: { type: "string", description: "The JavaScript code to evaluate." },
             },
             required: ["code"],
-        }, async (args) => {
-            await mkdir(this.sandboxDir, { recursive: true });
-            const { output, isError } = await this.runSubprocess("node", ["-e", String(args.code)]);
+        }, async (args, ctx) => {
+            // M3/G4: run in the sub-agent's worktree when one was injected, else the sandbox dir.
+            const cwd = ctx?.cwd ?? this.sandboxDir;
+            if (!ctx?.cwd)
+                await mkdir(this.sandboxDir, { recursive: true });
+            const { output, isError } = await this.runSubprocess("node", ["-e", String(args.code)], cwd);
             if (isError && !output.trim())
                 return "Script exited with non-zero status and produced no output.";
             return output || "(no output)";

package/dist/runtime/runner.d.ts

@@ -17,6 +17,19 @@ export interface SchedulerBudget {
 }
 export interface RuntimeOptions {
     provider: LLMProvider;
+    /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`). A workflow node's
+     *  `tokenBudget` flows here for its child run, so an expensive node self-terminates at the cap.
+     *  Undefined ⇒ the kernel default. */
+    maxTotalTokens?: number;
+    /** M1/G3 intelligence routing: resolve a per-node provider from a workflow node's `modelHint`
+     *  (e.g. "opus" / "sonnet" / "haiku"). Returns undefined ⇒ fall back to `provider`. A workflow
+     *  node carrying `model_hint` runs against the resolved provider; without this hook the hint is a
+     *  no-op (the kernel still carries it for audit). */
+    providerFor?: (modelHint: string) => LLMProvider | undefined;
+    /** M3/G4 worktree isolation: when set, an `isolation: "worktree"` sub-agent runs inside a git
+     *  worktree this manager creates (and removes on completion), injected as `RunContext.cwd`.
+     *  Undefined ⇒ worktree nodes fall back to the inherited plane (no isolation). */
+    worktreeManager?: import("./worktree-plane.js").WorktreeManager;
     sessionLog: SessionLog;
     executionPlane: ExecutionPlane;
     maxTokens: number;
@@ -89,6 +102,13 @@ export interface RuntimeOptions {
     milestoneContract?: MilestoneContract;
     /** Custom sub-agent host driver; defaults to SubAgentOrchestrator. */
     subAgentOrchestrator?: SubAgentOrchestrator;
+    /** M5 v2.1: marks this runner as executing AS a workflow node (a child spawned by the workflow
+     *  driver). A workflow node's `start_workflow` FLATTENS to the parent kernel (emits
+     *  `workflow_nodes_submitted` for `runWorkflow` to append). A top-level run (this flag unset)
+     *  instead AUTO-PIVOTS: it bootstraps + drives the authored workflow in its own kernel and resumes
+     *  the reason loop with the outcome. The orchestrator sets this on workflow-node children so a
+     *  nested `start_workflow` flattens rather than recursing. */
+    isWorkflowNode?: boolean;
     /**
      * When set, sub-agents run through a HarnessLoop with this config.
      * The eval provider evaluates the sub-agent's output against the criteria
@@ -123,6 +143,9 @@ export interface RuntimeOptions {
 export declare class RuntimeRunner {
     private readonly opts;
     private interrupted;
+    /** #2-B-ii: aborts the in-flight provider stream when the run is interrupted/preempted. Recreated
+     *  per `execute`; `interrupt()` fires it so a Critical `InterruptNow` cancels the live LLM call. */
+    private abortController;
     private activeKernel;
     private pendingObservations;
     private currentSessionId;
@@ -131,6 +154,9 @@ export declare class RuntimeRunner {
     private pendingSpoolOutputs;
     /** Local cache of paged-out/archived messages for priority memory retrieval. */
     private localPageOutCache;
+    /** M5 v2.1: sub-workflow specs a top-level agent authored via `start_workflow`, awaiting auto-drive
+     *  at the next safe point (after the tool turn resolves, kernel back in Reason — not suspended). */
+    private pendingAuthoredWorkflows;
     private dashboard;
     constructor(opts: RuntimeOptions);
     /** Host configuration (for coordinator / sub-agent spawn). */
@@ -191,7 +217,50 @@ export declare class RuntimeRunner {
     }): Promise<{
         completed: string[];
         failed: string[];
+        outputs: Record<string, string>;
     }>;
+    /**
+     * 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
+     * agent-reachable `Syscall::LoadWorkflow` (the `submit_workflow` event): with no workflow active the
+     * kernel **bootstraps** the DAG; if one is already active it **flattens** the spec's nodes onto it
+     * (bootstrap-or-flatten — one kernel, one quota, never a workflow stack). Gated by the same
+     * `max_workflow_nodes` backstop as runtime submission, so an authored harness can't overgrow the run.
+     * The resulting batches are driven by the same shared driver as `runWorkflow`.
+     */
+    bootstrapWorkflow(spec: WorkflowSpec, opts?: {
+        submitterAgentId?: string;
+    }): Promise<{
+        completed: string[];
+        failed: string[];
+        outputs: Record<string, string>;
+    }>;
+    /**
+     * M5 v2.1: drive the sub-workflow(s) a top-level agent authored via `start_workflow`. Called at the
+     * verified-safe point (right after the tool turn resolved to `call_provider` — kernel in Reason, not
+     * suspended). For each authored spec: `bootstrapWorkflow` runs it in THIS kernel (the kernel resumes
+     * the agent reason loop on `workflow_completed` — `finish_workflow` sets phase=Reason), then the
+     * outcome is injected as a user message so the agent's next turn sees the result. Returns a fresh
+     * `call_provider` synthesized from the updated context (the workflow drive consumed its own kernel
+     * actions, so we re-render — the same pattern as the reactive-compact retry path).
+     */
+    private driveAuthoredWorkflows;
+    /**
+     * #2-B-ii: while a workflow batch is in flight, poll the signal source. A Critical `InterruptNow`
+     * routes through the kernel (which, with the root suspended in `SubAgentAwait`, preempts — marks the
+     * running nodes `UserAbort`, tears the `WorkflowRun` down, emits `AgentPreempted`); we then abort the
+     * matching children's in-flight LLM calls (via their per-node `AbortController` → `interrupt()`).
+     * Returns the torn-down workflow's outcome on preemption, else `null`. No-op (null) without a signal
+     * source. Non-preempting signals (queue/observe/soft-interrupt) are still applied as they arrive.
+     */
+    private monitorWorkflowPreemption;
+    /**
+     * Shared workflow driver for `runWorkflow` (host `load_workflow`) and `bootstrapWorkflow` (agent
+     * `submit_workflow`): given the observations from the initial load/bootstrap, run each kernel-emitted
+     * batch in parallel, feed completions back (appending any agent-submitted nodes first), and loop
+     * until the kernel reports the workflow complete. Returns the completed / failed node agent-ids.
+     */
+    private driveWorkflow;
     /**
      * Resume a workflow from the parent session's completed nodes.
      * Reads the session log, extracts completed workflow node agent_ids, and