@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/background/subagent-runner-types.ts

@@ -1,210 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai/compat";
-import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
-import type {
-	ActivityState,
-	ArtifactConfig,
-	ArtifactPaths,
-	AsyncParallelGroupStatus,
-	AsyncStatus,
-	ChainOutputMap,
-	MaxOutputConfig,
-	ModelAttempt,
-	NestedRouteInfo,
-	ResolvedControlConfig,
-	SubagentRunMode,
-	TokenUsage,
-	Usage,
-	WorkflowGraphSnapshot,
-} from "../../shared/types.ts";
-import type { RunnerStep, RunnerSubagentStep as SubagentStep } from "../shared/parallel-utils.ts";
-import type { WorktreeSetup } from "../shared/worktree.ts";
-
-export interface SubagentRunConfig {
-	id: string;
-	steps: RunnerStep[];
-	resultPath: string;
-	cwd: string;
-	placeholder: string;
-	taskIndex?: number;
-	totalTasks?: number;
-	maxOutput?: MaxOutputConfig;
-	artifactsDir?: string;
-	artifactConfig?: Partial<ArtifactConfig>;
-	share?: boolean;
-	sessionDir?: string;
-	asyncDir: string;
-	sessionId?: string | null;
-	piPackageRoot?: string;
-	piArgv1?: string;
-	worktreeSetupHook?: string;
-	worktreeSetupHookTimeoutMs?: number;
-	controlConfig?: ResolvedControlConfig;
-	controlIntercomTarget?: string;
-	childIntercomTargets?: Array<string | undefined>;
-	supervisorAuthorizations?: Array<SupervisorAuthorization | undefined>;
-	dynamicSupervisorAuthorizations?: Record<number, SupervisorAuthorization[]>;
-	resultMode?: SubagentRunMode;
-	dynamicFanoutMaxItems?: number;
-	workflowGraph?: WorkflowGraphSnapshot;
-	nestedRoute?: NestedRouteInfo;
-	workflowStageSubagentGuard?: boolean;
-	nestedSelf?: {
-		parentRunId: string;
-		parentStepIndex?: number;
-		depth: number;
-		path?: Array<{ runId: string; stepIndex?: number; agent?: string }>;
-	};
-}
-
-export interface StepResult {
-	agent: string;
-	output: string;
-	error?: string;
-	success: boolean;
-	exitCode?: number | null;
-	skipped?: boolean;
-	sessionFile?: string;
-	intercomTarget?: string;
-	model?: string;
-	fastMode?: boolean;
-	attemptedModels?: string[];
-	modelAttempts?: ModelAttempt[];
-	artifactPaths?: ArtifactPaths;
-	truncated?: boolean;
-	structuredOutput?: unknown;
-	structuredOutputPath?: string;
-	structuredOutputSchemaPath?: string;
-}
-
-export interface ChildEventContext {
-	eventsPath: string;
-	runId: string;
-	stepIndex: number;
-	agent: string;
-}
-
-export interface ChildUsage {
-	input?: number;
-	inputTokens?: number;
-	output?: number;
-	outputTokens?: number;
-	cacheRead?: number;
-	cacheWrite?: number;
-	cost?: { total?: number };
-}
-
-export type ChildMessage = Message & {
-	model?: string;
-	errorMessage?: string;
-	usage?: ChildUsage;
-};
-
-export interface ChildEvent {
-	type?: string;
-	message?: ChildMessage;
-	toolName?: string;
-	args?: Record<string, unknown>;
-}
-
-export interface RunPiStreamingResult {
-	stderr: string;
-	exitCode: number | null;
-	messages: Message[];
-	usage: Usage;
-	model?: string;
-	error?: string;
-	finalOutput: string;
-	interrupted?: boolean;
-	modelFailureSignal?: unknown;
-}
-
-export interface SingleStepContext {
-	previousOutput: string;
-	outputs?: ChainOutputMap;
-	placeholder: string;
-	cwd: string;
-	sessionEnabled: boolean;
-	sessionDir?: string;
-	artifactsDir?: string;
-	artifactConfig?: Partial<ArtifactConfig>;
-	id: string;
-	flatIndex: number;
-	flatStepCount: number;
-	outputFile: string;
-	piPackageRoot?: string;
-	piArgv1?: string;
-	registerInterrupt?: (interrupt: (() => void) | undefined) => void;
-	childIntercomTarget?: string;
-	orchestratorIntercomTarget?: string;
-	supervisorAuthorization?: SupervisorAuthorization;
-	nestedRoute?: NestedRouteInfo;
-	onAttemptStart?: (attempt: { model?: string; thinking?: string; fastMode?: boolean }) => void;
-	onChildEvent?: (event: ChildEvent) => void;
-	workflowStageSubagentGuard?: boolean;
-}
-
-export type RunnerStatusStep = NonNullable<AsyncStatus["steps"]>[number] & {
-	exitCode?: number | null;
-};
-
-export type RunnerStatusPayload = Omit<
-	AsyncStatus,
-	"steps" | "parallelGroups" | "pid" | "cwd" | "currentStep" | "chainStepCount" | "lastUpdate"
-> & {
-	pid: number;
-	cwd: string;
-	currentStep: number;
-	chainStepCount: number;
-	parallelGroups: AsyncParallelGroupStatus[];
-	steps: RunnerStatusStep[];
-	lastUpdate: number;
-	artifactsDir?: string;
-	shareUrl?: string;
-	gistUrl?: string;
-	shareError?: string;
-	error?: string;
-};
-
-export interface RunnerExecutionState {
-	config: SubagentRunConfig;
-	id: string;
-	steps: RunnerStep[];
-	resultPath: string;
-	cwd: string;
-	placeholder: string;
-	taskIndex?: number;
-	totalTasks?: number;
-	maxOutput?: MaxOutputConfig;
-	artifactsDir?: string;
-	artifactConfig?: Partial<ArtifactConfig>;
-	previousOutput: string;
-	outputs: ChainOutputMap;
-	results: StepResult[];
-	overallStartTime: number;
-	shareEnabled: boolean;
-	asyncDir: string;
-	statusPath: string;
-	eventsPath: string;
-	logPath: string;
-	controlConfig: ResolvedControlConfig;
-	activeChildInterrupt?: (() => void) | undefined;
-	interrupted: boolean;
-	currentActivityState?: ActivityState;
-	activityTimer?: NodeJS.Timeout;
-	previousCumulativeTokens: TokenUsage;
-	latestSessionFile?: string;
-	flatSteps: SubagentStep[];
-	sessionEnabled: boolean;
-	statusPayload: RunnerStatusPayload;
-	flatIndex: number;
-	mutatingFailureStates: Array<
-		ReturnType<typeof import("../shared/long-running-guard.ts").createMutatingFailureState>
-	>;
-	pendingToolResults: Array<{ tool: string; path?: string; mutates: boolean; startedAt?: number } | undefined>;
-	emittedControlEventKeys: Set<string>;
-	activeLongRunningSteps: Set<number>;
-}
-
-export type ParallelGroup = Extract<RunnerStep, { parallel: SubagentStep[] }>;
-export type DynamicGroup = Extract<RunnerStep, { collect: { as: string } }>;
-export type { RunnerStep, SubagentStep, WorktreeSetup };

