@deepstrike/sdk 0.2.16 → 0.2.18

package/dist/harness/harness.js

@@ -84,7 +84,6 @@ export class HarnessLoop {
     }
     async *stream(request) {
         const kernel = getKernel();
-        const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
         const criteria = request.criteria ?? [];
         let currentGoal = request.goal;
         let lastIterations = 0;
@@ -126,11 +125,10 @@ export class HarnessLoop {
                 }
             }
             yield { type: "supervising" };
-            const evalAction = pipeline.feedOutcome(request.goal, criteria, lastResult, attempt);
-            if (evalAction.kind !== "evaluate")
-                break;
+            // #6 (0.5.0): the eval/verdict compute is the kernel's stateless free functions (was the
+            // EvalPipeline state machine). Build the eval prompt, call the eval LLM, parse the verdict.
+            const evalMsgs = kernel.buildEvalMessages(request.goal, criteria, lastResult, attempt, true);
             let evalText = "";
-            const evalMsgs = evalAction.messages ?? [];
             const evalContext = {
                 systemText: evalMsgs.filter((m) => m.role === "system").map((m) => m.content).join("\n\n"),
                 turns: evalMsgs.filter((m) => m.role !== "system"),
@@ -139,18 +137,16 @@ export class HarnessLoop {
                 if (evt.type === "text_delta")
                     evalText += evt.delta;
             }
-            const doneAction = pipeline.feedEvalResult(evalText);
-            if (doneAction.kind !== "done")
-                break;
+            const parsed = kernel.parseVerdict(evalText);
             const verdict = {
-                passed: doneAction.passed ?? false,
-                overallScore: doneAction.overallScore ?? 0,
-                feedback: doneAction.feedback ?? "",
-                details: doneAction.details ?? [],
+                passed: parsed.passed,
+                overallScore: parsed.overallScore,
+                feedback: parsed.feedback,
+                details: parsed.details ?? [],
             };
             if (verdict.passed) {
-                if (doneAction.skillCandidate && this.skillDir) {
-                    const { name, description, whenToUse, content } = doneAction.skillCandidate;
+                if (parsed.skillCandidate && this.skillDir) {
+                    const { name, description, whenToUse, content } = parsed.skillCandidate;
                     const fm = ["---", `name: ${name}`, `description: ${description}`,
                         whenToUse ? `when_to_use: ${whenToUse}` : null, "---", ""]
                         .filter(Boolean).join("\n");
@@ -162,7 +158,6 @@ export class HarnessLoop {
             yield { type: "revising", verdict };
             currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
             lastResult = "";
-            pipeline.reset();
         }
         yield { type: "max_attempts_reached" };
     }

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, genEval, } 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, genEval, } 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/kernel.d.ts

@@ -77,13 +77,11 @@ interface NativeCriterion {
     required: boolean;
     weight?: number;
 }
-interface EvalPipelineAction {
-    kind: "evaluate" | "done";
-    messages?: Message[];
-    passed?: boolean;
-    overallScore?: number;
-    feedback?: string;
-    details?: Array<{
+export interface Verdict {
+    passed: boolean;
+    overallScore: number;
+    feedback: string;
+    details: Array<{
         criterion: string;
         passed: boolean;
         score: number;
@@ -96,11 +94,6 @@ interface EvalPipelineAction {
         content: string;
     };
 }
-interface EvalPipelineInstance {
-    feedOutcome(goal: string, criteria: NativeCriterion[], result: string, attempt: number): EvalPipelineAction;
-    feedEvalResult(content: string): EvalPipelineAction;
-    reset(): void;
-}
 interface IdlePipelineAction {
     kind: "synthesize_insights" | "commit_memories" | "noop" | "aborted";
     messages?: Message[];
@@ -156,9 +149,9 @@ interface KernelModule {
         timeoutMs?: bigint;
     }) => KernelRuntimeInstance;
     SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
-    EvalPipeline: new (options?: {
-        extractSkillOnPass?: boolean;
-    }) => EvalPipelineInstance;
+    buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): Message[];
+    parseVerdict(content: string): Verdict;
+    verdictOutputSchema(extractSkillOnPass: boolean): string;
     IdlePipeline: new (agentId: string) => IdlePipelineInstance;
 }
 export declare function getKernel(): KernelModule;

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/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