@bastani/atomic 0.9.14-alpha.6 → 0.9.15-alpha.1

package/dist/builtin/subagents/src/agents/agent-management.ts

@@ -125,7 +125,6 @@ function formatAgentDetail(agent: AgentConfig): string {
 	if (agent.output) lines.push(`Output: ${agent.output}`);
 	if (agent.defaultReads?.length) lines.push(`Reads: ${agent.defaultReads.join(", ")}`);
 	if (agent.defaultProgress) lines.push("Progress: true");
-	if (agent.maxSubagentDepth !== undefined) lines.push(`Max subagent depth: ${agent.maxSubagentDepth}`);
 	if (agent.systemPrompt.trim()) lines.push("", "System Prompt:", agent.systemPrompt);
 	return lines.join("\n");
 }

package/dist/builtin/subagents/src/agents/agent-serializer.ts

@@ -23,10 +23,15 @@ export const KNOWN_FIELDS = new Set([
 	"defaultReads",
 	"defaultProgress",
 	"interactive",
-	"maxSubagentDepth",
 ]);
 
-const REMOVED_AGENT_FRONTMATTER_FIELDS = new Set<string>([`completion${"Guard"}`]);
+/**
+ * Frontmatter keys whose feature is gone. They are neither preserved on load nor
+ * re-emitted on serialize, so an agent-management rewrite strips a stale key from
+ * the file. Each is spelled with a splice so the removed identifier never appears
+ * as contiguous source text.
+ */
+const REMOVED_AGENT_FRONTMATTER_FIELDS = new Set<string>([`completion${"Guard"}`, `maxSubagent${"Depth"}`]);
 
 export function shouldPreserveAgentExtraField(key: string): boolean {
 	return !KNOWN_FIELDS.has(key) && !REMOVED_AGENT_FRONTMATTER_FIELDS.has(key);
@@ -93,10 +98,6 @@ export function serializeAgent(config: AgentConfig): string {
 
 	if (config.defaultProgress) lines.push("defaultProgress: true");
 	if (config.interactive) lines.push("interactive: true");
-	const maxSubagentDepth = config.maxSubagentDepth;
-	if (typeof maxSubagentDepth === "number" && Number.isInteger(maxSubagentDepth) && maxSubagentDepth >= 0) {
-		lines.push(`maxSubagentDepth: ${maxSubagentDepth}`);
-	}
 
 	if (config.extraFields) {
 		for (const [key, value] of Object.entries(config.extraFields)) {

package/dist/builtin/subagents/src/agents/agent-types.ts

@@ -79,7 +79,6 @@ export interface AgentConfig {
 	defaultReads?: string[];
 	defaultProgress?: boolean;
 	interactive?: boolean;
-	maxSubagentDepth?: number;
 	disabled?: boolean;
 	extraFields?: Record<string, FrontmatterValue>;
 	override?: BuiltinAgentOverrideInfo;

package/dist/builtin/subagents/src/extension/schemas.ts

@@ -3,7 +3,7 @@
  */
 
 import { Type } from "typebox";
-import { MAX_PARALLEL_TASKS, MAX_SUBAGENT_NESTING_DEPTH, SUBAGENT_ACTIONS } from "../shared/types.js";
+import { MAX_PARALLEL_TASKS, SUBAGENT_ACTIONS } from "../shared/types.js";
 
 const SkillOverride = Type.Unsafe({
 	anyOf: [{ type: "array", items: { type: "string" } }, { type: "boolean" }, { type: "string" }],
@@ -146,7 +146,7 @@ export const SubagentParams = Type.Object(
 		config: Type.Optional(
 			Type.Unsafe({
 				anyOf: [{ type: "object", additionalProperties: true }, { type: "string" }],
-				description: `Agent config for create/update. Agent: name, package (optional namespace; runtime name becomes package.name), description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth (integer >= 0, clamped to ${MAX_SUBAGENT_NESTING_DEPTH}). String values must be valid JSON.`,
+				description: `Agent config for create/update. Agent: name, package (optional namespace; runtime name becomes package.name), description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress. String values must be valid JSON.`,
 			}),
 		),
 		tasks: Type.Optional(

package/dist/builtin/subagents/src/extension/startup-maintenance.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
-import { cleanupOldNestedRuntimeDirs } from "../runs/inprocess/runtime-support/nested-api.js";
+import { cleanupOldSubagentRuntimeDirs } from "../runs/inprocess/runtime-support/temp-cleanup.js";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.js";
 import type { SubagentState } from "../shared/types.js";
 
@@ -105,7 +105,7 @@ export function createSubagentStartupMaintenance(
 	return {
 		scheduleStartupCleanup() {
 			schedule(() => {
-				swallowCleanup(() => cleanupOldNestedRuntimeDirs(options.artifactCleanupDays));
+				swallowCleanup(() => cleanupOldSubagentRuntimeDirs(options.artifactCleanupDays));
 				scheduleDelayed(
 					() => swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays, contextSessionsRoots)),
 					STARTUP_ARTIFACT_SCAN_DELAY_MS,

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 {