package/dist/builtin/subagents/src/runs/background/subagent-runner-utils.ts

@@ -1,69 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ModelAttempt, TokenUsage, Usage } from "../../shared/types.ts";
-import type { RunnerStatusStep, SubagentStep } from "./subagent-runner-types.ts";
-
-export function findLatestSessionFile(sessionDir: string): string | null {
-	try {
-		const files = fs
-			.readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => path.join(sessionDir, f));
-		if (files.length === 0) return null;
-		files.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-		return files[0] ?? null;
-	} catch {
-		return null;
-	}
-}
-
-export function emptyUsage(): Usage {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-
-export function tokenUsageFromAttempts(attempts: ModelAttempt[] | undefined): TokenUsage | null {
-	if (!attempts || attempts.length === 0) return null;
-	let input = 0;
-	let output = 0;
-	for (const attempt of attempts) {
-		input += attempt.usage?.input ?? 0;
-		output += attempt.usage?.output ?? 0;
-	}
-	const total = input + output;
-	return total > 0 ? { input, output, total } : null;
-}
-
-export function appendRecentStepOutput(step: RunnerStatusStep, lines: string[]): void {
-	const nonEmpty = lines.filter((line) => line.trim());
-	if (nonEmpty.length === 0) return;
-	step.recentOutput ??= [];
-	step.recentOutput.push(...nonEmpty);
-	if (step.recentOutput.length > 50) {
-		step.recentOutput.splice(0, step.recentOutput.length - 50);
-	}
-}
-
-export function resetStepLiveDetail(step: RunnerStatusStep): void {
-	step.currentTool = undefined;
-	step.currentToolArgs = undefined;
-	step.currentToolStartedAt = undefined;
-	step.currentPath = undefined;
-	step.recentTools = [];
-	step.recentOutput = [];
-}
-
-export function fastModeForStepAttempt(step: SubagentStep, model: string | undefined): boolean | undefined {
-	if (model && step.modelFastModes && Object.hasOwn(step.modelFastModes, model)) {
-		return step.modelFastModes[model];
-	}
-	if (model === undefined || model === step.model) return step.fastMode;
-	return undefined;
-}
-
-export function formatDuration(ms: number): string {
-	if (ms < 1000) return `${ms}ms`;
-	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-	const minutes = Math.floor(ms / 60000);
-	const seconds = Math.floor((ms % 60000) / 1000);
-	return `${minutes}m${seconds}s`;
-}

package/dist/builtin/subagents/src/runs/background/subagent-runner.ts

@@ -1,90 +0,0 @@
-import * as fs from "node:fs";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.ts";
-import { runDynamicGroup } from "./subagent-runner-dynamic.ts";
-import { finalizeRun } from "./subagent-runner-finalize.ts";
-import { runParallelGroup } from "./subagent-runner-parallel.ts";
-import { runSequentialStep } from "./subagent-runner-sequential.ts";
-import { createRunnerExecutionState, interruptRunner, startActivityTimer } from "./subagent-runner-state.ts";
-import type { SubagentRunConfig, SubagentStep } from "./subagent-runner-types.ts";
-
-const ASYNC_INTERRUPT_SIGNAL: NodeJS.Signals = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
-
-async function runSubagent(config: SubagentRunConfig): Promise<void> {
-	const state = createRunnerExecutionState(config);
-	startActivityTimer(state);
-	const onInterrupt = () => interruptRunner(state);
-	process.on(ASYNC_INTERRUPT_SIGNAL, onInterrupt);
-	appendJsonl(
-		state.eventsPath,
-		JSON.stringify({
-			type: "subagent.run.started",
-			ts: state.overallStartTime,
-			runId: state.id,
-			mode: state.statusPayload.mode,
-			cwd: state.cwd,
-			pid: process.pid,
-		}),
-	);
-
-	try {
-		for (let stepIndex = 0; stepIndex < state.steps.length; stepIndex++) {
-			if (state.interrupted) break;
-			const step = state.steps[stepIndex];
-			let shouldContinue = true;
-			if (isDynamicRunnerGroup(step)) {
-				shouldContinue = await runDynamicGroup(state, step, stepIndex);
-			} else if (isParallelGroup(step)) {
-				shouldContinue = await runParallelGroup(state, step, stepIndex);
-			} else {
-				shouldContinue = await runSequentialStep(state, step as SubagentStep, stepIndex);
-			}
-			if (!shouldContinue) break;
-		}
-		await finalizeRun(state);
-	} finally {
-		process.off(ASYNC_INTERRUPT_SIGNAL, onInterrupt);
-	}
-}
-
-function parseConfig(input: string): SubagentRunConfig {
-	return JSON.parse(input) as SubagentRunConfig;
-}
-
-function runConfig(config: SubagentRunConfig): void {
-	runSubagent(config).catch((runErr) => {
-		console.error("Subagent runner error:", runErr);
-		process.exit(1);
-	});
-}
-
-const configArg = process.argv[2];
-if (configArg) {
-	try {
-		const configJson = fs.readFileSync(configArg, "utf-8");
-		const config = parseConfig(configJson);
-		try {
-			fs.unlinkSync(configArg);
-		} catch {
-			// Temp config cleanup is best effort.
-		}
-		runConfig(config);
-	} catch (err) {
-		console.error("Subagent runner error:", err);
-		process.exit(1);
-	}
-} else {
-	let input = "";
-	process.stdin.setEncoding("utf-8");
-	process.stdin.on("data", (chunk) => {
-		input += chunk;
-	});
-	process.stdin.on("end", () => {
-		try {
-			runConfig(parseConfig(input));
-		} catch (err) {
-			console.error("Subagent runner error:", err);
-			process.exit(1);
-		}
-	});
-}

package/dist/builtin/subagents/src/runs/background/top-level-async.ts

@@ -1,12 +0,0 @@
-interface AsyncOverrideParams {
-	async?: boolean;
-}
-
-export function applyForceTopLevelAsyncOverride<T extends AsyncOverrideParams>(
-	params: T,
-	depth: number,
-	forceTopLevelAsync: boolean,
-): T {
-	if (!(depth === 0 && forceTopLevelAsync)) return params;
-	return { ...params, async: true };
-}

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

@@ -1,38 +0,0 @@
-import type { Details } from "../../shared/types.ts";
-import { compactForegroundDetails } from "../../shared/utils.ts";
-import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.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

@@ -1,280 +0,0 @@
-import * as path from "node:path";
-import { buildChainSummary } from "../../shared/formatters.ts";
-import {
-	aggregateParallelOutputs,
-	createParallelDirs,
-	type DynamicParallelStep,
-	type ParallelStep,
-	type ParallelTaskResult,
-	resolveParallelBehaviors,
-	suppressProgressForReadOnlyTask,
-} from "../../shared/settings.ts";
-import { getSingleResultOutput } from "../../shared/utils.ts";
-import {
-	collectDynamicResults,
-	type DynamicCollectedResult,
-	DynamicFanoutError,
-	materializeDynamicParallelStep,
-	validateDynamicCollection,
-} from "../shared/dynamic-fanout.ts";
-import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
-import { buildChainExecutionDetails, buildChainExecutionErrorResult } from "./chain-execution-details.ts";
-import { ensureParallelProgressFile, runParallelChainTasks } from "./chain-execution-parallel-runner.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,
-		group: step.group,
-	};
-	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,
-		chainIntercomGroup: context.params.group,
-		parallelTemplates,
-		parallelBehaviors,
-		agents: context.agents,
-		stepIndex,
-		availableModels: context.availableModels,
-		knownModelProviders: context.knownModelProviders,
-		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,
-		onDetachedExit: context.onDetachedExit,
-	});
-	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;
-}