@openclaw/lobster 2026.9.4 → 2026.9.6

package/node_modules/@clawdbot/lobster/dist/src/workflows/file.js

@@ -1,19 +1,50 @@
+import { dryRunWorkflow } from "./dry_run.js";
+import { createRecord, mergeEnv, resolveCwd, resolveInputValue, resolveShellStdin, resolveWorkflowStepArgs, } from "./values.js";
+import { loadWorkflowFile, getStepExecution, isApprovalStep, isInputStep } from "./load.js";
+import { evaluateCondition, resolveTemplate } from "./expressions.js";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
-import { parse as parseYaml } from "yaml";
 import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { PassThrough } from "node:stream";
 import { parsePipeline } from "../parser.js";
 import { runPipeline } from "../runtime.js";
 import { encodeToken, decodeToken } from "../token.js";
-import { createApprovalIndex, deleteStateJson, readStateJson, writeStateJson, } from "../state/store.js";
+import { cleanupApprovalIndexByStateKey, consumeResumeState, createApprovalIndex, deleteStateJsonWithBoundedResumeCleanup, deleteResumeStateWithRollback, deleteStateJson, deleteUnconsumedResumeState, isConsumedResumeState, readStateJsonWithLock, restoreConsumedResumeState, writeStateJson, stableStringify, } from "../state/store.js";
 import { readLineFromStream } from "../read_line.js";
-import { resolveInlineShellCommand } from "../shell.js";
 import { compileCached } from "../validation.js";
-import { CostTracker } from "../core/cost_tracker.js";
+import { createLlmSpendLedger, carryLlmProvenance, markLlmProvenanceReplayed, llmProvenanceOf, restoreLlmProvenance, } from "../core/llm_accounting.js";
+import { CostLimitExceededError, CostTracker } from "../core/cost_tracker.js";
 import { withRetry, resolveRetryConfig } from "../core/retry.js";
 import { RequestInputResumeError, validateCommandInputState, } from "../input_request.js";
