@bastani/atomic 0.9.14 → 0.9.15-alpha.1

package/dist/builtin/subagents/src/intercom/result-intercom.ts

@@ -3,9 +3,6 @@ import { isStaleExtensionContextError } from "@bastani/atomic";
 import {
 	type Details,
 	type IntercomEventBus,
-	MAX_SUBAGENT_NESTING_DEPTH,
-	type NestedRunSummary,
-	type PublicNestedRunSummary,
 	type SingleResult,
 	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
 	SUBAGENT_RESULT_INTERCOM_EVENT,
@@ -63,128 +60,6 @@ function resolveGroupedStatus(children: SubagentResultIntercomChild[]): Subagent
 	return "failed";
 }
 
-function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth = 0): PublicNestedRunSummary {
-	return {
-		id: run.id,
-		parentRunId: run.parentRunId,
-		...(run.parentStepIndex !== undefined ? { parentStepIndex: run.parentStepIndex } : {}),
-		...(run.parentAgent ? { parentAgent: run.parentAgent } : {}),
-		depth: run.depth,
-		path: run.path.slice(0, MAX_SUBAGENT_NESTING_DEPTH + 1).map((part) => ({
-			runId: part.runId,
-			...(part.stepIndex !== undefined ? { stepIndex: part.stepIndex } : {}),
-			...(part.agent ? { agent: part.agent } : {}),
-		})),
-		...(run.sessionId ? { sessionId: run.sessionId } : {}),
-		...(run.sessionFile ? { sessionFile: run.sessionFile } : {}),
-		...(run.intercomTarget ? { intercomTarget: run.intercomTarget } : {}),
-		...(run.ownerIntercomTarget ? { ownerIntercomTarget: run.ownerIntercomTarget } : {}),
-		...(run.leafIntercomTarget ? { leafIntercomTarget: run.leafIntercomTarget } : {}),
-		...(run.ownerState ? { ownerState: run.ownerState } : {}),
-		...(run.mode ? { mode: run.mode } : {}),
-		state: run.state,
-		...(run.agent ? { agent: run.agent } : {}),
-		...(run.agents?.length ? { agents: run.agents.slice(0, 12) } : {}),
-		...(run.activityState ? { activityState: run.activityState } : {}),
-		...(run.lastActivityAt !== undefined ? { lastActivityAt: run.lastActivityAt } : {}),
-		...(run.currentTool ? { currentTool: run.currentTool } : {}),
-		...(run.currentToolStartedAt !== undefined ? { currentToolStartedAt: run.currentToolStartedAt } : {}),
-		...(run.currentPath ? { currentPath: run.currentPath } : {}),
-		...(run.turnCount !== undefined ? { turnCount: run.turnCount } : {}),
-		...(run.toolCount !== undefined ? { toolCount: run.toolCount } : {}),
-		...(run.totalTokens ? { totalTokens: run.totalTokens } : {}),
-		...(run.startedAt !== undefined ? { startedAt: run.startedAt } : {}),
-		...(run.endedAt !== undefined ? { endedAt: run.endedAt } : {}),
-		...(run.lastUpdate !== undefined ? { lastUpdate: run.lastUpdate } : {}),
-		...(run.error ? { error: run.error } : {}),
-		...(run.steps?.length
-			? {
-					steps: run.steps.slice(0, 12).map((step) => ({
-						agent: step.agent,
-						status: step.status,
-						...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
-						...(step.activityState ? { activityState: step.activityState } : {}),
-						...(step.lastActivityAt !== undefined ? { lastActivityAt: step.lastActivityAt } : {}),
-						...(step.currentTool ? { currentTool: step.currentTool } : {}),
-						...(step.currentToolStartedAt !== undefined
-							? { currentToolStartedAt: step.currentToolStartedAt }
-							: {}),
-						...(step.currentPath ? { currentPath: step.currentPath } : {}),
-						...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
-						...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
-						...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
-						...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
-						...(step.error ? { error: step.error } : {}),
-						...(depth < MAX_SUBAGENT_NESTING_DEPTH && step.children?.length
-							? { children: step.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) }
-							: {}),
-					})),
-				}
-			: {}),
-		...(depth < MAX_SUBAGENT_NESTING_DEPTH && run.children?.length
-			? { children: run.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) }
-			: {}),
-	};
-}
-
-export function compactNestedResultChildren(
-	children: Array<NestedRunSummary | PublicNestedRunSummary> | undefined,
-): PublicNestedRunSummary[] | undefined {
-	if (!children?.length) return undefined;
-	return children.slice(0, 16).map((child) => compactNestedRun(child));
-}
-
-export function attachNestedChildrenToResultChildren(
-	runId: string,
-	children: SubagentResultIntercomChild[],
-	nestedChildren: NestedRunSummary[] | undefined,
-): SubagentResultIntercomChild[] {
-	const compact = compactNestedResultChildren(nestedChildren);
-	if (!compact?.length)
-		return children.map((child) => ({ ...child, children: compactNestedResultChildren(child.children) }));
-	return children.map((child, index) => {
-		const childIndex = child.index ?? index;
-		const alreadyAttachedIds = new Set(child.children?.map((nested) => nested.id) ?? []);
-		const attached = compact.filter(
-			(nested) =>
-				nested.parentRunId === runId && nested.parentStepIndex === childIndex && !alreadyAttachedIds.has(nested.id),
-		);
-		const fallbackAttached =
-			children.length === 1
-				? compact.filter(
-						(nested) =>
-							nested.parentRunId === runId &&
-							nested.parentStepIndex === undefined &&
-							!alreadyAttachedIds.has(nested.id),
-					)
-				: [];
-		const merged = compactNestedResultChildren([...(child.children ?? []), ...attached, ...fallbackAttached]);
-		return merged?.length ? { ...child, children: merged } : { ...child, children: undefined };
-	});
-}
-
-function formatNestedResultLines(children: PublicNestedRunSummary[] | undefined): string[] {
-	if (!children?.length) return [];
-	const lines = ["Nested subagents:"];
-	let remaining = 10;
-	const append = (runs: PublicNestedRunSummary[] | undefined, indent: string): void => {
-		for (const run of runs ?? []) {
-			if (remaining <= 0) {
-				lines.push(`${indent}↳ +more nested runs; inspect status for full tree`);
-				return;
-			}
-			remaining--;
-			const label = run.agent ?? run.agents?.join("+") ?? run.id;
-			lines.push(`${indent}↳ ${label} — ${run.state} [${run.id}]`);
-			if (run.sessionFile) lines.push(`${indent}  Session: ${run.sessionFile}`);
-			append(run.children, `${indent}  `);
-			for (const step of run.steps ?? []) append(step.children, `${indent}    `);
-		}
-	};
-	append(children, "");
-	return lines;
-}
-
 export interface GroupedResultIntercomMessageInput {
 	to: string;
 	runId: string;
@@ -220,7 +95,6 @@ function formatSubagentResultIntercomMessage(input: {
 		if (child.intercomTarget) lines.push(`Run intercom target: ${child.intercomTarget}`);
 		if (child.artifactPath) lines.push(`Output artifact: ${child.artifactPath}`);
 		if (child.sessionPath) lines.push(`Session: ${child.sessionPath}`);
-		lines.push(...formatNestedResultLines(child.children));
 		lines.push("Summary:", child.summary);
 	}
 
@@ -233,7 +107,6 @@ export function buildSubagentResultIntercomPayload(
 	const children = input.children.map((child) => ({
 		...child,
 		summary: child.summary.trim() || "(no output)",
-		children: compactNestedResultChildren(child.children),
 	}));
 	const status = resolveGroupedStatus(children);
 	const summary = formatStatusCounts(countStatuses(children));

package/dist/builtin/subagents/src/runs/foreground/inprocess-run-sync.ts

@@ -56,7 +56,6 @@ function workflowOrchestrationContext(options: RunSyncOptions): ParentContext["o
 		workflowStageName: workflow.stageName,
 		constraints: {
 			disableWorkflowTool: true,
-			maxSubagentDepth: options.maxSubagentDepth ?? 5,
 		},
 		...(options.intercomGroup ? { intercomGroup: options.intercomGroup } : {}),
 	};
@@ -263,7 +262,6 @@ export async function runSingleInProcess(
 		cwd,
 		testSession: testSession,
 		sessionFile: options.sessionFile,
-		...(options.maxSubagentDepth === undefined ? {} : { maxSubagentDepth: options.maxSubagentDepth }),
 		tools: agent.tools,
 		mcpDirectTools: agent.mcpDirectTools,
 		skills: options.skills ?? agent.skills,
@@ -351,7 +349,7 @@ export async function runSingleInProcess(
 			lastActivityAt: Date.now(),
 		});
 	}
-	control.registerNestedAttempt(options.runId, running, {
+	control.registerAttempt(options.runId, running, {
 		model: resolvedCandidate?.model,
 		modelId: candidate,
 		thinkingLevel: spec.thinkingLevel,

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

@@ -7,7 +7,6 @@ import {
 	applyIntercomBridgeToAgent,
 	resolveIntercomBridge,
 	resolveIntercomSessionTarget,
-	resolveSubagentIntercomTarget,
 } from "../../intercom/intercom-bridge.js";
 import { getArtifactsDir } from "../../shared/artifacts.js";
 import { createForkContextResolver } from "../../shared/fork-context.js";
@@ -15,19 +14,13 @@ import { resolveCurrentSessionId } from "../../shared/session-identity.js";
 import { buildReadInstruction } from "../../shared/settings.js";
 import {
 	type ArtifactConfig,
-	checkSubagentDepth,
 	DEFAULT_ARTIFACT_CONFIG,
-	resolveSubagentDepthPolicy,
+	getCurrentSubagentDepth,
+	isSubagentChildSession,
+	SUBAGENT_CHILD_DELEGATION_BLOCKED_MESSAGE,
+	type SubagentRunMode,
 	type SubagentToolResult,
-	subagentDepthBlockedMessage,
 } from "../../shared/types.js";
-
-import {
-	createNestedRoute,
-	resolveInheritedNestedRouteFromEnv,
-	resolveNestedParentAddressFromEnv,
-	writeNestedEvent,
-} from "../inprocess/runtime-support/nested-api.js";
 import { resolveControlConfig } from "../shared/subagent-control.js";
 import {
 	applyAgentDefaultContext,
@@ -43,23 +36,19 @@ import type {
 	SubagentParamsLike,
 } from "./subagent-executor-types.js";
 
-export function checkDepthForExecution(
-	ctx: ExtensionContext,
-	deps: ResolvedExecutorDeps,
+/**
+ * Delegation is one level deep and not configurable: a session that was itself
+ * admitted as a subagent child may never call the subagent tool.
+ */
+export function refuseSubagentChildDelegation(
+	ctx: Pick<ExtensionContext, "subagentPolicy">,
+	mode: SubagentRunMode | "management",
 ): SubagentToolResult | undefined {
-	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
-	const { blocked, depth, maxDepth } = checkSubagentDepth(ctx, depthPolicy.maxSubagentDepth);
-	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
-	if (!blocked) return undefined;
+	if (!isSubagentChildSession(ctx)) return undefined;
 	return {
-		content: [
-			{
-				type: "text",
-				text: subagentDepthBlockedMessage(depth, maxDepth, { workflowStageGuard: workflowStageSubagentGuard }),
-			},
-		],
+		content: [{ type: "text", text: SUBAGENT_CHILD_DELEGATION_BLOCKED_MESSAGE }],
 		isError: true,
-		details: { mode: "single" as const, results: [] },
+		details: { mode, results: [] },
 	};
 }
 
@@ -71,8 +60,7 @@ export function prepareExecutionContext(input: {
 	deps: ResolvedExecutorDeps;
 }): ExecutionContextBuildResult {
 	const { params, ctx, signal, onUpdate, deps } = input;
-	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
-	const { depth } = checkSubagentDepth(ctx, depthPolicy.maxSubagentDepth);
+	const depth = getCurrentSubagentDepth(ctx);
 	const normalized = normalizeRepeatedParallelCounts(params);
 	if (normalized.error) return { error: normalized.error };
 	const normalizedParams = normalized.params!;
@@ -96,9 +84,6 @@ export function prepareExecutionContext(input: {
 		? discoveredAgents.map((agent) => applyIntercomBridgeToAgent(agent, intercomBridge))
 		: discoveredAgents;
 	const runId = randomUUID().slice(0, 8);
-	const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
-	const nestedParentAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
-	const nestedRoute = inheritedNestedRoute ?? createNestedRoute(runId);
 	const shareEnabled = effectiveParams.share === true;
 	const hasTasks = (effectiveParams.tasks?.length ?? 0) > 0;
 	const hasSingle = !hasTasks && Boolean(effectiveParams.agent);
@@ -169,7 +154,6 @@ export function prepareExecutionContext(input: {
 		parentDepth: depth,
 		controlConfig,
 		intercomBridge,
-		nestedRoute,
 	};
 
 	const foregroundMode: "single" | "parallel" = hasTasks ? "parallel" : "single";
@@ -178,85 +162,11 @@ export function prepareExecutionContext(input: {
 		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",
-		result?: SubagentToolResult,
-	): void => {
-		if (!inheritedNestedRoute || !nestedParentAddress) return;
-		const now = Date.now();
-		const details = result?.details;
-		const state =
-			type === "subagent.nested.started"
-				? "running"
-				: result?.isError || details?.results.some((child) => child.status === "error")
-					? "failed"
-					: details?.results.some((child) => child.interrupted || child.status === "interrupted")
-						? "paused"
-						: "complete";
-		const errorText = result?.isError ? result.content.find((item) => item.type === "text")?.text : undefined;
-		const agentsForSummary =
-			hasTasks && effectiveParams.tasks
-				? effectiveParams.tasks.map((task) => task.agent)
-				: effectiveParams.agent
-					? [effectiveParams.agent]
-					: [];
-		const leafIntercomTarget =
-			intercomBridge.active && agentsForSummary[0]
-				? resolveSubagentIntercomTarget(runId, agentsForSummary[0], 0)
-				: undefined;
-		try {
-			writeNestedEvent(inheritedNestedRoute, {
-				type,
-				ts: now,
-				parentRunId: nestedParentAddress.parentRunId,
-				parentStepIndex: nestedParentAddress.parentStepIndex,
-				child: {
-					id: runId,
-					parentRunId: nestedParentAddress.parentRunId,
-					parentStepIndex: nestedParentAddress.parentStepIndex,
-					depth: nestedParentAddress.depth,
-					path: nestedParentAddress.path,
-					ownerIntercomTarget:
-						ctx.subagentPolicy?.intercom?.sessionName ?? ctx.subagentPolicy?.intercom?.orchestratorTarget,
-					leafIntercomTarget,
-					intercomTarget: leafIntercomTarget,
-					ownerState: state === "running" ? "live" : "gone",
-					mode: foregroundMode,
-					state,
-					agent: agentsForSummary[0],
-					agents: agentsForSummary,
-					startedAt: foregroundControl?.startedAt ?? now,
-					...(state !== "running" ? { endedAt: now } : {}),
-					lastUpdate: now,
-					...(errorText ? { error: errorText } : {}),
-					...(details?.results.length
-						? {
-								steps: details.results.map((child) => ({
-									agent: child.agent,
-									status:
-										child.interrupted || child.status === "interrupted"
-											? "paused"
-											: child.status === "ok"
-												? "complete"
-												: "failed",
-									...(child.sessionFile ? { sessionFile: child.sessionFile } : {}),
-									...(child.error ? { error: child.error } : {}),
-								})),
-							}
-						: {}),
-				},
-			});
-		} catch (error) {
-			console.error("Failed to emit nested foreground status event:", error);
-		}
-	};
-
 	return {
 		prepared: {
 			effectiveParams,
@@ -267,7 +177,6 @@ export function prepareExecutionContext(input: {
 			foregroundMode,
 			execData,
 			foregroundControl,
-			writeNestedForegroundEvent,
 		},
 	};
 }

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

@@ -38,7 +38,6 @@ interface ForegroundParallelRunInput {
 	artifactsDir: string;
 	maxOutput?: MaxOutputConfig;
 	paramsCwd: string;
-	maxSubagentDepths: number[];
 	parentDepth?: number;
 	workflowStageSubagentGuard?: boolean;
 	availableModels: ModelInfo[];
@@ -126,7 +125,6 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 				maxOutput: input.maxOutput,
 				outputPath,
 				outputMode: behavior?.outputMode,
-				maxSubagentDepth: input.maxSubagentDepths[index],
 				parentDepth: input.parentDepth,
 				workflowStageSubagentGuard: input.workflowStageSubagentGuard,
 				workflowSessionMetadata: workflowSessionMetadataFromContext(input.ctx),
@@ -142,7 +140,6 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 				onDetachedExit: (result) => input.onDetachedExit?.(index, result),
 				intercomDetachSignal: intercomDetachController.signal,
 				onIntercomDetachCommit: () => intercomDetachController.abort(),
-				nestedRoute: input.foregroundControl?.nestedRoute,
 				modelOverride: input.modelOverrides[index],
 				availableModels: input.availableModels,
 				knownModelProviders: input.knownModelProviders,

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

@@ -12,8 +12,7 @@ import {
 import {
 	type AgentProgress,
 	type ArtifactPaths,
-	resolveChildMaxSubagentDepth,
-	resolveSubagentDepthPolicy,
+	isWorkflowStageOrchestrationContext,
 	resolveTopLevelParallelConcurrency,
 	resolveTopLevelParallelMaxTasks,
 	type SingleResult,
@@ -21,7 +20,6 @@ import {
 	wrapForkTask,
 } from "../../shared/types.js";
 import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.js";
-import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.js";
 import { sharedAutoGroupForSet } from "../shared/intercom-group.js";
 import { resolveModelCandidate } from "../shared/model-fallback.js";
 import { aggregateParallelOutputs } from "../shared/parallel-utils.js";
@@ -97,12 +95,7 @@ export async function runParallelPath(
 		agentConfigs.push(config);
 	}
 
-	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
-	const currentMaxSubagentDepth = depthPolicy.maxSubagentDepth;
-	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
-	const maxSubagentDepths = agentConfigs.map((config) =>
-		resolveChildMaxSubagentDepth(currentMaxSubagentDepth, config.maxSubagentDepth),
-	);
+	const workflowStageSubagentGuard = isWorkflowStageOrchestrationContext(ctx);
 
 	if (params.worktree) {
 		const worktreeTaskCwdError = buildParallelWorktreeTaskCwdError(tasks, effectiveCwd);
@@ -227,7 +220,6 @@ export async function runParallelPath(
 			sharedAutoIntercomGroup: sharedAutoGroupForSet(params.group, tasks),
 			foregroundControl,
 			concurrencyLimit: parallelConcurrency,
-			maxSubagentDepths,
 			parentDepth: data.parentDepth,
 			liveResults,
 			liveProgress,
@@ -258,7 +250,6 @@ export async function runParallelPath(
 			mode: "parallel",
 			cwd: effectiveCwd,
 			results: details.results,
-			maxSubagentDepths,
 		});
 		if (interrupted) {
 			return {
@@ -288,14 +279,12 @@ export async function runParallelPath(
 			};
 		}
 
-		if (foregroundControl) updateForegroundNestedProjection(foregroundControl);
 		const intercomReceipt = await maybeBuildForegroundIntercomReceipt({
 			pi: deps.pi,
 			intercomBridge: data.intercomBridge,
 			runId,
 			mode: "parallel",
 			details,
-			...(foregroundControl?.nestedChildren?.length ? { nestedChildren: foregroundControl.nestedChildren } : {}),
 		});
 		if (intercomReceipt) {
 			return {

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

@@ -12,15 +12,13 @@ import {
 import {
 	type AgentProgress,
 	type ArtifactPaths,
-	resolveChildMaxSubagentDepth,
-	resolveSubagentDepthPolicy,
+	isWorkflowStageOrchestrationContext,
 	type SingleResult,
 	type SubagentToolResult,
 	workflowSessionMetadataFromContext,
 	wrapForkTask,
 } from "../../shared/types.js";
 import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.js";
-import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.js";
 import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.js";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.js";
 import { recordRun } from "../shared/run-history.js";
@@ -135,10 +133,7 @@ export async function runSinglePath(
 	const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
 	const effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
 	const effectiveOutputMode = params.outputMode ?? "inline";
-	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
-	const currentMaxSubagentDepth = depthPolicy.maxSubagentDepth;
-	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
-	const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, agentConfig.maxSubagentDepth);
+	const workflowStageSubagentGuard = isWorkflowStageOrchestrationContext(ctx);
 	const progress = resolveSingleProgress(agentConfig, params.progress, task);
 
 	if (params.context === "fork") {
@@ -204,7 +199,6 @@ export async function runSinglePath(
 			maxOutput: params.maxOutput,
 			outputPath,
 			outputMode: effectiveOutputMode,
-			maxSubagentDepth,
 			parentDepth: data.parentDepth,
 			workflowStageSubagentGuard,
 			workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
@@ -214,7 +208,6 @@ export async function runSinglePath(
 			intercomSessionName: childIntercomTarget,
 			orchestratorIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
 			intercomGroup: resolveChildIntercomGroup(params.group, inheritedIntercomGroup(ctx), undefined),
-			nestedRoute: foregroundControl?.nestedRoute,
 			onDetachedExit: (result) => {
 				cleanupTransientProgress(progressDir, artifactConfig.enabled);
 				if (result) {
@@ -279,18 +272,15 @@ export async function runSinglePath(
 		mode: "single",
 		cwd: effectiveCwd,
 		results: details.results,
-		maxSubagentDepths: [maxSubagentDepth],
 	});
 
 	if (!r.detached && !r.interrupted) {
-		if (foregroundControl) updateForegroundNestedProjection(foregroundControl);
 		const intercomReceipt = await maybeBuildForegroundIntercomReceipt({
 			pi: deps.pi,
 			intercomBridge: data.intercomBridge,
 			runId,
 			mode: "single",
 			details,
-			...(foregroundControl?.nestedChildren?.length ? { nestedChildren: foregroundControl.nestedChildren } : {}),
 		});
 		if (intercomReceipt) {
 			return {

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

@@ -1,7 +1,6 @@
 import { type ExtensionAPI, isStaleExtensionContextError } from "@bastani/atomic";
 import { type IntercomBridgeState, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
 import {
-	attachNestedChildrenToResultChildren,
 	buildSubagentResultIntercomPayload,
 	deliverSubagentResultIntercomEvent,
 	formatSubagentResultReceipt,
@@ -11,7 +10,6 @@ import {
 import {
 	type ControlEvent,
 	type Details,
-	type NestedRunSummary,
 	type SingleResult,
 	SUBAGENT_CONTROL_EVENT,
 	SUBAGENT_CONTROL_INTERCOM_EVENT,
@@ -20,8 +18,6 @@ import {
 	type SubagentToolResult,
 } from "../../shared/types.js";
 import { compactForegroundDetails, compactForegroundResult, getSingleResultOutput } from "../../shared/utils.js";
-import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.js";
-import { formatNestedRunStatusLines } from "../inprocess/runtime-support/nested-rendering.js";
 import {
 	formatControlIntercomMessage,
 	formatControlNoticeMessage,
@@ -68,12 +64,6 @@ function formatForegroundActivity(control: ForegroundControl): string | undefine
 }
 
 export function foregroundStatusResult(control: ForegroundControl): SubagentToolResult {
-	let nestedWarning: string | undefined;
-	try {
-		updateForegroundNestedProjection(control);
-	} catch (error) {
-		nestedWarning = `Nested status unavailable: ${error instanceof Error ? error.message : String(error)}`;
-	}
 	const activity = formatForegroundActivity(control);
 	const lines = [
 		`Run: ${control.runId}`,
@@ -84,8 +74,6 @@ export function foregroundStatusResult(control: ForegroundControl): SubagentTool
 			: undefined,
 		activity ? `Activity: ${activity}` : undefined,
 	].filter((line): line is string => Boolean(line));
-	lines.push(...formatNestedRunStatusLines(control.nestedChildren, { indent: "", commandHints: true, maxLines: 20 }));
-	if (nestedWarning) lines.push(`Warning: ${nestedWarning}`);
 	return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "management", results: [] } };
 }
 
@@ -132,8 +120,6 @@ export function rememberForegroundRun(
 		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();
@@ -144,7 +130,6 @@ 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,
@@ -154,7 +139,6 @@ export function rememberForegroundRun(
 					detached: result.detached,
 				}),
 				...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
-				...(maxSubagentDepth === undefined ? {} : { maxSubagentDepth }),
 				result,
 			};
 		}),
@@ -323,7 +307,6 @@ async function emitForegroundResultIntercom(input: {
 	runId: string;
 	mode: SubagentRunMode;
 	results: SingleResult[];
-	nestedChildren?: NestedRunSummary[];
 }): Promise<ReturnType<typeof buildSubagentResultIntercomPayload> | null> {
 	if (!input.intercomBridge.active || !input.intercomBridge.orchestratorTarget) return null;
 	const children = input.results.flatMap((result, index) =>
@@ -350,7 +333,7 @@ async function emitForegroundResultIntercom(input: {
 		to: input.intercomBridge.orchestratorTarget,
 		runId: input.runId,
 		mode: input.mode,
-		children: attachNestedChildrenToResultChildren(input.runId, children, input.nestedChildren),
+		children,
 	});
 	const delivered = await deliverSubagentResultIntercomEvent(input.pi.events, payload);
 	if (!delivered) return null;
@@ -363,7 +346,6 @@ export async function maybeBuildForegroundIntercomReceipt(input: {
 	runId: string;
 	mode: SubagentRunMode;
 	details: Details;
-	nestedChildren?: NestedRunSummary[];
 }): Promise<{ text: string; details: Details } | null> {
 	const payload = await emitForegroundResultIntercom({
 		pi: input.pi,
@@ -371,7 +353,6 @@ export async function maybeBuildForegroundIntercomReceipt(input: {
 		runId: input.runId,
 		mode: input.mode,
 		results: input.details.results,
-		...(input.nestedChildren?.length ? { nestedChildren: input.nestedChildren } : {}),
 	});
 	if (!payload) return null;
 	return {

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

@@ -6,7 +6,6 @@ import type {
 	ArtifactConfig,
 	ControlConfig,
 	MaxOutputConfig,
-	NestedRouteInfo,
 	ResolvedControlConfig,
 	SUBAGENT_ACTIONS,
 	SubagentState,
@@ -105,7 +104,6 @@ export interface ExecutionContextData {
 	parentDepth?: number;
 	controlConfig: ResolvedControlConfig;
 	intercomBridge: IntercomBridgeState;
-	nestedRoute?: NestedRouteInfo;
 }
 
 export interface PreparedExecutionContext {
@@ -117,10 +115,6 @@ export interface PreparedExecutionContext {
 	foregroundMode: "single" | "parallel";
 	execData: ExecutionContextData;
 	foregroundControl?: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
-	writeNestedForegroundEvent: (
-		type: "subagent.nested.started" | "subagent.nested.completed",
-		result?: SubagentToolResult,
-	) => void;
 }
 
 export interface ExecutionContextBuildResult {