@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

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

@@ -1,327 +0,0 @@
-import type { AgentConfig } from "../../agents/agents.js";
-import { normalizeSkillInput } from "../../agents/skills.js";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.js";
-import { createCandidateModelResolver } from "../../shared/model-resolution.js";
-import {
-	resolveStepBehavior,
-	type StepOverrides,
-	suppressProgressForReadOnlyTask,
-	writeInitialProgressFile,
-} from "../../shared/settings.js";
-import {
-	type AgentProgress,
-	type ArtifactPaths,
-	type ForegroundParentAskHandoff,
-	isWorkflowStageOrchestrationContext,
-	resolveTopLevelParallelConcurrency,
-	resolveTopLevelParallelMaxTasks,
-	type SingleResult,
-	type SubagentToolResult,
-	wrapForkTask,
-} from "../../shared/types.js";
-import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.js";
-import { sharedAutoGroupForSet } from "../shared/intercom-group.js";
-import { resolveModelCandidate } from "../shared/model-fallback.js";
-import { formatParallelResultContent } from "../shared/parallel-utils.js";
-import { recordRun } from "../shared/run-history.js";
-import { resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
-import { cleanupWorktrees, type WorktreeSetup } from "../shared/worktree.js";
-import { createDetachedCleanupBarrier } from "./detached-cleanup-barrier.js";
-import { formatParentAskHandoffOutput } from "./parent-ask-output.js";
-import { runForegroundParallelTasks } from "./subagent-executor-parallel-task.js";
-import { markParentAskHandoff } from "./subagent-executor-parent-ask-projection.js";
-import {
-	createForegroundControlNotifier,
-	maybeBuildForegroundIntercomReceipt,
-	notifyDetachedForegroundChildExit,
-} from "./subagent-executor-status.js";
-import type { ExecutionContextData, ResolvedExecutorDeps, TaskParam } from "./subagent-executor-types.js";
-import {
-	buildParallelModeError,
-	buildParallelWorktreeSuffix,
-	buildParallelWorktreeTaskCwdError,
-	createParallelWorktreeSetup,
-	findDuplicateParallelOutputPath,
-	resolveParallelTaskCwd,
-} from "./subagent-executor-worktree.js";
-
-export async function runParallelPath(
-	data: ExecutionContextData,
-	deps: ResolvedExecutorDeps,
-): Promise<SubagentToolResult> {
-	const {
-		params,
-		effectiveCwd,
-		agents,
-		ctx,
-		signal,
-		runId,
-		sessionDirForIndex,
-		sessionFileForIndex,
-		shareEnabled,
-		artifactConfig,
-		artifactsDir,
-		onUpdate,
-		controlConfig,
-	} = data;
-	const onControlEvent = createForegroundControlNotifier(data, deps);
-	const childIntercomTarget = data.intercomBridge.active ? resolveSubagentIntercomTarget : undefined;
-	const allProgress: AgentProgress[] = [];
-	const allArtifactPaths: ArtifactPaths[] = [];
-	const tasks = params.tasks!;
-	const maxParallelTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks);
-	const parallelConcurrency = resolveTopLevelParallelConcurrency(
-		params.concurrency,
-		deps.config.parallel?.concurrency,
-	);
-
-	if (tasks.length > maxParallelTasks)
-		return {
-			content: [{ type: "text", text: `Max ${maxParallelTasks} tasks` }],
-			isError: true,
-			details: { mode: "parallel" as const, results: [] },
-		};
-
-	const agentConfigs: AgentConfig[] = data.parallelAgentConfigs ? [...data.parallelAgentConfigs] : [];
-	if (!data.parallelAgentConfigs) {
-		for (const task of tasks) {
-			const config = agents.find((agent) => agent.name === task.agent);
-			if (!config) {
-				return {
-					content: [{ type: "text", text: `Unknown agent: ${task.agent}` }],
-					isError: true,
-					details: { mode: "parallel" as const, results: [] },
-				};
-			}
-			agentConfigs.push(config);
-		}
-	}
-
-	const workflowStageSubagentGuard = isWorkflowStageOrchestrationContext(ctx);
-
-	if (params.worktree) {
-		const worktreeTaskCwdError = buildParallelWorktreeTaskCwdError(tasks, effectiveCwd);
-		if (worktreeTaskCwdError) return buildParallelModeError(worktreeTaskCwdError);
-	}
-
-	const currentProvider = ctx.model?.provider;
-	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
-	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
-	const taskTexts = tasks.map((t) => t.task);
-	const skillOverrides: (string[] | false | undefined)[] = tasks.map((t) => normalizeSkillInput(t.skill));
-	const behaviorOverrides: StepOverrides[] = tasks.map((task, index) => ({
-		...(task.output !== undefined
-			? { output: task.output === true ? (agentConfigs[index]?.output ?? false) : task.output }
-			: {}),
-		...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
-		...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
-		...(task.progress !== undefined ? { progress: task.progress } : {}),
-		...(skillOverrides[index] !== undefined ? { skills: skillOverrides[index] } : {}),
-		...(task.model ? { model: task.model } : {}),
-	}));
-	const modelOverrides: (string | undefined)[] = tasks.map((_, i) =>
-		resolveModelCandidate(behaviorOverrides[i]?.model ?? agentConfigs[i]?.model, availableModels, currentProvider),
-	);
-
-	const behaviors = agentConfigs.map((config, index) =>
-		suppressProgressForReadOnlyTask(resolveStepBehavior(config, behaviorOverrides[index]!), taskTexts[index]),
-	);
-	const firstProgressIndex = behaviors.findIndex((behavior) => behavior.progress);
-	const liveResults: (SingleResult | undefined)[] = new Array(tasks.length).fill(undefined);
-	const liveProgress: (AgentProgress | undefined)[] = new Array(tasks.length).fill(undefined);
-	const foregroundControl = deps.state.foregroundControls.get(runId);
-	const { setup: worktreeSetup, errorResult } = createParallelWorktreeSetup(
-		params.worktree,
-		effectiveCwd,
-		runId,
-		tasks,
-		deps.config.worktreeSetupHook,
-		deps.config.worktreeSetupHookTimeoutMs,
-	);
-	let worktreeCleanupDeferred = false;
-	const detachedCleanup = createDetachedCleanupBarrier(() => {
-		if (!worktreeSetup) return;
-		buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks as TaskParam[]);
-		cleanupWorktrees(worktreeSetup);
-	});
-	if (errorResult) return errorResult;
-	let parentAsk: ForegroundParentAskHandoff | undefined;
-
-	try {
-		const duplicateOutputError = findDuplicateParallelOutputPath({
-			tasks,
-			behaviors,
-			paramsCwd: effectiveCwd,
-			ctxCwd: ctx.cwd,
-			worktreeSetup,
-		});
-		if (duplicateOutputError) return buildParallelModeError(duplicateOutputError);
-		for (let index = 0; index < tasks.length; index++) {
-			const taskCwd = resolveParallelTaskCwd(tasks[index]!, effectiveCwd, worktreeSetup, index);
-			const outputPath = resolveSingleOutputPath(behaviors[index]?.output, ctx.cwd, taskCwd);
-			const validationError = validateFileOnlyOutputMode(
-				behaviors[index]?.outputMode,
-				outputPath,
-				`Parallel task ${index + 1} (${tasks[index]!.agent})`,
-			);
-			if (validationError) return buildParallelModeError(validationError);
-		}
-
-		const parallelProgressPrecreated = firstProgressIndex !== -1;
-		if (parallelProgressPrecreated) writeInitialProgressFile(effectiveCwd);
-
-		if (params.context === "fork") {
-			for (let i = 0; i < taskTexts.length; i++) {
-				taskTexts[i] = wrapForkTask(taskTexts[i]!);
-			}
-		}
-
-		const results = await runForegroundParallelTasks({
-			onDetachedExit: (index, result) => {
-				try {
-					notifyDetachedForegroundChildExit({
-						pi: deps.pi,
-						runId,
-						mode: "parallel",
-						index,
-						totalTasks: tasks.length,
-						result,
-					});
-				} finally {
-					detachedCleanup.recover(index);
-				}
-			},
-			onParentAskHandoff: (handoff) => {
-				if (!parentAsk) parentAsk = handoff;
-			},
-			tasks,
-			taskTexts,
-			agents,
-			...(data.parallelAgentConfigs ? { agentConfigs } : {}),
-			ctx,
-			intercomEvents: deps.pi.events,
-			signal,
-			runId,
-			sessionDirForIndex,
-			sessionFileForIndex,
-			shareEnabled,
-			artifactConfig,
-			artifactsDir,
-			maxOutput: params.maxOutput,
-			paramsCwd: effectiveCwd,
-			workflowStageSubagentGuard,
-			availableModels,
-			knownModelProviders,
-			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, currentProvider),
-			modelOverrides,
-			behaviors,
-			firstProgressIndex: parallelProgressPrecreated ? -1 : firstProgressIndex,
-			controlConfig,
-			onControlEvent,
-			childIntercomTarget: childIntercomTarget
-				? (agent, index) => childIntercomTarget(runId, agent, index)
-				: undefined,
-			orchestratorIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-			setIntercomGroup: params.group,
-			sharedAutoIntercomGroup: sharedAutoGroupForSet(params.group, tasks),
-			foregroundControl,
-			concurrencyLimit: parallelConcurrency,
-			parentDepth: data.parentDepth,
-			liveResults,
-			liveProgress,
-			onUpdate,
-			worktreeSetup: worktreeSetup as WorktreeSetup | undefined,
-			runtime: deps.runtime,
-		});
-		for (let i = 0; i < results.length; i++) {
-			const run = results[i]!;
-			recordRun(run.agent, taskTexts[i]!, run.status, run.progressSummary?.durationMs ?? 0);
-		}
-
-		for (const result of results) {
-			if (result.progress) allProgress.push(result.progress);
-			if (result.artifactPaths) allArtifactPaths.push(result.artifactPaths);
-		}
-
-		const interrupted = results.find((result) => result.interrupted);
-		const details = compactForegroundDetails({
-			mode: "parallel",
-			runId,
-			results,
-			parentAskYielded: parentAsk !== undefined,
-			progress: params.includeProgress ? allProgress : undefined,
-			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
-		});
-		if (parentAsk) {
-			const worktreeSuffix = buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks as TaskParam[]);
-			const handoffText = formatParentAskHandoffOutput(parentAsk);
-			const yieldedResult: SubagentToolResult = {
-				content: [{ type: "text", text: worktreeSuffix ? `${handoffText}\n\n${worktreeSuffix}` : handoffText }],
-				details,
-			};
-			markParentAskHandoff(yieldedResult, parentAsk);
-			return yieldedResult;
-		}
-		if (interrupted) {
-			return {
-				content: [
-					{
-						type: "text",
-						text: `Parallel run ended after interrupt (${interrupted.agent}). Launch fresh subagents for any follow-up.`,
-					},
-				],
-				details,
-			};
-		}
-		const detachedIndex = results.findIndex((result) => result.detached);
-		const detached = detachedIndex >= 0 ? results[detachedIndex] : undefined;
-		worktreeCleanupDeferred = detachedCleanup.defer(
-			results.flatMap((result, index) => (result.detached ? [index] : [])),
-		);
-		if (detached) {
-			return {
-				content: [
-					{
-						type: "text",
-						text: `Parallel run detached for intercom coordination (${detached.agent}). Reply to the supervisor request first. After the child exits, launch fresh follow-up work if needed.`,
-					},
-				],
-				details,
-			};
-		}
-
-		const intercomReceipt = await maybeBuildForegroundIntercomReceipt({
-			pi: deps.pi,
-			intercomBridge: data.intercomBridge,
-			runId,
-			mode: "parallel",
-			details,
-		});
-		if (intercomReceipt) {
-			return {
-				content: [{ type: "text", text: intercomReceipt.text }],
-				details: intercomReceipt.details,
-			};
-		}
-
-		const worktreeSuffix = buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks as TaskParam[]);
-		const childContent = formatParallelResultContent(
-			results.map((result) => ({
-				agent: result.agent,
-				output: result.truncation?.text || getSingleResultOutput(result),
-				status: result.status,
-				error: result.error,
-			})),
-			(i, agent) => `=== Task ${i + 1}: ${agent} ===`,
-		);
-		const fullContent = worktreeSuffix ? `${childContent}\n\n${worktreeSuffix}` : childContent;
-
-		return {
-			content: [{ type: "text", text: fullContent }],
-			details,
-		};
-	} finally {
-		if (worktreeSetup && !worktreeCleanupDeferred) cleanupWorktrees(worktreeSetup);
-	}
-}

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-parent-ask-projection.ts

