@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.1

package/dist/builtin/subagents/src/runs/foreground/chain-execution-clarify.ts

@@ -0,0 +1,117 @@
+import type { AgentConfig } from "../../agents/agents.ts";
+import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
+import {
+	isParallelStep,
+	removeChainDir,
+	resolveStepBehavior,
+	type ChainStep,
+	type ResolvedTemplates,
+	type SequentialStep,
+	type StepOverrides,
+} from "../../shared/settings.ts";
+import { buildChainExecutionDetails } from "./chain-execution-details.ts";
+import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
+import type { ChainClarificationOutcome, ChainRuntimeContext } from "./chain-execution-types.ts";
+
+export async function resolveChainClarification(input: {
+	context: ChainRuntimeContext;
+	templates: ResolvedTemplates;
+	shouldClarify: boolean;
+}): Promise<ChainClarificationOutcome> {
+	const { context } = input;
+	if (!input.shouldClarify) return { templates: input.templates };
+
+	const availableSkills = discoverAvailableSkills(context.cwd ?? context.ctx.cwd);
+	const seqSteps = context.chainSteps as SequentialStep[];
+	const agentConfigs: AgentConfig[] = [];
+	for (const step of seqSteps) {
+		const config = context.agents.find((agent) => agent.name === step.agent);
+		if (!config) {
+			removeChainDir(context.chainDir);
+			return {
+				result: {
+					content: [{ type: "text", text: `Unknown agent: ${step.agent}` }],
+					isError: true,
+					details: buildChainExecutionDetails(context.makeDetailsInput({ currentStepIndex: seqSteps.indexOf(step) })),
+				},
+				templates: input.templates,
+			};
+		}
+		agentConfigs.push(config);
+	}
+
+	const stepOverrides: 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, index) =>
+		resolveStepBehavior(config, stepOverrides[index]!, context.chainSkills),
+	);
+	const flatTemplates = input.templates as string[];
+	const result = await context.ctx.ui.custom<ChainClarifyResult>(
+		(tui, theme, _kb, done) =>
+			new ChainClarifyComponent(
+				tui,
+				theme,
+				agentConfigs,
+				flatTemplates,
+				context.originalTask,
+				context.chainDir,
+				resolvedBehaviors,
+				context.availableModels,
+				context.ctx.model?.provider,
+				availableSkills,
+				done,
+			),
+		{
+			overlay: true,
+			overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" },
+		},
+	);
+
+	if (!result || !result.confirmed) {
+		removeChainDir(context.chainDir);
+		return {
+			result: {
+				content: [{ type: "text", text: "Chain cancelled" }],
+				details: buildChainExecutionDetails(context.makeDetailsInput()),
+			},
+			templates: input.templates,
+		};
+	}
+
+	if (result.runInBackground) {
+		removeChainDir(context.chainDir);
+		const updatedChain: ChainStep[] = context.chainSteps.map((step, index) => {
+			if (isParallelStep(step)) return step;
+			const override = result.behaviorOverrides[index];
+			return {
+				...step,
+				task: result.templates[index]!,
+				...(override?.model ? { 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 {
+			result: {
+				content: [{ type: "text", text: "Launching in background..." }],
+				details: buildChainExecutionDetails(context.makeDetailsInput()),
+				requestedAsync: { chain: updatedChain, chainSkills: context.chainSkills },
+			},
+			templates: input.templates,
+		};
+	}
+
+	return {
+		templates: result.templates,
+		tuiBehaviorOverrides: result.behaviorOverrides,
+	};
+}

package/dist/builtin/subagents/src/runs/foreground/chain-execution-details.ts

@@ -0,0 +1,35 @@
+import { compactForegroundDetails } from "../../shared/utils.ts";
+import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
+import type { Details } from "../../shared/types.ts";
+import type { ChainExecutionDetailsInput, ChainExecutionResult } from "./chain-execution-types.ts";
+
+export function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details {
+	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,
+		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,
+		}),
+	});
+}
+
+export function buildChainExecutionErrorResult(message: string, input: ChainExecutionDetailsInput): ChainExecutionResult {
+	return {
+		content: [{ type: "text", text: message }],
+		isError: true,
+		details: buildChainExecutionDetails(input),
+	};
+}

