@deepstrike/wasm 0.2.16 → 0.2.18

package/dist/runtime/runner.js

@@ -5,27 +5,33 @@ import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-rep
 import { sanitizeReplayText } from "./replay-sanitize.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, recoverCompletedWorkflowNodes, recoverSubmittedWorkflowNodes, repairEventsForRecovery, } from "./session-repair.js";
 import { forceCompact, kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
-import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, submitWorkflowNodesToKernel, workflowBudgetNote, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.js";
+import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, workflowBudgetNote, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
 import { resolveReducer } from "./reducers.js";
+import { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
 import { kernelObservationToSessionEvent, withCategory } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
 export class RuntimeRunner {
     opts;
     interrupted = false;
+    /** #2-B-ii: aborts the in-flight provider stream on interrupt/preempt. Recreated per `execute`. */
+    abortController = null;
     pendingObservations = [];
     activeKernel = null;
     currentSessionId = null;
     nextArchiveStart = 0;
     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). */
+    pendingAuthoredWorkflows = [];
     pendingSpoolOutputs = new Map();
     constructor(opts) {
         this.opts = opts;
     }
     get hostOptions() { return this.opts; }
-    interrupt() { this.interrupted = true; }
+    interrupt() { this.interrupted = true; this.abortController?.abort(); }
     async *run(req) {
         const prior = req.inheritEvents ?? await this.opts.sessionLog.read(req.sessionId);
         const midRun = isMidRun(prior);
@@ -245,6 +251,7 @@ export class RuntimeRunner {
     }
     async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
         this.interrupted = false;
+        this.abortController = new AbortController();
         this.pendingObservations = [];
         this.pendingSpoolOutputs.clear();
         this.currentSessionId = sessionId;
@@ -258,6 +265,8 @@ export class RuntimeRunner {
         const runtime = new kernel.KernelRuntime({
             maxTokens: this.opts.maxTokens,
             maxTurns: effectiveMaxTurns,
+            // M4/G5: per-node token cap → child run's cumulative token budget (wasm LoopPolicy.maxTotalTokens is f64).
+            ...(this.opts.maxTotalTokens !== undefined ? { maxTotalTokens: this.opts.maxTotalTokens } : {}),
             timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
         });
         this.activeKernel = runtime;
@@ -407,24 +416,7 @@ export class RuntimeRunner {
             if (this.opts.signalSource) {
                 const sig = await this.opts.signalSource.nextSignal();
                 if (sig) {
-                    const id = crypto.randomUUID();
-                    const source = sig.source ?? "custom";
-                    const signalType = sig.signalType ?? "event";
-                    const urgency = sig.urgency ?? "normal";
-                    const summary = String(sig.payload?.goal ?? "signal");
-                    const sigAction = kernelMaybeAction(runtime, this.pendingObservations, {
-                        kind: "signal",
-                        signal: {
-                            id,
-                            source,
-                            signal_type: signalType,
-                            urgency,
-                            summary,
-                            payload: sig.payload ?? {},
-                            ...(sig.dedupeKey ? { dedupe_key: sig.dedupeKey } : {}),
-                            timestamp_ms: Date.now(),
-                        },
-                    });
+                    const sigAction = kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig));
                     if (sigAction)
                         action = sigAction;
                 }
@@ -432,6 +424,12 @@ export class RuntimeRunner {
             if (runtime.isTerminal())
                 break;
             if (action.kind === "call_provider") {
+                // M5 v2.1: top-level auto-pivot at the safe point (kernel in Reason, not suspended). Loop-top
+                // placement catches every path to `call_provider` (incl. post-approval-resume), so a queued
+                // authored spec is never stranded. Drains the queue; fires once per authored batch.
+                if (this.pendingAuthoredWorkflows.length > 0) {
+                    action = await this.driveAuthoredWorkflows(runtime, action);
+                }
                 const finalToolCalls = [];
                 let finalText = "";
                 const context = action.context;
@@ -440,8 +438,12 @@ export class RuntimeRunner {
                 let turnInputTokens = 0;
                 let turnOutputTokens = 0;
                 let shouldRetry = false;
+                const abortSignal = this.abortController?.signal;
                 try {
-                    for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
+                    for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
+                        // #2-B-ii: a preempting interrupt fires abortController — stop consuming the live stream.
+                        if (abortSignal?.aborted)
+                            break;
                         if (evt.type === "usage") {
                             const usageEvt = evt;
                             turnTokens = usageEvt.totalTokens;
@@ -459,6 +461,10 @@ export class RuntimeRunner {
                     }
                 }
                 catch (err) {
+                    // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat as an interrupt.
+                    if (abortSignal?.aborted) {
+                        this.interrupted = true;
+                    }
                     const errMsg = String(err).toLowerCase();
                     if ((errMsg.includes("413") || errMsg.includes("too long") || errMsg.includes("context length exceeded") || errMsg.includes("context_length_exceeded")) &&
                         !hasAttemptedReactiveCompact) {
@@ -474,6 +480,11 @@ export class RuntimeRunner {
                         break;
                     }
                 }
+                // #2-B-ii: stream aborted (preempt/interrupt) via the break path — end the turn now.
+                if (abortSignal?.aborted) {
+                    action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
+                    break;
+                }
                 if (shouldRetry) {
                     action = {
                         kind: "call_provider",
@@ -532,10 +543,26 @@ export class RuntimeRunner {
                 // R3-1: intercept `submit_workflow_nodes` — it can't apply to this runner's kernel (when this
                 // runner is a workflow node, the workflow lives in the parent). Surface the nodes as an event;
                 // the orchestrator collects them and `runWorkflow` sends them to the parent kernel.
-                const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes");
-                const normalCalls = allCalls.filter(c => c.name !== "submit_workflow_nodes");
+                // M5 v1: `start_workflow` (author a sub-workflow) flattens to the same append path.
+                const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes" || c.name === "start_workflow");
+                const normalCalls = allCalls.filter(c => c.name !== "submit_workflow_nodes" && c.name !== "start_workflow");
                 for (const call of submitCalls) {
-                    const nodes = parseSubmitWorkflowNodesArgs(call.arguments);
+                    // M5 v2.1: a TOP-LEVEL agent authoring a whole sub-workflow via `start_workflow` — record the
+                    // spec and AUTO-PIVOT once this tool turn resolves. A workflow-NODE's `start_workflow` (and
+                    // every `submit_workflow_nodes`) instead FLATTENS for the parent `runWorkflow` to append.
+                    if (call.name === "start_workflow" && !this.opts.isWorkflowNode) {
+                        const spec = parseStartWorkflowSpec(call.arguments);
+                        if (spec) {
+                            this.pendingAuthoredWorkflows.push(spec);
+                            const out = "workflow authored; executing now";
+                            toolResults.push({ callId: call.id, output: out, isError: false });
+                            yield { type: "tool_result", callId: call.id, content: out, isError: false };
+                            continue;
+                        }
+                    }
+                    const nodes = call.name === "start_workflow"
+                        ? parseStartWorkflowArgs(call.arguments)
+                        : parseSubmitWorkflowNodesArgs(call.arguments);
                     yield { type: "workflow_nodes_submitted", nodes };
                     toolResults.push({ callId: call.id, output: "submitted", isError: false });
                     yield { type: "tool_result", callId: call.id, content: "submitted", isError: false };
@@ -725,7 +752,7 @@ export class RuntimeRunner {
      * fed back on mismatch. If it still does not conform, the node is failed with the validation
      * reason (an `Error`-terminated result fails the node in-kernel, starving its dependents).
      */
-    async runWorkflowNode(node, parentSessionId, orchestrator, budget, outputs) {
+    async runWorkflowNode(node, parentSessionId, orchestrator, budget, outputs, abortSignal) {
         // G2: a reduce node runs no LLM — execute the registered pure function over its dependency
         // outputs and feed the result back as an ordinary completion. Deterministic; no agent burned.
         if (node.reducer) {
@@ -742,7 +769,40 @@ export class RuntimeRunner {
             spec: { ...baseSpec, goal: withBudget(goal) },
             manifest,
             sessionLog: this.opts.sessionLog,
+            // M5 v2.1: this child IS a workflow node — its `start_workflow` flattens to this kernel.
+            isWorkflowNode: true,
+            // #2-B-ii: the per-node abort signal the driver fires when the kernel preempts this node.
+            ...(abortSignal ? { abortSignal } : {}),
         });
+        const textOf = (r) => {
+            const c = r.result.finalMessage?.content;
+            return typeof c === "string" ? c : c != null ? JSON.stringify(c) : "";
+        };
+        const withSignal = (r, patch) => ({ ...r, result: { ...r.result, ...patch } });
+        // A#2 tournament judge: compare two entrants' produced outputs rather than running the node's own
+        // goal. Look up both candidates, judge over the controller's criterion, and report the winner's id.
+        if (node.judge_match) {
+            const out = outputs ?? new Map();
+            const left = out.get(node.judge_match.left) ?? "";
+            const right = out.get(node.judge_match.right) ?? "";
+            const result = await orchestrator.run(mkCtx(judgeGoal(baseSpec.goal, left, right)));
+            const winner = extractJudgeWinner(textOf(result));
+            const winnerId = winner === "right" ? node.judge_match.right : node.judge_match.left;
+            return withSignal(result, { tournamentWinner: winnerId });
+        }
+        // A#2 v2 loop iteration: run the increment, then extract a stop signal. No signal ⇒ run to cap.
+        if (node.loop_max_iters != null) {
+            const result = await orchestrator.run(mkCtx(`${baseSpec.goal}\n\n${loopInstruction(node.loop_max_iters)}`));
+            const cont = extractLoopContinue(textOf(result));
+            return cont === undefined ? result : withSignal(result, { loopContinue: cont });
+        }
+        // A#2 classify: run the classifier, then extract the chosen branch label (kernel prunes the rest).
+        if (node.classify_labels && node.classify_labels.length) {
+            const labels = node.classify_labels;
+            const result = await orchestrator.run(mkCtx(`${baseSpec.goal}\n\n${classifyInstruction(labels)}`));
+            const branch = extractClassifyBranch(textOf(result), labels);
+            return branch === undefined ? result : withSignal(result, { classifyBranch: branch });
+        }
         const schema = node.output_schema;
         if (!schema)
             return orchestrator.run(mkCtx(baseSpec.goal));
@@ -805,7 +865,6 @@ export class RuntimeRunner {
         }
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
-        const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
         const observations = kernelApply(runtime, this.pendingObservations, {
             kind: "load_workflow",
             spec: workflowSpecToKernel(spec),
@@ -815,22 +874,103 @@ export class RuntimeRunner {
             // R3-1: re-apply recorded runtime submissions so dynamically-appended nodes are reconstructed.
             ...(opts?.resumedSubmissions && opts.resumedSubmissions.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
         });
+        return this.driveWorkflow(observations, parentSessionId, runtime);
+    }
+    /**
+     * M5/G1: bootstrap an **agent-authored** workflow ("the model writes its own harness"). Routes the
+     * spec through the agent-reachable `Syscall::LoadWorkflow` (`submit_workflow`): with no workflow
+     * active the kernel bootstraps the DAG, else it flattens onto the running one (bootstrap-or-flatten —
+     * one kernel, one quota). The same shared driver runs the resulting batches.
+     */
+    async bootstrapWorkflow(spec, opts) {
+        if (!this.activeKernel || !this.currentSessionId) {
+            throw new Error("bootstrapWorkflow requires an active parent run");
+        }
+        const parentSessionId = this.currentSessionId;
+        const runtime = this.activeKernel;
+        const observations = kernelApply(runtime, this.pendingObservations, submitWorkflowToKernel(spec, parentSessionId, opts?.submitterAgentId));
+        return this.driveWorkflow(observations, parentSessionId, runtime);
+    }
+    /**
+     * M5 v2.1: drive the sub-workflow(s) a top-level agent authored via `start_workflow`, at the safe
+     * point (tool turn resolved → kernel in Reason). Each runs in THIS kernel (the kernel resumes the
+     * reason loop on `workflow_completed`), then the outcome is injected as a user message and a fresh
+     * `call_provider` is synthesized from the updated context (the workflow drive consumed its own
+     * kernel actions — same re-render pattern as the reactive-compact retry path).
+     */
+    async driveAuthoredWorkflows(runtime, action) {
+        const specs = this.pendingAuthoredWorkflows;
+        this.pendingAuthoredWorkflows = [];
+        for (const spec of specs) {
+            const outcome = await this.bootstrapWorkflow(spec);
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "add_history_message",
+                message: messageToKernelMessage({ role: "user", content: authoredWorkflowOutcomeNote(outcome) }),
+            });
+        }
+        return { kind: "call_provider", context: runtime.render(), tools: action.tools };
+    }
+    /**
+     * #2-B-ii: while a workflow batch is in flight, poll the signal source; a Critical `InterruptNow`
+     * routes through the kernel (root in `SubAgentAwait` → preempt → `AgentPreempted` + tears the
+     * `WorkflowRun` down), and we abort the matching children's in-flight LLM calls. Returns the
+     * torn-down outcome on preemption, else `null`. No-op without a signal source.
+     */
+    async monitorWorkflowPreemption(runtime, controllers, batchState) {
+        const source = this.opts.signalSource;
+        if (!source)
+            return null;
+        while (!batchState.settled) {
+            const sig = await source.nextSignal();
+            if (batchState.settled)
+                break;
+            if (!sig) {
+                await new Promise(resolve => setTimeout(resolve, 5));
+                continue;
+            }
+            const obs = kernelApply(runtime, this.pendingObservations, signalToKernelEvent(sig));
+            const preempted = obs.find(o => o.kind === "agent_preempted");
+            if (preempted) {
+                for (const id of preempted.agent_ids ?? [])
+                    controllers.get(id)?.abort();
+                const wc = obs.find(o => o.kind === "workflow_completed");
+                return { completed: wc?.completed ?? [], failed: wc?.failed ?? [] };
+            }
+        }
+        return null;
+    }
+    /**
+     * Shared workflow driver for `runWorkflow` (host `load_workflow`) and `bootstrapWorkflow` (agent
+     * `submit_workflow`): 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.
+     */
+    async driveWorkflow(initial, parentSessionId, runtime) {
+        const observations = initial;
+        const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
         const collectNodes = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")?.nodes ?? [];
         // G4: the batch observation carries the workflow's remaining budget; track the latest.
         const collectBudget = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")?.budget;
         const findDone = (obs) => obs.find(o => o.kind === "workflow_completed");
         let done = findDone(observations);
         if (done)
-            return { completed: done.completed ?? [], failed: done.failed ?? [] };
+            return { completed: done.completed ?? [], failed: done.failed ?? [], outputs: {} };
         let nodes = collectNodes(observations);
         let budget = collectBudget(observations);
         // G2: each completed node's output, keyed by agent id — a reduce node reads its deps' outputs.
         const outputs = new Map();
         for (;;) {
             if (nodes.length === 0)
-                return { completed: [], failed: [] };
+                return { completed: [], failed: [], outputs: Object.fromEntries(outputs) };
             const roundBudget = budget;
-            const results = await Promise.all(nodes.map(node => this.runWorkflowNode(node, parentSessionId, orchestrator, roundBudget, outputs)));
+            // #2-B-ii: per-node abort controllers + a concurrent preemption monitor (see node runner).
+            const controllers = new Map(nodes.map(n => [n.agent_id, new AbortController()]));
+            const batchState = { settled: false };
+            const monitor = this.monitorWorkflowPreemption(runtime, controllers, batchState);
+            const results = await Promise.all(nodes.map(node => this.runWorkflowNode(node, parentSessionId, orchestrator, roundBudget, outputs, controllers.get(node.agent_id)?.signal)));
+            batchState.settled = true;
+            const preempted = await monitor;
+            if (preempted)
+                return { ...preempted, outputs: Object.fromEntries(outputs) };
             // Accumulate next-batch nodes across feeds (per-node unblock can spawn dependents per feed).
             const nextNodes = [];
             done = undefined;
@@ -871,7 +1011,7 @@ export class RuntimeRunner {
                 }));
             }
             if (done && nextNodes.length === 0) {
-                return { completed: done.completed ?? [], failed: done.failed ?? [] };
+                return { completed: done.completed ?? [], failed: done.failed ?? [], outputs: Object.fromEntries(outputs) };
             }
             nodes = nextNodes;
         }
@@ -1090,3 +1230,61 @@ function parseSubmitWorkflowNodesArgs(argsStr) {
     }
     return Array.isArray(parsed.nodes) ? parsed.nodes : [];
 }
+/** M5 v1: parse `start_workflow` tool args (`{ spec: { nodes: WorkflowNodeSpec[] } }`) into the
+ *  spec's node batch — flattened onto the running workflow via the same append path. */
+function parseStartWorkflowArgs(argsStr) {
+    let parsed = {};
+    try {
+        parsed = JSON.parse(argsStr);
+    }
+    catch {
+        // Ignore parse error → no nodes.
+    }
+    const spec = parsed.spec;
+    return Array.isArray(spec?.nodes) ? spec.nodes : [];
+}
+/** M5 v2.1: parse the full `WorkflowSpec` from a top-level `start_workflow` call for the auto-pivot
+ *  drive. Returns `undefined` on a malformed / empty payload (caller falls back to the flatten path). */
+function parseStartWorkflowSpec(argsStr) {
+    try {
+        const parsed = JSON.parse(argsStr);
+        if (Array.isArray(parsed.spec?.nodes) && parsed.spec.nodes.length > 0) {
+            return { nodes: parsed.spec.nodes };
+        }
+    }
+    catch {
+        // Ignore parse error → undefined (fall back to flatten).
+    }
+    return undefined;
+}
+/** M5 v2.1: render an authored-workflow outcome into a user-message note injected back into the
+ *  agent's context, so its next turn continues with the sub-workflow's results in view. */
+function authoredWorkflowOutcomeNote(outcome) {
+    const lines = [
+        `[authored workflow result] ${outcome.completed.length} node(s) completed` +
+            (outcome.failed.length ? `, ${outcome.failed.length} failed` : "") + ".",
+    ];
+    for (const id of outcome.completed) {
+        const out = outcome.outputs[id];
+        if (out)
+            lines.push(`- ${id}: ${out.length > 500 ? out.slice(0, 500) + "…" : out}`);
+    }
+    return lines.join("\n");
+}
+/** Lower a host `RuntimeSignal` to the kernel's snake_case `signal` input event. Shared by the main
+ *  loop's per-turn poll and #2-B-ii's workflow-batch preemption monitor (so the two never drift). */
+function signalToKernelEvent(sig) {
+    return {
+        kind: "signal",
+        signal: {
+            id: crypto.randomUUID(),
+            source: sig.source ?? "custom",
+            signal_type: sig.signalType ?? "event",
+            urgency: sig.urgency ?? "normal",
+            summary: String(sig.payload?.goal ?? "signal"),
+            payload: sig.payload ?? {},
+            ...(sig.dedupeKey ? { dedupe_key: sig.dedupeKey } : {}),
+            timestamp_ms: Date.now(),
+        },
+    };
+}

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -7,7 +7,16 @@ export interface SubAgentRunContext {
     spec: AgentRunSpec;
     manifest: AgentProcessChangedObservation;
     sessionLog: SessionLog;
+    /** M5 v2.1: set when this child is a workflow node — propagated so a nested `start_workflow`
+     *  FLATTENS to the parent kernel rather than auto-pivoting into its own bootstrap. */
+    isWorkflowNode?: boolean;
+    /** #2-B-ii: parent-controlled abort — when the kernel preempts this node (`AgentPreempted`), the
+     *  orchestrator interrupts the child runner, cancelling its in-flight LLM call. */
+    abortSignal?: AbortSignal;
 }
+/** M1/G3 intelligence routing: resolve the provider for a sub-agent from its spec's `modelHint`.
+ *  Falls back to the parent provider when there is no hint or no `providerFor` hook resolves it. */
+export declare function resolveProvider(opts: RuntimeOptions, modelHint?: string): RuntimeOptions["provider"];
 /** Host-side driver for kernel-isolated sub-agent runs. */
 export declare class SubAgentOrchestrator {
     run(ctx: SubAgentRunContext): Promise<SubAgentResult>;

package/dist/runtime/sub-agent-orchestrator.js

@@ -1,6 +1,16 @@
 import { agentRunSpecToKernel, findSpawnProcessObservation, spawnObservationToManifest } from "./types/agent.js";
 import { FilteredExecutionPlane } from "./filtered-plane.js";
 import { kernelApply } from "./kernel-step.js";
+/** #2-B-ii: bridge a parent AbortSignal to a child runner's `interrupt()` (fires now if already aborted). */
+function linkAbort(signal, runner) {
+    if (!signal)
+        return;
+    if (signal.aborted) {
+        runner.interrupt();
+        return;
+    }
+    signal.addEventListener("abort", () => runner.interrupt(), { once: true });
+}
 function terminationFromStatus(status) {
     const normalized = status.toLowerCase();
     if (normalized === "completed" ||
@@ -14,6 +24,16 @@ function terminationFromStatus(status) {
     }
     return status;
 }
+/** M1/G3 intelligence routing: resolve the provider for a sub-agent from its spec's `modelHint`.
+ *  Falls back to the parent provider when there is no hint or no `providerFor` hook resolves it. */
+export function resolveProvider(opts, modelHint) {
+    if (modelHint && opts.providerFor) {
+        const routed = opts.providerFor(modelHint);
+        if (routed)
+            return routed;
+    }
+    return opts.provider;
+}
 /** Derive which meta-tools a child runner should expose based on permitted IDs and available sources. */
 function deriveMetaTools(permitted, opts) {
     const metaTools = new Set();
@@ -48,6 +68,10 @@ export class SubAgentOrchestrator {
         const { RuntimeRunner } = await import("./runner.js");
         const childRunner = new RuntimeRunner({
             ...ctx.parentOpts,
+            // M1/G3: route to the node's hinted model (falls back to the parent provider).
+            provider: resolveProvider(ctx.parentOpts, ctx.spec.modelHint),
+            // M4/G5: cap the child run at the node's token budget (falls back to the inherited cap).
+            maxTotalTokens: ctx.spec.tokenBudget ?? ctx.parentOpts.maxTotalTokens,
             executionPlane: filteredPlane,
             agentId: ctx.spec.identity.agentId,
             systemPrompt,
@@ -56,7 +80,11 @@ export class SubAgentOrchestrator {
             dreamStore: metaTools.has("memory") ? ctx.parentOpts.dreamStore : undefined,
             knowledgeSource: metaTools.has("knowledge") ? ctx.parentOpts.knowledgeSource : undefined,
             enablePlanTool: metaTools.has("update_plan") ? ctx.parentOpts.enablePlanTool : undefined,
+            // M5 v2.1: a workflow node's `start_workflow` flattens to the parent kernel (no nested pivot).
+            isWorkflowNode: ctx.isWorkflowNode,
         });
+        // #2-B-ii: parent preempt → interrupt the child (cancels its in-flight LLM call).
+        linkAbort(ctx.abortSignal, childRunner);
         let done;
         let finalText = "";
         // R3-1: collect any nodes this node's agent submitted via the `submit_workflow_nodes` tool.

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

@@ -23,6 +23,11 @@ export interface AgentRunSpec {
     capabilityFilter?: AgentCapabilityFilter;
     milestones?: MilestoneContract;
     metadata?: Record<string, unknown>;
+    /** M1/G3: per-agent model preference; the host resolves it via `RuntimeOptions.providerFor`.
+     *  Host-side routing only — not sent to the kernel. */
+    modelHint?: string;
+    /** M4/G5: cumulative token cap for this sub-agent's run (sets the child kernel's `maxTotalTokens`). */
+    tokenBudget?: number;
 }
 /** Kernel process-table observation (Phase 3 canonical spawn signal). */
 export interface AgentProcessChangedObservation {
@@ -48,6 +53,14 @@ export interface LoopResult {
     finalMessage?: Message;
     turnsUsed: number;
     totalTokensUsed: number;
+    /** A#2 v2 loop stop signal: a loop iteration sets `false` to end the loop before `max_iters`.
+     *  `undefined` (every non-loop result) ⇒ no opinion → run to the cap. Sent only when set. */
+    loopContinue?: boolean;
+    /** A#2 classify routing: a classifier node reports the chosen branch label here; the kernel runs
+     *  that branch and prunes the rest. Sent only when set. */
+    classifyBranch?: string;
+    /** A#2 tournament verdict: a judge reports the winning entrant's agent id here. Sent only when set. */
+    tournamentWinner?: string;
 }
 export interface SubAgentResult {
     agentId: string;
@@ -99,6 +112,26 @@ export interface WorkflowNodeSpec {
     /** G2: make this a deterministic reduce node — runs no LLM; the runner routes it to the registered
      *  reducer of this name over its `dependsOn` nodes' outputs. */
     reducer?: string;
+    /** A#2 v2: make this a *loop* node — re-run its agent up to `maxIters` times. An iteration may end
+     *  the loop early by reporting `loopContinue: false` (the runner solicits this from the agent). */
+    loop?: {
+        maxIters: number;
+    };
+    /** A#2: make this a *classify* node — its agent picks exactly one branch `label`; that branch's
+     *  nodes run and the others are pruned. Each branch node must list this node's index in `dependsOn`. */
+    classify?: {
+        branches: Array<{
+            label: string;
+            nodes: number[];
+        }>;
+    };
+    /** A#2: make this a *tournament controller* — generate each `entrants` candidate in parallel, then
+     *  pairwise-judge them to one winner (this node's `task.goal` is the judging criterion). ≥2 entrants. */
+    tournament?: {
+        entrants: WorkflowTaskSpec[];
+    };
+    /** M4/G5: cap this node's child run at `tokenBudget` cumulative tokens (the per-node "use N tokens"). */
+    tokenBudget?: number;
     /** Indices of nodes this node depends on. */
     dependsOn?: number[];
 }
@@ -120,6 +153,20 @@ export interface WorkflowSpawnInfo {
     reducer?: string;
     /** G2: the dependency agent ids whose outputs a reduce node consumes. */
     input_agent_ids?: string[];
+    /** A#2: present only for a tournament *judge* spawn — the two entrant agent ids whose produced
+     *  outputs this judge compares. The runner looks them up and reports the winner as `tournamentWinner`. */
+    judge_match?: {
+        left: string;
+        right: string;
+    };
+    /** A#2 v2: present only for a *loop* iteration spawn — the loop's `max_iters`. Marks the spawn as a
+     *  loop iteration so the runner solicits + reports a `loopContinue` stop signal. */
+    loop_max_iters?: number;
+    /** A#2: present only for a *classify* spawn — the branch labels the classifier must choose among.
+     *  Non-empty marks the spawn as a classifier so the runner instructs the agent + reports `classifyBranch`. */
+    classify_labels?: string[];
+    /** M4/G5: the node's per-node cumulative token cap, if set — the runner caps the child run here. */
+    token_budget?: number;
 }
 /** G4 budget-as-signal: the workflow's remaining headroom under the active quota, carried on the
  *  `workflow_batch_spawned` observation so a coordinator node can scale its next submission. */
@@ -130,10 +177,14 @@ export interface WorkflowBudget {
     running_subagents: number;
     max_concurrent_subagents?: number;
     concurrency_remaining?: number;
+    /** M4/G5 token headroom: tokens used / run-level cap / tokens remaining, so a coordinator can scale
+     *  a submission to "use N tokens". */
+    tokens_used?: number;
+    tokens_max?: number;
+    tokens_remaining?: number;
 }
 /** G4: a concise budget note appended to a coordinator node's goal. "" when nothing is bounded. */
 export declare function workflowBudgetNote(budget: WorkflowBudget | undefined): string;
-/** Map a host `WorkflowSpec` to the snake_case kernel JSON (`load_workflow.spec`). */
 /** Map one host `WorkflowNodeSpec` to its snake_case kernel JSON. Shared by `load_workflow` and
  *  `submit_workflow_nodes` (R3-1) so the two encodings never drift. */
 export declare function workflowNodeSpecToKernel(n: WorkflowNodeSpec): Record<string, unknown>;
@@ -142,8 +193,16 @@ export declare function workflowSpecToKernel(spec: WorkflowSpec): Record<string,
  *  `submitterAgentId` so the kernel enforces no-privilege-escalation (quarantined submitter ⇒ its
  *  nodes coerced to quarantined). Omitted ⇒ no coercion. */
 export declare function submitWorkflowNodesToKernel(nodes: WorkflowNodeSpec[], submitterAgentId?: string): Record<string, unknown>;
-/** R3-1: the tool a workflow-coordinator node's agent calls to append work to the running DAG. */
+/** M5/G1: map an agent-authored spec to the `submit_workflow` kernel event body (the agent-reachable
+ *  `Syscall::LoadWorkflow`). The kernel bootstraps the DAG when none is active, else flattens onto it.
+ *  `parentSessionId` seeds child session ids on bootstrap; `submitterAgentId` carries G1 trust coercion
+ *  on the flatten case. */
+export declare function submitWorkflowToKernel(spec: WorkflowSpec, parentSessionId: string, submitterAgentId?: string): Record<string, unknown>;
 export declare const submitWorkflowNodesTool: ToolSchema;
+/** M5 v1 (flatten): the tool an agent calls to author a sub-workflow — a cohesive DAG of nodes
+ *  composed onto the running workflow. Lowers to the same append path as `submit_workflow_nodes`
+ *  (a `WorkflowSpec` is a node batch). v2 adds top-level bootstrap (the `LoadWorkflow` syscall). */
+export declare const startWorkflowTool: ToolSchema;
 /** Build a sub-agent run spec for a kernel-generated workflow node. */
 export declare function workflowNodeToSpec(node: WorkflowSpawnInfo, parentSessionId: string): AgentRunSpec;
 /** Build the host manifest for a kernel-generated workflow node. */