@ashx-j/lunr-dev 0.2.13-dev.1.1

package/dist/builtin-extensions/pi-subagents/src/runs/foreground/chain-execution.js

@@ -0,0 +1,1042 @@
+// @ts-nocheck
+/**
+ * Chain execution logic for subagent tool
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { normalizeChildSpec } from "../../shared/child-spec.js";
+import { snapshotParentPermissionMode } from "../../../../../core/subagent-permission-inherit.js";
+import { ChainClarifyComponent } from "./chain-clarify.js";
+import { toModelInfo } from "../../shared/model-info.js";
+import { resolveChainTemplates, createChainDir, removeChainDir, resolveStepBehavior, resolveParallelBehaviors, buildChainInstructions, writeInitialProgressFile, createParallelDirs, suppressProgressForReadOnlyTask, aggregateParallelOutputs, isDynamicParallelStep, isParallelStep, } from "../../shared/settings.js";
+import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.js";
+import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.js";
+import { runSync } from "./execution.js";
+import { buildChainSummary } from "../../shared/formatters.js";
+import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, resolveChildCwd, sumResultsCost, sumResultsUsage } from "../../shared/utils.js";
+import { DEFAULT_GLOBAL_CONCURRENCY_LIMIT, Semaphore } from "../shared/parallel-utils.js";
+import { recordRun } from "../shared/run-history.js";
+import { cleanupWorktrees, createWorktrees, diffWorktrees, findWorktreeTaskCwdConflict, formatWorktreeDiffSummary, formatWorktreeTaskCwdConflict, } from "../shared/worktree.js";
+import { MAX_CONCURRENCY, resolveChildMaxSubagentDepth, } from "../../shared/types.js";
+import { resolveEffectiveSubagentModel, resolveTierModelOverride } from "../shared/model-fallback.js";
+import { injectSingleOutputInstruction, validateFileOnlyOutputMode } from "../shared/single-output.js";
+import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.js";
+import { ChainOutputValidationError, outputEntryFromResult, resolveOutputReferences, validateChainOutputBindings } from "../shared/chain-outputs.js";
+import { createStructuredOutputRuntime } from "../shared/structured-output.js";
+import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection } from "../shared/dynamic-fanout.js";
+import { acceptanceFailureMessage, aggregateAcceptanceReport, evaluateAcceptance, resolveEffectiveAcceptance } from "../shared/acceptance.js";
+import { validateToolBudgetConfig } from "../shared/tool-budget.js";
+function buildChainExecutionDetails(input) {
+    return compactForegroundDetails({
+        mode: "chain",
+        results: input.results,
+        progress: input.includeProgress ? input.allProgress : undefined,
+        artifacts: input.allArtifactPaths.length ? { dir: input.artifactsDir, files: input.allArtifactPaths } : undefined,
+        chainAgents: input.chainAgents,
+        totalSteps: input.totalSteps,
+        currentStepIndex: input.currentStepIndex,
+        outputs: input.outputs,
+        totalChildUsage: sumResultsUsage(input.results),
+        totalCost: sumResultsCost(input.results),
+        workflowGraph: buildWorkflowGraphSnapshot({
+            runId: input.runId,
+            mode: "chain",
+            steps: input.chainSteps,
+            results: input.results,
+            currentStepIndex: input.currentStepIndex,
+            currentFlatIndex: input.currentFlatIndex,
+            dynamicChildren: input.dynamicChildren,
+            dynamicGroupStatuses: input.dynamicGroupStatuses,
+        }),
+    });
+}
+function buildChainExecutionErrorResult(message, input) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+        details: buildChainExecutionDetails(input),
+    };
+}
+function ensureParallelProgressFile(chainDir, progressCreated, parallelBehaviors) {
+    if (progressCreated || !parallelBehaviors.some((behavior) => behavior.progress)) {
+        return progressCreated;
+    }
+    writeInitialProgressFile(chainDir);
+    return true;
+}
+function appendParallelWorktreeSummary(output, worktreeSetup, diffsDir, agents) {
+    if (!worktreeSetup)
+        return output;
+    const diffs = diffWorktrees(worktreeSetup, agents, diffsDir);
+    const diffSummary = formatWorktreeDiffSummary(diffs);
+    if (!diffSummary)
+        return output;
+    return `${output}\n\n${diffSummary}`;
+}
+function resolveChainToolBudget(input) {
+    if (input.stepBudget !== undefined) {
+        const resolved = validateToolBudgetConfig(input.stepBudget, "toolBudget");
+        return { toolBudget: resolved.budget, error: resolved.error };
+    }
+    if (input.runBudget !== undefined)
+        return { toolBudget: input.runBudget };
+    if (input.agentBudget !== undefined) {
+        const resolved = validateToolBudgetConfig(input.agentBudget, "agent.toolBudget");
+        return { toolBudget: resolved.budget, error: resolved.error };
+    }
+    const resolved = validateToolBudgetConfig(input.configBudget, "config.toolBudget");
+    return { toolBudget: resolved.budget, error: resolved.error };
+}
+async function runParallelChainTasks(input) {
+    const concurrency = input.step.concurrency ?? MAX_CONCURRENCY;
+    const failFast = input.step.failFast ?? false;
+    let aborted = false;
+    const effectiveModels = input.step.parallel.map((task) => {
+        const taskChildConfig = input.agents.find((child) => child.name === task.agent);
+        return resolveEffectiveSubagentModel(
+        // lunr: model tiers — explicit per-task model wins; otherwise resolve task.tier via the tier bridge.
+        task.model ?? resolveTierModelOverride(task.tier), taskChildConfig?.model, input.ctx.model, input.availableModels, input.ctx.model?.provider, { scope: input.modelScope });
+    });
+    for (let taskIndex = 0; taskIndex < input.step.parallel.length; taskIndex++) {
+        const task = input.step.parallel[taskIndex];
+        input.sessionFileForTask?.(task.agent, input.globalTaskIndex + taskIndex, effectiveModels[taskIndex]);
+    }
+    const parallelResults = await mapConcurrent(input.step.parallel, concurrency, async (task, taskIndex) => {
+        if (aborted && failFast) {
+            return {
+                agent: task.agent,
+                task: "(skipped)",
+                exitCode: -1,
+                messages: [],
+                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+                error: "Skipped due to fail-fast",
+            };
+        }
+        const taskTemplate = input.parallelTemplates[taskIndex] ?? "{previous}";
+        const behavior = suppressProgressForReadOnlyTask(input.parallelBehaviors[taskIndex], taskTemplate, input.originalTask);
+        const taskChildConfig = input.agents.find((child) => child.name === task.agent);
+        const templateHasPrevious = taskTemplate.includes("{previous}");
+        const { prefix, suffix } = buildChainInstructions({ ...behavior, output: false }, input.chainDir, false, templateHasPrevious ? undefined : input.prev);
+        let taskStr = resolveOutputReferences(taskTemplate, input.outputs);
+        taskStr = taskStr.replace(/\{task\}/g, input.originalTask);
+        taskStr = taskStr.replace(/\{previous\}/g, input.prev);
+        taskStr = taskStr.replace(/\{chain_dir\}/g, input.chainDir);
+        const cleanTask = taskStr;
+        taskStr = prefix + taskStr + suffix;
+        const effectiveModel = effectiveModels[taskIndex];
+        const maxSubagentDepth = resolveChildMaxSubagentDepth(input.maxSubagentDepth, taskChildConfig?.maxSubagentDepth);
+        const toolBudget = resolveChainToolBudget({ stepBudget: task.toolBudget, runBudget: input.toolBudget, agentBudget: taskChildConfig?.toolBudget, configBudget: input.configToolBudget });
+        if (toolBudget.error)
+            throw new Error(toolBudget.error);
+        const taskCwd = input.worktreeSetup
+            ? input.worktreeSetup.worktrees[taskIndex].agentCwd
+            : resolveChildCwd(input.cwd ?? input.ctx.cwd, task.cwd);
+        const outputPath = typeof behavior.output === "string"
+            ? (path.isAbsolute(behavior.output) ? behavior.output : path.join(input.chainDir, behavior.output))
+            : undefined;
+        taskStr = injectSingleOutputInstruction(taskStr, outputPath, taskChildConfig);
+        const interruptController = new AbortController();
+        if (input.foregroundControl) {
+            input.foregroundControl.currentAgent = task.description || task.agent;
+            input.foregroundControl.currentChildId = task.agent;
+            input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex;
+            input.foregroundControl.currentActivityState = undefined;
+            input.foregroundControl.updatedAt = Date.now();
+            input.foregroundControl.interrupt = () => {
+                if (interruptController.signal.aborted)
+                    return false;
+                interruptController.abort();
+                input.foregroundControl.currentActivityState = undefined;
+                input.foregroundControl.updatedAt = Date.now();
+                return true;
+            };
+        }
+        const structuredRuntime = task.outputSchema
+            ? createStructuredOutputRuntime(task.outputSchema, path.join(input.chainDir, "structured-output"))
+            : undefined;
+        const result = await runSync(input.ctx.cwd, normalizeChildSpec({
+            task: taskStr,
+            description: task.description,
+            permissions: task.permissions,
+            model: effectiveModel ?? task.model,
+            skill: task.skill,
+            cwd: taskCwd,
+            output: task.output,
+            outputMode: task.outputMode,
+            acceptance: task.acceptance,
+            toolBudget: task.toolBudget,
+        }, { parentMode: snapshotParentPermissionMode(input.ctx.sessionManager.getSessionId() ?? undefined), runId: input.runId, index: input.globalTaskIndex + taskIndex }), {
+            parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
+            cwd: taskCwd,
+            signal: input.signal,
+            interruptSignal: interruptController.signal,
+            allowIntercomDetach: taskChildConfig?.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+            intercomEvents: input.intercomEvents,
+            runId: input.runId,
+            index: input.globalTaskIndex + taskIndex,
+            sessionDir: input.sessionDirForIndex(input.globalTaskIndex + taskIndex),
+            sessionFile: input.sessionFileForTask?.(task.agent, input.globalTaskIndex + taskIndex, effectiveModel)
+                ?? input.sessionFileForIndex?.(input.globalTaskIndex + taskIndex),
+            thinkingOverride: input.thinkingOverrideForTask?.(task.agent, input.globalTaskIndex + taskIndex, effectiveModel),
+            share: input.shareEnabled,
+            artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
+            artifactConfig: input.artifactConfig,
+            outputPath,
+            outputMode: behavior.outputMode,
+            maxSubagentDepth,
+            controlConfig: input.controlConfig,
+            onControlEvent: input.onControlEvent,
+            intercomSessionName: input.childIntercomTarget?.(task.agent, input.globalTaskIndex + taskIndex),
+            orchestratorIntercomTarget: input.orchestratorIntercomTarget,
+            nestedRoute: input.nestedRoute,
+            modelOverride: effectiveModel,
+            availableModels: input.availableModels,
+            preferredModelProvider: input.ctx.model?.provider,
+            modelScope: input.modelScope,
+            skills: behavior.skills === false ? [] : behavior.skills,
+            structuredOutput: structuredRuntime,
+            acceptance: task.acceptance,
+            acceptanceContext: { mode: "chain", dynamic: input.dynamic && task.acceptance === undefined },
+            timeoutMs: input.timeoutMs,
+            deadlineAt: input.deadlineAt,
+            turnBudget: input.turnBudget,
+            onDetachedExit: input.onDetachedExit
+                ? (result) => input.onDetachedExit?.(input.globalTaskIndex + taskIndex, result)
+                : undefined,
+            toolBudget: toolBudget.toolBudget,
+            onUpdate: input.onUpdate
+                ? (progressUpdate) => {
+                    const stepResults = progressUpdate.details?.results || [];
+                    const stepProgress = progressUpdate.details?.progress || [];
+                    if (input.foregroundControl && stepProgress.length > 0) {
+                        const current = stepProgress[0];
+                        input.foregroundControl.currentAgent = task.description || task.agent;
+                        input.foregroundControl.currentChildId = task.agent;
+                        input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex;
+                        input.foregroundControl.currentActivityState = current?.activityState;
+                        input.foregroundControl.lastActivityAt = current?.lastActivityAt;
+                        input.foregroundControl.currentTool = current?.currentTool;
+                        input.foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
+                        input.foregroundControl.currentPath = current?.currentPath;
+                        input.foregroundControl.turnCount = current?.turnCount;
+                        input.foregroundControl.tokens = current?.tokens;
+                        input.foregroundControl.toolCount = current?.toolCount;
+                        input.foregroundControl.updatedAt = Date.now();
+                    }
+                    input.onUpdate?.({
+                        ...progressUpdate,
+                        details: {
+                            mode: "chain",
+                            results: input.results.concat(stepResults),
+                            progress: input.allProgress.concat(stepProgress),
+                            controlEvents: progressUpdate.details?.controlEvents,
+                            chainAgents: input.chainAgents,
+                            totalSteps: input.totalSteps,
+                            currentStepIndex: input.stepIndex,
+                            outputs: input.outputs,
+                            workflowGraph: buildWorkflowGraphSnapshot({
+                                runId: input.runId,
+                                mode: "chain",
+                                steps: input.chainSteps,
+                                results: input.results.concat(stepResults),
+                                currentStepIndex: input.stepIndex,
+                                currentFlatIndex: input.globalTaskIndex + taskIndex,
+                                dynamicChildren: input.dynamicChildren,
+                                dynamicGroupStatuses: input.dynamicGroupStatuses,
+                            }),
+                        },
+                    });
+                }
+                : undefined,
+        });
+        if (input.foregroundControl?.currentIndex === input.globalTaskIndex + taskIndex) {
+            input.foregroundControl.interrupt = undefined;
+            input.foregroundControl.updatedAt = Date.now();
+        }
+        if (result.exitCode !== 0 && failFast) {
+            aborted = true;
+        }
+        recordRun(task.agent, cleanTask, result.exitCode, result.progressSummary?.durationMs ?? 0);
+        return result;
+    }, input.globalSemaphore);
+    return parallelResults;
+}
+/**
+ * Execute a chain of subagent steps
+ */
+export async function executeChain(params) {
+    const { chain: chainSteps, agents, ctx, signal, runId, cwd, shareEnabled, sessionDirForIndex, sessionFileForIndex, sessionFileForTask, thinkingOverrideForTask, artifactsDir, artifactConfig, includeProgress, clarify, onUpdate, onControlEvent, controlConfig, onDetachedExit, childIntercomTarget, orchestratorIntercomTarget, foregroundControl, intercomEvents, chainSkills: chainSkillsParam, chainDir: chainDirBase, modelScope, } = params;
+    const chainSkills = chainSkillsParam ?? [];
+    const results = [];
+    const outputs = {};
+    const dynamicChildren = {};
+    const dynamicGroupStatuses = {};
+    const allProgress = [];
+    const allArtifactPaths = [];
+    const chainAgents = chainSteps.map((step) => isParallelStep(step)
+        ? `[${step.parallel.map((t) => t.description || t.label || t.agent || "child").join("+")}]`
+        : isDynamicParallelStep(step)
+            ? `expand:${step.parallel.description || step.parallel.label || step.parallel.agent || "child"}`
+            : (step.description || step.label || step.agent || "child"));
+    const totalSteps = chainSteps.length;
+    const makeDetailsInput = (overrides = {}) => ({
+        results,
+        ...(includeProgress !== undefined ? { includeProgress } : {}),
+        allProgress,
+        allArtifactPaths,
+        artifactsDir,
+        chainAgents,
+        chainSteps,
+        totalSteps,
+        runId,
+        outputs,
+        dynamicChildren,
+        dynamicGroupStatuses,
+        ...overrides,
+    });
+    const firstStep = chainSteps[0];
+    const originalTask = params.task
+        ?? (isParallelStep(firstStep)
+            ? firstStep.parallel[0].task
+            : isDynamicParallelStep(firstStep)
+                ? firstStep.parallel.task
+                : firstStep.task);
+    try {
+        validateChainOutputBindings(chainSteps, { maxItems: params.dynamicFanoutMaxItems });
+    }
+    catch (error) {
+        if (error instanceof ChainOutputValidationError) {
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+                details: buildChainExecutionDetails(makeDetailsInput()),
+            };
+        }
+        throw error;
+    }
+    const chainDir = createChainDir(runId, chainDirBase);
+    const hasParallelSteps = chainSteps.some((step) => isParallelStep(step) || isDynamicParallelStep(step));
+    let templates = resolveChainTemplates(chainSteps);
+    const shouldClarify = clarify === true && ctx.hasUI && !hasParallelSteps;
+    let tuiBehaviorOverrides;
+    const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
+    const availableSkills = discoverAvailableSkills(cwd ?? ctx.cwd);
+    if (shouldClarify) {
+        const seqSteps = chainSteps;
+        const agentConfigs = [];
+        for (const step of seqSteps) {
+            const config = agents.find((a) => a.name === step.agent);
+            if (!config) {
+                removeChainDir(chainDir);
+                return {
+                    content: [{ type: "text", text: `Unknown agent: ${step.agent}` }],
+                    isError: true,
+                    details: buildChainExecutionDetails(makeDetailsInput({ currentStepIndex: seqSteps.indexOf(step) })),
+                };
+            }
+            agentConfigs.push(config);
+        }
+        const stepOverrides = seqSteps.map((step) => ({
+            output: step.output,
+            outputMode: step.outputMode,
+            reads: step.reads,
+            progress: step.progress,
+            skills: normalizeSkillInput(step.skill),
+            model: step.model,
+        }));
+        const resolvedBehaviors = agentConfigs.map((_config, i) => resolveStepBehavior(stepOverrides[i], chainSkills));
+        const flatTemplates = templates;
+        const result = await ctx.ui.custom((tui, theme, _kb, done) => new ChainClarifyComponent(tui, theme, agentConfigs, flatTemplates, originalTask, chainDir, resolvedBehaviors, availableModels, ctx.model?.provider, availableSkills, done), {
+            overlay: true,
+            overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" },
+        });
+        if (!result || !result.confirmed) {
+            removeChainDir(chainDir);
+            return {
+                content: [{ type: "text", text: "Chain cancelled" }],
+                details: buildChainExecutionDetails(makeDetailsInput()),
+            };
+        }
+        if (result.runInBackground) {
+            removeChainDir(chainDir);
+            const updatedChain = chainSteps.map((step, i) => {
+                if (isParallelStep(step))
+                    return step;
+                const override = result.behaviorOverrides[i];
+                return {
+                    ...step,
+                    task: result.templates[i],
+                    ...(override?.model !== undefined ? { model: override.model } : {}),
+                    ...(override?.output !== undefined ? { output: override.output } : {}),
+                    ...("outputMode" in step && step.outputMode !== undefined ? { outputMode: step.outputMode } : {}),
+                    ...(override?.reads !== undefined ? { reads: override.reads } : {}),
+                    ...(override?.progress !== undefined ? { progress: override.progress } : {}),
+                    ...(override?.skills !== undefined ? { skill: override.skills } : {}),
+                };
+            });
+            return {
+                content: [{ type: "text", text: "Launching in background..." }],
+                details: buildChainExecutionDetails(makeDetailsInput()),
+                requestedAsync: { chain: updatedChain, chainSkills },
+            };
+        }
+        templates = result.templates;
+        tuiBehaviorOverrides = result.behaviorOverrides;
+    }
+    const deadlineAt = params.deadlineAt ?? (params.timeoutMs !== undefined ? Date.now() + params.timeoutMs : undefined);
+    const globalSemaphore = new Semaphore(params.globalConcurrencyLimit ?? DEFAULT_GLOBAL_CONCURRENCY_LIMIT);
+    let prev = "";
+    let globalTaskIndex = 0;
+    let progressCreated = false;
+    for (let stepIndex = 0; stepIndex < chainSteps.length; stepIndex++) {
+        const step = chainSteps[stepIndex];
+        const stepTemplates = templates[stepIndex];
+        if (isParallelStep(step)) {
+            const parallelTemplates = stepTemplates;
+            const parallelCwd = resolveChildCwd(cwd ?? ctx.cwd, step.cwd);
+            let worktreeSetup;
+            if (step.worktree) {
+                const worktreeTaskCwdConflict = findWorktreeTaskCwdConflict(step.parallel, parallelCwd);
+                if (worktreeTaskCwdConflict) {
+                    return buildChainExecutionErrorResult(`parallel chain step ${stepIndex + 1}: ${formatWorktreeTaskCwdConflict(worktreeTaskCwdConflict, parallelCwd)}`, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
+                }
+                try {
+                    worktreeSetup = createWorktrees(parallelCwd, `${runId}-s${stepIndex}`, step.parallel.length, {
+                        agents: step.parallel.map((task) => task.agent),
+                        setupHook: params.worktreeSetupHook
+                            ? { hookPath: params.worktreeSetupHook, timeoutMs: params.worktreeSetupHookTimeoutMs }
+                            : undefined,
+                        baseDir: params.worktreeBaseDir,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    return buildChainExecutionErrorResult(message, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
+                }
+            }
+            try {
+                const agentNames = step.parallel.map((task) => task.agent);
+                const parallelBehaviors = resolveParallelBehaviors(step.parallel, stepIndex, chainSkills)
+                    .map((behavior, taskIndex) => suppressProgressForReadOnlyTask(behavior, parallelTemplates[taskIndex] ?? step.parallel[taskIndex]?.task, originalTask));
+                for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
+                    const behavior = parallelBehaviors[taskIndex];
+                    const outputPath = typeof behavior.output === "string"
+                        ? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
+                        : undefined;
+                    const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Parallel chain step ${stepIndex + 1} task ${taskIndex + 1} (${step.parallel[taskIndex].agent})`);
+                    if (validationError)
+                        return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex + taskIndex }));
+                }
+                progressCreated = ensureParallelProgressFile(chainDir, progressCreated, parallelBehaviors);
+                createParallelDirs(chainDir, stepIndex, step.parallel.length, agentNames);
+                const parallelResults = await runParallelChainTasks({
+                    step,
+                    parallelTemplates,
+                    parallelBehaviors,
+                    agents,
+                    stepIndex,
+                    availableModels,
+                    modelScope,
+                    chainDir,
+                    prev,
+                    originalTask,
+                    ctx,
+                    intercomEvents,
+                    cwd,
+                    runId,
+                    globalTaskIndex,
+                    sessionDirForIndex,
+                    sessionFileForIndex,
+                    sessionFileForTask,
+                    thinkingOverrideForTask,
+                    shareEnabled,
+                    artifactConfig,
+                    artifactsDir,
+                    signal,
+                    onUpdate,
+                    results,
+                    allProgress,
+                    outputs,
+                    chainAgents,
+                    chainSteps,
+                    totalSteps,
+                    dynamicChildren,
+                    dynamicGroupStatuses,
+                    controlConfig,
+                    onControlEvent,
+                    childIntercomTarget,
+                    orchestratorIntercomTarget,
+                    foregroundControl,
+                    nestedRoute: params.nestedRoute,
+                    worktreeSetup,
+                    maxSubagentDepth: params.maxSubagentDepth,
+                    timeoutMs: params.timeoutMs,
+                    deadlineAt,
+                    turnBudget: params.turnBudget,
+                    onDetachedExit,
+                    toolBudget: params.toolBudget,
+                    configToolBudget: params.configToolBudget,
+                    globalSemaphore,
+                });
+                globalTaskIndex += step.parallel.length;
+                for (const result of parallelResults) {
+                    results.push(result);
+                    if (result.progress)
+                        allProgress.push(result.progress);
+                    if (result.artifactPaths)
+                        allArtifactPaths.push(result.artifactPaths);
+                }
+                const interruptedIndexInStep = parallelResults.findIndex((result) => result.interrupted);
+                const interrupted = interruptedIndexInStep >= 0 ? parallelResults[interruptedIndexInStep] : undefined;
+                if (interrupted) {
+                    return {
+                        content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.` }],
+                        details: buildChainExecutionDetails(makeDetailsInput({
+                            currentStepIndex: stepIndex,
+                            currentFlatIndex: globalTaskIndex - step.parallel.length + interruptedIndexInStep,
+                        })),
+                    };
+                }
+                const detachedIndexInStep = parallelResults.findIndex((result) => result.detached);
+                const detached = detachedIndexInStep >= 0 ? parallelResults[detachedIndexInStep] : undefined;
+                if (detached) {
+                    return {
+                        content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first, then wait with subagent_wait({ id: "${runId}" }). Use subagent({ action: "status", id: "${runId}" }) to recover the result; do not resume or launch a replacement while it remains detached.` }],
+                        details: buildChainExecutionDetails(makeDetailsInput({
+                            currentStepIndex: stepIndex,
+                            currentFlatIndex: globalTaskIndex - step.parallel.length + detachedIndexInStep,
+                        })),
+                    };
+                }
+                const failures = parallelResults
+                    .map((result, originalIndex) => ({ ...result, originalIndex }))
+                    .filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
+                if (failures.length > 0) {
+                    const failureSummary = failures
+                        .map((failure) => `- Task ${failure.originalIndex + 1} (${failure.agent}): ${failure.error || "failed"}`)
+                        .join("\n");
+                    const errorMsg = `Parallel step ${stepIndex + 1} failed:\n${failureSummary}`;
+                    const summary = buildChainSummary(chainSteps, results, chainDir, "failed", {
+                        index: stepIndex,
+                        error: errorMsg,
+                    });
+                    return {
+                        content: [{ type: "text", text: summary }],
+                        isError: true,
+                        details: buildChainExecutionDetails(makeDetailsInput({
+                            currentStepIndex: stepIndex,
+                            currentFlatIndex: globalTaskIndex - step.parallel.length + failures[0].originalIndex,
+                        })),
+                    };
+                }
+                for (let taskIndex = 0; taskIndex < parallelResults.length; taskIndex++) {
+                    const outputName = step.parallel[taskIndex]?.as;
+                    if (outputName)
+                        outputs[outputName] = outputEntryFromResult(parallelResults[taskIndex], stepIndex);
+                }
+                const taskResults = parallelResults.map((result, i) => {
+                    const outputTarget = parallelBehaviors[i]?.output;
+                    const outputTargetPath = typeof outputTarget === "string"
+                        ? (path.isAbsolute(outputTarget) ? outputTarget : path.join(chainDir, outputTarget))
+                        : undefined;
+                    return {
+                        agent: result.agent,
+                        taskIndex: i,
+                        output: getSingleResultOutput(result),
+                        exitCode: result.exitCode,
+                        error: result.error,
+                        timedOut: result.timedOut,
+                        outputTargetPath,
+                        outputTargetExists: outputTargetPath ? fs.existsSync(outputTargetPath) : undefined,
+                    };
+                });
+                prev = aggregateParallelOutputs(taskResults);
+                prev = appendParallelWorktreeSummary(prev, worktreeSetup, path.join(chainDir, "worktree-diffs", `step-${stepIndex}`), agentNames);
+            }
+            finally {
+                if (worktreeSetup)
+                    cleanupWorktrees(worktreeSetup);
+            }
+        }
+        else if (isDynamicParallelStep(step)) {
+            const dynamicStartIndex = globalTaskIndex;
+            const reservedDynamicItems = step.expand.maxItems ?? params.dynamicFanoutMaxItems ?? 0;
+            let materialized;
+            try {
+                materialized = materializeDynamicParallelStep(step, outputs, stepIndex, { maxItems: params.dynamicFanoutMaxItems });
+            }
+            catch (error) {
+                const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+                dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
+                return buildChainExecutionErrorResult(message, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
+            }
+            dynamicChildren[stepIndex] = materialized.items.map((item, itemIndex) => ({
+                agent: step.parallel.agent,
+                label: materialized.parallel[itemIndex]?.label,
+                flatIndex: globalTaskIndex + itemIndex,
+                itemKey: item.key,
+                structured: Boolean(step.parallel.outputSchema),
+            }));
+            if (materialized.parallel.length === 0) {
+                const collection = [];
+                try {
+                    validateDynamicCollection(step.collect.outputSchema, collection);
+                }
+                catch (error) {
+                    const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+                    dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
+                    return buildChainExecutionErrorResult(message, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
+                }
+                outputs[step.collect.as] = {
+                    text: JSON.stringify(collection),
+                    structured: collection,
+                    agent: step.parallel.agent,
+                    stepIndex,
+                };
+                dynamicGroupStatuses[stepIndex] = { status: "completed" };
+                if (step.acceptance !== undefined) {
+                    const effectiveGroupAcceptance = resolveEffectiveAcceptance({
+                        explicit: step.acceptance,
+                        agentName: step.parallel.agent,
+                        acceptanceRole: agents.find((agent) => agent.name === step.parallel.agent)?.acceptanceRole,
+                        task: (step.parallel.task ?? originalTask ?? "").replace(/\{task\}/g, originalTask ?? ""),
+                        mode: "chain",
+                        dynamicGroup: true,
+                    });
+                    const groupAcceptance = await evaluateAcceptance({
+                        acceptance: effectiveGroupAcceptance,
+                        output: "",
+                        report: aggregateAcceptanceReport({
+                            results: [],
+                            notes: "Dynamic fanout produced 0 results.",
+                        }),
+                        cwd: cwd ?? ctx.cwd,
+                    });
+                    dynamicGroupStatuses[stepIndex].acceptance = groupAcceptance;
+                    const groupAcceptanceFailure = acceptanceFailureMessage(groupAcceptance);
+                    if (groupAcceptanceFailure) {
+                        dynamicGroupStatuses[stepIndex] = { status: "failed", error: groupAcceptanceFailure, acceptance: groupAcceptance };
+                        return buildChainExecutionErrorResult(groupAcceptanceFailure, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
+                    }
+                }
+                prev = "Dynamic fanout produced 0 results.";
+                globalTaskIndex = dynamicStartIndex + reservedDynamicItems;
+                continue;
+            }
+            const dynamicParallelStep = {
+                parallel: materialized.parallel,
+                concurrency: step.concurrency,
+                failFast: step.failFast,
+            };
+            const parallelTemplates = materialized.parallel.map((task) => task.task ?? "{previous}");
+            const parallelBehaviors = resolveParallelBehaviors(dynamicParallelStep.parallel, stepIndex, chainSkills)
+                .map((behavior, taskIndex) => suppressProgressForReadOnlyTask(behavior, parallelTemplates[taskIndex] ?? dynamicParallelStep.parallel[taskIndex]?.task, originalTask));
+            for (let taskIndex = 0; taskIndex < dynamicParallelStep.parallel.length; taskIndex++) {
+                const behavior = parallelBehaviors[taskIndex];
+                const outputPath = typeof behavior.output === "string"
+                    ? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
+                    : undefined;
+                const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${dynamicParallelStep.parallel[taskIndex].agent})`);
+                if (validationError) {
+                    dynamicGroupStatuses[stepIndex] = { status: "failed", error: validationError };
+                    return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex + taskIndex }));
+                }
+            }
+            progressCreated = ensureParallelProgressFile(chainDir, progressCreated, parallelBehaviors);
+            createParallelDirs(chainDir, stepIndex, dynamicParallelStep.parallel.length, dynamicParallelStep.parallel.map((task) => task.agent));
+            const parallelResults = await runParallelChainTasks({
+                step: dynamicParallelStep,
+                parallelTemplates,
+                parallelBehaviors,
+                agents,
+                stepIndex,
+                availableModels,
+                modelScope,
+                chainDir,
+                prev,
+                originalTask,
+                ctx,
+                intercomEvents,
+                cwd,
+                runId,
+                globalTaskIndex,
+                sessionDirForIndex,
+                sessionFileForIndex,
+                sessionFileForTask,
+                thinkingOverrideForTask,
+                shareEnabled,
+                artifactConfig,
+                artifactsDir,
+                signal,
+                onUpdate,
+                results,
+                allProgress,
+                outputs,
+                chainAgents,
+                chainSteps,
+                totalSteps,
+                dynamicChildren,
+                dynamicGroupStatuses,
+                controlConfig,
+                onControlEvent,
+                childIntercomTarget,
+                orchestratorIntercomTarget,
+                foregroundControl,
+                nestedRoute: params.nestedRoute,
+                maxSubagentDepth: params.maxSubagentDepth,
+                timeoutMs: params.timeoutMs,
+                deadlineAt,
+                turnBudget: params.turnBudget,
+                onDetachedExit,
+                toolBudget: params.toolBudget,
+                configToolBudget: params.configToolBudget,
+                globalSemaphore,
+                dynamic: true,
+            });
+            globalTaskIndex = dynamicStartIndex + reservedDynamicItems;
+            for (const result of parallelResults) {
+                results.push(result);
+                if (result.progress)
+                    allProgress.push(result.progress);
+                if (result.artifactPaths)
+                    allArtifactPaths.push(result.artifactPaths);
+            }
+            const collected = collectDynamicResults(step, materialized.items, parallelResults);
+            const interruptedIndexInStep = parallelResults.findIndex((result) => result.interrupted);
+            const interrupted = interruptedIndexInStep >= 0 ? parallelResults[interruptedIndexInStep] : undefined;
+            if (interrupted) {
+                return {
+                    content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.` }],
+                    details: buildChainExecutionDetails(makeDetailsInput({
+                        currentStepIndex: stepIndex,
+                        currentFlatIndex: dynamicStartIndex + interruptedIndexInStep,
+                    })),
+                };
+            }
+            const detachedIndexInStep = parallelResults.findIndex((result) => result.detached);
+            const detached = detachedIndexInStep >= 0 ? parallelResults[detachedIndexInStep] : undefined;
+            if (detached) {
+                return {
+                    content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first, then wait with subagent_wait({ id: "${runId}" }). Use subagent({ action: "status", id: "${runId}" }) to recover the result; do not resume or launch a replacement while it remains detached.` }],
+                    details: buildChainExecutionDetails(makeDetailsInput({
+                        currentStepIndex: stepIndex,
+                        currentFlatIndex: dynamicStartIndex + detachedIndexInStep,
+                    })),
+                };
+            }
+            const failures = parallelResults
+                .map((result, originalIndex) => ({ ...result, originalIndex }))
+                .filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
+            if (failures.length > 0) {
+                const failureSummary = failures
+                    .map((failure) => `- Item ${failure.originalIndex + 1} (${failure.agent}, key ${materialized.items[failure.originalIndex]?.key ?? failure.originalIndex}): ${failure.error || "failed"}`)
+                    .join("\n");
+                const errorMsg = `Dynamic step ${stepIndex + 1} failed:\n${failureSummary}`;
+                dynamicGroupStatuses[stepIndex] = { status: "failed", error: errorMsg };
+                const summary = buildChainSummary(chainSteps, results, chainDir, "failed", {
+                    index: stepIndex,
+                    error: errorMsg,
+                });
+                return {
+                    content: [{ type: "text", text: summary }],
+                    isError: true,
+                    details: buildChainExecutionDetails(makeDetailsInput({
+                        currentStepIndex: stepIndex,
+                        currentFlatIndex: dynamicStartIndex + failures[0].originalIndex,
+                    })),
+                };
+            }
+            try {
+                validateDynamicCollection(step.collect.outputSchema, collected);
+            }
+            catch (error) {
+                const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+                dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
+                return buildChainExecutionErrorResult(message, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: dynamicStartIndex }));
+            }
+            outputs[step.collect.as] = {
+                text: JSON.stringify(collected),
+                structured: collected,
+                agent: step.parallel.agent,
+                stepIndex,
+            };
+            dynamicGroupStatuses[stepIndex] = { status: "completed" };
+            const effectiveGroupAcceptance = resolveEffectiveAcceptance({
+                explicit: step.acceptance,
+                agentName: step.parallel.agent,
+                acceptanceRole: agents.find((agent) => agent.name === step.parallel.agent)?.acceptanceRole,
+                task: materialized.parallel
+                    .map((task) => (task.task ?? originalTask ?? "").replace(/\{task\}/g, originalTask ?? ""))
+                    .join("\n"),
+                mode: "chain",
+                dynamicGroup: true,
+            });
+            const groupAcceptance = await evaluateAcceptance({
+                acceptance: effectiveGroupAcceptance,
+                output: "",
+                report: aggregateAcceptanceReport({
+                    results: parallelResults,
+                    notes: `Dynamic fanout collected ${collected.length} result(s) into ${step.collect.as}.`,
+                }),
+                cwd: cwd ?? ctx.cwd,
+            });
+            dynamicGroupStatuses[stepIndex].acceptance = groupAcceptance;
+            const groupAcceptanceFailure = effectiveGroupAcceptance.explicit ? acceptanceFailureMessage(groupAcceptance) : undefined;
+            if (groupAcceptanceFailure) {
+                dynamicGroupStatuses[stepIndex] = { status: "failed", error: groupAcceptanceFailure, acceptance: groupAcceptance };
+                return buildChainExecutionErrorResult(groupAcceptanceFailure, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex - dynamicParallelStep.parallel.length }));
+            }
+            const taskResults = parallelResults.map((result, i) => ({
+                agent: result.agent,
+                taskIndex: i,
+                output: getSingleResultOutput(result),
+                exitCode: result.exitCode,
+                error: result.error,
+                timedOut: result.timedOut,
+            }));
+            prev = aggregateParallelOutputs(taskResults, (i, agent) => `=== Dynamic Item ${i + 1} (${agent}, key ${materialized.items[i]?.key ?? i}) ===`);
+        }
+        else {
+            const seqStep = step;
+            const stepTemplate = stepTemplates;
+            const agentConfig = agents.find((a) => a.name === seqStep.agent);
+            if (!agentConfig) {
+                removeChainDir(chainDir);
+                return {
+                    content: [{ type: "text", text: `Unknown agent: ${seqStep.agent}` }],
+                    isError: true,
+                    details: buildChainExecutionDetails(makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex })),
+                };
+            }
+            const tuiOverride = tuiBehaviorOverrides?.[stepIndex];
+            const stepOverride = {
+                output: tuiOverride?.output !== undefined ? tuiOverride.output : seqStep.output,
+                outputMode: seqStep.outputMode,
+                reads: tuiOverride?.reads !== undefined ? tuiOverride.reads : seqStep.reads,
+                progress: tuiOverride?.progress !== undefined ? tuiOverride.progress : seqStep.progress,
+                skills: tuiOverride?.skills !== undefined
+                    ? tuiOverride.skills
+                    : normalizeSkillInput(seqStep.skill),
+            };
+            const behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(stepOverride, chainSkills), stepTemplate, originalTask);
+            const isFirstProgress = behavior.progress && !progressCreated;
+            if (isFirstProgress) {
+                progressCreated = true;
+            }
+            const templateHasPrevious = stepTemplate.includes("{previous}");
+            const { prefix, suffix } = buildChainInstructions({ ...behavior, output: false }, chainDir, isFirstProgress, templateHasPrevious ? undefined : prev);
+            let stepTask = resolveOutputReferences(stepTemplate, outputs);
+            stepTask = stepTask.replace(/\{task\}/g, originalTask);
+            stepTask = stepTask.replace(/\{previous\}/g, prev);
+            stepTask = stepTask.replace(/\{chain_dir\}/g, chainDir);
+            const cleanTask = stepTask;
+            stepTask = prefix + stepTask + suffix;
+            // lunr: model tiers — explicit step model wins; otherwise resolve seqStep.tier via the tier bridge.
+            const explicitStepModel = tuiOverride?.model ?? seqStep.model ?? resolveTierModelOverride(seqStep.tier);
+            const effectiveModel = resolveEffectiveSubagentModel(explicitStepModel, agentConfig.model, ctx.model, availableModels, ctx.model?.provider, { scope: modelScope });
+            const outputPath = typeof behavior.output === "string"
+                ? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
+                : undefined;
+            stepTask = injectSingleOutputInstruction(stepTask, outputPath, agentConfig);
+            const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Chain step ${stepIndex + 1} (${seqStep.agent})`);
+            if (validationError) {
+                return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
+            }
+            const maxSubagentDepth = resolveChildMaxSubagentDepth(params.maxSubagentDepth, agentConfig.maxSubagentDepth);
+            const childIndex = globalTaskIndex;
+            const interruptController = new AbortController();
+            if (foregroundControl) {
+                foregroundControl.currentAgent = seqStep.description || seqStep.agent;
+                foregroundControl.currentChildId = seqStep.agent;
+                foregroundControl.currentIndex = childIndex;
+                foregroundControl.currentActivityState = undefined;
+                foregroundControl.updatedAt = Date.now();
+                foregroundControl.interrupt = () => {
+                    if (interruptController.signal.aborted)
+                        return false;
+                    interruptController.abort();
+                    foregroundControl.currentActivityState = undefined;
+                    foregroundControl.updatedAt = Date.now();
+                    return true;
+                };
+            }
+            const structuredRuntime = seqStep.outputSchema
+                ? createStructuredOutputRuntime(seqStep.outputSchema, path.join(chainDir, "structured-output"))
+                : undefined;
+            const toolBudget = resolveChainToolBudget({ stepBudget: seqStep.toolBudget, runBudget: params.toolBudget, agentBudget: agentConfig?.toolBudget, configBudget: params.configToolBudget });
+            if (toolBudget.error)
+                return buildChainExecutionErrorResult(toolBudget.error, {
+                    results,
+                    includeProgress,
+                    allProgress,
+                    allArtifactPaths,
+                    artifactsDir: params.artifactsDir,
+                    chainAgents,
+                    chainSteps,
+                    totalSteps,
+                    currentStepIndex: stepIndex,
+                    runId: params.runId,
+                    outputs,
+                    currentFlatIndex: globalTaskIndex,
+                    dynamicChildren,
+                    dynamicGroupStatuses,
+                });
+            const r = await runSync(ctx.cwd, normalizeChildSpec({
+                task: stepTask,
+                description: seqStep.description,
+                permissions: seqStep.permissions,
+                model: effectiveModel ?? seqStep.model,
+                skill: seqStep.skill,
+                cwd: seqStep.cwd,
+                output: seqStep.output,
+                outputMode: seqStep.outputMode,
+                acceptance: seqStep.acceptance,
+                toolBudget: seqStep.toolBudget,
+            }, { parentMode: snapshotParentPermissionMode(ctx.sessionManager.getSessionId() ?? undefined), runId, index: childIndex }), {
+                parentSessionId: ctx.sessionManager.getSessionId() ?? undefined,
+                cwd: resolveChildCwd(cwd ?? ctx.cwd, seqStep.cwd),
+                signal,
+                interruptSignal: interruptController.signal,
+                allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+                intercomEvents,
+                runId,
+                index: childIndex,
+                sessionDir: sessionDirForIndex(childIndex),
+                sessionFile: sessionFileForTask?.(seqStep.agent, childIndex, effectiveModel)
+                    ?? sessionFileForIndex?.(childIndex),
+                thinkingOverride: thinkingOverrideForTask?.(seqStep.agent, childIndex, effectiveModel),
+                share: shareEnabled,
+                artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+                artifactConfig,
+                outputPath,
+                outputMode: behavior.outputMode,
+                maxSubagentDepth,
+                controlConfig,
+                onControlEvent,
+                intercomSessionName: childIntercomTarget?.(seqStep.agent, childIndex),
+                orchestratorIntercomTarget,
+                nestedRoute: params.nestedRoute,
+                modelOverride: effectiveModel,
+                availableModels,
+                preferredModelProvider: ctx.model?.provider,
+                modelScope,
+                skills: behavior.skills === false ? [] : behavior.skills,
+                structuredOutput: structuredRuntime,
+                acceptance: seqStep.acceptance,
+                acceptanceContext: { mode: "chain" },
+                timeoutMs: params.timeoutMs,
+                deadlineAt,
+                turnBudget: params.turnBudget,
+                onDetachedExit: onDetachedExit
+                    ? (result) => onDetachedExit(childIndex, result)
+                    : undefined,
+                toolBudget: toolBudget.toolBudget,
+                onUpdate: onUpdate
+                    ? (p) => {
+                        const stepResults = p.details?.results || [];
+                        const stepProgress = p.details?.progress || [];
+                        if (foregroundControl && stepProgress.length > 0) {
+                            const current = stepProgress[0];
+                            foregroundControl.currentAgent = seqStep.description || seqStep.agent;
+                            foregroundControl.currentChildId = seqStep.agent;
+                            foregroundControl.currentIndex = childIndex;
+                            foregroundControl.currentActivityState = current?.activityState;
+                            foregroundControl.lastActivityAt = current?.lastActivityAt;
+                            foregroundControl.currentTool = current?.currentTool;
+                            foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
+                            foregroundControl.currentPath = current?.currentPath;
+                            foregroundControl.turnCount = current?.turnCount;
+                            foregroundControl.tokens = current?.tokens;
+                            foregroundControl.toolCount = current?.toolCount;
+                            foregroundControl.updatedAt = Date.now();
+                        }
+                        onUpdate({
+                            ...p,
+                            details: {
+                                mode: "chain",
+                                results: results.concat(stepResults),
+                                progress: allProgress.concat(stepProgress),
+                                controlEvents: p.details?.controlEvents,
+                                chainAgents,
+                                totalSteps,
+                                currentStepIndex: stepIndex,
+                                outputs,
+                                workflowGraph: buildWorkflowGraphSnapshot({
+                                    runId,
+                                    mode: "chain",
+                                    steps: chainSteps,
+                                    results: results.concat(stepResults),
+                                    currentStepIndex: stepIndex,
+                                    currentFlatIndex: childIndex,
+                                    dynamicChildren,
+                                    dynamicGroupStatuses,
+                                }),
+                            },
+                        });
+                    }
+                    : undefined,
+            });
+            if (foregroundControl?.currentIndex === childIndex) {
+                foregroundControl.interrupt = undefined;
+                foregroundControl.updatedAt = Date.now();
+            }
+            recordRun(seqStep.agent, cleanTask, r.exitCode, r.progressSummary?.durationMs ?? 0);
+            globalTaskIndex++;
+            results.push(r);
+            if (r.progress)
+                allProgress.push(r.progress);
+            if (r.artifactPaths)
+                allArtifactPaths.push(r.artifactPaths);
+            if (r.interrupted) {
+                return {
+                    content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${r.agent}). Waiting for explicit next action.` }],
+                    details: buildChainExecutionDetails(makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: childIndex })),
+                };
+            }
+            if (r.detached) {
+                return {
+                    content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${r.agent}). Reply to the supervisor request first, then wait with subagent_wait({ id: "${runId}" }). Use subagent({ action: "status", id: "${runId}" }) to recover the result; do not resume or launch a replacement while it remains detached.` }],
+                    details: buildChainExecutionDetails(makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: childIndex })),
+                };
+            }
+            if (r.exitCode !== 0) {
+                const summary = buildChainSummary(chainSteps, results, chainDir, "failed", {
+                    index: stepIndex,
+                    error: r.error || "Chain failed",
+                });
+                return {
+                    content: [{ type: "text", text: summary }],
+                    details: buildChainExecutionDetails(makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: childIndex })),
+                    isError: true,
+                };
+            }
+            if (behavior.output) {
+                try {
+                    const expectedPath = path.isAbsolute(behavior.output)
+                        ? behavior.output
+                        : path.join(chainDir, behavior.output);
+                    if (!fs.existsSync(expectedPath)) {
+                        const dirFiles = fs.readdirSync(chainDir);
+                        const mdFiles = dirFiles.filter((file) => file.endsWith(".md") && file !== "progress.md");
+                        const warning = mdFiles.length > 0
+                            ? `Agent wrote to different file(s): ${mdFiles.join(", ")} instead of ${behavior.output}`
+                            : `Agent did not create expected output file: ${behavior.output}`;
+                        r.error = r.error ? `${r.error}\n${warning}` : warning;
+                    }
+                }
+                catch {
+                    // Ignore validation errors; this diagnostic should not mask successful chain output.
+                }
+            }
+            if (seqStep.as)
+                outputs[seqStep.as] = outputEntryFromResult(r, stepIndex);
+            prev = getSingleResultOutput(r);
+        }
+    }
+    const summary = buildChainSummary(chainSteps, results, chainDir, "completed");
+    return {
+        content: [{ type: "text", text: summary }],
+        details: buildChainExecutionDetails(makeDetailsInput()),
+    };
+}
+//# sourceMappingURL=chain-execution.js.map