@acpus/runtime 0.1.0 → 0.2.0

package/dist/interpreter.js

@@ -1,58 +1,18 @@
-import { parseDurationMs, compileWorkflow } from "@acpus/core";
+import { parseDurationMs, compileWorkflow, hashIrNode } from "@acpus/core";
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { ExpressionEvaluator } from "./evaluator.js";
-import { resolveNodeKey, sanitizeValue } from "./keys.js";
-import { canTransition, transition, createInitialNodeState, resetFailedForRetry, resetRunningForCrashRecovery, resetAwaitingForCrashRecovery, resetPausedForRunResume } from "./state-machine.js";
+import { resolveNodeKey, staticNodePathFromKey, withNodeKeyPrefix } from "./keys.js";
+import { canTransition, transition, createInitialNodeState } from "./state-machine.js";
 import { ArtifactStore } from "./artifacts.js";
-import { renderAgentRequestPrompt } from "./executors/agent.js";
+import { AttemptArtifactRecorder } from "./attempt-artifacts.js";
+import { renderAgentRequestPrompt, renderAgentSessionKey } from "./executors/agent.js";
 import { validateInput } from "./validate-input.js";
+import { RunControl, abortedNodeError, isPausedContinuationState } from "./run-control.js";
+import { evaluateTemplatedValue, evaluateWorkflowOutputs } from "./workflow-outputs.js";
 import { randomBytes } from "node:crypto";
 import pLimit from "p-limit";
-const PAUSED_ABORT_ERROR = "Aborted: paused";
-function abortedNodeError(state) {
-    return state === "paused" ? PAUSED_ABORT_ERROR : "Aborted: cancelled";
-}
-function isPausedContinuationState(state) {
-    return state?.state === "pending" && state.attempt > 0 && state.error === PAUSED_ABORT_ERROR;
-}
-function pushUnique(target, refs) {
-    if (!refs)
-        return;
-    const seen = new Set(target);
-    for (const ref of refs) {
-        if (!seen.has(ref)) {
-            target.push(ref);
-            seen.add(ref);
-        }
-    }
-    target.sort(compareAttemptArtifactRefs);
-}
-function mergeStderrDiagnostics(stderr, diagnostics) {
-    if (diagnostics.length === 0)
-        return stderr;
-    const diagnosticText = diagnostics.map((line) => `[acpus] ${line}`).join("\n");
-    return stderr && stderr.length > 0 ? `${stderr}\n${diagnosticText}` : diagnosticText;
-}
-function compareAttemptArtifactRefs(a, b) {
-    const left = attemptArtifactSortKey(a);
-    const right = attemptArtifactSortKey(b);
-    if (!left || !right)
-        return 0;
-    return left.attempt - right.attempt || left.kind - right.kind;
-}
-function attemptArtifactSortKey(ref) {
-    const match = /attempt-(\d+)\.(prompt\.md|transcript\.jsonl|response\.md|stderr\.log)$/.exec(ref);
-    if (!match)
-        return undefined;
-    const kindOrder = {
-        "prompt.md": 0,
-        "transcript.jsonl": 1,
-        "response.md": 2,
-        "stderr.log": 3
-    };
-    return { attempt: Number(match[1]), kind: kindOrder[match[2]] ?? 99 };
-}
+import { AgentTelemetryAccumulator, upsertAgentAttemptTelemetry } from "./agent-telemetry.js";
 /**
  * The core IR interpreter that drives state transitions, orchestrates
  * execution, and persists state.
@@ -63,28 +23,24 @@ export class WorkflowInterpreter {
     agentExecutor;
     programExecutor;
     artifactStore;
+    attemptArtifacts;
+    runControl;
     maxConcurrency;
     allowedSourceRoots;
     sleep;
-    /** Active abort controllers keyed by "runId:nodeKey" for pause/cancel support */
-    abortControllers = new Map();
-    /** Intent of an in-flight abort keyed by "runId:nodeKey" (pause vs cancel). */
-    abortIntents = new Map();
     /** Pending human-decision resolvers for Approval Gates awaiting a signal,
      *  keyed by "runId:nodeKey". An entry exists only while a node is `awaiting`. */
     approvalResolvers = new Map();
     /** Absolute paths of subworkflow specs currently on the execution stack (cycle guard). */
     subworkflowStack = new Set();