package/dist/builtin/subagents/src/runs/foreground/chain-execution-dynamic-step.ts

@@ -0,0 +1,194 @@
+import * as path from "node:path";
+import {
+	aggregateParallelOutputs,
+	createParallelDirs,
+	resolveParallelBehaviors,
+	suppressProgressForReadOnlyTask,
+	type DynamicParallelStep,
+	type ParallelStep,
+	type ParallelTaskResult,
+} from "../../shared/settings.ts";
+import { getSingleResultOutput } from "../../shared/utils.ts";
+import { buildChainSummary } from "../../shared/formatters.ts";
+import { buildChainExecutionDetails, buildChainExecutionErrorResult } from "./chain-execution-details.ts";
+import { ensureParallelProgressFile, runParallelChainTasks } from "./chain-execution-parallel-runner.ts";
+import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
+import {
+	collectDynamicResults,
+	DynamicFanoutError,
+	materializeDynamicParallelStep,
+	validateDynamicCollection,
+	type DynamicCollectedResult,
+} from "../shared/dynamic-fanout.ts";
+import type { ChainExecutionMutableState, ChainExecutionResult, ChainRuntimeContext } from "./chain-execution-types.ts";
+
+export async function runDynamicParallelChainStep(input: {
+	context: ChainRuntimeContext;
+	state: ChainExecutionMutableState;
+	step: DynamicParallelStep;
+	stepIndex: number;
+}): Promise<ChainExecutionResult | undefined> {
+	const { context, state, step, stepIndex } = input;
+	let materialized: ReturnType<typeof materializeDynamicParallelStep>;
+	try {
+		materialized = materializeDynamicParallelStep(step, state.outputs, stepIndex, { maxItems: context.params.dynamicFanoutMaxItems });
+	} catch (error) {
+		const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+		state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
+		return buildChainExecutionErrorResult(message, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }));
+	}
+
+	state.dynamicChildren[stepIndex] = materialized.items.map((item, itemIndex) => ({
+		agent: step.parallel.agent,
+		label: materialized.parallel[itemIndex]?.label,
+		flatIndex: state.globalTaskIndex + itemIndex,
+		itemKey: item.key,
+		structured: Boolean(step.parallel.outputSchema),
+	}));
+
+	if (materialized.parallel.length === 0) {
+		const collection: DynamicCollectedResult[] = [];
+		try {
+			validateDynamicCollection(step.collect.outputSchema, collection);
+		} catch (error) {
+			const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+			state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
+			return buildChainExecutionErrorResult(message, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }));
+		}
+		state.outputs[step.collect.as] = {
+			text: JSON.stringify(collection),
+			structured: collection,
+			agent: step.parallel.agent,
+			stepIndex,
+		};
+		state.dynamicGroupStatuses[stepIndex] = { status: "completed" };
+		state.prev = "Dynamic fanout produced 0 results.";
+		return undefined;
+	}
+
+	const dynamicParallelStep: ParallelStep = {
+		parallel: materialized.parallel,
+		concurrency: step.concurrency,
+		failFast: step.failFast,
+	};
+	const parallelTemplates = materialized.parallel.map((task) => task.task ?? "{previous}");
+	const parallelBehaviors = resolveParallelBehaviors(dynamicParallelStep.parallel, context.agents, stepIndex, context.chainSkills)
+		.map((behavior, taskIndex) => suppressProgressForReadOnlyTask(behavior, parallelTemplates[taskIndex] ?? dynamicParallelStep.parallel[taskIndex]?.task, context.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(context.chainDir, behavior.output))
+			: undefined;
+		const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${dynamicParallelStep.parallel[taskIndex]!.agent})`);
+		if (validationError) {
+			state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: validationError };
+			return buildChainExecutionErrorResult(validationError, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex + taskIndex }));
+		}
+	}
+
+	state.progressCreated = ensureParallelProgressFile(context.chainDir, state.progressCreated, parallelBehaviors);
+	createParallelDirs(context.chainDir, stepIndex, dynamicParallelStep.parallel.length, dynamicParallelStep.parallel.map((task) => task.agent));
+	const parallelResults = await runParallelChainTasks({
+		step: dynamicParallelStep,
+		parallelTemplates,
+		parallelBehaviors,
+		agents: context.agents,
+		stepIndex,
+		availableModels: context.availableModels,
+		chainDir: context.chainDir,
+		prev: state.prev,
+		originalTask: context.originalTask,
+		ctx: context.ctx,
+		intercomEvents: context.intercomEvents,
+		cwd: context.cwd,
+		runId: context.runId,
+		globalTaskIndex: state.globalTaskIndex,
+		sessionDirForIndex: context.sessionDirForIndex,
+		sessionFileForIndex: context.sessionFileForIndex,
+		shareEnabled: context.shareEnabled,
+		artifactConfig: context.artifactConfig,
+		artifactsDir: context.artifactsDir,
+		signal: context.signal,
+		onUpdate: context.onUpdate,
+		results: state.results,
+		allProgress: state.allProgress,
+		outputs: state.outputs,
+		chainAgents: context.chainAgents,
+		chainSteps: context.chainSteps,
+		totalSteps: context.totalSteps,
+		dynamicChildren: state.dynamicChildren,
+		dynamicGroupStatuses: state.dynamicGroupStatuses,
+		controlConfig: context.controlConfig,
+		onControlEvent: context.onControlEvent,
+		childIntercomTarget: context.childIntercomTarget,
+		orchestratorIntercomTarget: context.orchestratorIntercomTarget,
+		foregroundControl: context.foregroundControl,
+		nestedRoute: context.params.nestedRoute,
+		maxSubagentDepth: context.params.maxSubagentDepth,
+		workflowStageSubagentGuard: context.params.workflowStageSubagentGuard,
+		runSync: context.executeRunSync,
+	});
+	state.globalTaskIndex += dynamicParallelStep.parallel.length;
+	for (const result of parallelResults) {
+		state.results.push(result);
+		if (result.progress) state.allProgress.push(result.progress);
+		if (result.artifactPaths) state.allArtifactPaths.push(result.artifactPaths);
+	}
+	const collected = collectDynamicResults(step, materialized.items, parallelResults);
+	const baseFlatIndex = state.globalTaskIndex - dynamicParallelStep.parallel.length;
+
+	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(context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex + 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. After the child exits, start a fresh follow-up if needed.` }],
+			details: buildChainExecutionDetails(context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex + 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}`;
+		state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: errorMsg };
+		const summary = buildChainSummary(context.chainSteps, state.results, context.chainDir, "failed", { index: stepIndex, error: errorMsg });
+		return {
+			content: [{ type: "text", text: summary }],
+			isError: true,
+			details: buildChainExecutionDetails(context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex + 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);
+		state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
+		return buildChainExecutionErrorResult(message, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex }));
+	}
+	state.outputs[step.collect.as] = {
+		text: JSON.stringify(collected),
+		structured: collected,
+		agent: step.parallel.agent,
+		stepIndex,
+	};
+	state.dynamicGroupStatuses[stepIndex] = { status: "completed" };
+	const taskResults: ParallelTaskResult[] = parallelResults.map((result, index) => ({
+		agent: result.agent,
+		taskIndex: index,
+		output: getSingleResultOutput(result),
+		exitCode: result.exitCode,
+		error: result.error,
+	}));
+	state.prev = aggregateParallelOutputs(taskResults, (index, agent) => `=== Dynamic Item ${index + 1} (${agent}, key ${materialized.items[index]?.key ?? index}) ===`);
+	return undefined;
+}

package/dist/builtin/subagents/src/runs/foreground/chain-execution-parallel-runner.ts

@@ -0,0 +1,183 @@
+import * as path from "node:path";
+import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.ts";
+import { mapConcurrent, resolveChildCwd } from "../../shared/utils.ts";
+import { MAX_CONCURRENCY, resolveChildMaxSubagentDepth, type SingleResult } from "../../shared/types.ts";
+import {
+	buildChainInstructions,
+	suppressProgressForReadOnlyTask,
+	writeInitialProgressFile,
+	type ResolvedStepBehavior,
+} from "../../shared/settings.ts";
+import { recordRun } from "../shared/run-history.ts";
+import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
+import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
+import { diffWorktrees, formatWorktreeDiffSummary, type WorktreeSetup } from "../shared/worktree.ts";
+import { resolveOutputReferences } from "../shared/chain-outputs.ts";
+import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
+import type { ParallelChainRunInput } from "./chain-execution-types.ts";
+
+export function ensureParallelProgressFile(
+	chainDir: string,
+	progressCreated: boolean,
+	parallelBehaviors: ResolvedStepBehavior[],
+): boolean {
+	if (progressCreated || !parallelBehaviors.some((behavior) => behavior.progress)) return progressCreated;
+	writeInitialProgressFile(chainDir);
+	return true;
+}
+
+export function appendParallelWorktreeSummary(
+	output: string,
+	worktreeSetup: WorktreeSetup | undefined,
+	diffsDir: string,
+	agents: string[],
+): string {
+	if (!worktreeSetup) return output;
+	const diffs = diffWorktrees(worktreeSetup, agents, diffsDir);
+	const diffSummary = formatWorktreeDiffSummary(diffs);
+	return diffSummary ? `${output}\n\n${diffSummary}` : output;
+}
+
+export async function runParallelChainTasks(input: ParallelChainRunInput): Promise<SingleResult[]> {
+	const concurrency = input.step.concurrency ?? MAX_CONCURRENCY;
+	const failFast = input.step.failFast ?? false;
+	let aborted = false;
+
+	return 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",
+			} as SingleResult;
+		}
+
+		const taskTemplate = input.parallelTemplates[taskIndex] ?? "{previous}";
+		const behavior = suppressProgressForReadOnlyTask(input.parallelBehaviors[taskIndex]!, taskTemplate, input.originalTask);
+		const templateHasPrevious = taskTemplate.includes("{previous}");
+		const { prefix, suffix } = buildChainInstructions(
+			behavior,
+			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 taskAgentConfig = input.agents.find((agent) => agent.name === task.agent);
+		const effectiveModel =
+			(task.model ? resolveModelCandidate(task.model, input.availableModels, input.ctx.model?.provider) : null)
+			?? resolveModelCandidate(taskAgentConfig?.model, input.availableModels, input.ctx.model?.provider);
+		const maxSubagentDepth = resolveChildMaxSubagentDepth(input.maxSubagentDepth, taskAgentConfig?.maxSubagentDepth);
+		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;
+		const interruptController = new AbortController();
+		if (input.foregroundControl) {
+			input.foregroundControl.currentAgent = 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 input.runSync(input.ctx.cwd, input.agents, task.agent, taskStr, {
+			cwd: taskCwd,
+			signal: input.signal,
+			interruptSignal: interruptController.signal,
+			allowIntercomDetach: taskAgentConfig?.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+			intercomEvents: input.intercomEvents,
+			runId: input.runId,
+			index: input.globalTaskIndex + taskIndex,
+			sessionDir: input.sessionDirForIndex(input.globalTaskIndex + taskIndex),
+			sessionFile: input.sessionFileForIndex?.(input.globalTaskIndex + taskIndex),
+			share: input.shareEnabled,
+			artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
+			artifactConfig: input.artifactConfig,
+			outputPath,
+			outputMode: behavior.outputMode,
+			maxSubagentDepth,
+			workflowStageSubagentGuard: input.workflowStageSubagentGuard,
+			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,
+			currentModel: currentModelFullId(input.ctx.model),
+			preferredModelProvider: input.ctx.model?.provider,
+			skills: behavior.skills === false ? [] : behavior.skills,
+			structuredOutput: structuredRuntime,
+			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.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;
+	});
+}