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

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

@@ -2,7 +2,6 @@ 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,
@@ -12,16 +11,12 @@ import {
 	wrapForkTask,
 } from "../../shared/types.ts";
 import { formatAsyncStartedMessage } from "../inprocess/background.ts";
-import { runChainPath } from "./subagent-executor-chain.ts";
+import { inheritedIntercomGroup } from "../shared/intercom-group.js";
 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";
+import { buildParallelModeError, buildParallelWorktreeTaskCwdError } from "./subagent-executor-worktree.ts";
 
-function continuedResult(data: ExecutionContextData, mode: "single" | "parallel" | "chain"): SingleResult {
+function continuedResult(data: ExecutionContextData, mode: "single" | "parallel"): SingleResult {
 	const path = `${data.runId}/orchestration_1`;
 	return {
 		agent: mode,
@@ -49,35 +44,20 @@ function continuedResult(data: ExecutionContextData, mode: "single" | "parallel"
 	};
 }
 
-function modeFor(data: ExecutionContextData): "single" | "parallel" | "chain" {
-	if ((data.params.chain?.length ?? 0) > 0) return "chain";
+function modeFor(data: ExecutionContextData): "single" | "parallel" {
 	if ((data.params.tasks?.length ?? 0) > 0) return "parallel";
 	return "single";
 }
 
-function runForegroundInBackground(
-	data: ExecutionContextData,
-	deps: ResolvedExecutorDeps,
-	mode: "parallel" | "chain",
-): void {
+function runForegroundInBackground(data: ExecutionContextData, deps: ResolvedExecutorDeps): void {
 	const backgroundData: ExecutionContextData = { ...data, effectiveAsync: false };
-	const work = mode === "chain" ? runChainPath(backgroundData, deps) : runParallelPath(backgroundData, deps);
-	void work.catch((error) => {
+	void runParallelPath(backgroundData, deps).catch((error) => {
 		const message = error instanceof Error ? error.message : String(error);
-		console.error(`[${APP_NAME}-subagents] in-process async ${mode} failed: ${message}`);
+		console.error(`[${APP_NAME}-subagents] in-process async parallel 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.
- */
+/** Async is a don't-wait request over the same in-process foreground executor. */
 export async function runAsyncPath(
 	data: ExecutionContextData,
 	deps: ResolvedExecutorDeps,
@@ -86,16 +66,6 @@ export async function runAsyncPath(
 
 	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`);
@@ -148,7 +118,7 @@ export async function runAsyncPath(
 				currentSessionId: deps.state.currentSessionId ?? data.ctx.sessionManager.getSessionId(),
 				currentModelProvider: data.ctx.model?.provider,
 				currentModel,
-				intercomGroup: data.ctx.orchestrationContext?.intercomGroup,
+				intercomGroup: inheritedIntercomGroup(data.ctx),
 				workflowSessionMetadata: workflowSessionMetadataFromContext(data.ctx),
 			},
 			cwd: effectiveCwd,
@@ -166,6 +136,7 @@ export async function runAsyncPath(
 			availableModels,
 			knownModelProviders,
 			maxSubagentDepth: resolveChildMaxSubagentDepth(depthPolicy.maxSubagentDepth, agent.maxSubagentDepth),
+			parentDepth: data.parentDepth,
 			workflowStageSubagentGuard: depthPolicy.workflowStageSubagentGuard,
 			worktreeSetupHook: deps.config.worktreeSetupHook,
 			worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
@@ -177,7 +148,7 @@ export async function runAsyncPath(
 	}
 
 	const continued = continuedResult(data, mode);
-	if (mode === "chain" || mode === "parallel") runForegroundInBackground(data, deps, mode);
+	if (mode === "parallel") runForegroundInBackground(data, deps);
 	return {
 		content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${mode}: ${data.runId}`) }],
 		details: {

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,
@@ -56,8 +52,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,7 +76,7 @@ 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!;
@@ -112,10 +108,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);
@@ -180,13 +175,14 @@ export function prepareExecutionContext(input: {
 		sessionFileForIndex: childSessionFileForIndex,
 		artifactConfig,
 		artifactsDir,
+		parentDepth: depth,
 		effectiveAsync,
 		controlConfig,
 		intercomBridge,
 		nestedRoute,
 	};
 
-	const foregroundMode: "single" | "parallel" | "chain" = hasChain ? "chain" : hasTasks ? "parallel" : "single";
+	const foregroundMode: "single" | "parallel" = hasTasks ? "parallel" : "single";
 	const foregroundControl = effectiveAsync
 		? undefined
 		: {
@@ -224,15 +220,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 +279,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,7 @@ 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 { buildTaskInstructions, type ResolvedStepBehavior } from "../../shared/settings.ts";
 import type {
 	AgentProgress,
 	ArtifactConfig,
@@ -15,7 +15,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,6 +38,7 @@ interface ForegroundParallelRunInput {
 	maxOutput?: MaxOutputConfig;
 	paramsCwd: string;
 	maxSubagentDepths: number[];
+	parentDepth?: number;
 	workflowStageSubagentGuard?: boolean;
 	availableModels: ModelInfo[];
 	knownModelProviders: string[];
@@ -77,10 +78,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 +125,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,

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

@@ -21,7 +21,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";
@@ -226,6 +226,7 @@ export async function runParallelPath(
 			foregroundControl,
 			concurrencyLimit: parallelConcurrency,
 			maxSubagentDepths,
+			parentDepth: data.parentDepth,
 			liveResults,
 			liveProgress,
 			onUpdate,
@@ -250,7 +251,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-single.ts

@@ -20,7 +20,7 @@ import {
 } from "../../shared/types.ts";
 import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.ts";
 import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.ts";
-import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.ts";
+import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.js";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
 import { recordRun } from "../shared/run-history.ts";
 import {
@@ -196,6 +196,7 @@ export async function runSinglePath(
 			outputPath,
 			outputMode: effectiveOutputMode,
 			maxSubagentDepth,
+			parentDepth: data.parentDepth,
 			workflowStageSubagentGuard,
 			workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
 			onUpdate: forwardSingleUpdate,
@@ -262,7 +263,13 @@ export async function runSinglePath(
 		artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 		truncation: r.truncation,
 	});
-	rememberForegroundRun(deps.state, { runId, mode: "single", cwd: effectiveCwd, results: details.results });
+	rememberForegroundRun(deps.state, {
+		runId,
+		mode: "single",
+		cwd: effectiveCwd,
+		results: details.results,
+		maxSubagentDepths: [maxSubagentDepth],
+	});
 
 	if (!r.detached && !r.interrupted) {
 		if (foregroundControl) updateForegroundNestedProjection(foregroundControl);

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

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@bastani/atomic";
+import { type ExtensionAPI, isStaleExtensionContextError } from "@bastani/atomic";
 import { type IntercomBridgeState, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import {
 	attachNestedChildrenToResultChildren,
@@ -127,7 +127,14 @@ function takeEarlyDetachedResult(state: SubagentState, runId: string, index: num
 
 export function rememberForegroundRun(
 	state: SubagentState,
-	input: { runId: string; mode: "single" | "parallel" | "chain"; cwd: string; results: SingleResult[] },
+	input: {
+		runId: string;
+		mode: "single" | "parallel";
+		cwd: string;
+		results: SingleResult[];
+		/** Effective delegation limit per child, aligned with `results` by index. */
+		maxSubagentDepths?: readonly (number | undefined)[];
+	},
 ): void {
 	state.foregroundRuns ??= new Map();
 	state.foregroundRuns.set(input.runId, {
@@ -137,6 +144,7 @@ export function rememberForegroundRun(
 		updatedAt: Date.now(),
 		children: input.results.map((originalResult, index) => {
 			const result = takeEarlyDetachedResult(state, input.runId, index) ?? originalResult;
+			const maxSubagentDepth = input.maxSubagentDepths?.[index];
 			return {
 				agent: result.agent,
 				index,
@@ -146,6 +154,7 @@ export function rememberForegroundRun(
 					detached: result.detached,
 				}),
 				...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
+				...(maxSubagentDepth === undefined ? {} : { maxSubagentDepth }),
 				result,
 			};
 		}),
@@ -218,7 +227,12 @@ export function emitControlNotification(input: {
 		noticeText: formatControlNoticeMessage(input.event, childIntercomTarget),
 	};
 	if (input.controlConfig.notifyChannels.includes("event")) {
-		input.pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
+		try {
+			input.pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Control notices are best effort after a parent runtime replacement.
+		}
 	}
 	if (
 		input.event.type !== "active_long_running" &&
@@ -226,11 +240,16 @@ export function emitControlNotification(input: {
 		input.intercomBridge.active &&
 		input.intercomBridge.orchestratorTarget
 	) {
-		input.pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
-			...payload,
-			to: input.intercomBridge.orchestratorTarget,
-			message: formatControlIntercomMessage(input.event, childIntercomTarget),
-		});
+		try {
+			input.pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
+				...payload,
+				to: input.intercomBridge.orchestratorTarget,
+				message: formatControlIntercomMessage(input.event, childIntercomTarget),
+			});
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Intercom control notices are best effort after a parent runtime replacement.
+		}
 	}
 }
 
@@ -290,7 +309,11 @@ export function notifyDetachedForegroundChildExit(input: {
 			noticeLabel: "Detached subagent task",
 		},
 		`foreground-detach-${runId}-${index}`,
-	);
+	).catch((error) => {
+		if (!isStaleExtensionContextError(error)) {
+			console.error("Failed to emit detached subagent completion notification:", error);
+		}
+	});
 }
 
 async function emitForegroundResultIntercom(input: {
@@ -299,7 +322,6 @@ async function emitForegroundResultIntercom(input: {
 	runId: string;
 	mode: SubagentRunMode;
 	results: SingleResult[];
-	chainSteps?: number;
 	nestedChildren?: NestedRunSummary[];
 }): Promise<ReturnType<typeof buildSubagentResultIntercomPayload> | null> {
 	if (!input.intercomBridge.active || !input.intercomBridge.orchestratorTarget) return null;
@@ -329,7 +351,6 @@ async function emitForegroundResultIntercom(input: {
 		mode: input.mode,
 		source: "foreground",
 		children: attachNestedChildrenToResultChildren(input.runId, children, input.nestedChildren),
-		...(typeof input.chainSteps === "number" ? { chainSteps: input.chainSteps } : {}),
 	});
 	const delivered = await deliverSubagentResultIntercomEvent(input.pi.events, payload);
 	if (!delivered) return null;
@@ -350,7 +371,6 @@ export async function maybeBuildForegroundIntercomReceipt(input: {
 		runId: input.runId,
 		mode: input.mode,
 		results: input.details.results,
-		...(typeof input.details.totalSteps === "number" ? { chainSteps: input.details.totalSteps } : {}),
 		...(input.nestedChildren?.length ? { nestedChildren: input.nestedChildren } : {}),
 	});
 	if (!payload) return null;