-    /** Scheduling guards for Run-level pause/cancel, keyed by runId.
-     *  Per-runId to prevent leakage across runs sharing the same interpreter. */
-    schedulingPaused = new Map();
-    schedulingCancelled = new Map();
     constructor(store, agentExecutor, programExecutor, options) {
         this.store = store;
         this.evaluator = new ExpressionEvaluator({ nowTimestamp: options?.nowTimestamp });
         this.agentExecutor = agentExecutor;
         this.programExecutor = programExecutor;
         this.artifactStore = new ArtifactStore(store.getBaseDir());
+        this.attemptArtifacts = new AttemptArtifactRecorder(this.artifactStore);
+        this.runControl = new RunControl(store);
         this.maxConcurrency = options?.maxConcurrency ?? 10;
         this.allowedSourceRoots = options?.allowedSourceRoots?.map((root) => resolve(root)) ?? [];
         this.sleep = options?.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
@@ -115,7 +71,10 @@ export class WorkflowInterpreter {
     async runToCompletion(ir, opts, runId) {
         const meta = this.store.readRunMeta(runId);
         try {
-            await this.executeNode(ir.root, this.buildContext(opts.input, runId), runId, {});
+            const ctx = this.buildContext(opts.input, runId);
+            await this.executeNode(ir.root, ctx, runId, {});
+            meta.output = evaluateWorkflowOutputs(ir, ctx, this.evaluator);
+            meta.error = undefined;
             meta.status = "completed";
         }
         catch (error) {
@@ -128,14 +87,20 @@ export class WorkflowInterpreter {
             }
             else {
                 meta.status = "failed";
-                void error;
+                meta.output = undefined;
+                meta.error = errorMessage(error);
+                if (rootState?.state === "completed") {
+                    rootState.state = "failed";
+                    rootState.error = meta.error;
+                    rootState.completedAt = new Date().toISOString();
+                    this.store.writeNodeState(runId, rootState);
+                }
             }
         }
         finally {
             // Clean up per-runId scheduling guards when the run settles,
             // so they don't leak memory across runs.
-            this.schedulingPaused.delete(runId);
-            this.schedulingCancelled.delete(runId);
+            this.runControl.clearSchedulingGuards(runId);
         }
         meta.updatedAt = new Date().toISOString();
         this.store.writeRunMeta(runId, meta);
@@ -150,16 +115,7 @@ export class WorkflowInterpreter {
      * for a fresh human decision on re-execution.
      */
     recoverStaleNodes(runId) {
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "running") {
-                nodeState.state = resetRunningForCrashRecovery(nodeState.state);
-                this.store.writeNodeState(runId, nodeState);
-            }
-            else if (nodeState.state === "awaiting") {
-                nodeState.state = resetAwaitingForCrashRecovery(nodeState.state);
-                this.store.writeNodeState(runId, nodeState);
-            }
-        }
+        this.runControl.recoverStaleNodes(runId);
     }
     /**
      * Deterministically replay a persisted Run and verify its reconstructed
@@ -225,7 +181,7 @@ export class WorkflowInterpreter {
      */
     replayNode(node, ctx, runId, dynamic, keyPrefix, recorded, reached, evaluator) {
         const resolved = resolveNodeKey(node.keyTemplate, dynamic);
-        const nodeKey = keyPrefix ? `${keyPrefix}/${resolved}` : resolved;
+        const nodeKey = withNodeKeyPrefix(keyPrefix, resolved);
         const rec = recorded.get(nodeKey);
         // A node absent from the recording was never reached on the original walk
         // (e.g. an untaken switch branch); skip it so we don't fabricate topology.
@@ -245,7 +201,7 @@ export class WorkflowInterpreter {
                 break;
             case "parallel":
                 (node.children ?? []).forEach((child, index) => {
-                    const branchDynamic = { ...dynamic, parallelBranchId: String(index) };
+                    const branchDynamic = nestedParallelBranchDynamic(dynamic, index);
                     this.replayNode(child, ctx, runId, branchDynamic, keyPrefix, recorded, reached, evaluator);
                 });
                 break;
@@ -290,7 +246,7 @@ export class WorkflowInterpreter {
                         this.replayNode(child, loopCtx, runId, loopDynamic, keyPrefix, recorded, reached, evaluator);
                         if (reached.size > before)
                             anyChildReached = true;
-                        const childKey = `${keyPrefix ? `${keyPrefix}/` : ""}${resolveNodeKey(child.keyTemplate, loopDynamic)}`;
+                        const childKey = withNodeKeyPrefix(keyPrefix, resolveNodeKey(child.keyTemplate, loopDynamic));
                         lastOutput = recorded.get(childKey)?.output ?? lastOutput;
                     }
                     if (!anyChildReached)
@@ -313,81 +269,13 @@ export class WorkflowInterpreter {
                 break;
         }
     }
-    /** Pause one running node as part of a Run-level pause operation. */
-    pauseRunningNode(runId, nodeKey) {
-        const state = this.store.readNodeState(runId, nodeKey);
-        if (!state || !canTransition(state.state, "paused")) {
-            return;
-        }
-        this.abortIntents.set(`${runId}:${nodeKey}`, "paused");
-        const controller = this.abortControllers.get(`${runId}:${nodeKey}`);
-        if (controller) {
-            controller.abort();
-        }
-        state.state = transition(state.state, "paused");
-        this.store.writeNodeState(runId, state);
-    }
-    /** Cancel one materialized node as part of Run-level cancel or fail-fast. */
-    cancelMaterializedNode(runId, nodeKey) {
-        this.abortIntents.set(`${runId}:${nodeKey}`, "cancelled");
-        const controller = this.abortControllers.get(`${runId}:${nodeKey}`);
-        if (controller) {
-            controller.abort();
-        }
-        const state = this.store.readNodeState(runId, nodeKey);
-        if (state && canTransition(state.state, "cancelled")) {
-            state.state = transition(state.state, "cancelled");
-            this.store.writeNodeState(runId, state);
-        }
-    }
-    /** Resolve the operator intent for an in-flight abort; defaults to paused. */
-    abortIntent(runId, nodeKey) {
-        return this.abortIntents.get(`${runId}:${nodeKey}`) ?? "paused";
-    }
-    /** True if the node has been persisted as terminal `cancelled` (e.g. by
-     * fail-fast). Used to avoid clobbering it when a still-running leaf later
-     * resolves/rejects. */
-    readAbortedStateOnDisk(runId, nodeKey) {
-        const state = this.store.readNodeState(runId, nodeKey)?.state;
-        return state === "paused" || state === "cancelled" ? state : undefined;
-    }
-    isStaleAttemptOnDisk(runId, nodeKey, attempt, startedAt) {
-        const current = this.store.readNodeState(runId, nodeKey);
-        return current !== undefined && current.attempt > attempt && current.startedAt !== startedAt;
-    }
-    syncInFrameAttemptFromDisk(runId, nodeKey, state) {
-        const current = this.store.readNodeState(runId, nodeKey);
-        if (current !== undefined && current.startedAt === state.startedAt && current.attempt > state.attempt) {
-            state.attempt = current.attempt;
-        }
-    }
     /**
      * Retry a failed executable Node. This is a local repair operation for the
      * target executable only; Run-level retry remains the operation that restores
      * Workflow progress from failed composite ancestors.
      */
     async retryNode(runId, nodeKey) {
-        const state = this.store.readNodeState(runId, nodeKey);
-        if (!state) {
-            throw new Error(`Node ${nodeKey} not found in run ${runId}`);
-        }
-        if (state.state !== "failed") {
-            throw new Error(`Cannot retry node ${nodeKey} in state '${state.state}': only failed executable nodes are retryable`);
-        }
-        if (state.kind !== "run.agent" && state.kind !== "run.program") {
-            throw new Error(`Cannot retry node ${nodeKey}: only failed executable nodes are retryable`);
-        }
-        const meta = this.store.readRunMeta(runId);
-        if (!meta)
-            throw new Error(`Run ${runId} not found`);
-        if (meta.status !== "failed") {
-            throw new Error(`Cannot retry node ${nodeKey}: node retry is accepted only when the Run is failed`);
-        }
-        const ir = this.store.readIr(runId);
-        const input = this.store.readInput(runId);
-        if (!ir || !input) {
-            throw new Error(`Cannot retry node ${nodeKey}: run ${runId} has no persisted IR or input`);
-        }
+        const { state, ir, input } = this.runControl.prepareNodeRetry(runId, nodeKey);
         // Resolve the node IR *before* mutating state. Subworkflow child IR is
         // compiled on demand and never persisted, so a child key like
         // `workflow/sub/child` is unresolvable here; reject explicitly rather than
@@ -398,9 +286,7 @@ export class WorkflowInterpreter {
         }
         // Control-plane reset (failed → pending), not a business-lifecycle
         // transition. `attempt` is incremented by executeNode.
-        state.state = resetFailedForRetry(state.state);
-        state.error = undefined;
-        this.store.writeNodeState(runId, state);
+        this.runControl.resetNodeForRetry(runId, state);
         const ctx = this.buildContext(input, runId);
         this.populateStepOutputs(runId, ctx);
         // Restore the parent dynamic value-context captured at first execution.
@@ -416,22 +302,7 @@ export class WorkflowInterpreter {
      * pauses all running nodes, and updates Run metadata to `paused`.
      */
     pauseRun(runId) {
-        const meta = this.store.readRunMeta(runId);
-        if (!meta)
-            throw new Error(`Run ${runId} not found`);
-        if (meta.status !== "running") {
-            throw new Error(`Cannot pause a run in state '${meta.status}'`);
-        }
-        this.schedulingPaused.set(runId, true);
-        // Pause all currently running nodes
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "running") {
-                this.pauseRunningNode(runId, nodeState.nodeKey);
-            }
-        }
-        meta.status = "paused";
-        meta.updatedAt = new Date().toISOString();
-        this.store.writeRunMeta(runId, meta);
+        this.runControl.pauseRun(runId);
     }
     /**
      * Cancel an entire Run. Validates Run is `running` or `paused`, sets
@@ -439,78 +310,14 @@ export class WorkflowInterpreter {
      * and updates Run metadata to `cancelled`.
      */
     cancelRun(runId) {
-        const meta = this.store.readRunMeta(runId);
-        if (!meta)
-            throw new Error(`Run ${runId} not found`);
-        if (meta.status !== "running" && meta.status !== "paused") {
-            throw new Error(`Cannot cancel a run in state '${meta.status}'`);
-        }
-        this.schedulingCancelled.set(runId, true);
-        // Override any prior pause abort intents to "cancelled" so that
-        // runToCompletion's catch block writes "cancelled" (not "paused").
-        for (const [key, intent] of this.abortIntents) {
-            if (key.startsWith(`${runId}:`) && intent === "paused") {
-                this.abortIntents.set(key, "cancelled");
-            }
-        }
-        // Cancel all currently running or awaiting nodes (abort the in-flight leaf
-        // or the pending approval wait, then transition to cancelled).
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "running" || nodeState.state === "awaiting") {
-                this.cancelMaterializedNode(runId, nodeState.nodeKey);
-            }
-        }
-        // Also transition paused nodes to cancelled (a prior pauseRun may have
-        // left nodes in "paused" state; cancel supersedes pause).
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "paused") {
-                if (canTransition(nodeState.state, "cancelled")) {
-                    nodeState.state = transition(nodeState.state, "cancelled");
-                    this.store.writeNodeState(runId, nodeState);
-                }
-            }
-        }
-        // Mark all pending nodes as cancelled (do NOT materialize unvisited nodes)
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "pending") {
-                if (canTransition(nodeState.state, "cancelled")) {
-                    nodeState.state = transition(nodeState.state, "cancelled");
-                    this.store.writeNodeState(runId, nodeState);
-                }
-            }
-        }
-        meta.status = "cancelled";
-        meta.updatedAt = new Date().toISOString();
-        this.store.writeRunMeta(runId, meta);
+        this.runControl.cancelRun(runId);
     }
     /**
      * Resume an entire paused Run. Validates Run is `paused`, clears scheduling
      * guards, recovers stale nodes, and re-executes from root.
      */
     async resumeRun(runId) {
-        const meta = this.store.readRunMeta(runId);
-        if (!meta)
-            throw new Error(`Run ${runId} not found`);
-        if (meta.status !== "paused") {
-            throw new Error(`Cannot resume a run in state '${meta.status}'`);
-        }
-        // Clear scheduling guards for this run
-        this.schedulingPaused.delete(runId);
-        this.schedulingCancelled.delete(runId);
-        // Recover stale running nodes back to pending
-        this.recoverStaleNodes(runId);
-        // Also reset paused nodes back to pending so runToCompletion can re-execute them.
-        // Without this, executeNode sees the 'paused' state and throws NodeAbortedError,
-        // making the run permanently stuck.
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "paused") {
-                nodeState.state = resetPausedForRunResume(nodeState.state);
-                this.store.writeNodeState(runId, nodeState);
-            }
-        }
-        meta.status = "running";
-        meta.updatedAt = new Date().toISOString();
-        this.store.writeRunMeta(runId, meta);
+        this.runControl.resumeRun(runId);
     }
     /**
      * Retry a failed Run. Validates Run is `failed`, resets failed materialized
@@ -518,33 +325,7 @@ export class WorkflowInterpreter {
      * re-executes from root. Same Run ID, no new Run.
      */
     retryRun(runId) {
-        const meta = this.store.readRunMeta(runId);
-        if (!meta)
-            throw new Error(`Run ${runId} not found`);
-        if (meta.status !== "failed") {
-            throw new Error(`Cannot retry a run in state '${meta.status}'`);
-        }
-        // Clear scheduling guards for this run
-        this.schedulingPaused.delete(runId);
-        this.schedulingCancelled.delete(runId);
-        // Reset failed and paused materialized nodes to pending (preserve completed).
-        // Paused nodes can exist in a "failed" run if it was paused before a sibling
-        // failed (e.g. parallel lane failure while another lane was paused).
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "failed") {
-                nodeState.state = resetFailedForRetry(nodeState.state);
-                nodeState.error = undefined;
-                this.store.writeNodeState(runId, nodeState);
-            }
-            else if (nodeState.state === "paused") {
-                nodeState.state = resetPausedForRunResume(nodeState.state);
-                this.store.writeNodeState(runId, nodeState);
-            }
-        }
-        meta.status = "running";
-        meta.runAttempt++;
-        meta.updatedAt = new Date().toISOString();
-        this.store.writeRunMeta(runId, meta);
+        this.runControl.retryRun(runId);
     }
     // ─── Node execution dispatch ──────────────────────────────────
     async executeNode(node, ctx, runId, dynamic, keyPrefix, isContinuation, overrideNodeKey) {
@@ -552,7 +333,7 @@ export class WorkflowInterpreter {
         // node's stable identity (and thus the agent's acpx session name) survives
         // across loop/fanout/lane/subworkflow dynamics that are not re-derived here.
         const resolved = resolveNodeKey(node.keyTemplate, dynamic);
-        const nodeKey = overrideNodeKey ?? (keyPrefix ? `${keyPrefix}/${resolved}` : resolved);
+        const nodeKey = overrideNodeKey ?? withNodeKeyPrefix(keyPrefix, resolved);
         // Check if already completed (from prior run)
         const existing = this.store.readNodeState(runId, nodeKey);
         if (existing?.state === "completed") {
@@ -564,25 +345,20 @@ export class WorkflowInterpreter {
         }
         const continuation = Boolean(isContinuation || isPausedContinuationState(existing));
         // Initialize state
-        const state = existing ?? createInitialNodeState(nodeKey, node.id, node.kind);
+        const definitionHash = hashIrNode(node);
+        const state = existing ?? createInitialNodeState(nodeKey, node.id, node.kind, definitionHash);
+        if (!state.definitionHash)
+            state.definitionHash = definitionHash;
         if (state.state === "failed") {
             throw new Error(`Node ${nodeKey} is in failed state`);
         }
-        // Run-level scheduling guards: if this Run is paused or cancelled,
-        // don't schedule new work.
-        if (this.schedulingPaused.get(runId) && state.state === "pending") {
-            throw new NodeAbortedError(nodeKey, "paused");
-        }
-        if (this.schedulingCancelled.get(runId) && state.state === "pending") {
-            if (canTransition(state.state, "cancelled")) {
-                state.state = transition(state.state, "cancelled");
-                this.store.writeNodeState(runId, state);
-            }
-            throw new NodeAbortedError(nodeKey, "cancelled");
+        const schedulingAbort = this.runControl.applySchedulingGuard(runId, state);
+        if (schedulingAbort) {
+            throw new NodeAbortedError(nodeKey, schedulingAbort);
         }
         // Set up abort controller
         const controller = new AbortController();
-        this.abortControllers.set(`${runId}:${nodeKey}`, controller);
+        this.runControl.registerAbortController(runId, nodeKey, controller);
         // Transition to running
         if (canTransition(state.state, "running")) {
             state.state = transition(state.state, "running");
@@ -614,8 +390,6 @@ export class WorkflowInterpreter {
                     const leaf = await this.executeAgent(node, ctx, runId, controller.signal, nodeKey, continuation);
                     output = leaf.output;
                     artifactRefs = leaf.artifactRefs;
-                    if (leaf.renderedPrompt)
-                        state.renderedPrompt = leaf.renderedPrompt;
                     break;
                 }
                 case "run.program": {
@@ -625,10 +399,10 @@ export class WorkflowInterpreter {
                     break;
                 }
                 case "parallel":
-                    output = await this.executeParallel(node, ctx, runId, dynamic, keyPrefix);
+                    output = await this.executeParallel(node, ctx, runId, dynamic, nodeKey, keyPrefix);
                     break;
                 case "fanout":
-                    output = await this.executeFanout(node, ctx, runId, dynamic, keyPrefix);
+                    output = await this.executeFanout(node, ctx, runId, dynamic, nodeKey, keyPrefix);
                     break;
                 case "switch":
                     output = await this.executeSwitch(node, ctx, runId, dynamic, keyPrefix);
@@ -653,15 +427,16 @@ export class WorkflowInterpreter {
             }
             // If a Run-level resume already re-entered this node, a late result from
             // the old attempt must not overwrite the newer attempt's state.
-            if (this.isStaleAttemptOnDisk(runId, nodeKey, state.attempt, state.startedAt)) {
+            if (this.runControl.isStaleAttemptOnDisk(runId, nodeKey, state.attempt, state.startedAt)) {
                 return output;
             }
-            this.syncInFrameAttemptFromDisk(runId, nodeKey, state);
+            this.runControl.syncInFrameAttemptFromDisk(runId, nodeKey, state);
+            this.syncAgentTelemetryFromDisk(runId, nodeKey, state);
             // Transition to completed unless an external pause/cancel already changed
             // this node's state on disk while we were awaiting the leaf.
-            const abortedState = this.readAbortedStateOnDisk(runId, nodeKey);
+            const abortedState = this.runControl.readAbortedStateOnDisk(runId, nodeKey);
             if (abortedState) {
-                throw new NodeAbortedError(nodeKey, abortedState, artifactRefs, output, state.renderedPrompt);
+                throw new NodeAbortedError(nodeKey, abortedState, artifactRefs, output);
             }
             state.state = "completed";
             state.error = undefined;
@@ -682,29 +457,29 @@ export class WorkflowInterpreter {
                 throw error;
             }
             if (error instanceof NodeAbortedError) {
-                if (this.isStaleAttemptOnDisk(runId, nodeKey, state.attempt, state.startedAt)) {
+                if (this.runControl.isStaleAttemptOnDisk(runId, nodeKey, state.attempt, state.startedAt)) {
                     throw error;
                 }
-                this.syncInFrameAttemptFromDisk(runId, nodeKey, state);
+                this.runControl.syncInFrameAttemptFromDisk(runId, nodeKey, state);
                 // Transition this node to the same state as the child that was aborted.
                 state.state = error.state === "paused" ? "paused" : "cancelled";
                 state.error = abortedNodeError(error.state);
-                // Preserve any output + partial transcript artifacts from the aborted leaf.
+                // Preserve any output + partial Agent artifacts from the aborted leaf.
                 if (error.output !== undefined)
                     state.output = error.output;
                 if (error.artifactRefs)
                     state.artifactRefs = error.artifactRefs;
-                state.renderedPrompt = error.renderedPrompt ?? state.renderedPrompt ?? this.store.readNodeState(runId, nodeKey)?.renderedPrompt;
+                this.syncAgentTelemetryFromDisk(runId, nodeKey, state);
                 this.store.writeNodeState(runId, state);
                 throw error;
             }
             // Don't clobber an external pause/cancel that landed while this node's
             // leaf was failing; keep the control-plane abort as the observed outcome.
-            if (this.isStaleAttemptOnDisk(runId, nodeKey, state.attempt, state.startedAt)) {
+            if (this.runControl.isStaleAttemptOnDisk(runId, nodeKey, state.attempt, state.startedAt)) {
                 throw error;
             }
-            this.syncInFrameAttemptFromDisk(runId, nodeKey, state);
-            const abortedState = this.readAbortedStateOnDisk(runId, nodeKey);
+            this.runControl.syncInFrameAttemptFromDisk(runId, nodeKey, state);
+            const abortedState = this.runControl.readAbortedStateOnDisk(runId, nodeKey);
             if (abortedState) {
                 throw new NodeAbortedError(nodeKey, abortedState);
             }
@@ -720,13 +495,13 @@ export class WorkflowInterpreter {
             if (error instanceof GuardFailureError) {
                 state.output = error.output;
             }
+            this.syncAgentTelemetryFromDisk(runId, nodeKey, state);
             state.completedAt = new Date().toISOString();
             this.store.writeNodeState(runId, state);
             throw error;
         }
         finally {
-            this.abortControllers.delete(`${runId}:${nodeKey}`);
-            this.abortIntents.delete(`${runId}:${nodeKey}`);
+            this.runControl.clearInFlightNode(runId, nodeKey);
         }
     }
     // ─── Kind-specific execution ───────────────────────────────────
@@ -738,12 +513,12 @@ export class WorkflowInterpreter {
             }
             catch (error) {
                 if (error instanceof ScopeCompleted)
-                    return error.output;
+                    return { output: error.output };
                 throw error;
             }
         }
         // Pipeline output: map of step outputs
-        return { ...ctx.steps };
+        return { output: { ...ctx.steps } };
     }
     async executeAgent(node, ctx, runId, signal, nodeKey, continuation) {
         const retry = node.metadata.retry;
@@ -757,52 +532,96 @@ export class WorkflowInterpreter {
         for (let attempt = 0;; attempt++) {
             const attemptNo = this.store.readNodeState(runId, nodeKey)?.attempt ?? attempt + 1;
             let preparedPrompt;
+            let renderedSessionKey;
             try {
                 preparedPrompt = renderAgentRequestPrompt(node, ctx, this.evaluator, Boolean(continuation), attempt > 0);
+                renderedSessionKey = renderAgentSessionKey(node, ctx, this.evaluator);
             }
             catch (error) {
                 const use = node.metadata.agent?.use ?? "?";
                 throw new LeafExecutionError(`Agent step '${node.id}' (use: ${use}) failed (config): Failed to evaluate agent configuration template: ${error instanceof Error ? error.message : String(error)}`);
             }
-            const liveRefs = this.startAgentAttemptArtifacts(runId, nodeKey, attemptNo, preparedPrompt);
-            pushUnique(allArtifactRefs, liveRefs);
-            this.publishRunningAgentAttempt(runId, nodeKey, preparedPrompt, allArtifactRefs);
+            const rawAcpDebug = process.env.ACPUS_AGENT_RAW_ACP_DEBUG === "1";
+            const liveArtifacts = this.attemptArtifacts.startAgentAttempt(runId, nodeKey, attemptNo, preparedPrompt, { rawAcpDebug });
+            this.attemptArtifacts.mergeAttemptRefs(allArtifactRefs, liveArtifacts.artifactRefs);
             const streamDiagnostics = [];
+            let sawStdoutStream = false;
+            const activity = new AgentTelemetryAccumulator({
+                attempt: attemptNo,
+                inputText: preparedPrompt,
+                inputArtifactRef: liveArtifacts.promptRef,
+                onTelemetry: (attemptTelemetry) => {
+                    this.publishAgentTelemetry(runId, nodeKey, attemptTelemetry);
+                }
+            });
+            this.publishRunningAgentAttempt(runId, nodeKey, allArtifactRefs, activity.snapshot("running"));
             const result = await this.agentExecutor.execute({
                 node,
                 context: ctx,
                 signal,
                 nodeKey,
                 prompt: preparedPrompt,
+                sessionKey: renderedSessionKey,
                 continuation,
                 retry: attempt > 0,
                 onStream: (stream, chunk) => {
                     if (stream === "stdout" && chunk.length > 0) {
+                        sawStdoutStream = true;
+                        if (rawAcpDebug) {
+                            try {
+                                this.attemptArtifacts.appendAgentRawAcpDebug(runId, nodeKey, attemptNo, chunk);
+                            }
+                            catch (error) {
+                                streamDiagnostics.push(`failed to append raw ACP debug stream: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
                         try {
-                            this.appendAgentTranscript(runId, nodeKey, attemptNo, chunk);
+                            activity.append(chunk);
                         }
                         catch (error) {
-                            streamDiagnostics.push(`failed to append live agent transcript: ${error instanceof Error ? error.message : String(error)}`);
+                            streamDiagnostics.push(`failed to parse live agent telemetry: ${error instanceof Error ? error.message : String(error)}`);
                         }
                     }
                 }
             });
-            // Persist per-attempt human-readable agent IO plus raw protocol artifacts
+            try {
+                if (!sawStdoutStream && result.stdout !== undefined)
+                    activity.append(result.stdout);
+                activity.flush();
+            }
+            catch (error) {
+                streamDiagnostics.push(`failed to parse live agent telemetry: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (result.responseText !== undefined)
+                activity.setResponseText(result.responseText);
+            const abortIntent = result.partial ? this.runControl.abortIntent(runId, nodeKey) : undefined;
+            const finalAttemptState = abortIntent
+                ?? (result.failureKind || (result.error && !result.partial) ? "failed" : "completed");
+            const completedAt = new Date().toISOString();
+            // Persist per-attempt human-readable agent IO plus diagnostics
             // when the executor exposed them. Refs flow back to executeNode via the
             // return value / thrown error (no shared mutable field).
-            const artifactRefs = result.responseText !== undefined || result.stdout !== undefined || result.stderr !== undefined
-                ? this.writeAgentArtifacts(runId, nodeKey, attemptNo, {
+            const finalized = result.responseText !== undefined || result.stderr !== undefined
+                ? this.attemptArtifacts.finalizeAgentAttempt(runId, nodeKey, attemptNo, {
                     responseText: result.responseText,
-                    transcript: result.stdout,
-                    stderr: mergeStderrDiagnostics(result.stderr, streamDiagnostics)
+                    stderr: result.stderr,
+                    diagnostics: streamDiagnostics
                 })
                 : result.artifactRefs;
+            const artifactRefs = Array.isArray(finalized) ? finalized : finalized?.artifactRefs;
+            const responseRef = !Array.isArray(finalized) ? finalized?.responseRef : undefined;
+            if (responseRef)
+                activity.setOutputArtifactRef(responseRef);
+            const finalTelemetry = activity.snapshot(finalAttemptState, completedAt);
+            const telemetryRef = this.attemptArtifacts.writeAgentTelemetry(runId, nodeKey, attemptNo, finalTelemetry);
+            this.publishAgentTelemetry(runId, nodeKey, finalTelemetry);
             if (artifactRefs)
-                pushUnique(allArtifactRefs, artifactRefs);
+                this.attemptArtifacts.mergeAttemptRefs(allArtifactRefs, artifactRefs);
+            this.attemptArtifacts.mergeAttemptRefs(allArtifactRefs, [telemetryRef]);
             if (result.partial) {
-                // Operator abort → carry output + transcript refs on the abort error;
+                // Operator abort → carry output + partial Agent artifact refs on the abort error;
                 // executeNode persists the paused/cancelled state.
-                throw new NodeAbortedError(nodeKey, this.abortIntent(runId, nodeKey), allArtifactRefs.length > 0 ? allArtifactRefs : undefined, result.output, preparedPrompt);
+                throw new NodeAbortedError(nodeKey, abortIntent ?? "paused", allArtifactRefs.length > 0 ? allArtifactRefs : undefined, result.output);
             }
             // parse/schema failures are retryable while attempts remain.
             const retryable = result.failureKind === "parse" || result.failureKind === "schema";
@@ -823,8 +642,7 @@ export class WorkflowInterpreter {
             // Agent output is wrapped in an envelope for parity with program steps.
             return {
                 output: { output: result.output },
-                artifactRefs: allArtifactRefs.length > 0 ? allArtifactRefs : artifactRefs,
-                renderedPrompt: result.prompt ?? result.renderedPrompt
+                artifactRefs: allArtifactRefs.length > 0 ? allArtifactRefs : artifactRefs
             };
         }
     }
@@ -832,73 +650,49 @@ export class WorkflowInterpreter {
         const result = await this.programExecutor.execute({ node, context: ctx, signal, nodeKey });
         // Operator abort → paused/cancelled (carry output on the abort error).
         if (result.partial) {
-            throw new NodeAbortedError(nodeKey, this.abortIntent(runId, nodeKey), undefined, result.output);
+            throw new NodeAbortedError(nodeKey, this.runControl.abortIntent(runId, nodeKey), undefined, result.output);
         }
         // Always persist stdout/stderr as artifacts (even when empty). An artifact
         // write failure is itself non-recoverable.
-        const artifactRefs = this.writeProgramArtifacts(runId, nodeKey, result.stdout ?? "", result.stderr ?? "");
+        const artifactRefs = this.attemptArtifacts.writeProgramArtifacts(runId, nodeKey, result.stdout ?? "", result.stderr ?? "");
         // Non-recoverable failures fail the node.
         if (result.failureKind) {
             throw new LeafExecutionError(`Program step '${node.id}' failed (${result.failureKind}): ${result.error ?? "unknown"}`, artifactRefs);
         }
-        // A non-zero exit code is step data. Expose output + exit_code envelope.
+        // exit code is allow-listed by `expect.exit_code` (default `[0]`); other
         return { output: { output: result.output, exit_code: result.exitCode ?? 0 }, artifactRefs };
     }
-    /** Write stdout.log/stderr.log artifacts; returns their URIs. */
-    writeProgramArtifacts(runId, nodeKey, stdout, stderr) {
-        const out = this.artifactStore.write(runId, nodeKey, "stdout.log", stdout);
-        const err = this.artifactStore.write(runId, nodeKey, "stderr.log", stderr);
-        return [out.uri, err.uri];
-    }
-    /** Write per-attempt agent response/protocol artifacts; returns their URIs. */
-    writeAgentArtifacts(runId, nodeKey, attemptNo, content) {
-        const prefix = this.agentAttemptPrefix(attemptNo);
-        const refs = [];
-        if (content.prompt !== undefined) {
-            refs.push(this.artifactStore.write(runId, nodeKey, `${prefix}.prompt.md`, content.prompt).uri);
-        }
-        if (content.responseText !== undefined) {
-            refs.push(this.artifactStore.write(runId, nodeKey, `${prefix}.response.md`, content.responseText).uri);
-        }
-        if (content.transcript !== undefined) {
-            // Transcript is pre-created and append-built while acpx runs. Finalization
-            // returns the live artifact ref without overwriting accumulated NDJSON.
-            refs.push(this.artifactStore.append(runId, nodeKey, `${prefix}.transcript.jsonl`, "").uri);
-        }
-        if (content.stderr !== undefined) {
-            refs.push(this.artifactStore.write(runId, nodeKey, `${prefix}.stderr.log`, content.stderr).uri);
-        }
-        return refs;
-    }
-    /** Pre-create live Agent attempt artifacts and return their refs immediately. */
-    startAgentAttemptArtifacts(runId, nodeKey, attemptNo, prompt) {
-        const prefix = this.agentAttemptPrefix(attemptNo);
-        const promptRef = this.artifactStore.write(runId, nodeKey, `${prefix}.prompt.md`, prompt);
-        const transcriptRef = this.artifactStore.create(runId, nodeKey, `${prefix}.transcript.jsonl`);
-        return [promptRef.uri, transcriptRef.uri];
-    }
-    appendAgentTranscript(runId, nodeKey, attemptNo, chunk) {
-        this.artifactStore.append(runId, nodeKey, `${this.agentAttemptPrefix(attemptNo)}.transcript.jsonl`, chunk);
-    }
-    publishRunningAgentAttempt(runId, nodeKey, prompt, artifactRefs) {
+    publishRunningAgentAttempt(runId, nodeKey, artifactRefs, attemptTelemetry) {
         const state = this.store.readNodeState(runId, nodeKey);
         if (!state)
             return;
-        state.renderedPrompt = prompt;
         state.artifactRefs = [...artifactRefs];
+        state.agentTelemetry = upsertAgentAttemptTelemetry(state.agentTelemetry, attemptTelemetry);
         this.store.writeNodeState(runId, state);
     }
-    agentAttemptPrefix(attemptNo) {
-        return `attempt-${String(Math.max(0, attemptNo)).padStart(3, "0")}`;
+    publishAgentTelemetry(runId, nodeKey, attemptTelemetry) {
+        const state = this.store.readNodeState(runId, nodeKey);
+        if (!state)
+            return;
+        state.agentTelemetry = upsertAgentAttemptTelemetry(state.agentTelemetry, attemptTelemetry);
+        this.store.writeNodeState(runId, state);
+    }
+    syncAgentTelemetryFromDisk(runId, nodeKey, state) {
+        state.agentTelemetry = this.store.readNodeState(runId, nodeKey)?.agentTelemetry ?? state.agentTelemetry;
     }
-    async executeParallel(node, ctx, runId, dynamic, keyPrefix) {
+    async executeParallel(node, ctx, runId, dynamic, nodeKey, keyPrefix) {
         const children = node.children ?? [];
         const maxConcurrency = node.metadata.max_concurrency ?? this.maxConcurrency;
         const join = node.metadata.join ?? "all";
+        if (join === "all") {
+            children.forEach((child, index) => {
+                this.materializePendingNode(runId, child, nestedParallelBranchDynamic(dynamic, index), keyPrefix);
+            });
+        }
         const limit = pLimit(maxConcurrency);
         // Each branch resolves to { child, output } so race can identify the winner.
         const branchPromises = children.map((child, index) => limit(async () => {
-            const branchDynamic = { ...dynamic, parallelBranchId: String(index) };
+            const branchDynamic = nestedParallelBranchDynamic(dynamic, index);
             let output;
             try {
                 output = await this.executeNode(child, { ...ctx, steps: { ...ctx.steps } }, runId, branchDynamic, keyPrefix);
@@ -921,11 +715,11 @@ export class WorkflowInterpreter {
                 branchPromises.forEach((p) => void p.catch(() => undefined));
                 const mapOutput = { [winner.child.id]: winner.output };
                 ctx.steps[winner.child.id] = winner.output;
-                return mapOutput;
+                return { output: mapOutput };
             }
             catch (error) {
                 if (!(error instanceof NodeAbortedError)) {
-                    this.cancelDescendantsInScope(runId, node, dynamic);
+                    this.runControl.cancelDescendantsInScope(runId, nodeKey);
                 }
                 branchPromises.forEach((p) => void p.catch(() => undefined));
                 throw error;
@@ -943,7 +737,7 @@ export class WorkflowInterpreter {
         catch (error) {
             if (!(error instanceof NodeAbortedError)) {
                 // Genuine failure or cancel — fast-stop: cancel still-running siblings
-                this.cancelDescendantsInScope(runId, node, dynamic);
+                this.runControl.cancelDescendantsInScope(runId, nodeKey);
             }
             branchPromises.forEach((p) => void p.catch(() => undefined));
             throw error;
@@ -953,65 +747,9 @@ export class WorkflowInterpreter {
             mapOutput[child.id] = output;
             ctx.steps[child.id] = output;
         }
-        return mapOutput;
+        return { output: mapOutput };
     }
-    /**
-     * Cancel still-running/pending/awaiting descendant nodes of a failed
-     * composite (parallel or fanout), scoped to the given dynamic context. A
-     * descendant must (a) be one of the composite's descendant IR node ids and
-     * (b) share every dynamic dimension (item/lane/round) the composite already
-     * carries — so concurrent sibling fanout lanes outside this scope are not
-     * affected.
-     *
-     * NOTE: pass the composite's OWN dynamic. For a parallel this scopes to the
-     * current lane (item/lane present). For a fanout, the dynamic does NOT yet
-     * carry this fanout's lane (lanes are introduced for its children), so the
-     * scope spans ALL of the fanout's lanes — exactly the fail-fast intent.
-     */
-    descendantsInScope(runId, node, dynamic, action) {
-        const descendantIds = new Set();
-        const collect = (n) => {
-            for (const c of n.children ?? []) {
-                descendantIds.add(c.id);
-                collect(c);
-            }
-            for (const b of n.branches ?? []) {
-                for (const c of b.children) {
-                    descendantIds.add(c.id);
-                    collect(c);
-                }
-            }
-        };
-        collect(node);
-        // Key segments that must be present for an instance to share this scope.
-        // Values are sanitized to match resolveNodeKey's on-disk encoding (e.g. an
-        // item id "file:alpha" is stored as "item:file_alpha").
-        const scopeSegments = [];
-        if (dynamic.fanoutItemId !== undefined)
-            scopeSegments.push(`item:${sanitizeValue(String(dynamic.fanoutItemId))}`);
-        if (dynamic.laneId !== undefined)
-            scopeSegments.push(`lane:${sanitizeValue(String(dynamic.laneId))}`);
-        if (dynamic.loopRound !== undefined)
-            scopeSegments.push(`round:${dynamic.loopRound}`);
-        for (const ns of this.store.listNodeStates(runId)) {
-            if (ns.state !== "running" && ns.state !== "awaiting" && ns.state !== "pending")
-                continue;
-            if (!descendantIds.has(ns.nodeId))
-                continue;
-            const segs = ns.nodeKey.split("/");
-            if (!scopeSegments.every((s) => segs.includes(s)))
-                continue;
-            action(runId, ns.nodeKey);
-        }
-    }
-    /**
-     * Cancel still-running/pending descendant nodes of a failed composite
-     * (parallel `join: all`, or fanout `join: all` fail-fast).
-     */
-    cancelDescendantsInScope(runId, node, dynamic) {
-        this.descendantsInScope(runId, node, dynamic, (rid, key) => this.cancelMaterializedNode(rid, key));
-    }
-    async executeFanout(node, ctx, runId, dynamic, keyPrefix) {
+    async executeFanout(node, ctx, runId, dynamic, nodeKey, keyPrefix) {
         const overExpr = node.metadata.over;
         if (!overExpr) {
             throw new Error(`fanout node ${node.id} missing 'over' expression`);
@@ -1026,6 +764,24 @@ export class WorkflowInterpreter {
         // Success target (how many lanes must succeed). Default follows join.
         const defaultMinSuccess = join === "race" ? 1 : join === "quorum" ? (quorum ?? 1) : items.length;
         const minSuccess = successCriteria?.min_success ?? defaultMinSuccess;
+        const lanePlan = items.map((item, index) => {
+            const keyCtx = { ...ctx, item, item_index: index };
+            const itemId = this.extractItemId(item, node.metadata.key, index, keyCtx, this.evaluator);
+            const laneDynamic = { fanoutItemId: itemId, laneId: String(index) };
+            return {
+                itemId,
+                keyCtx,
+                itemDynamic: laneDynamic
+            };
+        });
+        if (join === "all") {
+            for (const lane of lanePlan) {
+                const itemDynamic = { ...dynamic, ...lane.itemDynamic };
+                for (const child of children) {
+                    this.materializePendingNode(runId, child, itemDynamic, keyPrefix);
+                }
+            }
+        }
         // Fail-fast: once enough lanes have failed that the success target is
         // unreachable (failures > total - minSuccess), abort the whole fanout —
         // cancel every still-running/pending lane subtree and reject to short
@@ -1037,14 +793,12 @@ export class WorkflowInterpreter {
         // Each lane resolves to a LaneResult. A tolerable failure is captured (does
         // not reject) so the join/min_success logic can run. A NodeAbortedError
         // (operator pause/cancel) re-throws so it propagates to the parent.
-        const lanePromises = items.map((item, index) => limit(async () => {
-            const keyCtx = { ...ctx, item, item_index: index };
-            const itemId = this.extractItemId(item, node.metadata.key, index, keyCtx, this.evaluator);
-            const itemDynamic = { ...dynamic, fanoutItemId: itemId, laneId: String(index) };
+        const lanePromises = lanePlan.map((lane) => limit(async () => {
+            const itemDynamic = { ...dynamic, ...lane.itemDynamic };
             const itemCtx = {
-                ...keyCtx,
+                ...lane.keyCtx,
                 steps: { ...ctx.steps },
-                item_id: itemId
+                item_id: lane.itemId
             };
             try {
                 let laneOutput;
@@ -1071,7 +825,7 @@ export class WorkflowInterpreter {
                     // so it spans every lane), then reject to short-circuit the wait.
                     if (!failFastTriggered) {
                         failFastTriggered = true;
-                        this.cancelDescendantsInScope(runId, node, dynamic);
+                        this.runControl.cancelDescendantsInScope(runId, nodeKey);
                     }
                     throw error;
                 }
@@ -1085,7 +839,7 @@ export class WorkflowInterpreter {
             throw new Error(`fanout ${node.id}: ${successes.length} successful lanes, requires ${minSuccess}`);
         }
         // outputMerge: "array" of successful lane outputs.
-        return successes.map((r) => r.output);
+        return { output: successes.map((r) => r.output) };
     }
     /**
      * Resolve fanout lanes per the wait strategy. Lanes never reject on normal
@@ -1116,6 +870,13 @@ export class WorkflowInterpreter {
         // and the rejection propagates to fail the fanout immediately.
         return Promise.all(lanePromises);
     }
+    materializePendingNode(runId, node, dynamic, keyPrefix) {
+        const resolved = resolveNodeKey(node.keyTemplate, dynamic);
+        const nodeKey = withNodeKeyPrefix(keyPrefix, resolved);
+        if (this.store.readNodeState(runId, nodeKey))
+            return;
+        this.store.writeNodeState(runId, createInitialNodeState(nodeKey, node.id, node.kind, hashIrNode(node)));
+    }
     async executeSwitch(node, ctx, runId, dynamic, keyPrefix) {
         const branches = node.branches ?? [];
         for (const branch of branches) {
@@ -1129,11 +890,11 @@ export class WorkflowInterpreter {
                         }
                         catch (error) {
                             if (error instanceof ScopeCompleted)
-                                return error.output;
+                                return { output: error.output };
                             throw error;
                         }
                     }
-                    return lastOutput;
+                    return { output: lastOutput };
                 }
             }
             else {
@@ -1145,11 +906,11 @@ export class WorkflowInterpreter {
                     }
                     catch (error) {
                         if (error instanceof ScopeCompleted)
-                            return error.output;
+                            return { output: error.output };
                         throw error;
                     }
                 }
-                return lastOutput;
+                return { output: lastOutput };
             }
         }
         throw new Error(`Switch node ${node.id}: no branch matched and no default`);
@@ -1178,13 +939,13 @@ export class WorkflowInterpreter {
                 }
                 catch (error) {
                     if (error instanceof ScopeCompleted)
-                        return error.output;
+                        return { output: error.output };
                     throw error;
                 }
             }
         }
         // outputMerge: "last"
-        return lastOutput;
+        return { output: lastOutput };
     }
     executeGuard(node, ctx) {
         const when = node.metadata.when;
@@ -1196,15 +957,15 @@ export class WorkflowInterpreter {
         if (action !== "continue" && action !== "fail" && action !== "complete") {
             throw new Error(`guard node ${node.id}: action must be continue, fail, or complete`);
         }
-        const messageTemplate = node.metadata.message;
-        const message = typeof messageTemplate === "string" ? this.evaluator.evaluateTemplate(messageTemplate, ctx) : undefined;
-        const output = { matched, action };
-        if (message !== undefined)
-            output.message = message;
+        const guardOutput = { matched, action };
         if (action === "fail") {
-            throw new GuardFailureError(message ?? `Guard '${node.id}' failed`, output);
+            const messageTemplate = node.metadata.message;
+            const message = typeof messageTemplate === "string" ? this.evaluator.evaluateTemplate(messageTemplate, ctx) : undefined;
+            if (message !== undefined)
+                guardOutput.message = message;
+            throw new GuardFailureError(message ?? `Guard '${node.id}' failed`, { output: guardOutput });
         }
-        return { output, completeScope: action === "complete" };
+        return { output: { output: guardOutput }, completeScope: action === "complete" };
     }
     async executeApproval(node, ctx, runId, signal, nodeKey) {
         const timeout = node.metadata.timeout;
@@ -1225,7 +986,7 @@ export class WorkflowInterpreter {
                 cleanup();
                 // Honor the operator intent recorded by Run-level pause/cancel. An
                 // awaiting gate is normally cancelled (awaiting → cancelled).
-                reject(new NodeAbortedError(nodeKey, this.abortIntent(runId, nodeKey)));
+                reject(new NodeAbortedError(nodeKey, this.runControl.abortIntent(runId, nodeKey)));
             };
             const timer = timeoutMs
                 ? setTimeout(() => {
@@ -1234,10 +995,10 @@ export class WorkflowInterpreter {
                     // `approve`/`reject` resolve; `fail`/`escalate` fail the node
                     // (escalate has no runtime channel yet — see roadmap).
                     if (onTimeout === "approve") {
-                        resolve({ approved: true, decision: "timeout", at });
+                        resolve({ output: { approved: true, decision: "timeout", at } });
                     }
                     else if (onTimeout === "reject") {
-                        resolve({ approved: false, decision: "timeout", at });
+                        resolve({ output: { approved: false, decision: "timeout", at } });
                     }
                     else {
                         reject(new Error(`Approval timed out after ${timeout} (on_timeout: ${onTimeout ?? "fail"})`));
@@ -1257,7 +1018,7 @@ export class WorkflowInterpreter {
             // cleanup().
             this.approvalResolvers.set(resolverKey, (approved) => {
                 cleanup();
-                resolve({ approved, decision: approved ? "approved" : "rejected", at });
+                resolve({ output: { approved, decision: approved ? "approved" : "rejected", at } });
             });
         });
     }
@@ -1305,7 +1066,7 @@ export class WorkflowInterpreter {
         // template string.
         const childInput = {};
         for (const [key, value] of Object.entries(inputSpec ?? {})) {
-            childInput[key] = this.evaluateInputValue(value, ctx);
+            childInput[key] = evaluateTemplatedValue(value, ctx, this.evaluator);
         }
         // Validate subworkflow input against the child IR's compiled input schema.
         const validatedChildInput = validateInput(compiled.ir.input, childInput);
@@ -1315,7 +1076,7 @@ export class WorkflowInterpreter {
         try {
             const childCtx = this.buildContext(validatedChildInput, runId);
             await this.executeNode(compiled.ir.root, childCtx, runId, dynamic, nodeKey);
-            return { ...childCtx.steps };
+            return { output: evaluateWorkflowOutputs(compiled.ir, childCtx, this.evaluator) };
         }
         finally {
             this.subworkflowStack.delete(childAbs);
@@ -1328,16 +1089,6 @@ export class WorkflowInterpreter {
             return;
         throw new Error(message);
     }
-    /** Evaluate a subworkflow input value, preserving native type for single expressions. */
-    evaluateInputValue(value, ctx) {
-        if (typeof value !== "string")
-            return value;
-        const single = value.match(/^\s*\$\{\{(.+)\}\}\s*$/s);
-        if (single) {
-            return this.evaluator.evaluateExpression(single[1].trim(), ctx);
-        }
-        return this.evaluator.evaluateTemplate(value, ctx);
-    }
     // ─── Helpers ────────────────────────────────────────────────────
     buildContext(input, runId) {
         return { input, steps: {}, run_id: runId };
@@ -1395,17 +1146,8 @@ export class WorkflowInterpreter {
     }
     /** Extract the step ID from a resolved node key. The ID is the last path segment before dynamic dims. */
     extractNodeIdFromKey(nodeKey) {
-        // Key format: "workflow/step-a" or "workflow/mapped/item:0/lane:0"
-        // The node id is the second segment (after "workflow/") for top-level steps
-        // For nested, it's the segment before any "type:value" segments
-        const segments = nodeKey.split("/");
-        // Find the last segment that is NOT a "type:value" dynamic segment
-        for (let i = segments.length - 1; i >= 0; i--) {
-            if (!segments[i].includes(":")) {
-                return segments[i];
-            }
-        }
-        return segments[segments.length - 1];
+        const staticPath = staticNodePathFromKey(nodeKey);
+        return staticPath.split("/").at(-1) ?? nodeKey;
     }
     findNodeById(root, nodeId) {
         if (root.id === nodeId)
@@ -1446,25 +1188,28 @@ export function generateRunId(now = new Date()) {
     ].join("");
     return `${timestamp}${randomBytes(10).toString("hex").toUpperCase()}`;
 }
+function nestedParallelBranchDynamic(dynamic, branchIndex) {
+    const branchId = String(branchIndex);
+    return {
+        ...dynamic,
+        parallelBranchId: dynamic.parallelBranchId === undefined ? branchId : `${dynamic.parallelBranchId}.${branchId}`
+    };
+}
 class NodeAbortedError extends Error {
     nodeKey;
     state;
     artifactRefs;
     output;
-    renderedPrompt;
     constructor(nodeKey, state, 
-    /** Artifact refs (e.g. partial transcript) to persist on the aborted node. */
+    /** Artifact refs (e.g. partial Agent response/telemetry) to persist on the aborted node. */
     artifactRefs, 
     /** Partial output captured before the abort. */
-    output, 
-    /** Rendered Agent prompt to preserve when abort overwrites node state. */
-    renderedPrompt) {
+    output) {
         super(`Node ${nodeKey} aborted: ${state}`);
         this.nodeKey = nodeKey;
         this.state = state;
         this.artifactRefs = artifactRefs;
         this.output = output;
-        this.renderedPrompt = renderedPrompt;
         this.name = "NodeAbortedError";
     }
 }
@@ -1476,6 +1221,9 @@ class ScopeCompleted extends Error {
         this.name = "ScopeCompleted";
     }
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 class GuardFailureError extends Error {
     output;
     constructor(message, output) {