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

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);
-}

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-async.ts

@@ -1,190 +0,0 @@
-import { APP_NAME } from "@bastani/atomic";
-import { normalizeSkillInput } from "../../agents/skills.ts";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import { collectKnownModelProviders, toModelInfo } from "../../shared/model-info.ts";
-import type { ChainStep } from "../../shared/settings.ts";
-import type { SingleResult, SubagentToolResult } from "../../shared/types.ts";
-import {
-	resolveChildMaxSubagentDepth,
-	resolveSubagentDepthPolicy,
-	resolveTopLevelParallelMaxTasks,
-	workflowSessionMetadataFromContext,
-	wrapForkTask,
-} from "../../shared/types.ts";
-import { formatAsyncStartedMessage } from "../inprocess/background.ts";
-import { runChainPath } from "./subagent-executor-chain.ts";
-import { runParallelPath } from "./subagent-executor-parallel.ts";
-import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
-import {
-	buildChainWorktreeTaskCwdError,
-	buildParallelModeError,
-	buildParallelWorktreeTaskCwdError,
-} from "./subagent-executor-worktree.ts";
-
-function continuedResult(data: ExecutionContextData, mode: "single" | "parallel" | "chain"): SingleResult {
-	const path = `${data.runId}/orchestration_1`;
-	return {
-		agent: mode,
-		task: data.params.task ?? `${mode} subagent run`,
-		status: "continued",
-		path,
-		envelope: "Child continued in background.",
-		detached: true,
-		detachedReason: "async-requested",
-		messages: [],
-		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-		progress: {
-			index: 0,
-			agent: mode,
-			status: "running",
-			task: data.params.task ?? `${mode} subagent run`,
-			recentTools: [],
-			recentOutput: [],
-			toolCount: 0,
-			turnCount: 0,
-			tokens: 0,
-			durationMs: 0,
-			lastActivityAt: Date.now(),
-		},
-	};
-}
-
-function modeFor(data: ExecutionContextData): "single" | "parallel" | "chain" {
-	if ((data.params.chain?.length ?? 0) > 0) return "chain";
-	if ((data.params.tasks?.length ?? 0) > 0) return "parallel";
-	return "single";
-}
-
-function runForegroundInBackground(
-	data: ExecutionContextData,
-	deps: ResolvedExecutorDeps,
-	mode: "parallel" | "chain",
-): void {
-	const backgroundData: ExecutionContextData = { ...data, effectiveAsync: false };
-	const work = mode === "chain" ? runChainPath(backgroundData, deps) : runParallelPath(backgroundData, deps);
-	void work.catch((error) => {
-		const message = error instanceof Error ? error.message : String(error);
-		console.error(`[${APP_NAME}-subagents] in-process async ${mode} failed: ${message}`);
-	});
-}
-
-/**
- * Async is a don't-wait request over the same in-process foreground executor.
- *
- * Single runs retain the focused background-single helper because it owns the
- * child admission and terminal artifact delivery. Chain and parallel runs use
- * the existing foreground executors un-awaited; their child sessions are
- * admitted by runSync as the executor advances, so chain substitution,
- * dynamic fanout, worktrees, structured output, and fail-fast remain one code
- * path rather than a second serialized runner.
- */
-export async function runAsyncPath(
-	data: ExecutionContextData,
-	deps: ResolvedExecutorDeps,
-): Promise<SubagentToolResult | null> {
-	if (!data.effectiveAsync) return null;
-
-	const mode = modeFor(data);
-	const { params, effectiveCwd } = data;
-	if (mode === "chain" && params.chain) {
-		const chainWorktreeTaskCwdError = buildChainWorktreeTaskCwdError(params.chain as ChainStep[], effectiveCwd);
-		if (chainWorktreeTaskCwdError) {
-			return {
-				content: [{ type: "text", text: chainWorktreeTaskCwdError }],
-				isError: true,
-				details: { mode: "chain", results: [] },
-			};
-		}
-	}
-	if (mode === "parallel" && params.tasks) {
-		const maxParallelTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks);
-		if (params.tasks.length > maxParallelTasks) return buildParallelModeError(`Max ${maxParallelTasks} tasks`);
-		if (params.worktree) {
-			const worktreeTaskCwdError = buildParallelWorktreeTaskCwdError(params.tasks, effectiveCwd);
-			if (worktreeTaskCwdError) return buildParallelModeError(worktreeTaskCwdError);
-		}
-	}
-	if (!deps.runtime.isAsyncAvailable()) {
-		return {
-			content: [
-				{
-					type: "text",
-					text: `Async mode requires the in-process runner but it could not be initialized. Ensure the ${APP_NAME}-subagents package is installed.`,
-				},
-			],
-			isError: true,
-			details: { mode, results: [] },
-		};
-	}
-
-	if (mode === "single") {
-		const agent = data.agents.find((candidate) => candidate.name === params.agent);
-		if (!agent) {
-			return {
-				content: [{ type: "text", text: `Unknown agent: ${params.agent}` }],
-				isError: true,
-				details: { mode: "single", results: [] },
-			};
-		}
-		const availableModels = data.ctx.modelRegistry.getAvailable().map(toModelInfo);
-		const knownModelProviders = collectKnownModelProviders(data.ctx.modelRegistry);
-		const depthPolicy = resolveSubagentDepthPolicy(data.ctx, deps.config.maxSubagentDepth);
-		const normalizedSkills = normalizeSkillInput(params.skill);
-		const skills = normalizedSkills === false ? [] : normalizedSkills;
-		const task = params.context === "fork" ? wrapForkTask(params.task ?? "") : (params.task ?? "");
-		const childIntercomTarget = data.intercomBridge.active
-			? (childAgent: string, index: number) => resolveSubagentIntercomTarget(data.runId, childAgent, index)
-			: undefined;
-		const currentModel = data.ctx.model ? `${data.ctx.model.provider}/${data.ctx.model.id}` : undefined;
-		const modelOverride = params.model ?? agent.model;
-		return deps.runtime.executeAsyncSingle(data.runId, {
-			agent: params.agent!,
-			task,
-			group: params.group,
-			agentConfig: agent,
-			ctx: {
-				pi: deps.pi,
-				cwd: data.ctx.cwd,
-				currentSessionId: deps.state.currentSessionId ?? data.ctx.sessionManager.getSessionId(),
-				currentModelProvider: data.ctx.model?.provider,
-				currentModel,
-				intercomGroup: data.ctx.orchestrationContext?.intercomGroup,
-				workflowSessionMetadata: workflowSessionMetadataFromContext(data.ctx),
-			},
-			cwd: effectiveCwd,
-			maxOutput: params.maxOutput,
-			artifactsDir: data.artifactConfig.enabled ? data.artifactsDir : undefined,
-			artifactConfig: data.artifactConfig,
-			shareEnabled: data.shareEnabled,
-			sessionRoot: data.sessionRoot,
-			sessionFile: data.sessionFileForIndex(0),
-			skills,
-			output: params.output,
-			outputMode: params.outputMode,
-			progress: params.progress,
-			modelOverride,
-			availableModels,
-			knownModelProviders,
-			maxSubagentDepth: resolveChildMaxSubagentDepth(depthPolicy.maxSubagentDepth, agent.maxSubagentDepth),
-			workflowStageSubagentGuard: depthPolicy.workflowStageSubagentGuard,
-			worktreeSetupHook: deps.config.worktreeSetupHook,
-			worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
-			controlConfig: data.controlConfig,
-			controlIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-			childIntercomTarget,
-			nestedRoute: data.nestedRoute,
-		});
-	}
-
-	const continued = continuedResult(data, mode);
-	if (mode === "chain" || mode === "parallel") runForegroundInBackground(data, deps, mode);
-	return {
-		content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${mode}: ${data.runId}`) }],
-		details: {
-			mode,
-			runId: data.runId,
-			asyncId: data.runId,
-			results: [continued],
-		},
-	};
-}

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

@@ -1,109 +0,0 @@
-import { normalizeSkillInput } from "../../agents/skills.ts";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import type { ChainStep } from "../../shared/settings.ts";
-import { resolveSubagentDepthPolicy } from "../../shared/types.ts";
-import { compactForegroundDetails } from "../../shared/utils.ts";
-import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.ts";
-import { executeChain } from "./chain-execution.ts";
-import { wrapChainTasksForFork } from "./subagent-executor-input.ts";
-import {
-	createForegroundControlNotifier,
-	maybeBuildForegroundIntercomReceipt,
-	notifyDetachedForegroundChildExit,
-	rememberForegroundRun,
-	replaceForegroundRunChild,
-} from "./subagent-executor-status.ts";
-import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
-
-export async function runChainPath(
-	data: ExecutionContextData,
-	deps: ResolvedExecutorDeps,
-): Promise<import("../../shared/types.ts").SubagentToolResult> {
-	const {
-		params,
-		effectiveCwd,
-		agents,
-		ctx,
-		signal,
-		runId,
-		shareEnabled,
-		sessionDirForIndex,
-		sessionFileForIndex,
-		artifactsDir,
-		artifactConfig,
-		onUpdate,
-		controlConfig,
-	} = data;
-	const onControlEvent = createForegroundControlNotifier(data, deps);
-	const childIntercomTarget = data.intercomBridge.active ? resolveSubagentIntercomTarget : undefined;
-	const foregroundControl = deps.state.foregroundControls.get(runId);
-	const normalized = normalizeSkillInput(params.skill);
-	const chainSkills = normalized === false ? [] : (normalized ?? []);
-	const chain = wrapChainTasksForFork(params.chain as ChainStep[], params.context);
-	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
-	const currentMaxSubagentDepth = depthPolicy.maxSubagentDepth;
-	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
-	const chainResult = await executeChain({
-		chain,
-		task: params.task,
-		group: params.group,
-		agents,
-		ctx,
-		intercomEvents: deps.pi.events,
-		signal,
-		runId,
-		cwd: effectiveCwd,
-		shareEnabled,
-		sessionDirForIndex,
-		sessionFileForIndex,
-		artifactsDir,
-		artifactConfig,
-		includeProgress: params.includeProgress,
-		onUpdate,
-		onControlEvent,
-		controlConfig,
-		childIntercomTarget: childIntercomTarget ? (agent, index) => childIntercomTarget(runId, agent, index) : undefined,
-		orchestratorIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-		foregroundControl,
-		nestedRoute: foregroundControl?.nestedRoute,
-		chainSkills,
-		chainDir: params.chainDir,
-		dynamicFanoutMaxItems: deps.config.chain?.dynamicFanout?.maxItems,
-		maxSubagentDepth: currentMaxSubagentDepth,
-		workflowStageSubagentGuard,
-		worktreeSetupHook: deps.config.worktreeSetupHook,
-		worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
-		runSync: deps.runtime.runSync,
-		onDetachedExit: (index, result) => {
-			replaceForegroundRunChild(deps.state, runId, index, result);
-			notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "chain", index, result });
-		},
-	});
-
-	const chainDetails = chainResult.details ? compactForegroundDetails({ ...chainResult.details, runId }) : undefined;
-	if (foregroundControl) updateForegroundNestedProjection(foregroundControl);
-	if (chainDetails)
-		rememberForegroundRun(deps.state, { runId, mode: "chain", cwd: effectiveCwd, results: chainDetails.results });
-	const intercomReceipt =
-		chainDetails && !chainDetails.results.some((result) => result.interrupted || result.detached)
-			? await maybeBuildForegroundIntercomReceipt({
-					pi: deps.pi,
-					intercomBridge: data.intercomBridge,
-					runId,
-					mode: "chain",
-					details: chainDetails,
-					...(foregroundControl?.nestedChildren?.length
-						? { nestedChildren: foregroundControl.nestedChildren }
-						: {}),
-				})
-			: null;
-	if (intercomReceipt) {
-		return {
-			...chainResult,
-			content: [{ type: "text", text: intercomReceipt.text }],
-			details: intercomReceipt.details,
-		};
-	}
-
-	return chainDetails ? { ...chainResult, details: chainDetails } : chainResult;
-}