@@ -1,11 +0,0 @@
-import type { ForegroundParentAskHandoff, SubagentToolResult } from "../../shared/types.js";
-
-const parentAskHandoffs = new WeakMap<SubagentToolResult, ForegroundParentAskHandoff>();
-
-export function markParentAskHandoff(result: SubagentToolResult, handoff: ForegroundParentAskHandoff): void {
-	parentAskHandoffs.set(result, handoff);
-}
-
-export function getParentAskHandoff(result: SubagentToolResult): ForegroundParentAskHandoff | undefined {
-	return parentAskHandoffs.get(result);
-}

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

@@ -1,12 +0,0 @@
-import { runSync } from "./execution.js";
-import type { SubagentExecutorRuntimeDeps } from "./subagent-executor-types.js";
-
-const defaultSubagentExecutorRuntimeDeps: SubagentExecutorRuntimeDeps = {
-	runSync,
-};
-
-export function resolveSubagentExecutorRuntimeDeps(
-	overrides?: Partial<SubagentExecutorRuntimeDeps>,
-): SubagentExecutorRuntimeDeps {
-	return { ...defaultSubagentExecutorRuntimeDeps, ...overrides };
-}

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

@@ -1,350 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { normalizeSkillInput } from "../../agents/skills.js";
-import { INTERCOM_BRIDGE_MARKER, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.js";
-import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.js";
-import { createCandidateModelResolver } from "../../shared/model-resolution.js";
-import {
-	injectSingleProgressInstruction,
-	resolveSingleProgress,
-	writeInitialProgressFile,
-} from "../../shared/settings.js";
-import {
-	type AgentProgress,
-	type ArtifactPaths,
-	isWorkflowStageOrchestrationContext,
-	type ParentAskHandoffRequest,
-	type RunSyncOptions,
-	type SingleResult,
-	type SubagentToolResult,
-	workflowSessionMetadataFromContext,
-	wrapForkTask,
-} from "../../shared/types.js";
-import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.js";
-import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.js";
-import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.js";
-import { recordRun } from "../shared/run-history.js";
-import {
-	finalizeSingleOutput,
-	injectSingleOutputInstruction,
-	normalizeSingleOutputOverride,
-	resolveSingleOutputPath,
-	validateFileOnlyOutputMode,
-} from "../shared/single-output.js";
-import { formatParentAskHandoffOutput } from "./parent-ask-output.js";
-import {
-	createForegroundControlNotifier,
-	maybeBuildForegroundIntercomReceipt,
-	notifyDetachedForegroundChildExit,
-} from "./subagent-executor-status.js";
-import type { ExecutionContextData, ForegroundControl, ResolvedExecutorDeps } from "./subagent-executor-types.js";
-
-function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
-	const error = result.error || "Failed";
-	const output = displayOutput.trim();
-	const lines = [error];
-	if (output && output !== error.trim()) {
-		lines.push("", "Output:", output);
-	}
-	if (result.artifactPaths?.outputPath) {
-		lines.push("", `Output artifact: ${result.artifactPaths.outputPath}`);
-	}
-	return lines.join("\n");
-}
-
-function cleanupTransientProgress(progressDir: string | undefined, artifactsEnabled: boolean): void {
-	if (!progressDir || artifactsEnabled) return;
-	try {
-		fs.rmSync(progressDir, { recursive: true, force: true });
-	} catch {
-		// Scratch cleanup must never replace the child run's result or original error.
-	}
-}
-
-export function createForwardSingleUpdate(
-	onUpdate: ((r: SubagentToolResult) => void) | undefined,
-	foregroundControl: ForegroundControl | undefined,
-	agent: string,
-	index: number,
-): ((r: SubagentToolResult) => void) | undefined {
-	if (!onUpdate) return undefined;
-	return (update: SubagentToolResult) => {
-		if (foregroundControl) {
-			const firstProgress = update.details?.progress?.[0];
-			foregroundControl.currentAgent = agent;
-			foregroundControl.currentIndex = firstProgress?.index ?? index;
-			foregroundControl.currentActivityState = firstProgress?.activityState;
-			foregroundControl.lastActivityAt = firstProgress?.lastActivityAt;
-			foregroundControl.currentTool = firstProgress?.currentTool;
-			foregroundControl.currentToolStartedAt = firstProgress?.currentToolStartedAt;
-			foregroundControl.currentPath = firstProgress?.currentPath;
-			foregroundControl.turnCount = firstProgress?.turnCount;
-			foregroundControl.tokens = firstProgress?.tokens;
-			foregroundControl.toolCount = firstProgress?.toolCount;
-			foregroundControl.updatedAt = Date.now();
-		}
-		onUpdate(update);
-	};
-}
-
-export async function runSinglePath(
-	data: ExecutionContextData,
-	deps: ResolvedExecutorDeps,
-): Promise<SubagentToolResult> {
-	const {
-		params,
-		effectiveCwd,
-		agents,
-		ctx,
-		signal,
-		runId,
-		sessionDirForIndex,
-		sessionFileForIndex,
-		shareEnabled,
-		artifactConfig,
-		artifactsDir,
-		onUpdate,
-		controlConfig,
-	} = data;
-	const onControlEvent = createForegroundControlNotifier(data, deps);
-	const childIntercomTarget = data.intercomBridge.active
-		? resolveSubagentIntercomTarget(runId, params.agent!, 0)
-		: undefined;
-	const allProgress: AgentProgress[] = [];
-	const allArtifactPaths: ArtifactPaths[] = [];
-	const agentConfig = agents.find((a) => a.name === params.agent);
-	if (!agentConfig) {
-		return {
-			content: [{ type: "text", text: `Unknown agent: ${params.agent}` }],
-			isError: true,
-			details: { mode: "single", results: [] },
-		};
-	}
-
-	const currentProvider = ctx.model?.provider;
-	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
-	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
-	const handoffTaskContext = params.task ?? "";
-	let task = handoffTaskContext;
-	const modelOverride: string | undefined = resolveModelCandidate(
-		(params.model as string | undefined) ?? agentConfig.model,
-		availableModels,
-		currentProvider,
-	);
-	const skillOverride: string[] | false | undefined = normalizeSkillInput(params.skill);
-	const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
-	const effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
-	const effectiveOutputMode = params.outputMode ?? "inline";
-	const workflowStageSubagentGuard = isWorkflowStageOrchestrationContext(ctx);
-	const progress = resolveSingleProgress(agentConfig, params.progress, task);
-
-	if (params.context === "fork") {
-		task = wrapForkTask(task);
-	}
-	const cleanTask = task;
-	const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, effectiveCwd);
-	const validationError = validateFileOnlyOutputMode(effectiveOutputMode, outputPath, `Single run (${params.agent})`);
-	if (validationError) {
-		return {
-			content: [{ type: "text", text: validationError }],
-			isError: true,
-			details: { mode: "single", results: [] },
-		};
-	}
-	// Single-agent progress is isolated by run so the injected contract cannot
-	// overwrite a project's own progress.md or collide with another child.
-	const progressDir = progress ? path.join(artifactsDir, "progress", runId) : undefined;
-	if (progressDir) {
-		writeInitialProgressFile(progressDir);
-		task = injectSingleProgressInstruction(task, progressDir);
-	}
-	task = injectSingleOutputInstruction(task, outputPath);
-
-	let effectiveSkills: string[] | undefined;
-	if (skillOverride === false) {
-		effectiveSkills = [];
-	} else {
-		effectiveSkills = skillOverride;
-	}
-	const interruptController = new AbortController();
-	let parentAsk: ParentAskHandoffRequest | undefined;
-	const foregroundControl = deps.state.foregroundControls.get(runId);
-	if (foregroundControl) {
-		foregroundControl.currentAgent = params.agent;
-		foregroundControl.currentIndex = 0;
-		foregroundControl.currentActivityState = undefined;
-		foregroundControl.updatedAt = Date.now();
-		foregroundControl.interrupt = () => {
-			if (interruptController.signal.aborted) return false;
-			interruptController.abort();
-			foregroundControl.currentActivityState = undefined;
-			foregroundControl.updatedAt = Date.now();
-			return true;
-		};
-	}
-
-	const forwardSingleUpdate = createForwardSingleUpdate(onUpdate, foregroundControl, params.agent!, 0);
-
-	let r: SingleResult;
-	try {
-		const supervisorAuthorization = await requestSupervisorAuthorization(deps.pi.events, childIntercomTarget);
-		const runOptions: RunSyncOptions = {
-			cwd: effectiveCwd,
-			signal,
-			interruptSignal: interruptController.signal,
-			allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
-			intercomEvents: deps.pi.events,
-			runId,
-			sessionDir: sessionDirForIndex(0),
-			sessionFile: sessionFileForIndex(0),
-			share: shareEnabled,
-			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-			artifactConfig,
-			maxOutput: params.maxOutput,
-			outputPath,
-			outputMode: effectiveOutputMode,
-			parentDepth: data.parentDepth,
-			workflowStageSubagentGuard,
-			workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
-			onUpdate: forwardSingleUpdate,
-			controlConfig,
-			onControlEvent,
-			intercomSessionName: childIntercomTarget,
-			supervisorAuthorization,
-			orchestratorIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-			intercomGroup: resolveChildIntercomGroup(params.group, inheritedIntercomGroup(ctx), undefined),
-			onParentAskHandoff: (request) => {
-				if (parentAsk) return;
-				request.taskContext = handoffTaskContext;
-				parentAsk = request;
-				interruptController.abort();
-			},
-			onDetachedExit: (result) => {
-				cleanupTransientProgress(progressDir, artifactConfig.enabled);
-				if (result) notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "single", index: 0, result });
-			},
-			index: 0,
-			modelOverride,
-			availableModels,
-			knownModelProviders,
-			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, currentProvider),
-			preferredModelProvider: currentProvider,
-			currentModel: currentModelFullId(ctx.model),
-			currentThinkingLevel: ctx.thinkingLevel,
-			skills: effectiveSkills,
-		};
-		r = await deps.runtime.runSync(ctx.cwd, agents, params.agent!, task, runOptions);
-	} catch (error) {
-		cleanupTransientProgress(progressDir, artifactConfig.enabled);
-		throw error;
-	}
-	// Detached children still own this storage until their process closes.
-	if (!r.detached) cleanupTransientProgress(progressDir, artifactConfig.enabled);
-	if (foregroundControl?.currentIndex === 0) {
-		foregroundControl.interrupt = undefined;
-		foregroundControl.currentActivityState = r.progress?.activityState;
-		foregroundControl.lastActivityAt = r.progress?.lastActivityAt;
-		foregroundControl.currentTool = r.progress?.currentTool;
-		foregroundControl.currentToolStartedAt = r.progress?.currentToolStartedAt;
-		foregroundControl.currentPath = r.progress?.currentPath;
-		foregroundControl.turnCount = r.progress?.turnCount;
-		foregroundControl.tokens = r.progress?.tokens;
-		foregroundControl.toolCount = r.progress?.toolCount;
-		foregroundControl.updatedAt = Date.now();
-	}
-	recordRun(params.agent!, cleanTask, r.status, r.progressSummary?.durationMs ?? 0);
-
-	if (r.progress) allProgress.push(r.progress);
-	if (r.artifactPaths) allArtifactPaths.push(r.artifactPaths);
-
-	const fullOutput = getSingleResultOutput(r);
-	const finalizedOutput = finalizeSingleOutput({
-		fullOutput,
-		truncatedOutput: r.truncation?.text,
-		outputPath,
-		outputMode: r.outputMode,
-		status: r.status,
-		savedPath: r.savedOutputPath,
-		outputReference: r.outputReference,
-		saveError: r.outputSaveError,
-	});
-	const details = compactForegroundDetails({
-		mode: "single",
-		runId,
-		results: [r],
-		parentAskYielded: parentAsk !== undefined && r.interrupted,
-		progress: params.includeProgress ? allProgress : undefined,
-		artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
-		truncation: r.truncation,
-	});
-
-	if (!r.detached && !r.interrupted) {
-		const intercomReceipt = await maybeBuildForegroundIntercomReceipt({
-			pi: deps.pi,
-			intercomBridge: data.intercomBridge,
-			runId,
-			mode: "single",
-			details,
-		});
-		if (intercomReceipt) {
-			return {
-				content: [{ type: "text", text: intercomReceipt.text }],
-				details: intercomReceipt.details,
-				...(r.status === "error" ? { isError: true } : {}),
-			};
-		}
-	}
-
-	if (r.detached) {
-		return {
-			content: [
-				{
-					type: "text",
-					text: `Detached for intercom coordination: ${params.agent}. Reply to the supervisor request first. After the child exits, launch a fresh follow-up if needed.`,
-				},
-			],
-			details,
-		};
-	}
-
-	if (parentAsk && r.interrupted) {
-		return {
-			content: [
-				{
-					type: "text",
-					text: formatParentAskHandoffOutput({
-						askingChildIndex: 0,
-						releasedChildIndices: [0],
-						unlaunchedChildIndices: [],
-						request: parentAsk,
-					}),
-				},
-			],
-			details,
-		};
-	}
-
-	if (r.interrupted) {
-		return {
-			content: [
-				{
-					type: "text",
-					text: `Run ended after interrupt (${params.agent}). Launch a fresh subagent for any follow-up.`,
-				},
-			],
-			details,
-		};
-	}
-
-	if (r.status === "error")
-		return {
-			content: [{ type: "text", text: formatFailedSingleRunOutput(r, finalizedOutput.displayOutput) }],
-			details,
-			isError: true,
-		};
-	return {
-		content: [{ type: "text", text: finalizedOutput.displayOutput || "(no output)" }],
-		details,
-	};
-}