+import { runAbortableProcess } from "../abortable_process.js";
+export { loadWorkflowFile } from "./load.js";
+const NON_RETRYABLE_STEP_ERROR = Symbol("lobster.nonRetryableStepError");
+function markStepErrorNonRetryable(error) {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    Object.defineProperty(normalized, NON_RETRYABLE_STEP_ERROR, { value: true });
+    return normalized;
+}
+function isStepErrorNonRetryable(error) {
+    return Boolean(error instanceof Error &&
+        error[NON_RETRYABLE_STEP_ERROR]);
+}
+const PARALLEL_BRANCH_ABORT_SETTLE_TIMEOUT_MS = 500;
+async function waitForCancelledParallelBranches(branchesSettled) {
+    let timeoutId;
+    try {
+        await Promise.race([
+            branchesSettled,
+            new Promise((_resolve, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("Parallel branches did not settle after cancellation")), PARALLEL_BRANCH_ABORT_SETTLE_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+    }
+}
 export class WorkflowResumeArgumentError extends Error {
     constructor(message) {
         super(message);
@@ -32,322 +63,8 @@ class WorkflowPipelineInputSuspension extends Error {
         this.pipelineInput = pipelineInput;
     }
 }
-export async function loadWorkflowFile(filePath) {
-    const text = await fsp.readFile(filePath, "utf8");
-    const ext = path.extname(filePath).toLowerCase();
-    const parsed = ext === ".json" ? JSON.parse(text) : parseYaml(text);
-    if (!parsed || typeof parsed !== "object") {
-        throw new Error("Workflow file must be a JSON/YAML object");
-    }
-    const steps = parsed.steps;
-    if (!Array.isArray(steps) || steps.length === 0) {
-        throw new Error("Workflow file requires a non-empty steps array");
-    }
-    const costLimit = parsed.cost_limit;
-    if (costLimit !== undefined) {
-        if (!costLimit || typeof costLimit !== "object" || Array.isArray(costLimit)) {
-            throw new Error("Workflow cost_limit must be an object");
-        }
-        if (!Number.isFinite(Number(costLimit.max_usd)) || Number(costLimit.max_usd) < 0) {
-            throw new Error("Workflow cost_limit.max_usd must be a non-negative number");
-        }
-        if (costLimit.action !== undefined &&
-            costLimit.action !== "warn" &&
-            costLimit.action !== "stop") {
-            throw new Error('Workflow cost_limit.action must be "warn" or "stop"');
-        }
-    }
-    const seen = new Set();
-    for (const step of steps) {
-        if (!step || typeof step !== "object") {
-            throw new Error("Workflow step must be an object");
-        }
-        if (!step.id || typeof step.id !== "string") {
-            throw new Error("Workflow step requires an id");
-        }
-        if (step.workflow !== undefined && typeof step.workflow !== "string") {
-            throw new Error(`Workflow step ${step.id} workflow must be a string (file path)`);
-        }
-        if (typeof step.workflow === "string" && !step.workflow.trim()) {
-            throw new Error(`Workflow step ${step.id} workflow path cannot be blank`);
-        }
-        if (step.workflow_args !== undefined) {
-            if (!step.workflow_args ||
-                typeof step.workflow_args !== "object" ||
-                Array.isArray(step.workflow_args)) {
-                throw new Error(`Workflow step ${step.id} workflow_args must be a plain object`);
-            }
-        }
-        if (step.parallel !== undefined &&
-            (!step.parallel || typeof step.parallel !== "object" || Array.isArray(step.parallel))) {
-            throw new Error(`Workflow step ${step.id} parallel must be an object`);
-        }
-        const isParallel = Boolean(step.parallel && typeof step.parallel === "object" && !Array.isArray(step.parallel));
-        if (isParallel) {
-            const parallel = step.parallel;
-            if (!Array.isArray(parallel.branches) || parallel.branches.length === 0) {
-                throw new Error(`Workflow step ${step.id} parallel requires a non-empty branches array`);
-            }
-            if (parallel.wait !== undefined && parallel.wait !== "all" && parallel.wait !== "any") {
-                throw new Error(`Workflow step ${step.id} parallel wait must be "all" or "any"`);
-            }
-            if (parallel.timeout_ms !== undefined &&
-                (typeof parallel.timeout_ms !== "number" ||
-                    !Number.isFinite(parallel.timeout_ms) ||
-                    !Number.isInteger(parallel.timeout_ms) ||
-                    parallel.timeout_ms < 1 ||
-                    parallel.timeout_ms > 2_147_483_647)) {
-                throw new Error(`Workflow step ${step.id} parallel timeout_ms must be a positive integer between 1 and 2147483647`);
-            }
-            const branchIds = new Set();
-            for (const branch of parallel.branches) {
-                if (!branch || typeof branch !== "object") {
-                    throw new Error(`Workflow step ${step.id} parallel branches must be objects`);
-                }
-                if (!branch.id || typeof branch.id !== "string") {
-                    throw new Error(`Workflow step ${step.id} parallel branch requires an id`);
-                }
-                if (branch.id === step.id) {
-                    throw new Error(`Workflow step ${step.id} parallel branch id cannot match the step id`);
-                }
-                if (branchIds.has(branch.id)) {
-                    throw new Error(`Workflow step ${step.id} duplicate parallel branch id: ${branch.id}`);
-                }
-                if (seen.has(branch.id)) {
-                    throw new Error(`Duplicate workflow id across steps/parallel branches: ${branch.id}`);
-                }
-                branchIds.add(branch.id);
-                const branchShell = typeof branch.run === "string" ? branch.run : branch.command;
-                const branchPipeline = typeof branch.pipeline === "string" ? branch.pipeline : undefined;
-                const branchExecCount = Number(Boolean(branchShell)) + Number(Boolean(branchPipeline));
-                if (branchExecCount === 0) {
-                    throw new Error(`Workflow step ${step.id} parallel branch ${branch.id} requires run, command, or pipeline`);
-                }
-                if (branchExecCount > 1) {
-                    throw new Error(`Workflow step ${step.id} parallel branch ${branch.id} can only define one of run, command, or pipeline`);
-                }
-                if (branch.run !== undefined && typeof branch.run !== "string") {
-                    throw new Error(`Workflow step ${step.id} parallel branch ${branch.id} run must be a string`);
-                }
-                if (branch.command !== undefined && typeof branch.command !== "string") {
-                    throw new Error(`Workflow step ${step.id} parallel branch ${branch.id} command must be a string`);
-                }
-                if (branch.pipeline !== undefined && typeof branch.pipeline !== "string") {
-                    throw new Error(`Workflow step ${step.id} parallel branch ${branch.id} pipeline must be a string`);
-                }
-            }
-        }
-        if (step.for_each !== undefined && typeof step.for_each !== "string") {
-            throw new Error(`Workflow step ${step.id} for_each must be a string (step reference expression)`);
-        }
-        const isForEach = typeof step.for_each === "string";
-        if (isForEach) {
-            if (!Array.isArray(step.steps) || step.steps.length === 0) {
-                throw new Error(`Workflow step ${step.id} for_each requires a non-empty steps array`);
-            }
-            if (step.batch_size !== undefined &&
-                (typeof step.batch_size !== "number" ||
-                    !Number.isInteger(step.batch_size) ||
-                    step.batch_size < 1)) {
-                throw new Error(`Workflow step ${step.id} batch_size must be a positive integer`);
-            }
-            if (step.pause_ms !== undefined &&
-                (typeof step.pause_ms !== "number" || !Number.isFinite(step.pause_ms) || step.pause_ms < 0)) {
-                throw new Error(`Workflow step ${step.id} pause_ms must be a finite non-negative number`);
-            }
-            if (isApprovalStep(step.approval)) {
-                throw new Error(`Workflow step ${step.id} for_each steps cannot define approval (use a separate step after the loop)`);
-            }
-            if (isInputStep(step.input)) {
-                throw new Error(`Workflow step ${step.id} for_each steps cannot define input (use a separate step after the loop)`);
-            }
-            if (step.stdin !== undefined && step.stdin !== null) {
-                throw new Error(`Workflow step ${step.id} for_each steps cannot define stdin (loop input comes from the for_each expression)`);
-            }
-            const loopShell = typeof step.run === "string" ? step.run : step.command;
-            const loopPipeline = typeof step.pipeline === "string" ? step.pipeline : undefined;
-            if (loopShell || loopPipeline || step.workflow || step.parallel) {
-                throw new Error(`Workflow step ${step.id} for_each cannot also define run, command, pipeline, workflow, or parallel`);
-            }
-            if (step.item_var !== undefined && typeof step.item_var !== "string") {
-                throw new Error(`Workflow step ${step.id} item_var must be a string`);
-            }
-            if (step.index_var !== undefined && typeof step.index_var !== "string") {
-                throw new Error(`Workflow step ${step.id} index_var must be a string`);
-            }
-            const loopItemVar = step.item_var ?? "item";
-            const loopIndexVar = step.index_var ?? "index";
-            if (loopItemVar === loopIndexVar) {
-                throw new Error(`Workflow step ${step.id} item_var and index_var cannot be the same`);
-            }
-            const subStepIds = new Set();
-            for (const sub of step.steps) {
-                if (!sub || typeof sub !== "object" || !sub.id || typeof sub.id !== "string") {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step requires an id`);
-                }
-                if (sub.id === loopItemVar || sub.id === loopIndexVar) {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step id '${sub.id}' conflicts with loop variable`);
-                }
-                if (subStepIds.has(sub.id)) {
-                    throw new Error(`Workflow step ${step.id} duplicate for_each sub-step id: ${sub.id}`);
-                }
-                subStepIds.add(sub.id);
-                if (isApprovalStep(sub.approval) || isInputStep(sub.input)) {
-                    throw new Error(`Workflow step ${step.id} for_each sub-steps cannot contain approval or input steps`);
-                }
-                if (sub.run !== undefined && typeof sub.run !== "string") {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} run must be a string`);
-                }
-                if (sub.command !== undefined && typeof sub.command !== "string") {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} command must be a string`);
-                }
-                if (sub.pipeline !== undefined && typeof sub.pipeline !== "string") {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} pipeline must be a string`);
-                }
-                if (sub.workflow || sub.parallel || sub.for_each) {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} cannot define workflow, parallel, or for_each`);
-                }
-                const subShell = typeof sub.run === "string" && sub.run.trim()
-                    ? sub.run
-                    : typeof sub.command === "string" && sub.command.trim()
-                        ? sub.command
-                        : undefined;
-                const subPipeline = typeof sub.pipeline === "string" && sub.pipeline.trim() ? sub.pipeline : undefined;
-                if (!subShell && !subPipeline) {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} requires run, command, or pipeline`);
-                }
-                if (Number(Boolean(subShell)) + Number(Boolean(subPipeline)) > 1) {
-                    throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} can only define one of run, command, or pipeline`);
-                }
-            }
-        }
-        const shellCommand = typeof step.run === "string" ? step.run : step.command;
-        const pipeline = typeof step.pipeline === "string" ? step.pipeline : undefined;
-        const workflowRef = typeof step.workflow === "string" && step.workflow.trim() ? step.workflow : undefined;
-        const executionCount = Number(Boolean(shellCommand)) +
-            Number(Boolean(pipeline)) +
-            Number(Boolean(workflowRef)) +
-            Number(isParallel) +
-            Number(isForEach);
-        if (executionCount === 0 && !isApprovalStep(step.approval) && !isInputStep(step.input)) {
-            throw new Error(`Workflow step ${step.id} requires run, command, pipeline, workflow, parallel, for_each, approval, or input`);
-        }
-        if (executionCount > 1) {
-            throw new Error(`Workflow step ${step.id} can only define one of run, command, pipeline, workflow, parallel, or for_each`);
-        }
-        if (executionCount > 0 && isInputStep(step.input)) {
-            throw new Error(`Workflow step ${step.id} input steps cannot define run, command, pipeline, workflow, parallel, or for_each`);
-        }
-        if (isApprovalStep(step.approval) && isInputStep(step.input)) {
-            throw new Error(`Workflow step ${step.id} cannot define both approval and input`);
-        }
-        if (step.run !== undefined && typeof step.run !== "string") {
-            throw new Error(`Workflow step ${step.id} run must be a string`);
-        }
-        if (step.command !== undefined && typeof step.command !== "string") {
-            throw new Error(`Workflow step ${step.id} command must be a string`);
-        }
-        if (step.pipeline !== undefined && typeof step.pipeline !== "string") {
-            throw new Error(`Workflow step ${step.id} pipeline must be a string`);
-        }
-        if (step.input !== undefined && !isInputStep(step.input)) {
-            throw new Error(`Workflow step ${step.id} input must be an object`);
-        }
-        if (step.input && typeof step.input.prompt !== "string") {
-            throw new Error(`Workflow step ${step.id} input.prompt must be a string`);
-        }
-        if (step.input &&
-            (step.input.responseSchema === undefined || typeof step.input.responseSchema !== "object")) {
-            throw new Error(`Workflow step ${step.id} input.responseSchema must be an object`);
-        }
-        if (step.input) {
-            try {
-                compileCached(step.input.responseSchema);
-            }
-            catch (err) {
-                throw new Error(`Workflow step ${step.id} input.responseSchema is invalid: ${err?.message ?? String(err)}`);
-            }
-        }
-        if (step.approval && typeof step.approval === "object" && !Array.isArray(step.approval)) {
-            const approval = step.approval;
-            if (approval.initiated_by !== undefined && typeof approval.initiated_by !== "string") {
-                throw new Error(`Workflow step ${step.id} approval.initiated_by must be a string`);
-            }
-            if (approval.initiatedBy !== undefined && typeof approval.initiatedBy !== "string") {
-                throw new Error(`Workflow step ${step.id} approval.initiatedBy must be a string`);
-            }
-            if (approval.required_approver !== undefined &&
-                typeof approval.required_approver !== "string") {
-                throw new Error(`Workflow step ${step.id} approval.required_approver must be a string`);
-            }
-            if (approval.requiredApprover !== undefined &&
-                typeof approval.requiredApprover !== "string") {
-                throw new Error(`Workflow step ${step.id} approval.requiredApprover must be a string`);
-            }
-            if (approval.require_different_approver !== undefined &&
-                typeof approval.require_different_approver !== "boolean") {
-                throw new Error(`Workflow step ${step.id} approval.require_different_approver must be a boolean`);
-            }
-            if (approval.requireDifferentApprover !== undefined &&
-                typeof approval.requireDifferentApprover !== "boolean") {
-                throw new Error(`Workflow step ${step.id} approval.requireDifferentApprover must be a boolean`);
-            }
-        }
-        if (step.timeout_ms !== undefined &&
-            (typeof step.timeout_ms !== "number" ||
-                !Number.isFinite(step.timeout_ms) ||
-                !Number.isInteger(step.timeout_ms) ||
-                step.timeout_ms < 1 ||
-                step.timeout_ms > 2_147_483_647)) {
-            throw new Error(`Workflow step ${step.id} timeout_ms must be a positive integer between 1 and 2147483647`);
-        }
-        if (step.on_error !== undefined &&
-            step.on_error !== "stop" &&
-            step.on_error !== "continue" &&
-            step.on_error !== "skip_rest") {
-            throw new Error(`Workflow step ${step.id} on_error must be "stop", "continue", or "skip_rest"`);
-        }
-        if (step.retry !== undefined) {
-            if (!step.retry || typeof step.retry !== "object" || Array.isArray(step.retry)) {
-                throw new Error(`Workflow step ${step.id} retry must be an object`);
-            }
-            const r = step.retry;
-            if (r.max !== undefined &&
-                (typeof r.max !== "number" || !Number.isInteger(r.max) || r.max < 1)) {
-                throw new Error(`Workflow step ${step.id} retry.max must be a positive integer`);
-            }
-            if (r.backoff !== undefined && r.backoff !== "fixed" && r.backoff !== "exponential") {
-                throw new Error(`Workflow step ${step.id} retry.backoff must be "fixed" or "exponential"`);
-            }
-            if (r.delay_ms !== undefined &&
-                (typeof r.delay_ms !== "number" || !Number.isFinite(r.delay_ms) || r.delay_ms < 0)) {
-                throw new Error(`Workflow step ${step.id} retry.delay_ms must be a finite non-negative number`);
-            }
-            if (r.max_delay_ms !== undefined &&
-                (typeof r.max_delay_ms !== "number" ||
-                    !Number.isFinite(r.max_delay_ms) ||
-                    r.max_delay_ms < 0)) {
-                throw new Error(`Workflow step ${step.id} retry.max_delay_ms must be a finite non-negative number`);
-            }
-            if (r.jitter !== undefined && typeof r.jitter !== "boolean") {
-                throw new Error(`Workflow step ${step.id} retry.jitter must be a boolean`);
-            }
-        }
-        if (seen.has(step.id)) {
-            throw new Error(`Duplicate workflow step id: ${step.id}`);
-        }
-        if (isParallel) {
-            const parallel = step.parallel;
-            for (const branch of parallel.branches) {
-                seen.add(branch.id);
-            }
-        }
-        seen.add(step.id);
-    }
-    return parsed;
-}
 export function resolveWorkflowArgs(argDefs, provided) {
-    const resolved = {};
+    const resolved = createRecord();
     if (argDefs) {
         for (const [key, def] of Object.entries(argDefs)) {
             if (def && typeof def === "object" && "default" in def) {
@@ -364,11 +81,74 @@ export function resolveWorkflowArgs(argDefs, provided) {
 }
 export async function runWorkflowFile({ filePath, args, ctx, resume, approved, response, cancel, }) {
     const consumedResumeStateKey = resume?.stateKey && typeof resume.stateKey === "string"
-        ? await resolveWorkflowResumeStateKey(ctx.env, resume.stateKey)
+        ? await resolveWorkflowResumeStateKey(ctx.env, resume.stateKey, ctx.signal)
         : null;
+    if (consumedResumeStateKey)
+        ctx._onResumeStateResolved?.(consumedResumeStateKey);
     const resumeState = resume?.stateKey
-        ? await loadWorkflowResumeState(ctx.env, consumedResumeStateKey ?? resume.stateKey)
+        ? await loadWorkflowResumeState(ctx.env, consumedResumeStateKey ?? resume.stateKey, ctx.signal)
         : (resume ?? null);
+    let resumedExecutionStarted = false;
+    let resumeStateConsumed = false;
+    let executionBoundaryStarted = false;
+    const executionSignalListeners = [];
+    let executionStart;
+    const markExecutionStarted = async (signal) => {
+        if (!consumedResumeStateKey && !ctx._onExecutionStarted && !ctx._onExecutionInterrupted)
+            return;
+        if (executionStart)
+            return executionStart;
+        executionStart = (async () => {
+            signal?.throwIfAborted();
+            if (consumedResumeStateKey) {
+                const consumption = await consumeResumeState({
+                    env: ctx.env,
+                    key: consumedResumeStateKey,
+                    expectedState: resumeState,
+                    signal,
+                });
+                if (!consumption.consumed) {
+                    throw new Error("Workflow resume state not found");
+                }
+                if (consumption.signalAbortedAfterCommit) {
+                    await restoreConsumedResumeState({
+                        env: ctx.env,
+                        key: consumedResumeStateKey,
+                        expectedState: resumeState,
+                        claimId: consumption.claimId,
+                    });
+                    signal?.throwIfAborted();
+                }
+                signal?.throwIfAborted();
+                resumeStateConsumed = true;
+                resumedExecutionStarted = true;
+            }
+            await ctx._onExecutionStarted?.();
+            executionBoundaryStarted = true;
+            if (!signal)
+                return;
+            const onAbort = () => {
+                ctx._onExecutionInterrupted?.();
+            };
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+            executionSignalListeners.push({ signal, onAbort });
+        })();
+        try {
+            await executionStart;
+        }
+        catch (err) {
+            // A per-attempt timeout can abort while this invocation is only waiting
+            // to claim its resume state. Keep the successful boundary memoized, but
+            // let the workflow retry make a fresh claim after that pre-dispatch wait.
+            if (!resumeStateConsumed && !executionBoundaryStarted)
+                executionStart = undefined;
+            throw err;
+        }
+    };
     if (resumeState?.approvalStepId && resumeState?.inputStepId) {
         throw new Error("Invalid workflow resume state");
     }
@@ -381,14 +161,26 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
         }
         if (cancel === true || approved === false) {
             if (consumedResumeStateKey) {
-                await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
+                const deletion = await deleteUnconsumedResumeState({
+                    env: ctx.env,
+                    key: consumedResumeStateKey,
+                    signal: ctx.signal,
+                });
+                if (deletion !== "deleted")
+                    throw new Error("Workflow resume state not found");
             }
             return { status: "cancelled", output: [] };
         }
     }
     if (resumeState?.inputStepId && cancel === true) {
         if (consumedResumeStateKey) {
-            await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
+            const deletion = await deleteUnconsumedResumeState({
+                env: ctx.env,
+                key: consumedResumeStateKey,
+                signal: ctx.signal,
+            });
+            if (deletion !== "deleted")
+                throw new Error("Workflow resume state not found");
         }
         return { status: "cancelled", output: [] };
     }
@@ -408,7 +200,7 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
         const stepIndexById = new Map(steps.map((step, idx) => [step.id, idx]));
         const results = resumeState?.steps
             ? cloneResults(resumeState.steps)
-            : {};
+            : createRecord();
         const startIndex = resumeState?.resumeAtIndex ?? 0;
         if (resumeState?.approvalStepId && typeof approved === "boolean") {
             const previous = results[resumeState.approvalStepId] ?? { id: resumeState.approvalStepId };
@@ -459,11 +251,6 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                     stepId: resumeState.inputStepId,
                     response,
                     pipelineInput: resumeState.pipelineInput,
-                    onConsumed: consumedResumeStateKey
-                        ? async () => {
-                            await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
-                        }
-                        : undefined,
                 };
             }
             else {
@@ -492,8 +279,30 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
             return dryRunWorkflow({ steps, resolvedArgs, results, startIndex, ctx });
         }
         const costTracker = new CostTracker(CostTracker.parsePricingFromEnv(ctx.env, ctx.stderr), ctx.stderr);
+        // A gate pauses a run, it does not reset its spend: seed this run with what the paused
+        // run recorded, so `_meta.cost` covers the whole workflow and `cost_limit` cannot be
+        // walked past one gate at a time. A replay of a call billed before the pause then stays
+        // exempt, which is what an empty ledger already means for a charge someone else settled.
+        const pausedCost = resumeState && "cost" in resumeState ? resumeState.cost : undefined;
+        costTracker.restore(pausedCost?.byStep);
+        // One ledger per run: a live call this run paid for can be recovered from the replay a
+        // retry produced, and a cache entry written by any other run has nothing to claim here.
+        const llmSpendLedger = createLlmSpendLedger(composingSpendLedger(ctx));
+        // A pipeline that paused at an `ask` gate had already paid for its LLM call without
+        // billing it, so the charge travels in the same resume state and reopens here. It is the
+        // same run continuing, which is why this cannot hand a charge to an unrelated one.
+        llmSpendLedger.restore(resumeState && "llmSpend" in resumeState ? resumeState.llmSpend : undefined);
+        // The completed steps come back as JSON, so an LLM output among them has lost everything
+        // this process attached to it. A later step that re-emits one hands on a copy that still
+        // names its call, and the restored record is what lets that copy be recognized as one the
+        // paused run already paid for rather than billed a second time on top of `cost`.
+        llmSpendLedger.restoreSettled(resumeState && "llmBilled" in resumeState ? resumeState.llmBilled : undefined);
+        // Completed results lost their symbol keys when the pause was persisted. Restore those
+        // private marks only at this trusted resume boundary; ordinary command JSON stays billable.
+        restoreLlmProvenance(results, resumeState && "llmBilled" in resumeState ? resumeState.llmBilled : undefined);
         let lastStepId = resumeState?.inputStepId ?? findLastCompletedStepId(steps, results);
         for (let idx = startIndex; idx < steps.length; idx++) {
+            ctx.signal?.throwIfAborted();
             const step = steps[idx];
             if (!evaluateCondition(step.when ?? step.condition, results)) {
                 results[step.id] = { id: step.id, skipped: true };
@@ -515,40 +324,65 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         subject,
                         maxEnvelopeBytes: resolveToolEnvelopeMaxBytes(ctx.env),
                     });
-                    const stateKey = await saveWorkflowResumeState(ctx.env, {
-                        filePath: resolvedFilePath,
-                        resumeAtIndex: idx + 1,
-                        steps: results,
-                        args: resolvedArgs,
-                        inputStepId: step.id,
-                        inputSchema: step.input.responseSchema,
-                        // Preserve the full resolved subject for resume semantics; the tool
-                        // envelope may contain a truncated preview to stay within size limits.
-                        inputSubject: subject,
-                        createdAt: new Date().toISOString(),
-                    });
-                    if (consumedResumeStateKey && consumedResumeStateKey !== stateKey) {
-                        await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
+                    let stateKey;
+                    try {
+                        stateKey = await saveWorkflowResumeState(ctx.env, {
+                            filePath: resolvedFilePath,
+                            resumeAtIndex: idx + 1,
+                            steps: results,
+                            args: resolvedArgs,
+                            inputStepId: step.id,
+                            inputSchema: step.input.responseSchema,
+                            // Preserve the full resolved subject for resume semantics; the tool
+                            // envelope may contain a truncated preview to stay within size limits.
+                            inputSubject: subject,
+                            ...(costTracker.hasUsage() ? { cost: costTracker.getSummary() } : null),
+                            ...(llmSpendLedger.outstanding().length
+                                ? { llmSpend: llmSpendLedger.outstanding() }
+                                : null),
+                            ...(llmSpendLedger.settled().length
+                                ? { llmBilled: llmSpendLedger.settled() }
+                                : null),
+                            supersededResumeStateKeys: collectSupersededWorkflowResumeStateKeys(consumedResumeStateKey, resumeState),
+                            createdAt: new Date().toISOString(),
+                        }, ctx.signal);
+                        const replaced = await replaceWorkflowResumeState({
+                            env: ctx.env,
+                            previousStateKey: consumedResumeStateKey,
+                            expectedPreviousState: resumeState,
+                            previousStateConsumed: resumeStateConsumed,
+                            replacementStateKey: stateKey,
+                            signal: ctx.signal,
+                        });
+                        if (!replaced) {
+                            throw new Error("Workflow resume state not found");
+                        }
+                        const resumeToken = encodeToken({
+                            protocolVersion: 1,
+                            v: 1,
+                            kind: "workflow-file",
+                            stateKey,
+                        });
+                        return {
+                            status: "needs_input",
+                            output: [],
+                            requiresInput: {
+                                ...inputRequest,
+                                resumeToken,
+                            },
+                        };
+                    }
+                    catch (err) {
+                        if (stateKey)
+                            await discardWorkflowResumeState(ctx.env, stateKey);
+                        throw err;
                     }
-                    const resumeToken = encodeToken({
-                        protocolVersion: 1,
-                        v: 1,
-                        kind: "workflow-file",
-                        stateKey,
-                    });
-                    return {
-                        status: "needs_input",
-                        output: [],
-                        requiresInput: {
-                            ...inputRequest,
-                            resumeToken,
-                        },
-                    };
                 }
                 ctx.stdout.write(`${step.input.prompt}\n`);
                 ctx.stdout.write("Enter JSON response: ");
                 const raw = await readLineFromStream(ctx.stdin, {
                     timeoutMs: parseApprovalTimeoutMs(ctx.env),
+                    signal: ctx.signal,
                 });
                 const parsed = parseResponseJson(String(raw ?? "").trim());
                 validateInputResponse({
@@ -564,132 +398,170 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                 lastStepId = step.id;
                 continue;
             }
-            if (typeof step.for_each === "string" && Array.isArray(step.steps)) {
-                const itemsRef = resolveInputValue(step.for_each, resolvedArgs, results);
-                if (!Array.isArray(itemsRef)) {
-                    throw new Error(`Workflow step ${step.id} for_each: expected array, got ${typeof itemsRef}`);
-                }
-                const itemVar = step.item_var ?? "item";
-                const indexVar = step.index_var ?? "index";
-                const batchSize = step.batch_size ?? 1;
-                const iterationResults = [];
-                for (let itemIdx = 0; itemIdx < itemsRef.length; itemIdx++) {
-                    if (step.pause_ms && itemIdx > 0 && itemIdx % batchSize === 0) {
-                        await abortableSleep(step.pause_ms, ctx.signal);
-                    }
-                    const item = itemsRef[itemIdx];
-                    const scopedResults = { ...results };
-                    scopedResults[itemVar] = {
-                        id: itemVar,
-                        json: item,
-                        stdout: typeof item === "string" ? item : JSON.stringify(item),
-                    };
-                    scopedResults[indexVar] = {
-                        id: indexVar,
-                        json: itemIdx,
-                        stdout: String(itemIdx),
-                    };
-                    for (const subStep of step.steps) {
-                        if (!evaluateCondition(subStep.when ?? subStep.condition, scopedResults)) {
-                            scopedResults[subStep.id] = { id: subStep.id, skipped: true };
-                            continue;
-                        }
-                        const loopEnvBase = mergeEnv(ctx.env, workflow.env, step.env, resolvedArgs, scopedResults);
-                        const subEnv = subStep.env
-                            ? mergeEnv(loopEnvBase, undefined, subStep.env, resolvedArgs, scopedResults)
-                            : loopEnvBase;
-                        const subCwd = resolveCwd(subStep.cwd ?? step.cwd ?? workflow.cwd, resolvedArgs) ?? ctx.cwd;
-                        const subExecution = getStepExecution(subStep);
-                        let subResult;
-                        if (subExecution.kind === "shell") {
-                            const command = resolveTemplate(subExecution.value, resolvedArgs, scopedResults);
-                            const stdinValue = resolveShellStdin(subStep.stdin, resolvedArgs, scopedResults);
-                            const { stdout } = await runShellCommand({
-                                command,
-                                stdin: stdinValue,
-                                env: subEnv,
-                                cwd: subCwd,
-                                signal: ctx.signal,
-                            });
-                            subResult = { id: subStep.id, stdout, json: parseJson(stdout) };
-                        }
-                        else if (subExecution.kind === "pipeline") {
-                            if (!ctx.registry) {
-                                throw new Error(`Workflow step ${step.id} for_each sub-step ${subStep.id} requires a command registry for pipeline execution`);
-                            }
-                            const pipelineText = resolveTemplate(subExecution.value, resolvedArgs, scopedResults);
-                            const inputValue = resolveInputValue(subStep.stdin, resolvedArgs, scopedResults);
-                            subResult = await runPipelineStep({
-                                stepId: subStep.id,
-                                pipelineText,
-                                inputValue,
-                                ctx,
-                                env: subEnv,
-                                cwd: subCwd,
-                                requestInputEnabled: false,
-                            });
-                        }
-                        else {
-                            const inputValue = resolveInputValue(subStep.stdin, resolvedArgs, scopedResults);
-                            subResult = createSyntheticStepResult(subStep.id, inputValue);
-                        }
-                        scopedResults[subStep.id] = subResult;
-                        trackStepCost(costTracker, `${step.id}.${subStep.id}`, subResult);
-                        if (workflow.cost_limit) {
-                            costTracker.checkLimit(workflow.cost_limit, ctx.stderr);
-                        }
-                    }
-                    const iterResult = { [itemVar]: item, [indexVar]: itemIdx };
-                    for (const subStep of step.steps) {
-                        const subResult = scopedResults[subStep.id];
-                        if (subResult && !subResult.skipped) {
-                            iterResult[subStep.id] =
-                                subResult.json !== undefined ? subResult.json : subResult.stdout;
-                        }
-                    }
-                    iterationResults.push(iterResult);
-                }
-                const loopResult = {
-                    id: step.id,
-                    json: iterationResults,
-                    stdout: JSON.stringify(iterationResults),
-                };
-                results[step.id] = loopResult;
-                lastStepId = step.id;
-                trackStepCost(costTracker, step.id, loopResult);
-                if (workflow.cost_limit) {
-                    costTracker.checkLimit(workflow.cost_limit, ctx.stderr);
-                }
-                continue;
-            }
             const env = mergeEnv(ctx.env, workflow.env, step.env, resolvedArgs, results);
             const cwd = resolveCwd(step.cwd ?? workflow.cwd, resolvedArgs) ?? ctx.cwd;
             const execution = getStepExecution(step);
             const retryConfig = resolveRetryConfig(step.retry);
             const executeStepAttempt = async () => {
+                let attemptHadNonRetryableSideEffect = false;
+                const markNonRetryableSideEffect = () => {
+                    attemptHadNonRetryableSideEffect = true;
+                    ctx._onNonRetryableSideEffect?.();
+                };
+                ctx.signal?.throwIfAborted();
                 // Combine external cancellation and optional per-step timeout into one signal.
                 let stepSignal = ctx.signal;
                 let timeoutId;
+                let stepTimeoutController;
                 if (step.timeout_ms) {
-                    const timeoutController = new AbortController();
-                    timeoutId = setTimeout(() => timeoutController.abort(new Error(`Step '${step.id}' timed out after ${step.timeout_ms}ms`)), step.timeout_ms);
+                    stepTimeoutController = new AbortController();
+                    timeoutId = setTimeout(() => stepTimeoutController.abort(new Error(`Step '${step.id}' timed out after ${step.timeout_ms}ms`)), step.timeout_ms);
                     stepSignal = ctx.signal
-                        ? AbortSignal.any([ctx.signal, timeoutController.signal])
-                        : timeoutController.signal;
+                        ? AbortSignal.any([ctx.signal, stepTimeoutController.signal])
+                        : stepTimeoutController.signal;
                 }
                 let result;
                 let parallelBranchResults = null;
                 try {
-                    if (execution.kind === "parallel") {
+                    if (typeof step.for_each === "string" && Array.isArray(step.steps)) {
+                        const itemsRef = resolveInputValue(step.for_each, resolvedArgs, results);
+                        if (!Array.isArray(itemsRef)) {
+                            throw new Error(`Workflow step ${step.id} for_each: expected array, got ${typeof itemsRef}`);
+                        }
+                        const itemVar = step.item_var ?? "item";
+                        const indexVar = step.index_var ?? "index";
+                        const batchSize = step.batch_size ?? 1;
+                        const iterationResults = [];
+                        for (let itemIdx = 0; itemIdx < itemsRef.length; itemIdx++) {
+                            stepSignal?.throwIfAborted();
+                            if (step.pause_ms && itemIdx > 0 && itemIdx % batchSize === 0) {
+                                await abortableSleep(step.pause_ms, stepSignal);
+                            }
+                            const item = itemsRef[itemIdx];
+                            const scopedResults = createRecord(results);
+                            scopedResults[itemVar] = {
+                                id: itemVar,
+                                json: item,
+                                stdout: typeof item === "string" ? item : JSON.stringify(item),
+                            };
+                            scopedResults[indexVar] = {
+                                id: indexVar,
+                                json: itemIdx,
+                                stdout: String(itemIdx),
+                            };
+                            for (const subStep of step.steps) {
+                                stepSignal?.throwIfAborted();
+                                if (!evaluateCondition(subStep.when ?? subStep.condition, scopedResults)) {
+                                    scopedResults[subStep.id] = { id: subStep.id, skipped: true };
+                                    continue;
+                                }
+                                const loopEnvBase = mergeEnv(ctx.env, workflow.env, step.env, resolvedArgs, scopedResults);
+                                const subEnv = subStep.env
+                                    ? mergeEnv(loopEnvBase, undefined, subStep.env, resolvedArgs, scopedResults)
+                                    : loopEnvBase;
+                                const subCwd = resolveCwd(subStep.cwd ?? step.cwd ?? workflow.cwd, resolvedArgs) ?? ctx.cwd;
+                                const subExecution = getStepExecution(subStep);
+                                let subResult;
+                                if (subExecution.kind === "shell") {
+                                    const command = resolveTemplate(subExecution.value, resolvedArgs, scopedResults);
+                                    const stdinValue = resolveShellStdin(subStep.stdin, resolvedArgs, scopedResults);
+                                    await markExecutionStarted(stepSignal);
+                                    const { stdout } = await runShellCommand({
+                                        command,
+                                        stdin: stdinValue,
+                                        env: subEnv,
+                                        cwd: subCwd,
+                                        signal: stepSignal,
+                                        forceTerminationSignal: ctx.forceTerminationSignal,
+                                        killSignal: () => stepTimeoutController?.signal.aborted
+                                            ? "SIGKILL"
+                                            : undefined,
+                                    });
+                                    subResult = { id: subStep.id, stdout, json: parseJson(stdout) };
+                                }
+                                else if (subExecution.kind === "pipeline") {
+                                    if (!ctx.registry) {
+                                        throw new Error(`Workflow step ${step.id} for_each sub-step ${subStep.id} requires a command registry for pipeline execution`);
+                                    }
+                                    const pipelineText = resolveTemplate(subExecution.value, resolvedArgs, scopedResults);
+                                    const inputValue = resolveInputValue(subStep.stdin, resolvedArgs, scopedResults);
+                                    subResult = await runPipelineStep({
+                                        stepId: subStep.id,
+                                        pipelineText,
+                                        inputValue,
+                                        ctx: {
+                                            ...ctx,
+                                            signal: stepSignal,
+                                            _onNonRetryableSideEffect: markNonRetryableSideEffect,
+                                        },
+                                        llmSpendLedger,
+                                        env: subEnv,
+                                        cwd: subCwd,
+                                        requestInputEnabled: false,
+                                        onExecutionStart: () => markExecutionStarted(stepSignal),
+                                    });
+                                }
+                                else {
+                                    const inputValue = resolveInputValue(subStep.stdin, resolvedArgs, scopedResults);
+                                    subResult = createSyntheticStepResult(subStep.id, inputValue);
+                                }
+                                scopedResults[subStep.id] = subResult;
+                                trackStepCost(costTracker, `${step.id}.${subStep.id}`, subResult, llmSpendLedger);
+                                // Before the next step runs: a charge no item carried is spend the step really made,
+                                // and leaving it for the end would let `cost_limit` wave through every step after the
+                                // one that blew the budget.
+                                settleUnbilledCharges(costTracker, llmSpendLedger);
+                                if (workflow.cost_limit) {
+                                    costTracker.checkLimit(workflow.cost_limit, ctx.stderr);
+                                }
+                            }
+                            const iterResult = createRecord();
+                            iterResult[itemVar] = item;
+                            iterResult[indexVar] = itemIdx;
+                            for (const subStep of step.steps) {
+                                const subResult = scopedResults[subStep.id];
+                                if (subResult && !subResult.skipped) {
+                                    iterResult[subStep.id] =
+                                        subResult.json !== undefined ? subResult.json : subResult.stdout;
+                                }
+                            }
+                            iterationResults.push(Object.fromEntries(Object.entries(iterResult)));
+                        }
+                        result = {
+                            id: step.id,
+                            json: iterationResults,
+                            stdout: JSON.stringify(iterationResults),
+                        };
+                    }
+                    else if (execution.kind === "parallel") {
                         const parallel = execution.value;
                         const wait = parallel.wait ?? "all";
                         const branchAbortController = new AbortController();
-                        const branchSignal = stepSignal
-                            ? AbortSignal.any([stepSignal, branchAbortController.signal])
-                            : branchAbortController.signal;
-                        const shouldForceKill = Boolean(step.timeout_ms || parallel.timeout_ms);
+                        const parallelTimeoutController = new AbortController();
+                        const parallelSignal = stepSignal
+                            ? AbortSignal.any([stepSignal, parallelTimeoutController.signal])
+                            : parallelTimeoutController.signal;
+                        const branchSignal = AbortSignal.any([parallelSignal, branchAbortController.signal]);
+                        const timeoutKillSignal = () => stepTimeoutController?.signal.aborted || parallelTimeoutController.signal.aborted
+                            ? "SIGKILL"
+                            : undefined;
+                        // `wait: "any"` keeps the first branch to answer and abandons the rest, so a
+                        // losing branch spends against a buffer of its own. Only the winner's charges
+                        // reach the run. `wait: "all"` keeps every branch, so those bill straight
+                        // through as before.
+                        const branchLedgers = new Map();
+                        const ledgerFor = (branchId) => {
+                            if (wait !== "any")
+                                return llmSpendLedger;
+                            let buffered = branchLedgers.get(branchId);
+                            if (!buffered) {
+                                buffered = branchSpendBuffer(llmSpendLedger);
+                                branchLedgers.set(branchId, buffered);
+                            }
+                            return buffered;
+                        };
                         const runBranch = async (branch) => {
-                            const mergedBranchEnv = { ...(step.env ?? {}), ...(branch.env ?? {}) };
+                            const mergedBranchEnv = { ...step.env, ...branch.env };
                             const branchEnv = mergeEnv(ctx.env, workflow.env, mergedBranchEnv, resolvedArgs, results);
                             const branchCwd = resolveCwd(branch.cwd ?? step.cwd ?? workflow.cwd, resolvedArgs) ?? ctx.cwd;
                             const branchShell = typeof branch.run === "string" ? branch.run : branch.command;
@@ -701,13 +573,15 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                             if (branchExec.kind === "shell") {
                                 const command = resolveTemplate(branchExec.value, resolvedArgs, results);
                                 const stdinValue = resolveShellStdin(branch.stdin, resolvedArgs, results);
+                                await markExecutionStarted(branchSignal);
                                 const { stdout } = await runShellCommand({
                                     command,
                                     stdin: stdinValue,
                                     env: branchEnv,
                                     cwd: branchCwd,
                                     signal: branchSignal,
-                                    ...(shouldForceKill ? { killSignal: "SIGKILL" } : {}),
+                                    forceTerminationSignal: ctx.forceTerminationSignal,
+                                    killSignal: timeoutKillSignal,
                                 });
                                 return {
                                     branchId: branch.id,
@@ -724,10 +598,16 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                                     stepId: branch.id,
                                     pipelineText,
                                     inputValue,
-                                    ctx: { ...ctx, signal: branchSignal },
+                                    ctx: {
+                                        ...ctx,
+                                        signal: branchSignal,
+                                        _onNonRetryableSideEffect: markNonRetryableSideEffect,
+                                    },
+                                    llmSpendLedger: ledgerFor(branch.id),
                                     env: branchEnv,
                                     cwd: branchCwd,
                                     requestInputEnabled: false,
+                                    onExecutionStart: () => markExecutionStarted(branchSignal),
                                 });
                                 return { branchId: branch.id, result: branchResult };
                             }
@@ -737,26 +617,27 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         const timeoutPromise = parallel.timeout_ms
                             ? new Promise((_resolve, reject) => {
                                 parallelTimeoutId = setTimeout(() => {
-                                    branchAbortController.abort();
+                                    parallelTimeoutController.abort(new Error(`Parallel step ${step.id} timed out after ${parallel.timeout_ms}ms`));
                                     reject(new Error(`Parallel step ${step.id} timed out after ${parallel.timeout_ms}ms`));
                                 }, parallel.timeout_ms);
                             })
                             : null;
+                        const branchPromises = parallel.branches.map((branch) => runBranch(branch));
+                        const branchesSettled = Promise.allSettled(branchPromises);
                         try {
                             if (wait === "any") {
-                                const branchPromises = parallel.branches.map((branch) => runBranch(branch));
                                 const winner = (await (timeoutPromise
                                     ? Promise.race([...branchPromises, timeoutPromise])
                                     : Promise.race(branchPromises)));
-                                parallelBranchResults = { [winner.branchId]: winner.result };
-                                branchAbortController.abort();
+                                parallelBranchResults = createRecord();
+                                parallelBranchResults[winner.branchId] = winner.result;
+                                branchLedgers.get(winner.branchId)?.release();
                             }
                             else {
-                                const branchPromises = parallel.branches.map((branch) => runBranch(branch));
                                 const settled = (await (timeoutPromise
                                     ? Promise.race([Promise.allSettled(branchPromises), timeoutPromise])
-                                    : Promise.allSettled(branchPromises)));
-                                parallelBranchResults = {};
+                                    : branchesSettled));
+                                parallelBranchResults = createRecord();
                                 for (const entry of settled) {
                                     if (entry.status === "rejected") {
                                         throw new Error(`Parallel branch failed: ${entry.reason?.message ?? String(entry.reason)}`);
@@ -768,11 +649,18 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         finally {
                             if (parallelTimeoutId !== undefined)
                                 clearTimeout(parallelTimeoutId);
+                            const branchesCancelled = wait === "any" || parallelSignal.aborted;
+                            if (branchesCancelled)
+                                branchAbortController.abort();
+                            if (branchesCancelled)
+                                await waitForCancelledParallelBranches(branchesSettled);
+                            else
+                                await branchesSettled;
                         }
-                        const merged = {};
-                        for (const [branchId, branchResult] of Object.entries(parallelBranchResults ?? {})) {
-                            merged[branchId] = branchResult.json;
-                        }
+                        const merged = Object.fromEntries(Object.entries(parallelBranchResults ?? {}).map(([branchId, branchResult]) => [
+                            branchId,
+                            branchResult.json,
+                        ]));
                         result = {
                             id: step.id,
                             json: merged,
@@ -800,10 +688,25 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         const childActive = new Set(activeWorkflows);
                         childActive.add(canonicalWorkflowPath);
                         const subArgs = resolveWorkflowStepArgs(step.workflow_args, resolvedArgs, results);
+                        stepSignal?.throwIfAborted();
                         const subResult = await runWorkflowFile({
                             filePath: resolvedWorkflowPath,
                             args: subArgs,
-                            ctx: { ...ctx, env, cwd, _activeWorkflows: childActive },
+                            ctx: {
+                                ...ctx,
+                                env,
+                                cwd,
+                                signal: stepSignal,
+                                _activeWorkflows: childActive,
+                                _llmSpendLedger: stepScopedLedger(llmSpendLedger, step.id),
+                                _onExecutionStarted: async () => {
+                                    await markExecutionStarted(stepSignal);
+                                },
+                                _onExecutionInterrupted: () => {
+                                    ctx._onExecutionInterrupted?.();
+                                },
+                                _onNonRetryableSideEffect: markNonRetryableSideEffect,
+                            },
                         });
                         if (subResult.status === "needs_approval" || subResult.status === "needs_input") {
                             const resumeToken = subResult.requiresApproval?.resumeToken ?? subResult.requiresInput?.resumeToken;
@@ -823,17 +726,26 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         const json = subResult.output.length === 1 ? subResult.output[0] : subResult.output;
                         const stdout = subResult.output.length ? serializeValueForStdout(json) : "";
                         result = { id: step.id, stdout, json };
+                        // A child ending in a rendered pipeline (`llm.invoke | json`) prints its items
+                        // and returns JSON parsed back out of that print, which no symbol survives.
+                        // Carry the child's own items across the composition boundary so this run
+                        // applies to them the same replay rule it applies to its own pipelines.
+                        const composedItems = pipelineSourceItems(subResult);
+                        if (composedItems)
+                            attachPipelineSourceItems(result, composedItems);
                     }
                     else if (execution.kind === "shell") {
                         const command = resolveTemplate(execution.value, resolvedArgs, results);
                         const stdinValue = resolveShellStdin(step.stdin, resolvedArgs, results);
+                        await markExecutionStarted(stepSignal);
                         const { stdout } = await runShellCommand({
                             command,
                             stdin: stdinValue,
                             env,
                             cwd,
                             signal: stepSignal,
-                            ...(step.timeout_ms ? { killSignal: "SIGKILL" } : {}),
+                            forceTerminationSignal: ctx.forceTerminationSignal,
+                            killSignal: () => stepTimeoutController?.signal.aborted ? "SIGKILL" : undefined,
                         });
                         result = { id: step.id, stdout, json: parseJson(stdout) };
                     }
@@ -847,7 +759,12 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                             stepId: step.id,
                             pipelineText,
                             inputValue,
-                            ctx: { ...ctx, signal: stepSignal },
+                            ctx: {
+                                ...ctx,
+                                signal: stepSignal,
+                                _onNonRetryableSideEffect: markNonRetryableSideEffect,
+                            },
+                            llmSpendLedger,
                             env,
                             cwd,
                             resume: resumedPipelineInput?.stepId === step.id
@@ -857,14 +774,23 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                                     onConsumed: resumedPipelineInput.onConsumed,
                                 }
                                 : undefined,
+                            onExecutionStart: () => markExecutionStarted(stepSignal),
                         });
                     }
                     else {
+                        if (execution.kind !== "none")
+                            await markExecutionStarted(stepSignal);
                         const inputValue = resolveInputValue(step.stdin, resolvedArgs, results);
                         result = createSyntheticStepResult(step.id, inputValue);
                     }
                     return { result, parallelBranchResults };
                 }
+                catch (error) {
+                    if (attemptHadNonRetryableSideEffect) {
+                        throw markStepErrorNonRetryable(error);
+                    }
+                    throw error;
+                }
                 finally {
                     if (timeoutId !== undefined)
                         clearTimeout(timeoutId);
@@ -878,9 +804,20 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         signal: ctx.signal,
                         shouldRetry: (error) => {
                             if (error instanceof WorkflowPipelineInputSuspension ||
-                                error instanceof RequestInputResumeError) {
+                                error instanceof RequestInputResumeError ||
+                                error instanceof CostLimitExceededError) {
+                                return false;
+                            }
+                            if (isStepErrorNonRetryable(error)) {
                                 return false;
                             }
+                            if (ctx.signal?.aborted)
+                                return false;
+                            if (workflow.cost_limit?.action === "stop") {
+                                // Failed pipelines can discard output after the provider was paid.
+                                settleUnbilledCharges(costTracker, llmSpendLedger);
+                                costTracker.checkLimit(workflow.cost_limit, ctx.stderr);
+                            }
                             const message = error?.message ?? String(error);
                             return !/halted (for approval inside|before completion at) pipeline/.test(message);
                         },
@@ -902,40 +839,67 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         subject: err.request.subject,
                         maxEnvelopeBytes: resolveToolEnvelopeMaxBytes(ctx.env),
                     });
-                    const stateKey = await saveWorkflowResumeState(ctx.env, {
-                        filePath: resolvedFilePath,
-                        resumeAtIndex: idx,
-                        steps: results,
-                        args: resolvedArgs,
-                        inputStepId: err.stepId,
-                        inputKind: "pipeline_command",
-                        inputSchema: err.request.responseSchema,
-                        inputSubject: err.request.subject,
-                        pipelineInput: err.pipelineInput,
-                        createdAt: new Date().toISOString(),
-                    });
-                    if (consumedResumeStateKey && consumedResumeStateKey !== stateKey) {
-                        await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
+                    let stateKey;
+                    try {
+                        stateKey = await saveWorkflowResumeState(ctx.env, {
+                            filePath: resolvedFilePath,
+                            resumeAtIndex: idx,
+                            steps: results,
+                            args: resolvedArgs,
+                            inputStepId: err.stepId,
+                            inputKind: "pipeline_command",
+                            inputSchema: err.request.responseSchema,
+                            inputSubject: err.request.subject,
+                            pipelineInput: err.pipelineInput,
+                            ...(costTracker.hasUsage() ? { cost: costTracker.getSummary() } : null),
+                            ...(llmSpendLedger.outstanding().length
+                                ? { llmSpend: llmSpendLedger.outstanding() }
+                                : null),
+                            ...(llmSpendLedger.settled().length
+                                ? { llmBilled: llmSpendLedger.settled() }
+                                : null),
+                            supersededResumeStateKeys: collectSupersededWorkflowResumeStateKeys(consumedResumeStateKey, resumeState),
+                            createdAt: new Date().toISOString(),
+                        }, ctx.signal);
+                        const replaced = await replaceWorkflowResumeState({
+                            env: ctx.env,
+                            previousStateKey: consumedResumeStateKey,
+                            expectedPreviousState: resumeState,
+                            previousStateConsumed: resumeStateConsumed,
+                            replacementStateKey: stateKey,
+                            signal: ctx.signal,
+                        });
+                        if (!replaced) {
+                            throw new Error("Workflow resume state not found");
+                        }
+                        const resumeToken = encodeToken({
+                            protocolVersion: 1,
+                            v: 1,
+                            kind: "workflow-file",
+                            stateKey,
+                        });
+                        return {
+                            status: "needs_input",
+                            output: [],
+                            requiresInput: {
+                                ...inputRequest,
+                                resumeToken,
+                            },
+                        };
+                    }
+                    catch (stateError) {
+                        if (stateKey)
+                            await discardWorkflowResumeState(ctx.env, stateKey);
+                        throw stateError;
                     }
-                    const resumeToken = encodeToken({
-                        protocolVersion: 1,
-                        v: 1,
-                        kind: "workflow-file",
-                        stateKey,
-                    });
-                    return {
-                        status: "needs_input",
-                        output: [],
-                        requiresInput: {
-                            ...inputRequest,
-                            resumeToken,
-                        },
-                    };
                 }
                 if (err instanceof RequestInputResumeError) {
                     throw err;
                 }
-                if (ctx.signal?.aborted && (err?.name === "AbortError" || err?.code === "ABORT_ERR")) {
+                if (err instanceof CostLimitExceededError) {
+                    throw err;
+                }
+                if (ctx.signal?.aborted) {
                     throw err;
                 }
                 if (err?.message &&
@@ -956,20 +920,36 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                     error: true,
                     errorMessage,
                 };
+                // The step failed after paying a provider: a call it made before failing is spend
+                // this run really made, and its items are gone with the failure. Settling here is
+                // what stops a budget already blown from letting the next step run its side
+                // effects, which is the whole point of `action: stop`.
+                settleUnbilledCharges(costTracker, llmSpendLedger);
+                if (workflow.cost_limit) {
+                    costTracker.checkLimit(workflow.cost_limit, ctx.stderr);
+                }
                 if (policy === "skip_rest") {
                     break;
                 }
                 continue;
             }
+            // One accounting group per step: its parallel branches and its own result settle
+            // together, so no branch can be billed for a charge another branch is about to claim.
+            const deferredCharges = [];
             if (parallelBranchResults) {
                 for (const [branchId, branchResult] of Object.entries(parallelBranchResults)) {
                     results[branchId] = branchResult;
-                    trackStepCost(costTracker, branchId, branchResult);
+                    trackStepCost(costTracker, branchId, branchResult, llmSpendLedger, deferredCharges);
                 }
             }
             results[step.id] = result;
             lastStepId = step.id;
-            trackStepCost(costTracker, step.id, result);
+            trackStepCost(costTracker, step.id, result, llmSpendLedger, deferredCharges);
+            settleDeferredCosts(costTracker, deferredCharges, llmSpendLedger);
+            // Before the next step runs: a charge no item carried is spend the step really made,
+            // and leaving it for the end would let `cost_limit` wave through every step after the
+            // one that blew the budget.
+            settleUnbilledCharges(costTracker, llmSpendLedger);
             if (workflow.cost_limit) {
                 costTracker.checkLimit(workflow.cost_limit, ctx.stderr);
             }
@@ -980,45 +960,64 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                     results[step.id].initiatedBy = approvalIdentity.initiatedBy;
                 }
                 if (ctx.mode === "tool" || !isInteractive(ctx.stdin)) {
-                    const stateKey = await saveWorkflowResumeState(ctx.env, {
-                        filePath: resolvedFilePath,
-                        resumeAtIndex: idx + 1,
-                        steps: results,
-                        args: resolvedArgs,
-                        approvalStepId: step.id,
-                        approvalIdentity,
-                        createdAt: new Date().toISOString(),
-                    });
-                    let approvalId;
+                    let stateKey;
                     try {
-                        approvalId = await createApprovalIndex({ env: ctx.env, stateKey });
+                        stateKey = await saveWorkflowResumeState(ctx.env, {
+                            filePath: resolvedFilePath,
+                            resumeAtIndex: idx + 1,
+                            steps: results,
+                            args: resolvedArgs,
+                            approvalStepId: step.id,
+                            approvalIdentity,
+                            ...(costTracker.hasUsage() ? { cost: costTracker.getSummary() } : null),
+                            ...(llmSpendLedger.outstanding().length
+                                ? { llmSpend: llmSpendLedger.outstanding() }
+                                : null),
+                            ...(llmSpendLedger.settled().length
+                                ? { llmBilled: llmSpendLedger.settled() }
+                                : null),
+                            supersededResumeStateKeys: collectSupersededWorkflowResumeStateKeys(consumedResumeStateKey, resumeState),
+                            createdAt: new Date().toISOString(),
+                        }, ctx.signal);
+                        const approvalId = await createApprovalIndex({ env: ctx.env, stateKey });
+                        ctx.signal?.throwIfAborted();
+                        const replaced = await replaceWorkflowResumeState({
+                            env: ctx.env,
+                            previousStateKey: consumedResumeStateKey,
+                            expectedPreviousState: resumeState,
+                            previousStateConsumed: resumeStateConsumed,
+                            replacementStateKey: stateKey,
+                            signal: ctx.signal,
+                        });
+                        if (!replaced) {
+                            throw new Error("Workflow resume state not found");
+                        }
+                        const resumeToken = encodeToken({
+                            protocolVersion: 1,
+                            v: 1,
+                            kind: "workflow-file",
+                            stateKey,
+                        });
+                        return {
+                            status: "needs_approval",
+                            output: [],
+                            requiresApproval: {
+                                ...approval,
+                                resumeToken,
+                                ...(approvalId ? { approvalId } : null),
+                            },
+                        };
                     }
                     catch (err) {
-                        await deleteStateJson({ env: ctx.env, key: stateKey }).catch(() => { });
+                        if (stateKey)
+                            await discardWorkflowResumeState(ctx.env, stateKey);
                         throw err;
                     }
-                    if (consumedResumeStateKey && consumedResumeStateKey !== stateKey) {
-                        await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
-                    }
-                    const resumeToken = encodeToken({
-                        protocolVersion: 1,
-                        v: 1,
-                        kind: "workflow-file",
-                        stateKey,
-                    });
-                    return {
-                        status: "needs_approval",
-                        output: [],
-                        requiresApproval: {
-                            ...approval,
-                            resumeToken,
-                            ...(approvalId ? { approvalId } : null),
-                        },
-                    };
                 }
                 ctx.stdout.write(`${approval.prompt} [y/N] `);
                 const answer = await readLineFromStream(ctx.stdin, {
                     timeoutMs: parseApprovalTimeoutMs(ctx.env),
+                    signal: ctx.signal,
                 });
                 if (!/^y(es)?$/i.test(String(answer).trim())) {
                     throw new Error("Not approved");
@@ -1034,270 +1033,88 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                     results[step.id].approvedBy = approvedBy;
             }
         }
+        // Whatever a skipped or failed step left open, and anything from a run with no step left
+        // to settle it against. A paused run does not reach this line -- its charges travel in
+        // the resume state instead -- so this settles only calls with nowhere left to be billed.
+        settleUnbilledCharges(costTracker, llmSpendLedger);
+        if (workflow.cost_limit) {
+            costTracker.checkLimit(workflow.cost_limit, ctx.stderr);
+        }
         const output = lastStepId ? toOutputItems(results[lastStepId]) : [];
         if (consumedResumeStateKey) {
-            await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
+            if (resumeStateConsumed) {
+                ctx.signal?.throwIfAborted();
+                await deleteStateJson({
+                    env: ctx.env,
+                    key: consumedResumeStateKey,
+                    signal: ctx.signal,
+                });
+                ctx.signal?.throwIfAborted();
+            }
+            else {
+                const deleted = await deleteResumeStateWithRollback({
+                    env: ctx.env,
+                    key: consumedResumeStateKey,
+                    expectedState: resumeState,
+                    signal: ctx.signal,
+                });
+                if (!deleted) {
+                    throw new Error("Workflow resume state not found");
+                }
+            }
+            await cleanupSupersededWorkflowResumeStates(ctx.env, resumeState?.supersededResumeStateKeys);
+        }
+        else {
+            ctx.signal?.throwIfAborted();
         }
         const runResult = { status: "ok", output };
+        // `output` is what the last step could serialize; a run composing this one also needs the
+        // items themselves, because that is where replay provenance lives.
+        const lastItems = lastStepId ? pipelineSourceItems(results[lastStepId]) : undefined;
+        if (lastItems)
+            attachPipelineSourceItems(runResult, lastItems);
         if (costTracker.hasUsage()) {
             runResult._meta = { cost: costTracker.getSummary() };
         }
         return runResult;
     }
-    finally {
-        ctx._activeWorkflows?.delete(canonicalFilePath);
-    }
-}
-// Returns a human-readable note if a step.stdin value references a prior step's
-// output. Because dry-run placeholders have no actual stdout/json, we surface
-// this so users know the value is unknown at plan time rather than silently
-// resolving to an empty string.
-function dryRunStdinNote(stdin) {
-    if (stdin === null || stdin === undefined)
-        return null;
-    if (typeof stdin !== "string")
-        return null;
-    const trimmed = stdin.trim();
-    // Strict step ref: '$step-id.stdout' or '$step-id.json'
-    if (/^\$[A-Za-z0-9_-]+\.(stdout|json)$/.test(trimmed)) {
-        return `${trimmed}  [output unknown at plan time]`;
-    }
-    // Inline template ref: contains '$stepid.stdout' or '$stepid.json'
-    if (/\$[A-Za-z0-9_-]+\.(stdout|json)/.test(trimmed)) {
-        return `${trimmed}  [contains step output refs — unknown at plan time]`;
-    }
-    return null;
-}
-function dryRunTemplateNote(input) {
-    if (/\$[A-Za-z0-9_-]+\.(stdout|json)/.test(input)) {
-        return "[contains step output refs — unknown at plan time]";
-    }
-    return null;
-}
-function hasDeferredDryRunStageName(input) {
-    return /\$[A-Za-z0-9_-]+\.(stdout|json)/.test(input);
-}
-function resolveDryRunTemplate(input, args, results) {
-    const withArgs = resolveArgsTemplate(input, args);
-    return withArgs.replace(/\$([A-Za-z0-9_-]+)\.(stdout|json|approved)/g, (match, id, field) => {
-        if (field === "approved") {
-            const step = results[id];
-            if (!step)
-                return match;
-            return step.approved === true ? "true" : "false";
-        }
-        return match;
-    });
-}
-function dryRunWorkflow({ steps, resolvedArgs, results, startIndex, ctx, }) {
-    const lines = [];
-    const totalSteps = steps.length - startIndex;
-    lines.push(`[DRY RUN] Would execute ${totalSteps} step${totalSteps !== 1 ? "s" : ""}:\n`);
-    for (let idx = startIndex; idx < steps.length; idx++) {
-        const step = steps[idx];
-        const num = idx - startIndex + 1;
-        if (!evaluateCondition(step.when ?? step.condition, results)) {
-            results[step.id] = { id: step.id, skipped: true };
-            lines.push(`  ${num}. ${step.id}  [skipped — condition: false]`);
-            continue;
-        }
-        if (isInputStep(step.input)) {
-            lines.push(`  ${num}. ${step.id}  [input]`);
-            lines.push(`     prompt: ${step.input.prompt}`);
-            lines.push(`     [input required]`);
-            results[step.id] = { id: step.id, response: { pending: true } };
-            continue;
-        }
-        if (typeof step.for_each === "string" && Array.isArray(step.steps)) {
-            lines.push(`  ${num}. ${step.id}  [for_each]`);
-            const forEachRef = step.for_each;
-            const forEachNote = dryRunTemplateNote(forEachRef);
-            lines.push(`     for_each: ${forEachRef}${forEachNote ? `  ${forEachNote}` : ""}`);
-            if (forEachRef.trim().startsWith("$")) {
-                try {
-                    resolveInputValue(forEachRef, resolvedArgs, results);
-                }
-                catch (err) {
-                    throw new Error(`Workflow step ${step.id} for_each: ${err?.message ?? String(err)}`);
-                }
-            }
-            const dryItemVar = step.item_var ?? "item";
-            const dryIndexVar = step.index_var ?? "index";
-            lines.push(`     item_var: ${dryItemVar}, index_var: ${dryIndexVar}`);
-            if (step.batch_size)
-                lines.push(`     batch_size: ${step.batch_size}`);
-            if (step.pause_ms)
-                lines.push(`     pause_ms: ${step.pause_ms}`);
-            lines.push(`     sub-steps: ${step.steps.length}`);
-            const loopScopedResults = { ...results };
-            loopScopedResults[dryItemVar] = { id: dryItemVar, json: { _placeholder: true } };
-            loopScopedResults[dryIndexVar] = { id: dryIndexVar, json: 0 };
-            for (let subIdx = 0; subIdx < step.steps.length; subIdx++) {
-                const sub = step.steps[subIdx];
-                if (!evaluateCondition(sub.when ?? sub.condition, loopScopedResults)) {
-                    lines.push(`       ${subIdx + 1}. ${sub.id}  [skipped — condition: false]`);
-                    loopScopedResults[sub.id] = { id: sub.id, skipped: true };
-                    continue;
-                }
-                if (sub.stdin !== undefined && sub.stdin !== null) {
-                    try {
-                        resolveInputValue(sub.stdin, resolvedArgs, loopScopedResults);
-                    }
-                    catch (err) {
-                        throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} stdin: ${err?.message ?? String(err)}`);
-                    }
-                }
-                const subExec = getStepExecution(sub);
-                if (subExec.kind === "shell") {
-                    const command = resolveDryRunTemplate(subExec.value, resolvedArgs, loopScopedResults);
-                    lines.push(`       ${subIdx + 1}. ${sub.id}  [shell] run: ${command}`);
-                }
-                else if (subExec.kind === "pipeline") {
-                    if (!ctx.registry) {
-                        throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} requires a command registry for pipeline execution`);
-                    }
-                    const pipelineText = resolveDryRunTemplate(subExec.value, resolvedArgs, loopScopedResults);
-                    const stages = parsePipeline(pipelineText);
-                    for (const stage of stages) {
-                        if (hasDeferredDryRunStageName(stage.name))
-                            continue;
-                        if (!ctx.registry.get(stage.name)) {
-                            throw new Error(`Workflow step ${step.id} for_each sub-step ${sub.id} pipeline: unknown command: ${stage.name}`);
-                        }
-                    }
-                    lines.push(`       ${subIdx + 1}. ${sub.id}  [pipeline] pipeline: ${pipelineText}`);
-                }
-                else {
-                    lines.push(`       ${subIdx + 1}. ${sub.id}  [no-op]`);
-                }
-                loopScopedResults[sub.id] = { id: sub.id };
-            }
-            results[step.id] = { id: step.id };
-            continue;
-        }
-        // Validate stdin refs early — throws if a strict ref like '$missing.stdout'
-        // points to a step that doesn't exist at all (real execution would also fail).
-        // We call resolveInputValue with the current results so refs to steps we've
-        // already visited (placeholders) are accepted without throwing.
-        if (step.stdin !== undefined && step.stdin !== null) {
+    catch (err) {
+        if (resumedExecutionStarted && consumedResumeStateKey) {
             try {
-                resolveInputValue(step.stdin, resolvedArgs, results);
-            }
-            catch (err) {
-                throw new Error(`Workflow step ${step.id} stdin: ${err?.message ?? String(err)}`);
-            }
-        }
-        const execution = getStepExecution(step);
-        // Annotate when the resolved command/pipeline references a prior step's output.
-        // Since dry-run placeholders have no actual stdout/json, note it explicitly
-        // rather than silently collapsing the reference to an empty string.
-        const stdinNote = dryRunStdinNote(step.stdin);
-        if (execution.kind === "parallel") {
-            lines.push(`  ${num}. ${step.id}  [parallel]`);
-            lines.push(`     wait: ${step.parallel?.wait ?? "all"}`);
-            if (step.parallel?.timeout_ms) {
-                lines.push(`     timeout: ${step.parallel.timeout_ms}ms`);
-            }
-            for (const branch of step.parallel?.branches ?? []) {
-                const branchShell = typeof branch.run === "string" ? branch.run : branch.command;
-                if (typeof branch.pipeline === "string" && branch.pipeline.trim()) {
-                    const pipelineText = resolveDryRunTemplate(branch.pipeline, resolvedArgs, results);
-                    const pipelineNote = dryRunTemplateNote(pipelineText);
-                    if (!ctx.registry) {
-                        throw new Error(`Parallel branch ${branch.id} requires a command registry for pipeline execution`);
-                    }
-                    const stages = parsePipeline(pipelineText);
-                    for (const stage of stages) {
-                        if (hasDeferredDryRunStageName(stage.name))
-                            continue;
-                        if (!ctx.registry.get(stage.name)) {
-                            throw new Error(`Parallel branch ${branch.id} pipeline references unknown command: ${stage.name}`);
-                        }
-                    }
-                    lines.push(`     branch ${branch.id}: [pipeline] ${pipelineText}${pipelineNote ? `  ${pipelineNote}` : ""}`);
-                }
-                else if (typeof branchShell === "string" && branchShell.trim()) {
-                    const command = resolveDryRunTemplate(branchShell, resolvedArgs, results);
-                    const commandNote = dryRunTemplateNote(command);
-                    lines.push(`     branch ${branch.id}: [shell] ${command}${commandNote ? `  ${commandNote}` : ""}`);
+                if (ctx.signal?.aborted) {
+                    await deleteStateJsonWithBoundedResumeCleanup({
+                        env: ctx.env,
+                        key: consumedResumeStateKey,
+                    });
                 }
                 else {
-                    lines.push(`     branch ${branch.id}: [no-op]`);
+                    await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
                 }
-                results[branch.id] = { id: branch.id };
             }
-        }
-        else if (execution.kind === "workflow") {
-            const workflowPath = resolveDryRunTemplate(execution.value, resolvedArgs, results);
-            const pathNote = dryRunTemplateNote(workflowPath);
-            lines.push(`  ${num}. ${step.id}  [workflow]`);
-            lines.push(`     workflow: ${workflowPath}${pathNote ? `  ${pathNote}` : ""}`);
-            if (step.workflow_args && typeof step.workflow_args === "object") {
-                const argKeys = Object.keys(step.workflow_args);
-                if (argKeys.length) {
-                    lines.push(`     args: ${argKeys.join(", ")}`);
-                }
-            }
-        }
-        else if (execution.kind === "shell") {
-            const command = resolveDryRunTemplate(execution.value, resolvedArgs, results);
-            const commandNote = dryRunTemplateNote(command);
-            lines.push(`  ${num}. ${step.id}  [shell]`);
-            lines.push(`     run: ${command}${commandNote ? `  ${commandNote}` : ""}`);
-        }
-        else if (execution.kind === "pipeline") {
-            const pipelineText = resolveDryRunTemplate(execution.value, resolvedArgs, results);
-            const pipelineNote = dryRunTemplateNote(pipelineText);
-            // Validate pipeline syntax and registry even in dry-run so errors surface early.
-            if (!ctx.registry) {
-                throw new Error(`Workflow step ${step.id} requires a command registry for pipeline execution`);
-            }
-            // Validate that every stage name is a known command.
-            const stages = parsePipeline(pipelineText);
-            for (const stage of stages) {
-                if (hasDeferredDryRunStageName(stage.name)) {
-                    continue;
-                }
-                if (!ctx.registry.get(stage.name)) {
-                    throw new Error(`Workflow step ${step.id} pipeline references unknown command: ${stage.name}`);
-                }
-            }
-            lines.push(`  ${num}. ${step.id}  [pipeline]`);
-            lines.push(`     pipeline: ${pipelineText}${pipelineNote ? `  ${pipelineNote}` : ""}`);
-            if (stages.some((stage) => hasDeferredDryRunStageName(stage.name))) {
-                lines.push("     [command validation deferred — stage name depends on step output]");
-            }
-        }
-        else {
-            lines.push(`  ${num}. ${step.id}  [no-op]`);
-        }
-        if (stdinNote)
-            lines.push(`     stdin: ${stdinNote}`);
-        if (step.timeout_ms)
-            lines.push(`     timeout: ${step.timeout_ms}ms`);
-        if (step.on_error && step.on_error !== "stop")
-            lines.push(`     on_error: ${step.on_error}`);
-        if (step.retry && typeof step.retry === "object") {
-            const rc = resolveRetryConfig(step.retry);
-            if (rc.max > 1) {
-                lines.push(`     retry: up to ${rc.max} attempts, ${rc.backoff} backoff (base: ${rc.delay_ms}ms${rc.jitter ? ", jitter" : ""})`);
+            catch {
+                // Leave the tombstone in place if cleanup fails: it is the durable
+                // record that prevents the consumed token from replaying an effect.
             }
+            // A consumed marker remains non-replayable even when its bounded cleanup
+            // times out, so its short approval ID can be retired independently.
+            await cleanupApprovalIndexByStateKey({
+                env: ctx.env,
+                stateKey: consumedResumeStateKey,
+            }).catch(() => { });
         }
-        if (isApprovalStep(step.approval)) {
-            lines.push(`     [approval required]`);
+        throw err;
+    }
+    finally {
+        for (const { signal, onAbort } of executionSignalListeners) {
+            signal.removeEventListener("abort", onAbort);
         }
-        // Record a placeholder result so later steps can reference this step in conditions.
-        // For approval steps, model approval as granted so downstream conditions like
-        // $step.approved evaluate correctly in the plan (rather than always being false).
-        // We intentionally omit stdout/json — dryRunStdinNote() surfaces that gap.
-        results[step.id] = isApprovalStep(step.approval)
-            ? { id: step.id, approved: true }
-            : { id: step.id };
-    }
-    lines.push("");
-    ctx.stderr.write(lines.join("\n"));
-    return { status: "ok", output: [] };
+        ctx._activeWorkflows?.delete(canonicalFilePath);
+    }
 }
+// Returns a human-readable note if a step.stdin value references a prior step's
+// output. Because dry-run placeholders have no actual stdout/json, we surface
+// this so users know the value is unknown at plan time rather than silently
+// resolving to an empty string.
 export function decodeWorkflowResumePayload(payload) {
     if (!payload || typeof payload !== "object")
         return null;
@@ -1319,12 +1136,87 @@ export function decodeWorkflowResumePayload(payload) {
         throw new Error("Invalid workflow token");
     return data;
 }
-async function saveWorkflowResumeState(env, state) {
+async function saveWorkflowResumeState(env, state, signal) {
     const stateKey = `workflow_resume_${randomUUID()}`;
-    await writeStateJson({ env, key: stateKey, value: state });
-    return stateKey;
+    try {
+        signal?.throwIfAborted();
+        await writeStateJson({ env, key: stateKey, value: state, signal });
+        signal?.throwIfAborted();
+        return stateKey;
+    }
+    catch (err) {
+        if (signal?.aborted)
+            await discardWorkflowResumeState(env, stateKey);
+        throw err;
+    }
 }
-function alternateWorkflowResumeStateKey(stateKey) {
+async function replaceWorkflowResumeState({ env, previousStateKey, expectedPreviousState, previousStateConsumed, replacementStateKey, signal, }) {
+    if (!previousStateKey || previousStateKey === replacementStateKey) {
+        signal?.throwIfAborted();
+        return true;
+    }
+    if (previousStateConsumed) {
+        signal?.throwIfAborted();
+        // The successor is already durable. Retire the predecessor's short ID here,
+        // rather than when the preceding unsafe execution is only being claimed.
+        await cleanupApprovalIndexByStateKey({ env, stateKey: previousStateKey }).catch(() => { });
+        return true;
+    }
+    if (!expectedPreviousState)
+        return false;
+    let claimId;
+    try {
+        const consumption = await consumeResumeState({
+            env,
+            key: previousStateKey,
+            expectedState: expectedPreviousState,
+            signal,
+        });
+        if (!consumption.consumed)
+            return false;
+        claimId = consumption.claimId;
+        // Keep the consumed marker until terminal cleanup. It is the atomic
+        // predecessor-to-successor handoff and prevents another resume from
+        // creating a competing successor after this call returns.
+        signal?.throwIfAborted();
+        await cleanupApprovalIndexByStateKey({ env, stateKey: previousStateKey }).catch(() => { });
+        return true;
+    }
+    catch (err) {
+        if (claimId && signal?.aborted) {
+            await restoreConsumedResumeState({
+                env,
+                key: previousStateKey,
+                expectedState: expectedPreviousState,
+                claimId,
+            }).catch(() => { });
+        }
+        throw err;
+    }
+}
+function collectSupersededWorkflowResumeStateKeys(previousStateKey, previousState) {
+    return [
+        ...(previousState?.supersededResumeStateKeys ?? []),
+        ...(previousStateKey ? [previousStateKey] : []),
+    ].filter((stateKey, index, all) => stateKey && all.indexOf(stateKey) === index);
+}
+async function cleanupSupersededWorkflowResumeStates(env, stateKeys) {
+    for (const stateKey of stateKeys ?? []) {
+        try {
+            if (isConsumedResumeState(await readStateJsonWithLock({ env, key: stateKey }))) {
+                await deleteStateJson({ env, key: stateKey });
+            }
+        }
+        catch {
+            // The completed successor makes retained ancestor markers safe.
+        }
+    }
+}
+async function discardWorkflowResumeState(env, stateKey) {
+    await cleanupApprovalIndexByStateKey({ env, stateKey }).catch(() => { });
+    await deleteStateJson({ env, key: stateKey }).catch(() => { });
+}
+export function alternateWorkflowResumeStateKey(stateKey) {
     if (stateKey.includes("workflow-resume_")) {
         return stateKey.replace("workflow-resume_", "workflow_resume_");
     }
@@ -1333,8 +1225,8 @@ function alternateWorkflowResumeStateKey(stateKey) {
     }
     return null;
 }
-async function resolveWorkflowResumeStateKey(env, stateKey) {
-    const stored = await readStateJson({ env, key: stateKey });
+async function resolveWorkflowResumeStateKey(env, stateKey, signal) {
+    const stored = await readStateJsonWithLock({ env, key: stateKey, signal });
     if (stored && typeof stored === "object") {
         return stateKey;
     }
@@ -1342,18 +1234,24 @@ async function resolveWorkflowResumeStateKey(env, stateKey) {
     if (!altKey) {
         return stateKey;
     }
-    const altStored = await readStateJson({ env, key: altKey });
+    const altStored = await readStateJsonWithLock({ env, key: altKey, signal });
     if (altStored && typeof altStored === "object") {
         return altKey;
     }
     return stateKey;
 }
-async function loadWorkflowResumeState(env, stateKey) {
-    let stored = await readStateJson({ env, key: stateKey });
+async function loadWorkflowResumeState(env, stateKey, signal) {
+    let stored = await readStateJsonWithLock({ env, key: stateKey, signal });
+    if (isConsumedResumeState(stored)) {
+        throw new Error("Workflow resume state not found");
+    }
     if ((!stored || typeof stored !== "object") && typeof stateKey === "string") {
         const altKey = alternateWorkflowResumeStateKey(stateKey);
         if (altKey) {
-            stored = await readStateJson({ env, key: altKey });
+            stored = await readStateJsonWithLock({ env, key: altKey, signal });
+            if (isConsumedResumeState(stored)) {
+                throw new Error("Workflow resume state not found");
+            }
         }
     }
     if (!stored || typeof stored !== "object") {
@@ -1368,6 +1266,11 @@ async function loadWorkflowResumeState(env, stateKey) {
         throw new Error("Invalid workflow resume state");
     if (!data.args || typeof data.args !== "object")
         throw new Error("Invalid workflow resume state");
+    if (data.supersededResumeStateKeys !== undefined &&
+        (!Array.isArray(data.supersededResumeStateKeys) ||
+            data.supersededResumeStateKeys.some((stateKey) => typeof stateKey !== "string"))) {
+        throw new Error("Invalid workflow resume state");
+    }
     if (data.inputKind !== undefined &&
         !["workflow_step", "pipeline_command"].includes(data.inputKind)) {
         throw new Error("Invalid workflow resume state");
@@ -1417,141 +1320,6 @@ function validateWorkflowPipelineShape(pipeline) {
             throw new Error("Invalid workflow resume state");
     }
 }
-function mergeEnv(base, workflowEnv, stepEnv, args, results) {
-    const env = { ...base };
-    // Expose resolved args as env vars so shell commands can safely reference them
-    // without embedding raw values into the command string.
-    // Example: $LOBSTER_ARG_TEXT
-    env.LOBSTER_ARGS_JSON = JSON.stringify(args ?? {});
-    for (const [key, value] of Object.entries(args ?? {})) {
-        const normalized = normalizeArgEnvKey(key);
-        if (!normalized)
-            continue;
-        env[`LOBSTER_ARG_${normalized}`] = String(value);
-    }
-    const apply = (source) => {
-        if (!source)
-            return;
-        for (const [key, value] of Object.entries(source)) {
-            if (typeof value === "string") {
-                env[key] = resolveTemplate(value, args, results);
-            }
-        }
-    };
-    // Allow explicit env blocks to override injected defaults.
-    apply(workflowEnv);
-    apply(stepEnv);
-    return env;
-}
-function normalizeArgEnvKey(key) {
-    const trimmed = String(key ?? "").trim();
-    if (!trimmed)
-        return null;
-    // Keep it predictable for shells: uppercase and [A-Z0-9_]
-    const up = trimmed.toUpperCase();
-    const normalized = up.replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-    return normalized || null;
-}
-function resolveCwd(cwd, args) {
-    if (!cwd)
-        return undefined;
-    return resolveArgsTemplate(cwd, args);
-}
-function resolveInputValue(stdin, args, results) {
-    if (stdin === null || stdin === undefined)
-        return null;
-    if (typeof stdin === "string") {
-        const ref = parseStepRef(stdin.trim());
-        if (ref)
-            return getStepRefValue(ref, results, true);
-        return resolveTemplate(stdin, args, results);
-    }
-    return stdin;
-}
-function resolveShellStdin(stdin, args, results) {
-    const value = resolveInputValue(stdin, args, results);
-    return encodeShellInput(value);
-}
-function resolveTemplate(input, args, results) {
-    const withArgs = resolveArgsTemplate(input, args);
-    return resolveStepRefs(withArgs, results);
-}
-function resolveWorkflowStepArgs(workflowArgs, parentArgs, results) {
-    if (!workflowArgs)
-        return {};
-    const resolved = {};
-    for (const [key, value] of Object.entries(workflowArgs)) {
-        if (typeof value === "string") {
-            resolved[key] = resolveTemplate(value, parentArgs, results);
-        }
-        else {
-            resolved[key] = value;
-        }
-    }
-    return resolved;
-}
-function resolveArgsTemplate(input, args) {
-    return input.replace(/\$\{([A-Za-z0-9_-]+)\}/g, (match, key) => {
-        if (key in args)
-            return String(args[key]);
-        return match;
-    });
-}
-function resolveStepRefs(input, results) {
-    return input.replace(/\$([A-Za-z0-9_-]+)\.([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)*)/g, (match, id, pathValue) => {
-        if (!(id in results)) {
-            return match;
-        }
-        const refValue = getStepRefValue({ id, path: pathValue }, results, false);
-        if (refValue === undefined) {
-            if (pathValue === "approved" || pathValue === "skipped")
-                return "false";
-            return "";
-        }
-        return renderTemplateValue(refValue);
-    });
-}
-function parseStepRef(value) {
-    const match = value.match(/^\$([A-Za-z0-9_-]+)\.([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)*)$/);
-    if (!match)
-        return null;
-    return { id: match[1], path: match[2] };
-}
-function getStepRefValue(ref, results, strict) {
-    const step = results[ref.id];
-    if (!step) {
-        if (strict)
-            throw new Error(`Unknown step reference: ${ref.id}.${ref.path}`);
-        return undefined;
-    }
-    return getValueByPath(step, ref.path);
-}
-function evaluateCondition(condition, results) {
-    if (condition === undefined || condition === null)
-        return true;
-    if (typeof condition === "boolean")
-        return condition;
-    if (typeof condition !== "string")
-        throw new Error("Unsupported condition type");
-    const trimmed = condition.trim();
-    if (trimmed === "true")
-        return true;
-    if (trimmed === "false")
-        return false;
-    return evaluateConditionExpression(trimmed, results);
-}
-function isApprovalStep(approval) {
-    if (approval === true)
-        return true;
-    if (typeof approval === "string" && approval.trim().length > 0)
-        return true;
-    if (approval && typeof approval === "object" && !Array.isArray(approval))
-        return true;
-    return false;
-}
-function isInputStep(input) {
-    return Boolean(input && typeof input === "object" && !Array.isArray(input));
-}
 function extractApprovalRequest(step, result, env) {
     const approvalConfig = normalizeApprovalConfig(step.approval);
     const configIdentity = approvalIdentityFromRaw(approvalConfig);
@@ -1671,21 +1439,226 @@ function parseBoolLike(value) {
         return false;
     return undefined;
 }
-function trackStepCost(costTracker, stepId, result) {
-    const json = result.json;
+// The objects a step's pipeline produced, held apart from the serializable step result.
+// A rendered pipeline such as `llm.invoke | json` prints its items and returns an empty
+// stream, so the step's `json` is parsed back out of stdout and only carries what JSON can
+// express. A symbol key survives neither `JSON.stringify` nor `JSON.parse`, so this holds
+// exactly the items this process made, and no workflow input can put one here.
+const PIPELINE_SOURCE_ITEMS = Symbol("lobster.workflow.pipelineSourceItems");
+function attachPipelineSourceItems(target, items) {
+    Object.defineProperty(target, PIPELINE_SOURCE_ITEMS, {
+        value: items,
+        enumerable: false,
+        configurable: true,
+    });
+    return target;
+}
+function pipelineSourceItems(target) {
+    if (!target)
+        return undefined;
+    const items = target[PIPELINE_SOURCE_ITEMS];
+    return Array.isArray(items) ? items : undefined;
+}
+// The ledger of the run that invoked this one as a `workflow:` step. A composed run bills its
+// own steps and the composing run bills the output handed back to it, so a live call has to be
+// open in both ledgers for each of them to count it once. Read defensively: this arrives
+// through the same context object a caller supplies.
+function composingSpendLedger(ctx) {
+    const ledger = ctx._llmSpendLedger;
+    if (!ledger || typeof ledger !== "object")
+        return null;
+    return typeof ledger.record === "function" && typeof ledger.claim === "function" ? ledger : null;
+}
+/**
+ * One `wait: "any"` branch's view of the run ledger. The race returns as soon as a branch
+ * answers and leaves the others running, so a losing branch can pay a provider long after the
+ * step settled. Writing that charge straight to the run ledger makes the workflow's own total
+ * depend on how long the run happened to live afterwards: land before the run ends and the
+ * discarded branch's spend is billed, land after and it is billed nowhere.
+ *
+ * So a branch opens its charges here instead, and only the winner releases them into the run.
+ * The output of a losing branch is thrown away; its accounting goes with it. Reads pass
+ * through, because they settle charges the run opened before the race and are made by the
+ * workflow after a branch has returned, never from inside one.
+ */
+function branchSpendBuffer(ledger) {
+    const held = [];
+    let released = false;
+    return {
+        record: (cacheKey, charge) => {
+            if (released)
+                ledger.record(cacheKey, charge);
+            else
+                held.push({ cacheKey, charge });
+        },
+        claim: (cacheKey, cost) => ledger.claim(cacheKey, cost),
+        billCopy: (cacheKey, model, usage) => ledger.billCopy(cacheKey, model, usage),
+        outstanding: () => ledger.outstanding(),
+        restore: (charges) => ledger.restore(charges),
+        settled: () => ledger.settled(),
+        restoreSettled: (charges) => ledger.restoreSettled(charges),
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            for (const { cacheKey, charge } of held)
+                ledger.record(cacheKey, charge);
+            held.length = 0;
+        },
+    };
+}
+/**
+ * The run ledger seen by one step, so a charge opened inside it knows where it came from. A
+ * composed run's charges reach the composing run through this too, which is why the step id is
+ * overwritten rather than kept: in the parent's totals the spend belongs to the `workflow:`
+ * step, not to whatever the child called its own.
+ */
+function stepScopedLedger(ledger, stepId) {
+    return {
+        record: (cacheKey, charge) => ledger.record(cacheKey, { ...charge, stepId }),
+        claim: (cacheKey, cost) => ledger.claim(cacheKey, cost),
+        billCopy: (cacheKey, model, usage) => ledger.billCopy(cacheKey, model, usage),
+        outstanding: () => ledger.outstanding(),
+        restore: (charges) => ledger.restore(charges),
+        settled: () => ledger.settled(),
+        restoreSettled: (charges) => ledger.restoreSettled(charges),
+    };
+}
+/**
+ * Bills the calls that ended the run unclaimed. An item is the usual carrier of usage, but a
+ * renderer can consume the pipeline before a later stage emits items of its own, an `ask` gate
+ * can swallow the only item, and a composed run can end on a step that carries none. The
+ * charge outlives all three, and dropping it would leave real spend out of `_meta.cost` and
+ * out of `cost_limit`.
+ */
+function settleUnbilledCharges(costTracker, llmSpendLedger) {
+    for (const charge of llmSpendLedger.outstanding()) {
+        if (!charge.usage)
+            continue;
+        if (!llmSpendLedger.claim(charge.cacheKey))
+            continue;
+        costTracker.recordUsage(charge.stepId ?? "llm", charge.model ?? null, charge.usage);
+    }
+}
+function trackStepCost(costTracker, stepId, result, llmSpendLedger, deferredCharges) {
+    // Bill the items the pipeline produced rather than the JSON re-read from its stdout: a
+    // renderer serializes them, and replay provenance does not survive that round trip. Steps
+    // without a pipeline (shell commands) have no such items and are read from `json` as before.
+    const json = pipelineSourceItems(result) ?? result.json;
     if (!json || typeof json !== "object")
         return;
+    // Replays wait for the live results accounted with them. Branches of one parallel step are
+    // billed in declaration order, so a cached replay declared before an identical `--refresh`
+    // branch would otherwise claim the charge that branch had just opened — and the live branch,
+    // billed whatever its own claim returns, would be billed for it too. One provider call, two
+    // charges, and a `cost_limit` tripped on spend that never happened.
+    const deferred = deferredCharges ?? [];
     const items = Array.isArray(json) ? json : [json];
     for (const item of items) {
         if (!item || typeof item !== "object")
             continue;
-        const usage = item.usage;
+        const record = item;
+        const usage = record.usage;
         if (!usage || typeof usage !== "object")
             continue;
-        const modelValue = item.model;
+        const modelValue = record.model;
         const model = typeof modelValue === "string" ? modelValue : null;
+        // Provenance the LLM commands attach in-process, never a field in the JSON: a step that
+        // prints a replay-shaped object stays billed, so `cost_limit` cannot be evaded. A
+        // projection can drop the item's own mark while carrying its usage record across, so the
+        // record is read too — both marks are symbol keys built in this process.
+        const provenance = llmProvenanceOf(record) ?? llmProvenanceOf(usage);
+        if (provenance) {
+            if (provenance.replayed) {
+                deferred.push({
+                    kind: "replay",
+                    stepId,
+                    cacheKey: provenance.cacheKey,
+                    model,
+                    usage: usage,
+                });
+                continue;
+            }
+            // Settles the charge this live call opened -- the one that cost what this item cost,
+            // not merely the first under the key. A step retried after an attempt that failed
+            // after paying leaves more than one charge open, and they did not cost the same.
+            const settled = llmSpendLedger.claim(provenance.cacheKey, {
+                model,
+                usage: usage,
+            });
+            // Bill what the provider was really asked for, not what the item says by the time it
+            // gets here. A pipeline can drop the model on the way -- `| pick usage` hands on the
+            // marked usage record without it -- or rewrite it, and the step is then priced at the
+            // wrong rate or at nothing at all while `cost_limit` reads the difference as room left.
+            // The charge the call opened is the same witness a replay is already billed from. A
+            // charge restored from resume state written before it carried a cost falls back.
+            if (settled?.usage) {
+                costTracker.recordUsage(stepId, settled.model ?? null, settled.usage);
+                markLlmProvenanceReplayed(record);
+                markLlmProvenanceReplayed(usage);
+                continue;
+            }
+        }
+        else {
+            // No mark, but numbers: a stage that JSON round-trips the stream hands on a copy that
+            // kept `model` and `usage` and lost everything this process attached -- sometimes the
+            // cache key with it. Held back like a replay, and for the same reason: a copy that
+            // lost its key is read by cost alone, and until the marked results have settled their
+            // own charges an identical parallel call's charge is still open to be mistaken for
+            // the one this copy came from.
+            deferred.push({
+                kind: "copy",
+                stepId,
+                cacheKey: typeof record.cacheKey === "string" && record.cacheKey ? record.cacheKey : null,
+                model,
+                usage: usage,
+            });
+            continue;
+        }
         costTracker.recordUsage(stepId, model, usage);
+        markLlmProvenanceReplayed(record);
+        markLlmProvenanceReplayed(usage);
+    }
+    if (!deferredCharges)
+        settleDeferredCosts(costTracker, deferred, llmSpendLedger);
+}
+/**
+ * Bills what a step held back, now that every marked live result accounted alongside them has
+ * settled its own charge. Replays go first: one carries the mark of the call it stands in for,
+ * which is better evidence than the cost a copy carries on its own.
+ *
+ * A replay carries the usage of the call that produced it, so counting it again charges a run
+ * for tokens no provider was asked to spend. It is billed only when the call it replays is
+ * still unpaid for: a step is costed once it succeeds, so a step that failed after its LLM
+ * call and was retried leaves its real spend riding on the replay the retry produced.
+ *
+ * A copy is billed either way — it is a record of a call, and nothing in a JSON payload can be
+ * trusted to say otherwise — but the ledger still decides whether it settles a charge, so the
+ * step settlement does not add a second record of the same call.
+ */
+function settleDeferredCosts(costTracker, deferred, llmSpendLedger) {
+    for (const replay of deferred) {
+        if (replay.kind !== "replay" || replay.cacheKey === null)
+            continue;
+        const settled = llmSpendLedger.claim(replay.cacheKey);
+        if (!settled)
+            continue;
+        // Bill what the call this settles actually cost, not what the replay carries. Identical
+        // calls that raced on a cold cache are separate charges under one key, and every replay
+        // of them repeats whichever single answer was stored -- so costing each replay by its
+        // own copy reports all of those calls at the price of the one that won the cache write.
+        // A charge restored from resume state written before it carried a cost falls back.
+        const cost = typeof settled === "object" && settled.usage ? settled : null;
+        costTracker.recordUsage(replay.stepId, cost ? (cost.model ?? null) : replay.model, cost?.usage ?? replay.usage);
+    }
+    for (const copy of deferred) {
+        if (copy.kind !== "copy")
+            continue;
+        if (llmSpendLedger.billCopy(copy.cacheKey, copy.model, copy.usage)) {
+            costTracker.recordUsage(copy.stepId, copy.model, copy.usage);
+        }
     }
+    deferred.length = 0;
 }
 function parseJson(stdout) {
     const trimmed = stdout.trim();
@@ -1713,7 +1686,7 @@ function toOutputItems(result) {
     return [];
 }
 function cloneResults(results) {
-    const out = {};
+    const out = createRecord();
     for (const [key, value] of Object.entries(results)) {
         out[key] = { ...value };
     }
@@ -1852,346 +1825,24 @@ function estimateSerializedBytes(value) {
         return Number.POSITIVE_INFINITY;
     }
 }
-function renderTemplateValue(value) {
-    if (value === undefined || value === null)
-        return "";
-    if (typeof value === "string")
-        return value;
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-        return String(value);
-    }
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
-function getValueByPath(value, pathValue) {
-    const fields = pathValue.split(".");
-    let current = value;
-    for (const field of fields) {
-        if (current === null || current === undefined)
-            return undefined;
-        if (Array.isArray(current)) {
-            const idx = Number(field);
-            if (!Number.isInteger(idx) || idx < 0 || idx >= current.length)
-                return undefined;
-            current = current[idx];
-            continue;
-        }
-        if (typeof current !== "object")
-            return undefined;
-        current = current[field];
-    }
-    return current;
-}
-function evaluateConditionExpression(expression, results) {
-    const tokens = tokenizeCondition(expression);
-    if (tokens.length === 0) {
-        throw new Error(`Unsupported condition: ${expression}`);
-    }
-    let index = 0;
-    function parseOr() {
-        let left = parseAnd();
-        while (match("or")) {
-            const right = parseAnd();
-            left = Boolean(left) || Boolean(right);
-        }
-        return left;
-    }
-    function parseAnd() {
-        let left = parseEquality();
-        while (match("and")) {
-            const right = parseEquality();
-            left = Boolean(left) && Boolean(right);
-        }
-        return left;
-    }
-    function parseEquality() {
-        const left = parseUnary(false);
-        if (match("eq")) {
-            return compareConditionValues(left, parseUnary(true));
-        }
-        if (match("neq")) {
-            return !compareConditionValues(left, parseUnary(true));
-        }
-        if (match("lt")) {
-            return numericCompare(left, parseUnary(true), (a, b) => a < b);
-        }
-        if (match("lte")) {
-            return numericCompare(left, parseUnary(true), (a, b) => a <= b);
-        }
-        if (match("gt")) {
-            return numericCompare(left, parseUnary(true), (a, b) => a > b);
-        }
-        if (match("gte")) {
-            return numericCompare(left, parseUnary(true), (a, b) => a >= b);
-        }
-        return left;
-    }
-    function parseUnary(allowBareIdentifier) {
-        if (match("not")) {
-            return !Boolean(parseUnary(allowBareIdentifier));
-        }
-        return parsePrimary(allowBareIdentifier);
-    }
-    function parsePrimary(allowBareIdentifier) {
-        const token = tokens[index];
-        if (!token) {
-            throw new Error(`Unsupported condition: ${expression}`);
-        }
-        index += 1;
-        if (token.type === "lparen") {
-            const value = parseOr();
-            expect("rparen");
-            return value;
-        }
-        if (token.type === "step_ref") {
-            return getStepRefValue(token.value, results, true);
-        }
-        if (token.type === "string" ||
-            token.type === "number" ||
-            token.type === "boolean" ||
-            token.type === "null") {
-            return token.value;
-        }
-        if (token.type === "identifier" && allowBareIdentifier) {
-            return token.value;
-        }
-        throw new Error(`Unsupported condition: ${expression}`);
-    }
-    function match(type) {
-        if (tokens[index]?.type !== type)
-            return false;
-        index += 1;
-        return true;
-    }
-    function expect(type) {
-        if (!match(type)) {
-            throw new Error(`Unsupported condition: ${expression}`);
-        }
-    }
-    const value = parseOr();
-    if (index !== tokens.length) {
-        throw new Error(`Unsupported condition: ${expression}`);
-    }
-    return Boolean(value);
-}
-function compareConditionValues(left, right) {
-    if (Array.isArray(left) ||
-        Array.isArray(right) ||
-        isPlainConditionObject(left) ||
-        isPlainConditionObject(right)) {
-        return isDeepStrictEqual(left, right);
-    }
-    return Object.is(left, right);
-}
-function isStrictlyNumeric(value) {
-    if (typeof value === "number")
-        return !Number.isNaN(value);
-    if (typeof value === "string")
-        return value.trim() !== "" && !Number.isNaN(Number(value));
-    return false;
-}
-function numericCompare(left, right, cmp) {
-    if (!isStrictlyNumeric(left) || !isStrictlyNumeric(right))
-        return false;
-    return cmp(Number(left), Number(right));
-}
-function isPlainConditionObject(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function tokenizeCondition(expression) {
-    const tokens = [];
-    let index = 0;
-    while (index < expression.length) {
-        const ch = expression[index];
-        if (/\s/.test(ch)) {
-            index += 1;
-            continue;
-        }
-        if (ch === "(") {
-            tokens.push({ type: "lparen" });
-            index += 1;
-            continue;
-        }
-        if (ch === ")") {
-            tokens.push({ type: "rparen" });
-            index += 1;
-            continue;
-        }
-        if (expression.startsWith("&&", index)) {
-            tokens.push({ type: "and" });
-            index += 2;
-            continue;
-        }
-        if (expression.startsWith("||", index)) {
-            tokens.push({ type: "or" });
-            index += 2;
-            continue;
-        }
-        if (expression.startsWith("==", index)) {
-            tokens.push({ type: "eq" });
-            index += 2;
-            continue;
-        }
-        if (expression.startsWith("!=", index)) {
-            tokens.push({ type: "neq" });
-            index += 2;
-            continue;
-        }
-        if (expression.startsWith("<=", index)) {
-            tokens.push({ type: "lte" });
-            index += 2;
-            continue;
-        }
-        if (expression.startsWith(">=", index)) {
-            tokens.push({ type: "gte" });
-            index += 2;
-            continue;
-        }
-        if (ch === "<") {
-            tokens.push({ type: "lt" });
-            index += 1;
-            continue;
-        }
-        if (ch === ">") {
-            tokens.push({ type: "gt" });
-            index += 1;
-            continue;
-        }
-        if (ch === "!") {
-            tokens.push({ type: "not" });
-            index += 1;
-            continue;
-        }
-        if (ch === "$") {
-            const matched = matchConditionStepRef(expression, index);
-            if (!matched) {
-                throw new Error(`Unsupported condition: ${expression}`);
-            }
-            tokens.push({ type: "step_ref", value: matched.ref });
-            index = matched.nextIndex;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            const parsed = parseQuotedConditionString(expression, index, ch);
-            tokens.push({ type: "string", value: parsed.value });
-            index = parsed.nextIndex;
-            continue;
-        }
-        const numberMatch = expression.slice(index).match(/^-?\d+(?:\.\d+)?/);
-        if (numberMatch) {
-            tokens.push({ type: "number", value: Number(numberMatch[0]) });
-            index += numberMatch[0].length;
-            continue;
-        }
-        const identMatch = expression.slice(index).match(/^[A-Za-z_][A-Za-z0-9_-]*/);
-        if (identMatch) {
-            const raw = identMatch[0];
-            if (raw === "true") {
-                tokens.push({ type: "boolean", value: true });
-            }
-            else if (raw === "false") {
-                tokens.push({ type: "boolean", value: false });
-            }
-            else if (raw === "null") {
-                tokens.push({ type: "null", value: null });
-            }
-            else {
-                tokens.push({ type: "identifier", value: raw });
-            }
-            index += raw.length;
-            continue;
-        }
-        throw new Error(`Unsupported condition: ${expression}`);
-    }
-    return tokens;
-}
-function matchConditionStepRef(expression, startIndex) {
-    const match = expression
-        .slice(startIndex)
-        .match(/^\$([A-Za-z0-9_-]+)\.([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)*)/);
-    if (!match)
-        return null;
-    return {
-        ref: { id: match[1], path: match[2] },
-        nextIndex: startIndex + match[0].length,
-    };
-}
-function parseQuotedConditionString(expression, startIndex, quoteChar) {
-    let value = "";
-    let index = startIndex + 1;
-    while (index < expression.length) {
-        const ch = expression[index];
-        if (ch === "\\") {
-            const next = expression[index + 1];
-            if (next === undefined)
-                break;
-            value += next;
-            index += 2;
-            continue;
-        }
-        if (ch === quoteChar) {
-            return { value, nextIndex: index + 1 };
-        }
-        value += ch;
-        index += 1;
-    }
-    throw new Error(`Unsupported condition: ${expression}`);
-}
-async function runShellCommand({ command, stdin, env, cwd, signal, killSignal, }) {
-    const { spawn } = await import("node:child_process");
-    return await new Promise((resolve, reject) => {
-        const shell = resolveInlineShellCommand({ command, env });
-        const child = spawn(shell.command, shell.argv, {
-            env,
-            cwd,
-            signal,
-            killSignal,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (d) => {
-            stdout += d;
-        });
-        child.stderr.on("data", (d) => {
-            stderr += d;
-        });
-        if (typeof stdin === "string") {
-            child.stdin.setDefaultEncoding("utf8");
-            child.stdin.write(stdin);
-        }
-        child.stdin.end();
-        child.on("error", reject);
-        child.on("close", (code) => {
-            if (code === 0)
-                return resolve({ stdout, stderr });
-            reject(new Error(`workflow command failed (${code}): ${stderr.trim() || stdout.trim() || command}`));
-        });
+async function runShellCommand({ command, stdin, env, cwd, signal, forceTerminationSignal, killSignal, }) {
+    signal?.throwIfAborted();
+    signal?.throwIfAborted();
+    const { stdout, stderr, code } = await runAbortableProcess({
+        shellCommand: command,
+        env,
+        cwd,
+        stdin,
+        signal,
+        forceTerminationSignal,
+        killSignal,
+        notFoundMessage: "workflow shell not found; check LOBSTER_SHELL or ComSpec",
     });
+    if (code === 0)
+        return { stdout, stderr };
+    throw new Error(`workflow command failed (${code}): ${stderr.trim() || stdout.trim() || command}`);
 }
-function getStepExecution(step) {
-    if (step.parallel && typeof step.parallel === "object" && !Array.isArray(step.parallel)) {
-        return { kind: "parallel", value: step.parallel };
-    }
-    if (typeof step.workflow === "string" && step.workflow.trim()) {
-        return { kind: "workflow", value: step.workflow };
-    }
-    if (typeof step.pipeline === "string" && step.pipeline.trim()) {
-        return { kind: "pipeline", value: step.pipeline };
-    }
-    const shellCommand = typeof step.run === "string" ? step.run : step.command;
-    if (typeof shellCommand === "string" && shellCommand.trim()) {
-        return { kind: "shell", value: shellCommand };
-    }
-    return { kind: "none" };
-}
-async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd, resume, requestInputEnabled = true, }) {
+async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, llmSpendLedger, env, cwd, resume, requestInputEnabled = true, onExecutionStart, }) {
     let pipeline;
     try {
         const currentPipeline = parsePipeline(pipelineText);
@@ -2228,7 +1879,11 @@ async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd
         mode: ctx.mode,
         cwd,
         signal: ctx.signal,
+        forceTerminationSignal: ctx.forceTerminationSignal,
+        haltAfterStageOnAbort: true,
         llmAdapters: ctx.llmAdapters,
+        // Scoped so a charge nothing bills can still name the step that opened it.
+        llmSpendLedger: llmSpendLedger ? stepScopedLedger(llmSpendLedger, stepId) : undefined,
         input: resume ? resume.pipelineInput.items : inputValueToPipelineItems(inputValue),
         requestInputEnabled,
         requestInputResume: resume
@@ -2238,8 +1893,11 @@ async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd
                 onConsumed: resume.onConsumed,
             }
             : undefined,
+        onExecutionStart,
+        onNonRetryableSideEffect: ctx._onNonRetryableSideEffect,
     });
     stdout.end();
+    ctx.signal?.throwIfAborted();
     if (result.halted) {
         const haltedName = result.haltedAt?.stage?.name ?? "unknown";
         if (result.items.length === 1 && result.items[0]?.type === "approval_request") {
@@ -2273,11 +1931,25 @@ async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd
             ? result.items[0]
             : result.items
         : parseJson(renderedStdout);
-    return {
+    const stepResult = {
         id: stepId,
         stdout: normalizedStdout,
         json,
     };
+    // Only when a renderer consumed the pipeline: otherwise `json` already is those items.
+    if (!result.items.length && result.renderedItems.length) {
+        // Only restore marks from the renderer's own matching objects, never from public JSON fields.
+        const source = Array.isArray(json)
+            ? result.renderedItems
+            : result.renderedItems.length === 1
+                ? result.renderedItems[0]
+                : undefined;
+        if (source !== undefined && stableStringify(source) === stableStringify(json)) {
+            carryLlmProvenance(source, json);
+        }
+        attachPipelineSourceItems(stepResult, result.renderedItems);
+    }
+    return stepResult;
 }
 function createSyntheticStepResult(stepId, value) {
     if (value === null || value === undefined) {
@@ -2317,13 +1989,6 @@ function abortableSleep(ms, signal) {
         signal.addEventListener("abort", onAbort, { once: true });
     });
 }
-function encodeShellInput(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value === "string")
-        return value;
-    return JSON.stringify(value);
-}
 function* inputValueToItems(value) {
     if (value === null || value === undefined)
         return;