@bastani/atomic 0.9.12 → 0.9.13-alpha.2

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

@@ -1,217 +0,0 @@
-import * as path from "node:path";
-import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.ts";
-import {
-	buildChainInstructions,
-	type ResolvedStepBehavior,
-	suppressProgressForReadOnlyTask,
-	writeInitialProgressFile,
-} from "../../shared/settings.ts";
-import { MAX_CONCURRENCY, resolveChildMaxSubagentDepth, type SingleResult } from "../../shared/types.ts";
-import { workflowSessionMetadataFromContext } from "../../shared/types-depth.ts";
-import { mapConcurrent, resolveChildCwd } from "../../shared/utils.ts";
-import { resolveOutputReferences } from "../shared/chain-outputs.ts";
-import { inheritedIntercomGroup, resolveChildIntercomGroup, sharedAutoGroupForSet } from "../shared/intercom-group.ts";
-import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
-import { recordRun } from "../shared/run-history.ts";
-import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
-import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
-import { diffWorktrees, formatWorktreeDiffSummary, type WorktreeSetup } from "../shared/worktree.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;
-	const intercomDetachController = new AbortController();
-	const setGroup = input.step.group ?? input.chainIntercomGroup;
-	const sharedAutoGroup = sharedAutoGroupForSet(setGroup, input.step.parallel);
-
-	return mapConcurrent(input.step.parallel, concurrency, async (task, taskIndex) => {
-		if (intercomDetachController.signal.aborted) {
-			return {
-				agent: task.agent,
-				task: input.parallelTemplates[taskIndex] ?? task.task ?? "{previous}",
-				exitCode: -1,
-				messages: [],
-				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-				error: "Skipped after foreground group detached for intercom coordination",
-			};
-		}
-		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,
-			workflowSessionMetadata: workflowSessionMetadataFromContext(input.ctx),
-			controlConfig: input.controlConfig,
-			onControlEvent: input.onControlEvent,
-			intercomSessionName: input.childIntercomTarget?.(task.agent, input.globalTaskIndex + taskIndex),
-			orchestratorIntercomTarget: input.orchestratorIntercomTarget,
-			intercomGroup: resolveChildIntercomGroup(
-				task.group ?? setGroup,
-				inheritedIntercomGroup(input.ctx),
-				sharedAutoGroup,
-			),
-			nestedRoute: input.nestedRoute,
-			onDetachedExit: (recovered) => input.onDetachedExit?.(input.globalTaskIndex + taskIndex, recovered),
-			intercomDetachSignal: intercomDetachController.signal,
-			onIntercomDetachCommit: () => intercomDetachController.abort(),
-			modelOverride: effectiveModel,
-			availableModels: input.availableModels,
-			knownModelProviders: input.knownModelProviders,
-			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;
-	});
-}

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

