@bastani/atomic 0.9.15 → 0.9.16-alpha.2

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

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@bastani/atomic";
 import type { AgentConfig } from "../../agents/agents.js";
 import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.js";
+import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.js";
 import type { ModelInfo } from "../../shared/model-info.js";
 import type { CandidateModelResolver } from "../../shared/model-resolution.js";
 import { buildTaskInstructions, type ResolvedStepBehavior } from "../../shared/settings.js";
@@ -8,8 +9,10 @@ import type {
 	AgentProgress,
 	ArtifactConfig,
 	ControlEvent,
+	ForegroundParentAskHandoff,
 	IntercomEventBus,
 	MaxOutputConfig,
+	RunSyncOptions,
 	SingleResult,
 	SubagentState,
 	SubagentToolResult,
@@ -20,6 +23,7 @@ import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/int
 import { currentModelFullId } from "../shared/model-fallback.js";
 import { injectSingleOutputInstruction, resolveSingleOutputPath } from "../shared/single-output.js";
 import type { WorktreeSetup } from "../shared/worktree.js";
+import { markLiveResultIndices } from "./subagent-executor-live-update.js";
 import type { SubagentExecutorRuntimeDeps, TaskParam } from "./subagent-executor-types.js";
 import { resolveParallelTaskCwd } from "./subagent-executor-worktree.js";
 
@@ -27,6 +31,7 @@ interface ForegroundParallelRunInput {
 	tasks: TaskParam[];
 	taskTexts: string[];
 	agents: AgentConfig[];
+	agentConfigs?: AgentConfig[];
 	ctx: ExtensionContext;
 	intercomEvents: IntercomEventBus;
 	signal: AbortSignal;
@@ -57,23 +62,39 @@ interface ForegroundParallelRunInput {
 	liveResults: (SingleResult | undefined)[];
 	liveProgress: (AgentProgress | undefined)[];
 	onUpdate?: (r: SubagentToolResult) => void;
+	onParentAskHandoff?: (handoff: ForegroundParentAskHandoff) => void;
 	onDetachedExit?: (index: number, result: SingleResult) => void;
+	onExecution?: (index: number, runtimeCwd: string, options: RunSyncOptions) => void;
 	worktreeSetup?: WorktreeSetup;
 	runtime: Pick<SubagentExecutorRuntimeDeps, "runSync">;
 }
 
+function skippedParallelResult(task: TaskParam, taskText: string, error: string): SingleResult {
+	return {
+		agent: task.agent,
+		task: taskText,
+		status: "skipped",
+		messages: [],
+		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+		error,
+	};
+}
+
 export async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Promise<SingleResult[]> {
 	const intercomDetachController = new AbortController();
+	const parentAskController = new AbortController();
+	const startedIndices = new Set<number>();
+	const activeIndices = new Set<number>();
 	return mapConcurrent(input.tasks, input.concurrencyLimit, async (task, index) => {
+		if (parentAskController.signal.aborted) {
+			return skippedParallelResult(task, input.taskTexts[index] ?? task.task, "Skipped after parent ask handoff");
+		}
 		if (intercomDetachController.signal.aborted) {
-			return {
-				agent: task.agent,
-				task: input.taskTexts[index] ?? task.task,
-				status: "skipped",
-				messages: [],
-				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-				error: "Skipped after foreground group detached for intercom coordination",
-			};
+			return skippedParallelResult(
+				task,
+				input.taskTexts[index] ?? task.task,
+				"Skipped after foreground group detached for intercom coordination",
+			);
 		}
 		const behavior = input.behaviors[index];
 		const effectiveSkills = behavior?.skills;
@@ -93,7 +114,24 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 			`${readInstructions.prefix}${input.taskTexts[index]!}${progressInstructions.suffix}`,
 			outputPath,
 		);
+		const childIntercomTarget = input.childIntercomTarget?.(task.agent, index);
+		const supervisorAuthorization = await requestSupervisorAuthorization(input.intercomEvents, childIntercomTarget);
+		if (parentAskController.signal.aborted) {
+			return skippedParallelResult(task, input.taskTexts[index] ?? task.task, "Skipped after parent ask handoff");
+		}
+		if (intercomDetachController.signal.aborted) {
+			return skippedParallelResult(
+				task,
+				input.taskTexts[index] ?? task.task,
+				"Skipped after foreground group detached for intercom coordination",
+			);
+		}
 		const interruptController = new AbortController();
+		const interruptForParentAsk = () => interruptController.abort();
+		parentAskController.signal.addEventListener("abort", interruptForParentAsk, { once: true });
+		if (parentAskController.signal.aborted) interruptController.abort();
+		startedIndices.add(index);
+		activeIndices.add(index);
 		if (input.foregroundControl) {
 			input.foregroundControl.currentAgent = task.agent;
 			input.foregroundControl.currentIndex = index;
@@ -107,91 +145,124 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 				return true;
 			};
 		}
-		const agentConfig = input.agents.find((agent) => agent.name === task.agent);
-		return input.runtime
-			.runSync(input.ctx.cwd, input.agents, task.agent, taskText, {
-				cwd: taskCwd,
-				signal: input.signal,
-				interruptSignal: interruptController.signal,
-				allowIntercomDetach: agentConfig?.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
-				intercomEvents: input.intercomEvents,
-				runId: input.runId,
-				index,
-				sessionDir: input.sessionDirForIndex(index),
-				sessionFile: input.sessionFileForIndex(index),
-				share: input.shareEnabled,
-				artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
-				artifactConfig: input.artifactConfig,
-				maxOutput: input.maxOutput,
-				outputPath,
-				outputMode: behavior?.outputMode,
-				parentDepth: input.parentDepth,
-				workflowStageSubagentGuard: input.workflowStageSubagentGuard,
-				workflowSessionMetadata: workflowSessionMetadataFromContext(input.ctx),
-				controlConfig: input.controlConfig,
-				onControlEvent: input.onControlEvent,
-				intercomSessionName: input.childIntercomTarget?.(task.agent, index),
-				orchestratorIntercomTarget: input.orchestratorIntercomTarget,
-				intercomGroup: resolveChildIntercomGroup(
-					task.group ?? input.setIntercomGroup,
-					inheritedIntercomGroup(input.ctx),
-					input.sharedAutoIntercomGroup,
-				),
-				onDetachedExit: (result) => input.onDetachedExit?.(index, result),
-				intercomDetachSignal: intercomDetachController.signal,
-				onIntercomDetachCommit: () => intercomDetachController.abort(),
-				modelOverride: input.modelOverrides[index],
-				availableModels: input.availableModels,
-				knownModelProviders: input.knownModelProviders,
-				resolveCandidateModel: input.resolveCandidateModel,
-				preferredModelProvider: input.ctx.model?.provider,
-				currentModel: currentModelFullId(input.ctx.model),
-				currentThinkingLevel: input.ctx.thinkingLevel,
-				skills: effectiveSkills === false ? [] : effectiveSkills,
-				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 = index;
-								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();
-							}
-							if (stepResults.length > 0) input.liveResults[index] = stepResults[0];
-							if (stepProgress.length > 0) input.liveProgress[index] = stepProgress[0];
-							const mergedResults = input.liveResults.filter(
-								(result): result is SingleResult => result !== undefined,
-							);
-							const mergedProgress = input.liveProgress.filter(
-								(progress): progress is AgentProgress => progress !== undefined,
-							);
-							input.onUpdate?.({
-								content: progressUpdate.content,
-								details: {
-									mode: "parallel",
-									results: mergedResults,
-									progress: mergedProgress,
-									controlEvents: progressUpdate.details?.controlEvents,
-									totalSteps: input.tasks.length,
-								},
-							});
+		const agentConfig = input.agentConfigs?.[index] ?? input.agents.find((agent) => agent.name === task.agent);
+		const taskAgents = input.agentConfigs && agentConfig ? [agentConfig] : input.agents;
+		const runOptions: RunSyncOptions = {
+			cwd: taskCwd,
+			signal: input.signal,
+			interruptSignal: interruptController.signal,
+			allowIntercomDetach: agentConfig?.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+			intercomEvents: input.intercomEvents,
+			runId: input.runId,
+			index,
+			sessionDir: input.sessionDirForIndex(index),
+			sessionFile: input.sessionFileForIndex(index),
+			share: input.shareEnabled,
+			artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
+			artifactConfig: input.artifactConfig,
+			maxOutput: input.maxOutput,
+			outputPath,
+			outputMode: behavior?.outputMode,
+			parentDepth: input.parentDepth,
+			workflowStageSubagentGuard: input.workflowStageSubagentGuard,
+			workflowSessionMetadata: workflowSessionMetadataFromContext(input.ctx),
+			controlConfig: input.controlConfig,
+			onControlEvent: input.onControlEvent,
+			intercomSessionName: childIntercomTarget,
+			supervisorAuthorization,
+			orchestratorIntercomTarget: input.orchestratorIntercomTarget,
+			intercomGroup: resolveChildIntercomGroup(
+				task.group ?? input.setIntercomGroup,
+				inheritedIntercomGroup(input.ctx),
+				input.sharedAutoIntercomGroup,
+			),
+			onDetachedExit: (result) => input.onDetachedExit?.(index, result),
+			intercomDetachSignal: intercomDetachController.signal,
+			onIntercomDetachCommit: () => intercomDetachController.abort(),
+			onParentAskHandoff: input.onParentAskHandoff
+				? (request) => {
+						if (parentAskController.signal.aborted) return;
+						request.taskContext = input.tasks[request.index]?.task ?? "";
+						input.onParentAskHandoff?.({
+							askingChildIndex: request.index,
+							releasedChildIndices: [...activeIndices].sort((left, right) => left - right),
+							unlaunchedChildIndices: input.tasks
+								.map((_, taskIndex) => taskIndex)
+								.filter((taskIndex) => !startedIndices.has(taskIndex)),
+							request,
+						});
+						parentAskController.abort();
+					}
+				: undefined,
+			modelOverride: input.modelOverrides[index],
+			availableModels: input.availableModels,
+			knownModelProviders: input.knownModelProviders,
+			resolveCandidateModel: input.resolveCandidateModel,
+			preferredModelProvider: input.ctx.model?.provider,
+			currentModel: currentModelFullId(input.ctx.model),
+			currentThinkingLevel: input.ctx.thinkingLevel,
+			skills: effectiveSkills === false ? [] : effectiveSkills,
+			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 = index;
+							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();
 						}
-					: undefined,
-			})
-			.finally(() => {
-				if (input.foregroundControl?.currentIndex === index) {
-					input.foregroundControl.interrupt = undefined;
-					input.foregroundControl.updatedAt = Date.now();
-				}
-			});
+						if (stepResults.length > 0) input.liveResults[index] = stepResults[0];
+						if (stepProgress.length > 0) input.liveProgress[index] = stepProgress[0];
+						const indexedResults = input.liveResults.flatMap((result, resultIndex) =>
+							result === undefined ? [] : [{ result, index: resultIndex }],
+						);
+						const mergedResults = indexedResults.map(({ result }) => result);
+						const mergedProgress = input.liveProgress.filter(
+							(progress): progress is AgentProgress => progress !== undefined,
+						);
+						const controlEvents = progressUpdate.details?.controlEvents?.map((event) => ({ ...event, index }));
+						const artifactDir = progressUpdate.details?.artifacts?.dir;
+						const artifactFiles = mergedResults.flatMap((result) =>
+							result.artifactPaths ? [result.artifactPaths] : [],
+						);
+						const aggregateUpdate: SubagentToolResult = {
+							content: progressUpdate.content,
+							details: {
+								mode: "parallel",
+								results: mergedResults,
+								progress: mergedProgress,
+								...(controlEvents?.length ? { controlEvents } : {}),
+								totalSteps: input.tasks.length,
+								...(artifactDir && artifactFiles.length
+									? { artifacts: { dir: artifactDir, files: artifactFiles } }
+									: {}),
+							},
+						};
+						markLiveResultIndices(
+							aggregateUpdate,
+							indexedResults.map(({ index: resultIndex }) => resultIndex),
+						);
+						input.onUpdate?.(aggregateUpdate);
+					}
+				: undefined,
+		};
+		input.onExecution?.(index, input.ctx.cwd, runOptions);
+		return input.runtime.runSync(input.ctx.cwd, taskAgents, task.agent, taskText, runOptions).finally(() => {
+			activeIndices.delete(index);
+			parentAskController.signal.removeEventListener("abort", interruptForParentAsk);
+			if (input.foregroundControl?.currentIndex === index) {
+				input.foregroundControl.interrupt = undefined;
+				input.foregroundControl.updatedAt = Date.now();
+			}
+		});
 	});
 }

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

