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

package/dist/builtin/subagents/src/runs/{background → foreground}/notify.ts

@@ -2,16 +2,16 @@
  * Subagent completion notifications.
  */
 
-import type { ExtensionAPI } from "@bastani/atomic";
+import { type ExtensionAPI, isStaleExtensionContextError } from "@bastani/atomic";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import {
-	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	SUBAGENT_COMPLETE_EVENT,
 	SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT,
 	type SubagentAttemptStatus,
 } from "../../shared/types.ts";
 import type { CompletionNotificationEnvelope } from "./completion-notification.ts";
 
-interface ChainStepResult {
+interface SubagentStepResult {
 	agent: string;
 	output: string;
 	status: SubagentAttemptStatus;
@@ -43,7 +43,7 @@ interface SubagentResult {
 	shareUrl?: string;
 	gistUrl?: string;
 	shareError?: string;
-	results?: ChainStepResult[];
+	results?: SubagentStepResult[];
 	taskIndex?: number;
 	totalTasks?: number;
 	noticeLabel?: string;
@@ -134,13 +134,6 @@ async function dispatchFallback(
 export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 	const registry = getNotifyRegistry();
 	const previous = registry.get(pi);
-	if (previous) {
-		try {
-			previous.unsubscribe();
-		} catch {
-			// Best effort cleanup for stale handlers from an older reload.
-		}
-	}
 	const seen = getNotifySeen(pi);
 	const ttlMs = 10 * 60 * 1000;
 
@@ -166,24 +159,35 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 		const terminalId = result.notificationId?.startsWith("completion-notify-")
 			? result.notificationId.slice("completion-notify-".length)
 			: result.notificationId;
+		let dispatchStarted = false;
+		const barrierDispatch = dispatch
+			? (prefix: TerminalPreludeMessage[]) => {
+					dispatchStarted = true;
+					return dispatch(prefix);
+				}
+			: undefined;
 		const payload = {
 			runId,
 			...(terminalId ? { terminalId } : {}),
 			terminalAt: Number.isFinite(result.timestamp) ? result.timestamp : Date.now(),
-			source: "background-notify" as const,
+			source: "detached-notify" as const,
 			sourceSessionTargets,
-			...(dispatch ? { dispatch } : {}),
+			...(barrierDispatch ? { dispatch: barrierDispatch } : {}),
 		};
 		Object.defineProperty(payload, "terminalOwner", { value: pi });
-		pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+		try {
+			pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+		} catch (error) {
+			if (!isStaleExtensionContextError(error) || dispatchStarted) throw error;
+		}
 		const globalHandler = (globalThis as Record<string, unknown>).__atomicTerminalOrderingBarrierHandler;
 		if (typeof globalHandler === "function") (globalHandler as (value: unknown) => void)(payload);
 		return (payload as typeof payload & { completion?: Promise<void> }).completion;
 	};
 	const inFlight = new Map<string, Promise<void>>();
-	let registration: NotifyRegistration;
+	let registration: NotifyRegistration | undefined;
 	const handleComplete = (data: unknown): void => {
-		if (registry.get(pi) !== registration) return;
+		if (!registration || registry.get(pi) !== registration) return;
 		const result = data as SubagentResult & Partial<CompletionNotificationEnvelope>;
 		const now = Date.now();
 		const key = result.notificationId
@@ -234,7 +238,7 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 		const noticeLabel =
 			typeof result.noticeLabel === "string" && result.noticeLabel.trim()
 				? result.noticeLabel.trim()
-				: "Background task";
+				: "Subagent task";
 		let sessionLabel: string | undefined;
 		let sessionValue: string | undefined;
 		if (sessionLine) {
@@ -277,7 +281,7 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			inFlight.delete(key);
 			ownership.reject(error);
 			result.acknowledge?.(false);
-			console.error("Failed to deliver async subagent completion notification:", error);
+			console.error("Failed to deliver subagent completion notification:", error);
 		};
 		const observe = (delivery: PromiseLike<void>): void => {
 			result.defer?.();
@@ -308,13 +312,45 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			fail(error);
 		}
 	};
-
-	const unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+	let unsubscribe: () => void;
+	try {
+		unsubscribe = pi.events.on(SUBAGENT_COMPLETE_EVENT, handleComplete);
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// A stale API cannot accept a new subscription; keep the prior one usable.
+		return () => {};
+	}
 	registration = { unsubscribe };
 	registry.set(pi, registration);
+	if (previous) {
+		try {
+			previous.unsubscribe();
+		} catch (error) {
+			if (isStaleExtensionContextError(error)) {
+				// The old handler is inert because the registry now belongs to this registration.
+			} else {
+				// A failed replacement cleanup aborts activation; remove the new entry before rethrowing.
+				if (registry.get(pi) === registration) registry.delete(pi);
+				try {
+					unsubscribe();
+				} catch (rollbackError) {
+					if (!isStaleExtensionContextError(rollbackError)) {
+						throw new AggregateError([error, rollbackError], "Failed to roll back notification registration");
+					}
+					// Stale cleanup is best effort after the registry rollback.
+				}
+				throw error;
+			}
+		}
+	}
 	return () => {
-		if (registry.get(pi) !== registration) return;
+		if (!registration || registry.get(pi) !== registration) return;
 		registry.delete(pi);
-		unsubscribe();
+		try {
+			unsubscribe();
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Stale event-bus cleanup is best effort.
+		}
 	};
 }

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

@@ -12,11 +12,7 @@ import {
 import { getArtifactsDir } from "../../shared/artifacts.ts";
 import { createForkContextResolver } from "../../shared/fork-context.ts";
 import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
-import {
-	buildReadInstruction,
-	isParallelStep as isSettingsParallelStep,
-	type SequentialStep,
-} from "../../shared/settings.ts";
+import { buildReadInstruction } from "../../shared/settings.ts";
 import {
 	type ArtifactConfig,
 	checkSubagentDepth,
@@ -26,10 +22,6 @@ import {
 	subagentDepthBlockedMessage,
 } from "../../shared/types.ts";
 
-function applyForceTopLevelAsyncOverride<T extends { async?: boolean }>(params: T, depth: number, force: boolean): T {
-	return depth === 0 && force ? { ...params, async: true } : params;
-}
-
 import {
 	createNestedRoute,
 	resolveInheritedNestedRouteFromEnv,
@@ -56,8 +48,8 @@ export function checkDepthForExecution(
 	deps: ResolvedExecutorDeps,
 ): SubagentToolResult | undefined {
 	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
-	const { blocked, depth, maxDepth, workflowStageGuard } = checkSubagentDepth(depthPolicy.maxSubagentDepth);
-	const workflowStageSubagentGuard = workflowStageGuard || depthPolicy.workflowStageSubagentGuard;
+	const { blocked, depth, maxDepth } = checkSubagentDepth(ctx, depthPolicy.maxSubagentDepth);
+	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
 	if (!blocked) return undefined;
 	return {
 		content: [
@@ -80,16 +72,12 @@ export function prepareExecutionContext(input: {
 }): ExecutionContextBuildResult {
 	const { params, ctx, signal, onUpdate, deps } = input;
 	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
-	const { depth } = checkSubagentDepth(depthPolicy.maxSubagentDepth);
+	const { depth } = checkSubagentDepth(ctx, depthPolicy.maxSubagentDepth);
 	const normalized = normalizeRepeatedParallelCounts(params);
 	if (normalized.error) return { error: normalized.error };
 	const normalizedParams = normalized.params!;
 
-	let effectiveParams = applyForceTopLevelAsyncOverride(
-		normalizedParams,
-		depth,
-		deps.config.forceTopLevelAsync === true,
-	);
+	let effectiveParams = normalizedParams;
 
 	const scope = resolveExecutionAgentScope(effectiveParams.agentScope);
 	const effectiveCwd = effectiveParams.cwd ?? ctx.cwd;
@@ -112,10 +100,9 @@ export function prepareExecutionContext(input: {
 	const nestedParentAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
 	const nestedRoute = inheritedNestedRoute ?? createNestedRoute(runId);
 	const shareEnabled = effectiveParams.share === true;
-	const hasChain = (effectiveParams.chain?.length ?? 0) > 0;
 	const hasTasks = (effectiveParams.tasks?.length ?? 0) > 0;
-	const hasSingle = !hasChain && !hasTasks && Boolean(effectiveParams.agent);
-	const validationError = validateExecutionInput(effectiveParams, agents, hasChain, hasTasks, hasSingle);
+	const hasSingle = !hasTasks && Boolean(effectiveParams.agent);
+	const validationError = validateExecutionInput(effectiveParams, agents, hasTasks, hasSingle);
 	if (validationError) return { error: validationError };
 	if (hasSingle) {
 		const readInstruction = buildReadInstruction(effectiveParams.reads, effectiveCwd);
@@ -129,7 +116,6 @@ export function prepareExecutionContext(input: {
 	} catch (error) {
 		return { error: toExecutionErrorResult(effectiveParams, error) };
 	}
-	const effectiveAsync = effectiveParams.async ?? deps.asyncByDefault;
 	const controlConfig = resolveControlConfig(deps.config.control, effectiveParams.control);
 
 	const artifactConfig: ArtifactConfig = {
@@ -180,30 +166,23 @@ export function prepareExecutionContext(input: {
 		sessionFileForIndex: childSessionFileForIndex,
 		artifactConfig,
 		artifactsDir,
-		effectiveAsync,
+		parentDepth: depth,
 		controlConfig,
 		intercomBridge,
 		nestedRoute,
 	};
 
-	const foregroundMode: "single" | "parallel" | "chain" = hasChain ? "chain" : hasTasks ? "parallel" : "single";
-	const foregroundControl = effectiveAsync
-		? undefined
-		: {
-				runId,
-				mode: foregroundMode,
-				startedAt: Date.now(),
-				updatedAt: Date.now(),
-				currentAgent: undefined,
-				currentIndex: undefined,
-				currentActivityState: undefined,
-				nestedRoute,
-				interrupt: undefined,
-			};
-	if (foregroundControl) {
-		deps.state.foregroundControls.set(runId, foregroundControl);
-		deps.state.lastForegroundControlId = runId;
-	}
+	const foregroundMode: "single" | "parallel" = hasTasks ? "parallel" : "single";
+	const foregroundControl = {
+		runId,
+		mode: foregroundMode,
+		startedAt: Date.now(),
+		updatedAt: Date.now(),
+		nestedRoute,
+		interrupt: undefined,
+	};
+	deps.state.foregroundControls.set(runId, foregroundControl);
+	deps.state.lastForegroundControlId = runId;
 
 	const writeNestedForegroundEvent = (
 		type: "subagent.nested.started" | "subagent.nested.completed",
@@ -224,15 +203,9 @@ export function prepareExecutionContext(input: {
 		const agentsForSummary =
 			hasTasks && effectiveParams.tasks
 				? effectiveParams.tasks.map((task) => task.agent)
-				: hasChain && effectiveParams.chain
-					? effectiveParams.chain.flatMap((step) =>
-							isSettingsParallelStep(step)
-								? step.parallel.map((task) => task.agent)
-								: [(step as SequentialStep).agent],
-						)
-					: effectiveParams.agent
-						? [effectiveParams.agent]
-						: [];
+				: effectiveParams.agent
+					? [effectiveParams.agent]
+					: [];
 		const leafIntercomTarget =
 			intercomBridge.active && agentsForSummary[0]
 				? resolveSubagentIntercomTarget(runId, agentsForSummary[0], 0)
@@ -289,7 +262,6 @@ export function prepareExecutionContext(input: {
 			effectiveParams,
 			effectiveCwd,
 			runId,
-			hasChain,
 			hasTasks,
 			hasSingle,
 			foregroundMode,

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

@@ -1,22 +1,14 @@
 import type { AgentConfig } from "../../agents/agents.ts";
-import {
-	type ChainStep,
-	getStepAgents,
-	isDynamicParallelStep,
-	isParallelStep,
-	type SequentialStep,
-} from "../../shared/settings.ts";
-import { type Details, type SubagentToolResult, wrapForkTask } from "../../shared/types.ts";
+import type { Details, SubagentToolResult } from "../../shared/types.ts";
 import type { SubagentParamsLike, TaskParam } from "./subagent-executor-types.ts";
 
 export function validateExecutionInput(
 	params: SubagentParamsLike,
 	agents: AgentConfig[],
-	hasChain: boolean,
 	hasTasks: boolean,
 	hasSingle: boolean,
 ): SubagentToolResult | null {
-	if (Number(hasChain) + Number(hasTasks) + Number(hasSingle) !== 1) {
+	if (Number(hasTasks) + Number(hasSingle) !== 1) {
 		return {
 			content: [
 				{
@@ -28,8 +20,9 @@ export function validateExecutionInput(
 			details: { mode: "single" as const, results: [] },
 		};
 	}
+
 	if (hasSingle) {
-		const reads = (params as SubagentParamsLike & { reads?: unknown }).reads;
+		const reads = params.reads;
 		if (
 			reads !== undefined &&
 			reads !== false &&
@@ -64,74 +57,10 @@ export function validateExecutionInput(
 		}
 	}
 
-	if (hasChain && params.chain) {
-		if (params.chain.length === 0) {
-			return {
-				content: [{ type: "text", text: "Chain must have at least one step" }],
-				isError: true,
-				details: { mode: "chain" as const, results: [] },
-			};
-		}
-		const firstStep = params.chain[0] as ChainStep;
-		if (isParallelStep(firstStep)) {
-			const missingTaskIndex = firstStep.parallel.findIndex((t) => !t.task);
-			if (missingTaskIndex !== -1) {
-				return {
-					content: [
-						{
-							type: "text",
-							text: `First parallel step: task ${missingTaskIndex + 1} must have a task (no previous output to reference)`,
-						},
-					],
-					isError: true,
-					details: { mode: "chain" as const, results: [] },
-				};
-			}
-		} else if (isDynamicParallelStep(firstStep)) {
-			return {
-				content: [
-					{
-						type: "text",
-						text: "First step in chain cannot be dynamic fanout; expand.from requires a prior structured named output",
-					},
-				],
-				isError: true,
-				details: { mode: "chain" as const, results: [] },
-			};
-		} else if (!(firstStep as SequentialStep).task && !params.task) {
-			return {
-				content: [{ type: "text", text: "First step in chain must have a task" }],
-				isError: true,
-				details: { mode: "chain" as const, results: [] },
-			};
-		}
-		for (let i = 0; i < params.chain.length; i++) {
-			const step = params.chain[i] as ChainStep;
-			const stepAgents = getStepAgents(step);
-			for (const agentName of stepAgents) {
-				if (!agents.find((a) => a.name === agentName)) {
-					return {
-						content: [{ type: "text", text: `Unknown agent: ${agentName} (step ${i + 1})` }],
-						isError: true,
-						details: { mode: "chain" as const, results: [] },
-					};
-				}
-			}
-			if (isParallelStep(step) && step.parallel.length === 0) {
-				return {
-					content: [{ type: "text", text: `Parallel step ${i + 1} must have at least one task` }],
-					isError: true,
-					details: { mode: "chain" as const, results: [] },
-				};
-			}
-		}
-	}
-
 	return null;
 }
 
 export function getRequestedModeLabel(params: SubagentParamsLike): Details["mode"] {
-	if ((params.chain?.length ?? 0) > 0) return "chain";
 	if ((params.tasks?.length ?? 0) > 0) return "parallel";
 	if (params.agent) return "single";
 	return "single";
@@ -143,7 +72,6 @@ export function applyAgentDefaultContext(params: SubagentParamsLike, agents: Age
 	const names: string[] = [];
 	if (params.agent) names.push(params.agent);
 	for (const task of params.tasks ?? []) names.push(task.agent);
-	for (const step of params.chain ?? []) names.push(...getStepAgents(step));
 	return names.some((name) => byName.get(name)?.defaultContext === "fork") ? { ...params, context: "fork" } : params;
 }
 
@@ -166,58 +94,20 @@ function expandTopLevelTaskCounts(tasks: TaskParam[]): { tasks?: TaskParam[]; er
 		if (rawCount !== undefined && (typeof rawCount !== "number" || !Number.isInteger(rawCount) || rawCount < 1)) {
 			return { error: `tasks[${taskIndex}].count must be an integer >= 1` };
 		}
-		const { count, ...concreteTask } = task;
-		for (let repeat = 0; repeat < (rawCount ?? 1); repeat++) {
-			expanded.push({ ...concreteTask });
-		}
+		const { count: _count, ...concreteTask } = task;
+		for (let repeat = 0; repeat < (rawCount ?? 1); repeat++) expanded.push({ ...concreteTask });
 	}
 	return { tasks: expanded };
 }
 
-function expandChainParallelCounts(chain: ChainStep[]): { chain?: ChainStep[]; error?: string } {
-	const expandedChain: ChainStep[] = [];
-	for (let stepIndex = 0; stepIndex < chain.length; stepIndex++) {
-		const step = chain[stepIndex]!;
-		if (!isParallelStep(step)) {
-			expandedChain.push(step);
-			continue;
-		}
-		const expandedParallel = [];
-		for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
-			const task = step.parallel[taskIndex]!;
-			const rawCount = (task as typeof task & { count?: unknown }).count;
-			if (rawCount !== undefined && (typeof rawCount !== "number" || !Number.isInteger(rawCount) || rawCount < 1)) {
-				return { error: `chain[${stepIndex}].parallel[${taskIndex}].count must be an integer >= 1` };
-			}
-			const { count, ...concreteTask } = task;
-			for (let repeat = 0; repeat < (rawCount ?? 1); repeat++) {
-				expandedParallel.push({ ...concreteTask });
-			}
-		}
-		expandedChain.push({ ...step, parallel: expandedParallel });
-	}
-	return { chain: expandedChain };
-}
-
 export function normalizeRepeatedParallelCounts(params: SubagentParamsLike): {
 	params?: SubagentParamsLike;
 	error?: SubagentToolResult;
 } {
-	if (params.tasks) {
-		const expandedTasks = expandTopLevelTaskCounts(params.tasks);
-		if (expandedTasks.error) {
-			return { error: buildRequestedModeError(params, expandedTasks.error) };
-		}
-		return { params: { ...params, tasks: expandedTasks.tasks } };
-	}
-	if (params.chain) {
-		const expandedChain = expandChainParallelCounts(params.chain);
-		if (expandedChain.error) {
-			return { error: buildRequestedModeError(params, expandedChain.error) };
-		}
-		return { params: { ...params, chain: expandedChain.chain } };
-	}
-	return { params };
+	if (!params.tasks) return { params };
+	const expandedTasks = expandTopLevelTaskCounts(params.tasks);
+	if (expandedTasks.error) return { error: buildRequestedModeError(params, expandedTasks.error) };
+	return { params: { ...params, tasks: expandedTasks.tasks } };
 }
 
 export function withForkContext(
@@ -245,56 +135,3 @@ export function toExecutionErrorResult(params: SubagentParamsLike, error: unknow
 		params.context,
 	);
 }
-
-export function collectChainSessionFiles(
-	chain: ChainStep[],
-	sessionFileForIndex: (idx?: number) => string | undefined,
-): (string | undefined)[] {
-	const sessionFiles: (string | undefined)[] = [];
-	let flatIndex = 0;
-	for (const step of chain) {
-		if (isParallelStep(step)) {
-			for (let i = 0; i < step.parallel.length; i++) {
-				sessionFiles.push(sessionFileForIndex(flatIndex));
-				flatIndex++;
-			}
-			continue;
-		}
-		if (isDynamicParallelStep(step)) {
-			sessionFiles.push(undefined);
-			continue;
-		}
-		sessionFiles.push(sessionFileForIndex(flatIndex));
-		flatIndex++;
-	}
-	return sessionFiles;
-}
-
-export function wrapChainTasksForFork(chain: ChainStep[], context: SubagentParamsLike["context"]): ChainStep[] {
-	if (context !== "fork") return chain;
-	return chain.map((step, stepIndex) => {
-		if (isParallelStep(step)) {
-			return {
-				...step,
-				parallel: step.parallel.map((task) => ({
-					...task,
-					task: wrapForkTask(task.task ?? "{previous}"),
-				})),
-			};
-		}
-		if (isDynamicParallelStep(step)) {
-			return {
-				...step,
-				parallel: {
-					...step.parallel,
-					task: wrapForkTask(step.parallel.task ?? "{previous}"),
-				},
-			};
-		}
-		const sequential = step as SequentialStep;
-		return {
-			...sequential,
-			task: wrapForkTask(sequential.task ?? (stepIndex === 0 ? "{task}" : "{previous}")),
-		};
-	});
-}

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

@@ -2,7 +2,8 @@ import type { ExtensionContext } from "@bastani/atomic";
 import type { AgentConfig } from "../../agents/agents.ts";
 import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.ts";
 import type { ModelInfo } from "../../shared/model-info.ts";
-import { buildChainInstructions, type ResolvedStepBehavior } from "../../shared/settings.ts";
+import type { CandidateModelResolver } from "../../shared/model-resolution.ts";
+import { buildTaskInstructions, type ResolvedStepBehavior } from "../../shared/settings.ts";
 import type {
 	AgentProgress,
 	ArtifactConfig,
@@ -15,7 +16,7 @@ import type {
 } from "../../shared/types.ts";
 import { workflowSessionMetadataFromContext } from "../../shared/types-depth.ts";
 import { mapConcurrent } from "../../shared/utils.ts";
-import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.ts";
+import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.js";
 import { currentModelFullId } from "../shared/model-fallback.ts";
 import { injectSingleOutputInstruction, resolveSingleOutputPath } from "../shared/single-output.ts";
 import type { WorktreeSetup } from "../shared/worktree.ts";
@@ -38,9 +39,11 @@ interface ForegroundParallelRunInput {
 	maxOutput?: MaxOutputConfig;
 	paramsCwd: string;
 	maxSubagentDepths: number[];
+	parentDepth?: number;
 	workflowStageSubagentGuard?: boolean;
 	availableModels: ModelInfo[];
 	knownModelProviders: string[];
+	resolveCandidateModel: CandidateModelResolver;
 	modelOverrides: (string | undefined)[];
 	behaviors: ResolvedStepBehavior[];
 	firstProgressIndex: number;
@@ -77,10 +80,10 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 		const effectiveSkills = behavior?.skills;
 		const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
 		const readInstructions = behavior
-			? buildChainInstructions({ ...behavior, output: false, progress: false }, taskCwd, false)
+			? buildTaskInstructions({ ...behavior, output: false, progress: false }, taskCwd, false)
 			: { prefix: "", suffix: "" };
 		const progressInstructions = behavior
-			? buildChainInstructions(
+			? buildTaskInstructions(
 					{ ...behavior, output: false, reads: false },
 					input.paramsCwd,
 					index === input.firstProgressIndex,
@@ -124,6 +127,7 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 				outputPath,
 				outputMode: behavior?.outputMode,
 				maxSubagentDepth: input.maxSubagentDepths[index],
+				parentDepth: input.parentDepth,
 				workflowStageSubagentGuard: input.workflowStageSubagentGuard,
 				workflowSessionMetadata: workflowSessionMetadataFromContext(input.ctx),
 				controlConfig: input.controlConfig,
@@ -142,6 +146,7 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 				modelOverride: input.modelOverrides[index],
 				availableModels: input.availableModels,
 				knownModelProviders: input.knownModelProviders,
+				resolveCandidateModel: input.resolveCandidateModel,
 				preferredModelProvider: input.ctx.model?.provider,
 				currentModel: currentModelFullId(input.ctx.model),
 				skills: effectiveSkills === false ? [] : effectiveSkills,

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

@@ -2,6 +2,7 @@ import type { AgentConfig } from "../../agents/agents.ts";
 import { normalizeSkillInput } from "../../agents/skills.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.ts";
+import { createCandidateModelResolver } from "../../shared/model-resolution.ts";
 import {
 	resolveStepBehavior,
 	type StepOverrides,
@@ -21,7 +22,7 @@ import {
 } from "../../shared/types.ts";
 import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.ts";
 import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.ts";
-import { sharedAutoGroupForSet } from "../shared/intercom-group.ts";
+import { sharedAutoGroupForSet } from "../shared/intercom-group.js";
 import { resolveModelCandidate } from "../shared/model-fallback.ts";
 import { aggregateParallelOutputs } from "../shared/parallel-utils.ts";
 import { recordRun } from "../shared/run-history.ts";
@@ -212,6 +213,7 @@ export async function runParallelPath(
 			workflowStageSubagentGuard,
 			availableModels,
 			knownModelProviders,
+			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, currentProvider),
 			modelOverrides,
 			behaviors,
 			firstProgressIndex: parallelProgressPrecreated ? -1 : firstProgressIndex,
@@ -226,6 +228,7 @@ export async function runParallelPath(
 			foregroundControl,
 			concurrencyLimit: parallelConcurrency,
 			maxSubagentDepths,
+			parentDepth: data.parentDepth,
 			liveResults,
 			liveProgress,
 			onUpdate,
@@ -250,7 +253,13 @@ export async function runParallelPath(
 			progress: params.includeProgress ? allProgress : undefined,
 			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 		});
-		rememberForegroundRun(deps.state, { runId, mode: "parallel", cwd: effectiveCwd, results: details.results });
+		rememberForegroundRun(deps.state, {
+			runId,
+			mode: "parallel",
+			cwd: effectiveCwd,
+			results: details.results,
+			maxSubagentDepths,
+		});
 		if (interrupted) {
 			return {
 				content: [

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

@@ -1,13 +1,8 @@
-import { formatAsyncStartedMessage, isAsyncAvailable } from "../inprocess/background.ts";
-import { executeAsyncSingle } from "../inprocess/background-single.ts";
 import { runSync } from "./execution.ts";
 import type { SubagentExecutorRuntimeDeps } from "./subagent-executor-types.ts";
 
 const defaultSubagentExecutorRuntimeDeps: SubagentExecutorRuntimeDeps = {
 	runSync,
-	executeAsyncSingle,
-	isAsyncAvailable,
-	formatAsyncStartedMessage,
 };
 
 export function resolveSubagentExecutorRuntimeDeps(