@openclaw/lobster 2026.9.5 → 2026.9.7

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

@@ -1,29 +1,25 @@
+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 { cleanupApprovalIndexByStateKey, consumeResumeState, createApprovalIndex, deleteStateJsonWithBoundedResumeCleanup, deleteResumeStateWithRollback, deleteStateJson, deleteUnconsumedResumeState, isConsumedResumeState, readStateJsonWithLock, restoreConsumedResumeState, 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 { compileCached } from "../validation.js";
-import { createLlmSpendLedger, llmProvenanceOf, restoreLlmProvenance, } from "../commands/stdlib/llm_invoke.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 createRecord(source) {
-    const record = Object.create(null);
-    if (!source)
-        return record;
-    for (const [key, value] of Object.entries(source))
-        record[key] = value;
-    return record;
-}
 function markStepErrorNonRetryable(error) {
     const normalized = error instanceof Error ? error : new Error(String(error));
     Object.defineProperty(normalized, NON_RETRYABLE_STEP_ERROR, { value: true });
@@ -67,320 +63,6 @@ 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 = createRecord();
     if (argDefs) {
@@ -879,7 +561,7 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                             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;
@@ -1433,262 +1115,6 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
 // 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 = createRecord(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 };
-            }
-            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" : ""})`);
-                }
-            }
-            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) {
-            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}` : ""}`);
-                }
-                else {
-                    lines.push(`     branch ${branch.id}: [no-op]`);
-                }
-                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" : ""})`);
-            }
-        }
-        if (isApprovalStep(step.approval)) {
-            lines.push(`     [approval required]`);
-        }
-        // 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: [] };
-}
 export function decodeWorkflowResumePayload(payload) {
     if (!payload || typeof payload !== "object")
         return null;
@@ -1894,148 +1320,6 @@ function validateWorkflowPipelineShape(pipeline) {
             throw new Error("Invalid workflow resume state");
     }
 }
-function mergeEnv(base, workflowEnv, stepEnv, args, results) {
-    const env = createRecord(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();
-    let normalized = up.replace(/[^A-Z0-9]+/g, "_");
-    let start = 0;
-    while (normalized[start] === "_")
-        start++;
-    let end = normalized.length;
-    while (end > start && normalized[end - 1] === "_")
-        end--;
-    normalized = normalized.slice(start, end);
-    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 createRecord();
-    const resolved = createRecord();
-    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 (Object.hasOwn(args, key))
-            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);
@@ -2310,6 +1594,8 @@ function trackStepCost(costTracker, stepId, result, llmSpendLedger, deferredChar
             // 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;
             }
         }
@@ -2330,6 +1616,8 @@ function trackStepCost(costTracker, stepId, result, llmSpendLedger, deferredChar
             continue;
         }
         costTracker.recordUsage(stepId, model, usage);
+        markLlmProvenanceReplayed(record);
+        markLlmProvenanceReplayed(usage);
     }
     if (!deferredCharges)
         settleDeferredCosts(costTracker, deferred, llmSpendLedger);
@@ -2537,295 +1825,6 @@ 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, forceTerminationSignal, killSignal, }) {
     signal?.throwIfAborted();
     signal?.throwIfAborted();
@@ -2843,22 +1842,6 @@ async function runShellCommand({ command, stdin, env, cwd, signal, forceTerminat
         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, llmSpendLedger, env, cwd, resume, requestInputEnabled = true, onExecutionStart, }) {
     let pipeline;
     try {
@@ -2955,6 +1938,15 @@ async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, llmSpend
     };
     // 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;
@@ -2997,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;