@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.2

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

@@ -1,271 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { normalizeSkillInput } from "../../agents/skills.ts";
-import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.ts";
-import { buildChainSummary } from "../../shared/formatters.ts";
-import {
-	buildChainInstructions,
-	removeChainDir,
-	resolveStepBehavior,
-	type SequentialStep,
-	type StepOverrides,
-	suppressProgressForReadOnlyTask,
-} from "../../shared/settings.ts";
-import { resolveChildMaxSubagentDepth } from "../../shared/types.ts";
-import { workflowSessionMetadataFromContext } from "../../shared/types-depth.ts";
-import { getSingleResultOutput, resolveChildCwd } from "../../shared/utils.ts";
-import { outputEntryFromResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
-import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.ts";
-import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
-import { recordRun } from "../shared/run-history.ts";
-import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
-import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
-import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
-import { buildChainExecutionDetails, buildChainExecutionErrorResult } from "./chain-execution-details.ts";
-import type { ChainExecutionMutableState, ChainExecutionResult, ChainRuntimeContext } from "./chain-execution-types.ts";
-
-export async function runSequentialChainStep(input: {
-	context: ChainRuntimeContext;
-	state: ChainExecutionMutableState;
-	seqStep: SequentialStep;
-	stepIndex: number;
-	stepTemplate: string;
-}): Promise<ChainExecutionResult | undefined> {
-	const { context, state, seqStep, stepIndex, stepTemplate } = input;
-	const agentConfig = context.agents.find((agent) => agent.name === seqStep.agent);
-	if (!agentConfig) {
-		removeChainDir(context.chainDir);
-		return {
-			content: [{ type: "text", text: `Unknown agent: ${seqStep.agent}` }],
-			isError: true,
-			details: buildChainExecutionDetails(
-				context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }),
-			),
-		};
-	}
-
-	const stepOverride: StepOverrides = {
-		output: seqStep.output,
-		outputMode: seqStep.outputMode,
-		reads: seqStep.reads,
-		progress: seqStep.progress,
-		skills: normalizeSkillInput(seqStep.skill),
-	};
-	const behavior = suppressProgressForReadOnlyTask(
-		resolveStepBehavior(agentConfig, stepOverride, context.chainSkills),
-		stepTemplate,
-		context.originalTask,
-	);
-	const isFirstProgress = behavior.progress && !state.progressCreated;
-	if (isFirstProgress) state.progressCreated = true;
-
-	const templateHasPrevious = stepTemplate.includes("{previous}");
-	const { prefix, suffix } = buildChainInstructions(
-		behavior,
-		context.chainDir,
-		isFirstProgress,
-		templateHasPrevious ? undefined : state.prev,
-	);
-
-	let stepTask = resolveOutputReferences(stepTemplate, state.outputs);
-	stepTask = stepTask.replace(/\{task\}/g, context.originalTask);
-	stepTask = stepTask.replace(/\{previous\}/g, state.prev);
-	stepTask = stepTask.replace(/\{chain_dir\}/g, context.chainDir);
-	const cleanTask = stepTask;
-	stepTask = prefix + stepTask + suffix;
-
-	const effectiveModel =
-		(seqStep.model
-			? resolveModelCandidate(seqStep.model, context.availableModels, context.ctx.model?.provider)
-			: null) ?? resolveModelCandidate(agentConfig.model, context.availableModels, context.ctx.model?.provider);
-	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,
-		`Chain step ${stepIndex + 1} (${seqStep.agent})`,
-	);
-	if (validationError)
-		return buildChainExecutionErrorResult(
-			validationError,
-			context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }),
-		);
-
-	const maxSubagentDepth = resolveChildMaxSubagentDepth(context.params.maxSubagentDepth, agentConfig.maxSubagentDepth);
-	const interruptController = new AbortController();
-	if (context.foregroundControl) {
-		context.foregroundControl.currentAgent = seqStep.agent;
-		context.foregroundControl.currentIndex = state.globalTaskIndex;
-		context.foregroundControl.currentActivityState = undefined;
-		context.foregroundControl.updatedAt = Date.now();
-		context.foregroundControl.interrupt = () => {
-			if (interruptController.signal.aborted) return false;
-			interruptController.abort();
-			context.foregroundControl!.currentActivityState = undefined;
-			context.foregroundControl!.updatedAt = Date.now();
-			return true;
-		};
-	}
-
-	const flatIndex = state.globalTaskIndex;
-	const structuredRuntime = seqStep.outputSchema
-		? createStructuredOutputRuntime(seqStep.outputSchema, path.join(context.chainDir, "structured-output"))
-		: undefined;
-	const result = await context.executeRunSync(context.ctx.cwd, context.agents, seqStep.agent, stepTask, {
-		cwd: resolveChildCwd(context.cwd ?? context.ctx.cwd, seqStep.cwd),
-		signal: context.signal,
-		interruptSignal: interruptController.signal,
-		allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
-		intercomEvents: context.intercomEvents,
-		runId: context.runId,
-		index: flatIndex,
-		sessionDir: context.sessionDirForIndex(flatIndex),
-		sessionFile: context.sessionFileForIndex?.(flatIndex),
-		share: context.shareEnabled,
-		artifactsDir: context.artifactConfig.enabled ? context.artifactsDir : undefined,
-		artifactConfig: context.artifactConfig,
-		outputPath,
-		outputMode: behavior.outputMode,
-		maxSubagentDepth,
-		workflowStageSubagentGuard: context.params.workflowStageSubagentGuard,
-		workflowSessionMetadata: workflowSessionMetadataFromContext(context.params.ctx),
-		controlConfig: context.controlConfig,
-		onControlEvent: context.onControlEvent,
-		intercomSessionName: context.childIntercomTarget?.(seqStep.agent, flatIndex),
-		orchestratorIntercomTarget: context.orchestratorIntercomTarget,
-		intercomGroup: resolveChildIntercomGroup(
-			seqStep.group ?? context.params.group,
-			inheritedIntercomGroup(context.ctx),
-			undefined,
-		),
-		nestedRoute: context.params.nestedRoute,
-		onDetachedExit: (recovered) => context.onDetachedExit?.(flatIndex, recovered),
-		modelOverride: effectiveModel,
-		availableModels: context.availableModels,
-		knownModelProviders: context.knownModelProviders,
-		currentModel: currentModelFullId(context.ctx.model),
-		preferredModelProvider: context.ctx.model?.provider,
-		skills: behavior.skills === false ? [] : behavior.skills,
-		structuredOutput: structuredRuntime,
-		onUpdate: context.onUpdate
-			? (update) => {
-					const stepResults = update.details?.results || [];
-					const stepProgress = update.details?.progress || [];
-					if (context.foregroundControl && stepProgress.length > 0) {
-						const current = stepProgress[0];
-						context.foregroundControl.currentAgent = seqStep.agent;
-						context.foregroundControl.currentIndex = flatIndex;
-						context.foregroundControl.currentActivityState = current?.activityState;
-						context.foregroundControl.lastActivityAt = current?.lastActivityAt;
-						context.foregroundControl.currentTool = current?.currentTool;
-						context.foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
-						context.foregroundControl.currentPath = current?.currentPath;
-						context.foregroundControl.turnCount = current?.turnCount;
-						context.foregroundControl.tokens = current?.tokens;
-						context.foregroundControl.toolCount = current?.toolCount;
-						context.foregroundControl.updatedAt = Date.now();
-					}
-					context.onUpdate?.({
-						...update,
-						details: {
-							mode: "chain",
-							results: state.results.concat(stepResults),
-							progress: state.allProgress.concat(stepProgress),
-							controlEvents: update.details?.controlEvents,
-							chainAgents: context.chainAgents,
-							totalSteps: context.totalSteps,
-							currentStepIndex: stepIndex,
-							outputs: state.outputs,
-							workflowGraph: buildWorkflowGraphSnapshot({
-								runId: context.runId,
-								mode: "chain",
-								steps: context.chainSteps,
-								results: state.results.concat(stepResults),
-								currentStepIndex: stepIndex,
-								currentFlatIndex: flatIndex,
-								dynamicChildren: state.dynamicChildren,
-								dynamicGroupStatuses: state.dynamicGroupStatuses,
-							}),
-						},
-					});
-				}
-			: undefined,
-	});
-	if (context.foregroundControl?.currentIndex === flatIndex) {
-		context.foregroundControl.interrupt = undefined;
-		context.foregroundControl.updatedAt = Date.now();
-	}
-	recordRun(seqStep.agent, cleanTask, result.status, result.progressSummary?.durationMs ?? 0);
-
-	state.globalTaskIndex++;
-	state.results.push(result);
-	if (result.progress) state.allProgress.push(result.progress);
-	if (result.artifactPaths) state.allArtifactPaths.push(result.artifactPaths);
-
-	if (result.interrupted) {
-		return {
-			content: [
-				{
-					type: "text",
-					text: `Chain paused after interrupt at step ${stepIndex + 1} (${result.agent}). Waiting for explicit next action.`,
-				},
-			],
-			details: buildChainExecutionDetails(
-				context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex - 1 }),
-			),
-		};
-	}
-	if (result.detached) {
-		return {
-			content: [
-				{
-					type: "text",
-					text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${result.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 - 1 }),
-			),
-		};
-	}
-	if (result.status !== "ok") {
-		const summary = buildChainSummary(context.chainSteps, state.results, context.chainDir, "failed", {
-			index: stepIndex,
-			error: result.error || "Chain failed",
-		});
-		return {
-			content: [{ type: "text", text: summary }],
-			details: buildChainExecutionDetails(
-				context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex - 1 }),
-			),
-			isError: true,
-		};
-	}
-
-	if (behavior.output) {
-		try {
-			const expectedPath = path.isAbsolute(behavior.output)
-				? behavior.output
-				: path.join(context.chainDir, behavior.output);
-			if (!fs.existsSync(expectedPath)) {
-				const dirFiles = fs.readdirSync(context.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}`;
-				result.error = result.error ? `${result.error}\n${warning}` : warning;
-			}
-		} catch {
-			// Ignore validation errors; this diagnostic should not mask successful chain output.
-		}
-	}
-
-	if (seqStep.as) state.outputs[seqStep.as] = outputEntryFromResult(result, stepIndex);
-	state.prev = getSingleResultOutput(result);
-	return undefined;
-}

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

@@ -1,200 +0,0 @@
-import type { ExtensionContext } from "@bastani/atomic";
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { AgentConfig } from "../../agents/agents.ts";
-import type { ModelInfo } from "../../shared/model-info.ts";
-import type { ChainStep, ParallelStep, ResolvedStepBehavior } from "../../shared/settings.ts";
-import type {
-	ActivityState,
-	AgentProgress,
-	ArtifactConfig,
-	ArtifactPaths,
-	ChainOutputMap,
-	ControlEvent,
-	Details,
-	IntercomEventBus,
-	NestedRouteInfo,
-	ResolvedControlConfig,
-	SingleResult,
-} from "../../shared/types.ts";
-import type { WorktreeSetup } from "../shared/worktree.ts";
-import type { runSync } from "./execution.ts";
-
-export type RunSyncDependency = typeof runSync;
-
-export type ChainForegroundControl = {
-	updatedAt: number;
-	currentAgent?: string;
-	currentIndex?: number;
-	currentActivityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	tokens?: number;
-	toolCount?: number;
-	interrupt?: () => boolean;
-};
-
-export interface ChainExecutionDetailsInput {
-	results: SingleResult[];
-	includeProgress?: boolean;
-	allProgress: AgentProgress[];
-	allArtifactPaths: ArtifactPaths[];
-	artifactsDir: string;
-	chainAgents: string[];
-	chainSteps: ChainStep[];
-	totalSteps: number;
-	currentStepIndex?: number;
-	runId: string;
-	outputs?: ChainOutputMap;
-	currentFlatIndex?: number;
-	dynamicChildren?: Record<
-		number,
-		Array<{
-			agent: string;
-			label?: string;
-			flatIndex: number;
-			itemKey: string;
-			outputName?: string;
-			structured?: boolean;
-			error?: string;
-		}>
-	>;
-	dynamicGroupStatuses?: Record<
-		number,
-		{ status: "pending" | "running" | "completed" | "failed" | "paused" | "detached"; error?: string }
-	>;
-}
-
-export interface ChainExecutionParams {
-	chain: ChainStep[];
-	task?: string;
-	group?: string | true;
-	agents: AgentConfig[];
-	ctx: ExtensionContext;
-	intercomEvents?: IntercomEventBus;
-	signal?: AbortSignal;
-	runId: string;
-	cwd?: string;
-	shareEnabled: boolean;
-	sessionDirForIndex: (idx?: number) => string | undefined;
-	sessionFileForIndex?: (idx?: number) => string | undefined;
-	artifactsDir: string;
-	artifactConfig: ArtifactConfig;
-	includeProgress?: boolean;
-	onUpdate?: (r: AgentToolResult<Details>) => void;
-	onControlEvent?: (event: ControlEvent) => void;
-	controlConfig: ResolvedControlConfig;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	orchestratorIntercomTarget?: string;
-	foregroundControl?: ChainForegroundControl;
-	chainSkills?: string[];
-	chainDir?: string;
-	dynamicFanoutMaxItems?: number;
-	maxSubagentDepth: number;
-	workflowStageSubagentGuard?: boolean;
-	nestedRoute?: NestedRouteInfo;
-	worktreeSetupHook?: string;
-	worktreeSetupHookTimeoutMs?: number;
-	runSync?: RunSyncDependency;
-	onDetachedExit?: (index: number, result: SingleResult) => void;
-}
-
-export interface ChainExecutionResult {
-	content: Array<{ type: "text"; text: string }>;
-	details: Details;
-	isError?: boolean;
-}
-
-export interface ParallelChainRunInput {
-	step: ParallelStep;
-	chainIntercomGroup?: string | true;
-	parallelTemplates: string[];
-	parallelBehaviors: ResolvedStepBehavior[];
-	agents: AgentConfig[];
-	stepIndex: number;
-	availableModels: ModelInfo[];
-	knownModelProviders: string[];
-	chainDir: string;
-	prev: string;
-	originalTask: string;
-	ctx: ExtensionContext;
-	intercomEvents?: IntercomEventBus;
-	cwd?: string;
-	runId: string;
-	globalTaskIndex: number;
-	sessionDirForIndex: (idx?: number) => string | undefined;
-	sessionFileForIndex?: (idx?: number) => string | undefined;
-	shareEnabled: boolean;
-	artifactConfig: ArtifactConfig;
-	artifactsDir: string;
-	signal?: AbortSignal;
-	onUpdate?: (r: AgentToolResult<Details>) => void;
-	onControlEvent?: (event: ControlEvent) => void;
-	controlConfig: ResolvedControlConfig;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	orchestratorIntercomTarget?: string;
-	foregroundControl?: ChainForegroundControl;
-	results: SingleResult[];
-	allProgress: AgentProgress[];
-	outputs: ChainOutputMap;
-	chainAgents: string[];
-	chainSteps: ChainStep[];
-	totalSteps: number;
-	dynamicChildren?: ChainExecutionDetailsInput["dynamicChildren"];
-	dynamicGroupStatuses?: ChainExecutionDetailsInput["dynamicGroupStatuses"];
-	worktreeSetup?: WorktreeSetup;
-	maxSubagentDepth: number;
-	workflowStageSubagentGuard?: boolean;
-	nestedRoute?: NestedRouteInfo;
-	runSync: RunSyncDependency;
-	onDetachedExit?: (index: number, result: SingleResult) => void;
-}
-
-export interface ChainExecutionMutableState {
-	results: SingleResult[];
-	outputs: ChainOutputMap;
-	dynamicChildren: NonNullable<ChainExecutionDetailsInput["dynamicChildren"]>;
-	dynamicGroupStatuses: NonNullable<ChainExecutionDetailsInput["dynamicGroupStatuses"]>;
-	allProgress: AgentProgress[];
-	allArtifactPaths: ArtifactPaths[];
-	prev: string;
-	globalTaskIndex: number;
-	progressCreated: boolean;
-}
-
-export interface ChainRuntimeContext {
-	params: ChainExecutionParams;
-	agents: AgentConfig[];
-	ctx: ExtensionContext;
-	intercomEvents?: IntercomEventBus;
-	signal?: AbortSignal;
-	runId: string;
-	cwd?: string;
-	shareEnabled: boolean;
-	sessionDirForIndex: (idx?: number) => string | undefined;
-	sessionFileForIndex?: (idx?: number) => string | undefined;
-	artifactsDir: string;
-	artifactConfig: ArtifactConfig;
-	includeProgress?: boolean;
-	onUpdate?: (r: AgentToolResult<Details>) => void;
-	onControlEvent?: (event: ControlEvent) => void;
-	controlConfig: ResolvedControlConfig;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	orchestratorIntercomTarget?: string;
-	foregroundControl?: ChainForegroundControl;
-	chainSkills: string[];
-	chainDir: string;
-	availableModels: ModelInfo[];
-	knownModelProviders: string[];
-	originalTask: string;
-	chainAgents: string[];
-	chainSteps: ChainStep[];
-	totalSteps: number;
-	executeRunSync: RunSyncDependency;
-	makeDetailsInput(
-		overrides?: Pick<Partial<ChainExecutionDetailsInput>, "currentStepIndex" | "currentFlatIndex">,
-	): ChainExecutionDetailsInput;
-	onDetachedExit?: (index: number, result: SingleResult) => void;
-}

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

@@ -1,184 +0,0 @@
-/**
- * Public foreground chain execution API.
- */
-
-import { buildChainSummary } from "../../shared/formatters.ts";
-import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.ts";
-import {
-	createChainDir,
-	isDynamicParallelStep,
-	isParallelStep,
-	type ResolvedTemplates,
-	resolveChainTemplates,
-	type SequentialStep,
-} from "../../shared/settings.ts";
-import { ChainOutputValidationError, validateChainOutputBindings } from "../shared/chain-outputs.ts";
-import { buildChainExecutionDetails } from "./chain-execution-details.ts";
-import { runDynamicParallelChainStep } from "./chain-execution-dynamic-step.ts";
-import { runStaticParallelChainStep } from "./chain-execution-parallel-step.ts";
-import { runSequentialChainStep } from "./chain-execution-sequential-step.ts";
-import type {
-	ChainExecutionDetailsInput,
-	ChainExecutionMutableState,
-	ChainExecutionParams,
-	ChainExecutionResult,
-	ChainRuntimeContext,
-} from "./chain-execution-types.ts";
-import { runSync } from "./execution.ts";
-
-/**
- * Execute a chain of subagent steps.
- */
-export async function executeChain(params: ChainExecutionParams): Promise<ChainExecutionResult> {
-	const executeRunSync = params.runSync ?? runSync;
-	const {
-		chain: chainSteps,
-		agents,
-		ctx,
-		signal,
-		runId,
-		cwd,
-		shareEnabled,
-		sessionDirForIndex,
-		sessionFileForIndex,
-		artifactsDir,
-		artifactConfig,
-		includeProgress,
-		onUpdate,
-		onControlEvent,
-		controlConfig,
-		childIntercomTarget,
-		orchestratorIntercomTarget,
-		foregroundControl,
-		intercomEvents,
-		chainSkills: chainSkillsParam,
-		chainDir: chainDirBase,
-	} = params;
-	const chainSkills = chainSkillsParam ?? [];
-	const state: ChainExecutionMutableState = {
-		results: [],
-		outputs: {},
-		dynamicChildren: {},
-		dynamicGroupStatuses: {},
-		allProgress: [],
-		allArtifactPaths: [],
-		prev: "",
-		globalTaskIndex: 0,
-		progressCreated: false,
-	};
-	const chainAgents = chainSteps.map((step) =>
-		isParallelStep(step)
-			? `[${step.parallel.map((task) => task.agent).join("+")}]`
-			: isDynamicParallelStep(step)
-				? `expand:${step.parallel.agent}`
-				: (step as SequentialStep).agent,
-	);
-	const totalSteps = chainSteps.length;
-	const makeDetailsInput = (
-		overrides: Pick<Partial<ChainExecutionDetailsInput>, "currentStepIndex" | "currentFlatIndex"> = {},
-	): ChainExecutionDetailsInput => ({
-		results: state.results,
-		...(includeProgress !== undefined ? { includeProgress } : {}),
-		allProgress: state.allProgress,
-		allArtifactPaths: state.allArtifactPaths,
-		artifactsDir,
-		chainAgents,
-		chainSteps,
-		totalSteps,
-		runId,
-		outputs: state.outputs,
-		dynamicChildren: state.dynamicChildren,
-		dynamicGroupStatuses: state.dynamicGroupStatuses,
-		...overrides,
-	});
-
-	const firstStep = chainSteps[0]!;
-	const originalTask =
-		params.task ??
-		(isParallelStep(firstStep)
-			? firstStep.parallel[0]!.task!
-			: isDynamicParallelStep(firstStep)
-				? firstStep.parallel.task!
-				: (firstStep as SequentialStep).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 templates: ResolvedTemplates = resolveChainTemplates(chainSteps);
-	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
-	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
-	const context: ChainRuntimeContext = {
-		params,
-		agents,
-		ctx,
-		intercomEvents,
-		signal,
-		runId,
-		cwd,
-		shareEnabled,
-		sessionDirForIndex,
-		sessionFileForIndex,
-		artifactsDir,
-		artifactConfig,
-		includeProgress,
-		onUpdate,
-		onControlEvent,
-		controlConfig,
-		childIntercomTarget,
-		orchestratorIntercomTarget,
-		foregroundControl,
-		chainSkills,
-		chainDir,
-		availableModels,
-		knownModelProviders,
-		originalTask,
-		chainAgents,
-		chainSteps,
-		totalSteps,
-		executeRunSync,
-		makeDetailsInput,
-		onDetachedExit: params.onDetachedExit,
-	};
-
-	for (let stepIndex = 0; stepIndex < chainSteps.length; stepIndex++) {
-		const step = chainSteps[stepIndex]!;
-		const stepTemplates = templates[stepIndex]!;
-		let earlyResult: ChainExecutionResult | undefined;
-		if (isParallelStep(step)) {
-			earlyResult = await runStaticParallelChainStep({
-				context,
-				state,
-				step,
-				stepIndex,
-				parallelTemplates: stepTemplates as string[],
-			});
-		} else if (isDynamicParallelStep(step)) {
-			earlyResult = await runDynamicParallelChainStep({ context, state, step, stepIndex });
-		} else {
-			earlyResult = await runSequentialChainStep({
-				context,
-				state,
-				seqStep: step as SequentialStep,
-				stepIndex,
-				stepTemplate: stepTemplates as string,
-			});
-		}
-		if (earlyResult) return earlyResult;
-	}
-
-	const summary = buildChainSummary(chainSteps, state.results, chainDir, "completed");
-	return {
-		content: [{ type: "text", text: summary }],
-		details: buildChainExecutionDetails(makeDetailsInput()),
-	};
-}

package/dist/builtin/subagents/src/runs/foreground/execution-structured-retries.ts

@@ -1,19 +0,0 @@
-import type { AgentConfig } from "../../agents/agent-types.ts";
-import type { RunSyncOptions, SingleResult } from "../../shared/types.ts";
-import { runSingleInProcess } from "./inprocess-run-sync.ts";
-
-/**
- * Kept as the local foreground seam while callers migrate to the in-process door.
- * Structured output correction is handled by the SDK custom-tool policy in the
- * new runner; no process retry or stdout parser remains here.
- */
-export function runSingleAttemptWithStructuredOutputRetries(
-	runtimeCwd: string,
-	agent: AgentConfig,
-	task: string,
-	_model: string | undefined,
-	options: RunSyncOptions,
-	_shared: object,
-): Promise<SingleResult> {
-	return runSingleInProcess(runtimeCwd, agent, task, options);
-}