@@ -12,6 +12,7 @@ import {
 import {
 	type AgentProgress,
 	type ArtifactPaths,
+	type ForegroundParentAskHandoff,
 	isWorkflowStageOrchestrationContext,
 	resolveTopLevelParallelConcurrency,
 	resolveTopLevelParallelMaxTasks,
@@ -22,18 +23,18 @@ import {
 import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.js";
 import { sharedAutoGroupForSet } from "../shared/intercom-group.js";
 import { resolveModelCandidate } from "../shared/model-fallback.js";
-import { aggregateParallelOutputs } from "../shared/parallel-utils.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,
-	rememberForegroundRun,
-	replaceForegroundRunChild,
 } from "./subagent-executor-status.js";
 import type { ExecutionContextData, ResolvedExecutorDeps, TaskParam } from "./subagent-executor-types.js";
 import {
@@ -82,17 +83,19 @@ export async function runParallelPath(
 			details: { mode: "parallel" as const, results: [] },
 		};
 
-	const agentConfigs: AgentConfig[] = [];
-	for (const t of tasks) {
-		const config = agents.find((a) => a.name === t.agent);
-		if (!config) {
-			return {
-				content: [{ type: "text", text: `Unknown agent: ${t.agent}` }],
-				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);
 		}
-		agentConfigs.push(config);
 	}
 
 	const workflowStageSubagentGuard = isWorkflowStageOrchestrationContext(ctx);
@@ -143,6 +146,7 @@ export async function runParallelPath(
 		cleanupWorktrees(worktreeSetup);
 	});
 	if (errorResult) return errorResult;
+	let parentAsk: ForegroundParentAskHandoff | undefined;
 
 	try {
 		const duplicateOutputError = findDuplicateParallelOutputPath({
@@ -176,7 +180,6 @@ export async function runParallelPath(
 		const results = await runForegroundParallelTasks({
 			onDetachedExit: (index, result) => {
 				try {
-					replaceForegroundRunChild(deps.state, runId, index, result);
 					notifyDetachedForegroundChildExit({
 						pi: deps.pi,
 						runId,
@@ -189,9 +192,13 @@ export async function runParallelPath(
 					detachedCleanup.recover(index);
 				}
 			},
+			onParentAskHandoff: (handoff) => {
+				if (!parentAsk) parentAsk = handoff;
+			},
 			tasks,
 			taskTexts,
 			agents,
+			...(data.parallelAgentConfigs ? { agentConfigs } : {}),
 			ctx,
 			intercomEvents: deps.pi.events,
 			signal,
@@ -242,21 +249,26 @@ export async function runParallelPath(
 			mode: "parallel",
 			runId,
 			results,
+			parentAskYielded: parentAsk !== undefined,
 			progress: params.includeProgress ? allProgress : undefined,
 			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 		});
-		rememberForegroundRun(deps.state, {
-			runId,
-			mode: "parallel",
-			cwd: effectiveCwd,
-			results: details.results,
-		});
+		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 paused after interrupt (${interrupted.agent}). Waiting for explicit next action.`,
+						text: `Parallel run ended after interrupt (${interrupted.agent}). Launch fresh subagents for any follow-up.`,
 					},
 				],
 				details,
@@ -272,7 +284,7 @@ export async function runParallelPath(
 				content: [
 					{
 						type: "text",
-						text: `Parallel run detached for intercom coordination (${detached.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.`,
+						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,
@@ -294,8 +306,7 @@ export async function runParallelPath(
 		}
 
 		const worktreeSuffix = buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks as TaskParam[]);
-		const ok = results.filter((result) => result.status === "ok").length;
-		const aggregatedOutput = aggregateParallelOutputs(
+		const childContent = formatParallelResultContent(
 			results.map((result) => ({
 				agent: result.agent,
 				output: result.truncation?.text || getSingleResultOutput(result),
@@ -304,11 +315,7 @@ export async function runParallelPath(
 			})),
 			(i, agent) => `=== Task ${i + 1}: ${agent} ===`,
 		);
-
-		const summary = `${ok}/${results.length} succeeded`;
-		const fullContent = worktreeSuffix
-			? `${summary}\n\n${aggregatedOutput}\n\n${worktreeSuffix}`
-			: `${summary}\n\n${aggregatedOutput}`;
+		const fullContent = worktreeSuffix ? `${childContent}\n\n${worktreeSuffix}` : childContent;
 
 		return {
 			content: [{ type: "text", text: fullContent }],

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

@@ -0,0 +1,11 @@
+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-single.ts

@@ -2,6 +2,7 @@ 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 {
@@ -13,6 +14,8 @@ import {
 	type AgentProgress,
 	type ArtifactPaths,
 	isWorkflowStageOrchestrationContext,
+	type ParentAskHandoffRequest,
+	type RunSyncOptions,
 	type SingleResult,
 	type SubagentToolResult,
 	workflowSessionMetadataFromContext,
@@ -29,12 +32,11 @@ import {
 	resolveSingleOutputPath,
 	validateFileOnlyOutputMode,
 } from "../shared/single-output.js";
+import { formatParentAskHandoffOutput } from "./parent-ask-output.js";
 import {
 	createForegroundControlNotifier,
 	maybeBuildForegroundIntercomReceipt,
 	notifyDetachedForegroundChildExit,
-	rememberForegroundRun,
-	replaceForegroundRunChild,
 } from "./subagent-executor-status.js";
 import type { ExecutionContextData, ForegroundControl, ResolvedExecutorDeps } from "./subagent-executor-types.js";
 
@@ -123,7 +125,8 @@ export async function runSinglePath(
 	const currentProvider = ctx.model?.provider;
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
-	let task = params.task ?? "";
+	const handoffTaskContext = params.task ?? "";
+	let task = handoffTaskContext;
 	const modelOverride: string | undefined = resolveModelCandidate(
 		(params.model as string | undefined) ?? agentConfig.model,
 		availableModels,
@@ -165,6 +168,7 @@ export async function runSinglePath(
 		effectiveSkills = skillOverride;
 	}
 	const interruptController = new AbortController();
+	let parentAsk: ParentAskHandoffRequest | undefined;
 	const foregroundControl = deps.state.foregroundControls.get(runId);
 	if (foregroundControl) {
 		foregroundControl.currentAgent = params.agent;
@@ -184,7 +188,8 @@ export async function runSinglePath(
 
 	let r: SingleResult;
 	try {
-		r = await deps.runtime.runSync(ctx.cwd, agents, params.agent!, task, {
+		const supervisorAuthorization = await requestSupervisorAuthorization(deps.pi.events, childIntercomTarget);
+		const runOptions: RunSyncOptions = {
 			cwd: effectiveCwd,
 			signal,
 			interruptSignal: interruptController.signal,
@@ -206,14 +211,18 @@ export async function runSinglePath(
 			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) {
-					replaceForegroundRunChild(deps.state, runId, 0, result);
-					notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "single", index: 0, result });
-				}
+				if (result) notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "single", index: 0, result });
 			},
 			index: 0,
 			modelOverride,
@@ -224,7 +233,8 @@ export async function runSinglePath(
 			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;
@@ -263,16 +273,11 @@ export async function runSinglePath(
 		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,
 	});
-	rememberForegroundRun(deps.state, {
-		runId,
-		mode: "single",
-		cwd: effectiveCwd,
-		results: details.results,
-	});
 
 	if (!r.detached && !r.interrupted) {
 		const intercomReceipt = await maybeBuildForegroundIntercomReceipt({
@@ -296,7 +301,24 @@ export async function runSinglePath(
 			content: [
 				{
 					type: "text",
-					text: `Detached for intercom coordination: ${params.agent}. Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.`,
+					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,
@@ -306,7 +328,10 @@ export async function runSinglePath(
 	if (r.interrupted) {
 		return {
 			content: [
-				{ type: "text", text: `Run paused after interrupt (${params.agent}). Waiting for explicit next action.` },
+				{
+					type: "text",
+					text: `Run ended after interrupt (${params.agent}). Launch a fresh subagent for any follow-up.`,
+				},
 			],
 			details,
 		};