@@ -1,271 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { buildChainSummary } from "../../shared/formatters.ts";
-import {
-	aggregateParallelOutputs,
-	createParallelDirs,
-	type ParallelStep,
-	type ParallelTaskResult,
-	resolveParallelBehaviors,
-	suppressProgressForReadOnlyTask,
-} from "../../shared/settings.ts";
-import { getSingleResultOutput, resolveChildCwd } from "../../shared/utils.ts";
-import { outputEntryFromResult } from "../shared/chain-outputs.ts";
-import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
-import {
-	cleanupWorktrees,
-	createWorktrees,
-	findWorktreeTaskCwdConflict,
-	formatWorktreeTaskCwdConflict,
-	type WorktreeSetup,
-} from "../shared/worktree.ts";
-import { buildChainExecutionDetails, buildChainExecutionErrorResult } from "./chain-execution-details.ts";
-import {
-	appendParallelWorktreeSummary,
-	ensureParallelProgressFile,
-	runParallelChainTasks,
-} from "./chain-execution-parallel-runner.ts";
-import type { ChainExecutionMutableState, ChainExecutionResult, ChainRuntimeContext } from "./chain-execution-types.ts";
-import { createDetachedCleanupBarrier } from "./detached-cleanup-barrier.ts";
-
-export async function runStaticParallelChainStep(input: {
-	context: ChainRuntimeContext;
-	state: ChainExecutionMutableState;
-	step: ParallelStep;
-	stepIndex: number;
-	parallelTemplates: string[];
-}): Promise<ChainExecutionResult | undefined> {
-	const { context, state, step, stepIndex, parallelTemplates } = input;
-	const parallelCwd = resolveChildCwd(context.cwd ?? context.ctx.cwd, step.cwd);
-	let worktreeSetup: WorktreeSetup | undefined;
-	let worktreeCleanupDeferred = false;
-	if (step.worktree) {
-		const worktreeTaskCwdConflict = findWorktreeTaskCwdConflict(step.parallel, parallelCwd);
-		if (worktreeTaskCwdConflict) {
-			return buildChainExecutionErrorResult(
-				`parallel chain step ${stepIndex + 1}: ${formatWorktreeTaskCwdConflict(worktreeTaskCwdConflict, parallelCwd)}`,
-				context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }),
-			);
-		}
-		try {
-			worktreeSetup = createWorktrees(parallelCwd, `${context.runId}-s${stepIndex}`, step.parallel.length, {
-				agents: step.parallel.map((task) => task.agent),
-				setupHook: context.params.worktreeSetupHook
-					? { hookPath: context.params.worktreeSetupHook, timeoutMs: context.params.worktreeSetupHookTimeoutMs }
-					: undefined,
-			});
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			return buildChainExecutionErrorResult(
-				message,
-				context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }),
-			);
-		}
-	}
-
-	try {
-		const agentNames = step.parallel.map((task) => task.agent);
-		const parallelBaseIndex = state.globalTaskIndex;
-		const detachedCleanup = createDetachedCleanupBarrier(() => {
-			if (!worktreeSetup) return;
-			appendParallelWorktreeSummary(
-				"",
-				worktreeSetup,
-				path.join(context.chainDir, "worktree-diffs", `step-${stepIndex}`),
-				agentNames,
-			);
-			cleanupWorktrees(worktreeSetup);
-		});
-		const parallelBehaviors = resolveParallelBehaviors(
-			step.parallel,
-			context.agents,
-			stepIndex,
-			context.chainSkills,
-		).map((behavior, taskIndex) =>
-			suppressProgressForReadOnlyTask(
-				behavior,
-				parallelTemplates[taskIndex] ?? step.parallel[taskIndex]?.task,
-				context.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(context.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,
-					context.makeDetailsInput({
-						currentStepIndex: stepIndex,
-						currentFlatIndex: state.globalTaskIndex + taskIndex,
-					}),
-				);
-			}
-		}
-		state.progressCreated = ensureParallelProgressFile(context.chainDir, state.progressCreated, parallelBehaviors);
-		createParallelDirs(context.chainDir, stepIndex, step.parallel.length, agentNames);
-
-		const parallelResults = await runParallelChainTasks({
-			step,
-			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,
-			worktreeSetup,
-			maxSubagentDepth: context.params.maxSubagentDepth,
-			workflowStageSubagentGuard: context.params.workflowStageSubagentGuard,
-			runSync: context.executeRunSync,
-			onDetachedExit: (index, result) => {
-				try {
-					context.onDetachedExit?.(index, result);
-				} finally {
-					detachedCleanup.recover(index);
-				}
-			},
-		});
-		worktreeCleanupDeferred = detachedCleanup.defer(
-			parallelResults.flatMap((result, index) => (result.detached ? [parallelBaseIndex + index] : [])),
-		);
-		state.globalTaskIndex += step.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 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: state.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. After the child exits, start a fresh follow-up if needed.`,
-					},
-				],
-				details: buildChainExecutionDetails(
-					context.makeDetailsInput({
-						currentStepIndex: stepIndex,
-						currentFlatIndex: state.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(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: state.globalTaskIndex - step.parallel.length + failures[0]!.originalIndex,
-					}),
-				),
-			};
-		}
-
-		for (let taskIndex = 0; taskIndex < parallelResults.length; taskIndex++) {
-			const outputName = step.parallel[taskIndex]?.as;
-			if (outputName) state.outputs[outputName] = outputEntryFromResult(parallelResults[taskIndex]!, stepIndex);
-		}
-		const taskResults: ParallelTaskResult[] = parallelResults.map((result, index) => {
-			const outputTarget = parallelBehaviors[index]?.output;
-			const outputTargetPath =
-				typeof outputTarget === "string"
-					? path.isAbsolute(outputTarget)
-						? outputTarget
-						: path.join(context.chainDir, outputTarget)
-					: undefined;
-			return {
-				agent: result.agent,
-				taskIndex: index,
-				output: getSingleResultOutput(result),
-				exitCode: result.exitCode,
-				error: result.error,
-				outputTargetPath,
-				outputTargetExists: outputTargetPath ? fs.existsSync(outputTargetPath) : undefined,
-			};
-		});
-		state.prev = aggregateParallelOutputs(taskResults);
-		state.prev = appendParallelWorktreeSummary(
-			state.prev,
-			worktreeSetup,
-			path.join(context.chainDir, "worktree-diffs", `step-${stepIndex}`),
-			agentNames,
-		);
-		return undefined;
-	} finally {
-		if (worktreeSetup && !worktreeCleanupDeferred) cleanupWorktrees(worktreeSetup);
-	}
-}