@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

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

@@ -1,246 +0,0 @@
-import { type ExtensionAPI, isStaleExtensionContextError } from "@bastani/atomic";
-import { type IntercomBridgeState, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import {
-	buildSubagentResultIntercomPayload,
-	deliverSubagentResultIntercomEvent,
-	formatSubagentResultReceipt,
-	resolveSubagentResultStatus,
-	stripDetailsOutputsForIntercomReceipt,
-} from "../../intercom/result-intercom.js";
-import {
-	type ControlEvent,
-	type Details,
-	type SingleResult,
-	SUBAGENT_CONTROL_EVENT,
-	SUBAGENT_CONTROL_INTERCOM_EVENT,
-	type SubagentRunMode,
-	type SubagentState,
-	type SubagentToolResult,
-} from "../../shared/types.js";
-import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.js";
-import {
-	formatControlIntercomMessage,
-	formatControlNoticeMessage,
-	shouldNotifyControlEvent,
-} from "../shared/subagent-control.js";
-import { deliverLocalCompletionNotification } from "./completion-notification.js";
-import type { ExecutionContextData, ExecutorDeps, ForegroundControl } from "./subagent-executor-types.js";
-
-export function getForegroundControl(state: SubagentState, runId: string | undefined): ForegroundControl | undefined {
-	if (runId) return state.foregroundControls.get(runId);
-	if (state.lastForegroundControlId) {
-		const latest = state.foregroundControls.get(state.lastForegroundControlId);
-		if (latest) return latest;
-	}
-	let newest: ForegroundControl | undefined;
-	for (const control of state.foregroundControls.values()) {
-		if (!newest || control.updatedAt > newest.updatedAt) newest = control;
-	}
-	return newest;
-}
-
-function formatForegroundActivity(control: ForegroundControl): string | undefined {
-	const facts: string[] = [];
-	if (control.currentTool && control.currentToolStartedAt)
-		facts.push(
-			`tool ${control.currentTool} for ${Math.floor(Math.max(0, Date.now() - control.currentToolStartedAt) / 1000)}s`,
-		);
-	else if (control.currentTool) facts.push(`tool ${control.currentTool}`);
-	if (control.currentPath) facts.push(`path ${control.currentPath}`);
-	if (control.turnCount !== undefined) facts.push(`${control.turnCount} turns`);
-	if (control.tokens !== undefined) facts.push(`${control.tokens} tokens`);
-	if (control.toolCount !== undefined) facts.push(`${control.toolCount} tools`);
-	if (!control.lastActivityAt) {
-		if (control.currentActivityState === "needs_attention") return ["needs attention", ...facts].join(" | ");
-		if (control.currentActivityState === "active_long_running")
-			return ["active but long-running", ...facts].join(" | ");
-		return facts.length ? facts.join(" | ") : undefined;
-	}
-	const seconds = Math.floor(Math.max(0, Date.now() - control.lastActivityAt) / 1000);
-	if (control.currentActivityState === "needs_attention") return [`no activity for ${seconds}s`, ...facts].join(" | ");
-	if (control.currentActivityState === "active_long_running")
-		return [`active but long-running; last activity ${seconds}s ago`, ...facts].join(" | ");
-	return [`active ${seconds}s ago`, ...facts].join(" | ");
-}
-
-export function foregroundStatusResult(control: ForegroundControl): SubagentToolResult {
-	const activity = formatForegroundActivity(control);
-	const lines = [
-		`Run: ${control.runId}`,
-		"State: running",
-		`Mode: ${control.mode}`,
-		control.currentAgent
-			? `Current: ${control.currentAgent}${control.currentIndex !== undefined ? ` step ${control.currentIndex + 1}` : ""}`
-			: undefined,
-		activity ? `Activity: ${activity}` : undefined,
-	].filter((line): line is string => Boolean(line));
-	return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "management", results: [] } };
-}
-
-export function emitControlNotification(input: {
-	pi: ExtensionAPI;
-	controlConfig: ExecutionContextData["controlConfig"];
-	intercomBridge: Pick<IntercomBridgeState, "active" | "orchestratorTarget">;
-	event: ControlEvent;
-}): void {
-	if (!shouldNotifyControlEvent(input.controlConfig, input.event)) return;
-	const childIntercomTarget = input.intercomBridge.active
-		? resolveSubagentIntercomTarget(input.event.runId, input.event.agent, input.event.index)
-		: undefined;
-	const payload = {
-		event: input.event,
-		source: "foreground" as const,
-		childIntercomTarget,
-		noticeText: formatControlNoticeMessage(input.event, childIntercomTarget),
-	};
-	if (input.controlConfig.notifyChannels.includes("event")) {
-		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" &&
-		input.controlConfig.notifyChannels.includes("intercom") &&
-		input.intercomBridge.active &&
-		input.intercomBridge.orchestratorTarget
-	) {
-		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.
-		}
-	}
-}
-
-export function createForegroundControlNotifier(
-	data: Pick<ExecutionContextData, "controlConfig" | "intercomBridge">,
-	deps: Pick<ExecutorDeps, "pi">,
-): (event: ControlEvent) => void {
-	return (event) =>
-		emitControlNotification({
-			pi: deps.pi,
-			controlConfig: data.controlConfig,
-			intercomBridge: data.intercomBridge,
-			event,
-		});
-}
-
-function resultSummaryForIntercom(result: SingleResult): string {
-	const output = getSingleResultOutput(result);
-	if (result.status === "error" && result.error) {
-		return output ? `${result.error}\n\nOutput:\n${output}` : result.error;
-	}
-	return output || result.error || "(no output)";
-}
-
-/**
- * Deliver a completion notice to the parent session for a foreground child
- * that detached for intercom coordination and later exited. Foreground runs
- * normally return their results inline in the tool result, but a detached
- * child outlives that tool call, so without this the parent never learns the
- * child finished (see run history: detached parallel runs completed silently).
- * Reuses the detached completion pipeline (dedupe, ordering barrier, triggerTurn).
- */
-export function notifyDetachedForegroundChildExit(input: {
-	pi: ExtensionAPI;
-	runId: string;
-	mode: SubagentRunMode;
-	index: number;
-	totalTasks?: number;
-	result: SingleResult;
-}): void {
-	const { pi, runId, index, result } = input;
-	void deliverLocalCompletionNotification(
-		pi.events,
-		{
-			id: runId,
-			runId,
-			agent: result.agent,
-			status: result.status,
-			summary: resultSummaryForIntercom(result),
-			...(result.interrupted ? { state: "interrupted" } : {}),
-			timestamp: Date.now(),
-			...(result.progressSummary?.durationMs !== undefined ? { durationMs: result.progressSummary.durationMs } : {}),
-			...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
-			...(input.totalTasks !== undefined && input.totalTasks > 1
-				? { taskIndex: index, totalTasks: input.totalTasks }
-				: {}),
-			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: {
-	pi: ExtensionAPI;
-	intercomBridge: IntercomBridgeState;
-	runId: string;
-	mode: SubagentRunMode;
-	results: SingleResult[];
-}): Promise<ReturnType<typeof buildSubagentResultIntercomPayload> | null> {
-	if (!input.intercomBridge.active || !input.intercomBridge.orchestratorTarget) return null;
-	const children = input.results.flatMap((result, index) =>
-		result.detached
-			? []
-			: [
-					{
-						agent: result.agent,
-						status: resolveSubagentResultStatus({
-							status: result.status,
-							interrupted: result.interrupted,
-							detached: result.detached,
-						}),
-						summary: resultSummaryForIntercom(result),
-						index,
-						artifactPath: result.artifactPaths?.outputPath,
-						sessionPath: result.sessionFile,
-						intercomTarget: resolveSubagentIntercomTarget(input.runId, result.agent, index),
-					},
-				],
-	);
-	if (children.length === 0) return null;
-	const payload = buildSubagentResultIntercomPayload({
-		to: input.intercomBridge.orchestratorTarget,
-		runId: input.runId,
-		mode: input.mode,
-		children,
-	});
-	const delivered = await deliverSubagentResultIntercomEvent(input.pi.events, payload);
-	if (!delivered) return null;
-	return payload;
-}
-
-export async function maybeBuildForegroundIntercomReceipt(input: {
-	pi: ExtensionAPI;
-	intercomBridge: IntercomBridgeState;
-	runId: string;
-	mode: SubagentRunMode;
-	details: Details;
-}): Promise<{ text: string; details: Details } | null> {
-	const payload = await emitForegroundResultIntercom({
-		pi: input.pi,
-		intercomBridge: input.intercomBridge,
-		runId: input.runId,
-		mode: input.mode,
-		results: input.details.results,
-	});
-	if (!payload) return null;
-	return {
-		text: formatSubagentResultReceipt({ mode: input.mode, runId: input.runId, payload }),
-		details: stripDetailsOutputsForIntercomReceipt(input.details),
-	};
-}
-
-export { compactForegroundDetails };

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

@@ -1,131 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { AgentConfig, AgentScope } from "../../agents/agents.js";
-import type { IntercomBridgeState } from "../../intercom/intercom-bridge.js";
-import type { ModelInfo } from "../../shared/model-info.js";
-import type {
-	ArtifactConfig,
-	ControlConfig,
-	MaxOutputConfig,
-	ResolvedControlConfig,
-	SUBAGENT_ACTIONS,
-	SubagentState,
-	SubagentToolResult,
-} from "../../shared/types.js";
-import type { ChildModePolicy } from "../inprocess/child-policy.js";
-import type { runSync } from "./execution.js";
-
-export const BURST_TASK_DISCOVERY_CWD = Symbol("burstTaskDiscoveryCwd");
-
-export interface TaskParam {
-	agent: string;
-	task: string;
-	cwd?: string;
-	count?: number;
-	output?: string | boolean;
-	outputMode?: "inline" | "file-only";
-	reads?: string[] | boolean;
-	progress?: boolean;
-	model?: string;
-	skill?: string | string[] | boolean;
-	group?: string | true;
-}
-
-export type BurstTaskParam = TaskParam & {
-	[BURST_TASK_DISCOVERY_CWD]?: string;
-};
-
-export interface SubagentParamsLike {
-	action?: (typeof SUBAGENT_ACTIONS)[number];
-	id?: string;
-	runId?: string;
-	agent?: string;
-	task?: string;
-	config?: unknown;
-	tasks?: TaskParam[];
-	concurrency?: number;
-	worktree?: boolean;
-	context?: "fresh" | "fork";
-	share?: boolean;
-	control?: ControlConfig;
-	sessionDir?: string;
-	cwd?: string;
-	maxOutput?: MaxOutputConfig;
-	artifacts?: boolean;
-	includeProgress?: boolean;
-	model?: string;
-	skill?: string | string[] | boolean;
-	group?: string | true;
-	output?: string | boolean;
-	outputMode?: "inline" | "file-only";
-	reads?: string[] | false;
-	progress?: boolean;
-	agentScope?: string;
-}
-
-export interface SubagentExecutorRuntimeDeps {
-	runSync: typeof runSync;
-}
-
-export interface ExecutorDeps {
-	pi: ExtensionAPI;
-	state: SubagentState;
-	config: import("../../shared/types.js").ExtensionConfig;
-	tempArtifactsDir: string;
-	getSubagentSessionRoot: (parentSessionFile: string | null) => string;
-	expandTilde: (p: string) => string;
-	discoverAgents: (cwd: string, scope: AgentScope) => { agents: AgentConfig[] };
-	allowMutatingManagementActions?: boolean;
-	/** Typed admission policy; when present it is authoritative over the legacy boolean. */
-	childPolicy?: ChildModePolicy;
-	runtime?: Partial<SubagentExecutorRuntimeDeps>;
-}
-
-export function isManagementActionsRestricted(
-	deps: Pick<ExecutorDeps, "childPolicy" | "allowMutatingManagementActions">,
-): boolean {
-	return deps.childPolicy
-		? deps.childPolicy.managementActions === "restricted"
-		: deps.allowMutatingManagementActions === false;
-}
-export interface ResolvedExecutorDeps extends Omit<ExecutorDeps, "runtime"> {
-	runtime: SubagentExecutorRuntimeDeps;
-}
-
-export interface ExecutionContextData {
-	params: SubagentParamsLike;
-	effectiveCwd: string;
-	ctx: ExtensionContext;
-	signal: AbortSignal;
-	onUpdate?: (r: SubagentToolResult) => void;
-	agents: AgentConfig[];
-	parallelAgentConfigs?: AgentConfig[];
-	runId: string;
-	shareEnabled: boolean;
-	sessionRoot: string;
-	sessionDirForIndex: (idx?: number) => string;
-	sessionFileForIndex: (idx?: number) => string | undefined;
-	artifactConfig: ArtifactConfig;
-	artifactsDir: string;
-	parentDepth?: number;
-	controlConfig: ResolvedControlConfig;
-	intercomBridge: IntercomBridgeState;
-}
-
-export interface PreparedExecutionContext {
-	effectiveParams: SubagentParamsLike;
-	effectiveCwd: string;
-	runId: string;
-	hasTasks: boolean;
-	hasSingle: boolean;
-	foregroundMode: "single" | "parallel";
-	execData: ExecutionContextData;
-	foregroundControl?: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
-}
-
-export interface ExecutionContextBuildResult {
-	prepared?: PreparedExecutionContext;
-	error?: SubagentToolResult;
-}
-
-export type ForegroundControl = SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
-export type AvailableModelInfo = ModelInfo;

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

@@ -1,102 +0,0 @@
-import * as path from "node:path";
-import type { ResolvedStepBehavior } from "../../shared/settings.js";
-import type { ExtensionConfig, SubagentToolResult } from "../../shared/types.js";
-import { resolveChildCwd } from "../../shared/utils.js";
-import { resolveSingleOutputPath } from "../shared/single-output.js";
-import {
-	createWorktrees,
-	diffWorktrees,
-	findWorktreeTaskCwdConflict,
-	formatWorktreeDiffSummary,
-	formatWorktreeTaskCwdConflict,
-	type WorktreeSetup,
-} from "../shared/worktree.js";
-import type { TaskParam } from "./subagent-executor-types.js";
-
-export function buildParallelModeError(message: string): SubagentToolResult {
-	return {
-		content: [{ type: "text", text: message }],
-		isError: true,
-		details: { mode: "parallel" as const, results: [] },
-	};
-}
-
-export function createParallelWorktreeSetup(
-	enabled: boolean | undefined,
-	cwd: string,
-	runId: string,
-	tasks: TaskParam[],
-	setupHook: ExtensionConfig["worktreeSetupHook"],
-	setupHookTimeoutMs: ExtensionConfig["worktreeSetupHookTimeoutMs"],
-): { setup?: WorktreeSetup; errorResult?: SubagentToolResult } {
-	if (!enabled) return {};
-	try {
-		return {
-			setup: createWorktrees(cwd, runId, tasks.length, {
-				agents: tasks.map((task) => task.agent),
-				setupHook: setupHook ? { hookPath: setupHook, timeoutMs: setupHookTimeoutMs } : undefined,
-			}),
-		};
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return { errorResult: buildParallelModeError(message) };
-	}
-}
-
-export function buildParallelWorktreeTaskCwdError(
-	tasks: ReadonlyArray<{ agent: string; cwd?: string }>,
-	sharedCwd: string,
-): string | undefined {
-	const conflict = findWorktreeTaskCwdConflict(tasks, sharedCwd);
-	if (!conflict) return undefined;
-	return formatWorktreeTaskCwdConflict(conflict, sharedCwd);
-}
-
-export function resolveParallelTaskCwd(
-	task: TaskParam,
-	paramsCwd: string,
-	worktreeSetup: WorktreeSetup | undefined,
-	index: number,
-): string {
-	if (worktreeSetup) return worktreeSetup.worktrees[index]!.agentCwd;
-	return resolveChildCwd(paramsCwd, task.cwd);
-}
-
-export function buildParallelWorktreeSuffix(
-	worktreeSetup: WorktreeSetup | undefined,
-	artifactsDir: string,
-	tasks: TaskParam[],
-): string {
-	if (!worktreeSetup) return "";
-	const diffsDir = path.join(artifactsDir, "worktree-diffs");
-	const diffs = diffWorktrees(
-		worktreeSetup,
-		tasks.map((task) => task.agent),
-		diffsDir,
-	);
-	return formatWorktreeDiffSummary(diffs);
-}
-
-export function findDuplicateParallelOutputPath(input: {
-	tasks: TaskParam[];
-	behaviors: ResolvedStepBehavior[];
-	paramsCwd: string;
-	ctxCwd: string;
-	worktreeSetup?: WorktreeSetup;
-}): string | undefined {
-	const seen = new Map<string, { index: number; agent: string }>();
-	for (let index = 0; index < input.tasks.length; index++) {
-		const behavior = input.behaviors[index];
-		if (!behavior?.output) continue;
-		const task = input.tasks[index]!;
-		const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
-		const outputPath = resolveSingleOutputPath(behavior.output, input.ctxCwd, taskCwd);
-		if (!outputPath) continue;
-		const previous = seen.get(outputPath);
-		if (previous) {
-			return `Parallel tasks ${previous.index + 1} (${previous.agent}) and ${index + 1} (${task.agent}) resolve output to the same path: ${outputPath}. Use distinct output paths.`;
-		}
-		seen.set(outputPath, { index, agent: task.agent });
-	}
-	return undefined;
-}

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

@@ -1,217 +0,0 @@
-import type { ExtensionContext } from "@bastani/atomic";
-import { handleManagementAction } from "../../agents/agent-management.js";
-import { clearPendingForegroundControlNotices } from "../../extension/control-notices.js";
-import { SUBAGENT_ACTIONS, type SubagentToolResult } from "../../shared/types.js";
-import { inspectInProcessChildStatus, interruptInProcessChild } from "../inprocess/control-status.js";
-import { createExecutionBurstDispatcher } from "./subagent-executor-burst.js";
-import { prepareExecutionContext, refuseSubagentChildDelegation } from "./subagent-executor-context.js";
-import { resolveRequestedCwd } from "./subagent-executor-cwd.js";
-import { toExecutionErrorResult, withForkContext } from "./subagent-executor-input.js";
-import { runParallelPath } from "./subagent-executor-parallel.js";
-import { resolveSubagentExecutorRuntimeDeps } from "./subagent-executor-runtime.js";
-import { runSinglePath } from "./subagent-executor-single.js";
-import { foregroundStatusResult, getForegroundControl } from "./subagent-executor-status.js";
-import {
-	type ExecutorDeps,
-	isManagementActionsRestricted,
-	type ResolvedExecutorDeps,
-	type SubagentParamsLike,
-} from "./subagent-executor-types.js";
-
-const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete"]);
-/** Observing management actions do not start or mutate child execution. */
-const READ_ONLY_MANAGEMENT_ACTIONS = new Set(["list", "get", "status"]);
-const FANOUT_REFUSAL_MESSAGE = "Subagent fanout is not authorized for this child.";
-
-export type { SubagentExecutorRuntimeDeps, SubagentParamsLike } from "./subagent-executor-types.js";
-
-async function handleManagementRequest(input: {
-	params: SubagentParamsLike;
-	paramsWithResolvedCwd: SubagentParamsLike;
-	requestCwd: string;
-	ctx: ExtensionContext;
-	deps: ResolvedExecutorDeps;
-}): Promise<SubagentToolResult> {
-	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps } = input;
-	const action = params.action;
-	if (!action) {
-		return {
-			content: [{ type: "text", text: "Missing action." }],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
-	if (!(SUBAGENT_ACTIONS as readonly string[]).includes(action)) {
-		return {
-			content: [{ type: "text", text: `Unknown action: ${action}. Valid: ${SUBAGENT_ACTIONS.join(", ")}` }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
-	if (isManagementActionsRestricted(deps) && MUTATING_MANAGEMENT_ACTIONS.has(action)) {
-		return {
-			content: [{ type: "text", text: `Action '${action}' is not available from child-safe subagent fanout mode.` }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
-	// `interrupt` is privileged control over a running child, so only the
-	// observing actions reach handlers for a child without fanout authorization.
-	if (deps.childPolicy && !deps.childPolicy.fanoutAuthorized && !READ_ONLY_MANAGEMENT_ACTIONS.has(action)) {
-		return {
-			content: [{ type: "text", text: FANOUT_REFUSAL_MESSAGE }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
-	// Delegation is one level deep: a child may never control another child.
-	if (!READ_ONLY_MANAGEMENT_ACTIONS.has(action)) {
-		const childRefusal = refuseSubagentChildDelegation(ctx, "management");
-		if (childRefusal) return childRefusal;
-	}
-	if (action === "status") {
-		const targetRunId = paramsWithResolvedCwd.id ?? paramsWithResolvedCwd.runId;
-		const inProcess = inspectInProcessChildStatus(targetRunId);
-		if (inProcess) return inProcess;
-		const foreground = getForegroundControl(deps.state, targetRunId);
-		if (foreground) return foregroundStatusResult(foreground);
-		return {
-			content: [
-				{
-					type: "text",
-					text: targetRunId ? `No in-process child found for '${targetRunId}'.` : "No in-process subagent found.",
-				},
-			],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
-	if (action === "interrupt") {
-		const targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
-		if (targetRunId) {
-			const inProcess = await interruptInProcessChild(targetRunId);
-			if (inProcess) return inProcess;
-		}
-		return {
-			content: [
-				{
-					type: "text",
-					text: targetRunId
-						? `No running in-process child found for '${targetRunId}'.`
-						: "No interrupt-capable child found.",
-				},
-			],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
-	return handleManagementAction(action, paramsWithResolvedCwd, { ...ctx, cwd: requestCwd });
-}
-
-function inferExecutionMode(params: SubagentParamsLike): "single" | "parallel" {
-	if ((params.tasks?.length ?? 0) > 0) return "parallel";
-	return "single";
-}
-
-function duplicateSubagentCallResult(params: SubagentParamsLike): SubagentToolResult {
-	return {
-		content: [
-			{
-				type: "text",
-				text: "Rejected: a subagent call is already in progress. Issue exactly ONE subagent call per turn.",
-			},
-		],
-		isError: true,
-		details: { mode: inferExecutionMode(params), results: [] },
-	};
-}
-
-export function createSubagentExecutor(rawDeps: ExecutorDeps): {
-	execute: (
-		id: string,
-		params: SubagentParamsLike,
-		signal: AbortSignal,
-		onUpdate: ((r: SubagentToolResult) => void) | undefined,
-		ctx: ExtensionContext,
-	) => Promise<SubagentToolResult>;
-} {
-	const deps: ResolvedExecutorDeps = { ...rawDeps, runtime: resolveSubagentExecutorRuntimeDeps(rawDeps.runtime) };
-	const execute = async (
-		_id: string,
-		params: SubagentParamsLike,
-		signal: AbortSignal,
-		onUpdate: ((r: SubagentToolResult) => void) | undefined,
-		ctx: ExtensionContext,
-	): Promise<SubagentToolResult> => {
-		deps.state.baseCwd = ctx.cwd;
-		deps.state.foregroundControls ??= new Map();
-		deps.state.lastForegroundControlId ??= null;
-		const requestCwd = resolveRequestedCwd(ctx.cwd, params.cwd);
-		const paramsWithResolvedCwd = params.cwd === undefined ? params : { ...params, cwd: requestCwd };
-		if (params.action) {
-			return handleManagementRequest({ params, paramsWithResolvedCwd, requestCwd, ctx, deps });
-		}
-		// Fanout authorization gates delegation and privileged control. Only `list`,
-		// `get`, and `status` stay available to an unauthorized child; `interrupt`
-		// and mutating management are refused by handleManagementRequest.
-		if (deps.childPolicy && !deps.childPolicy.fanoutAuthorized) {
-			return {
-				content: [{ type: "text", text: FANOUT_REFUSAL_MESSAGE }],
-				isError: true,
-				details: { mode: inferExecutionMode(params), results: [] },
-			};
-		}
-
-		const childRefusal = refuseSubagentChildDelegation(ctx, inferExecutionMode(params));
-		if (childRefusal) return childRefusal;
-
-		const built = prepareExecutionContext({ params: paramsWithResolvedCwd, ctx, signal, onUpdate, deps });
-		if (built.error) return built.error;
-		const prepared = built.prepared!;
-		try {
-			if (prepared.hasTasks && prepared.effectiveParams.tasks) {
-				const result = await runParallelPath(prepared.execData, deps);
-				return withForkContext(result, prepared.effectiveParams.context);
-			}
-			if (prepared.hasSingle) {
-				const result = await runSinglePath(prepared.execData, deps);
-				return withForkContext(result, prepared.effectiveParams.context);
-			}
-		} catch (error) {
-			return toExecutionErrorResult(prepared.effectiveParams, error);
-		} finally {
-			if (prepared.foregroundControl) {
-				clearPendingForegroundControlNotices(deps.state, prepared.runId);
-				deps.state.foregroundControls.delete(prepared.runId);
-				if (deps.state.lastForegroundControlId === prepared.runId) {
-					deps.state.lastForegroundControlId = null;
-				}
-			}
-		}
-
-		return withForkContext(
-			{
-				content: [{ type: "text", text: "Invalid params" }],
-				isError: true,
-				details: { mode: "single" as const, results: [] },
-			},
-			prepared.effectiveParams.context,
-		);
-	};
-
-	const executeWithBurstCollection = createExecutionBurstDispatcher({
-		execute,
-		isActive: () => deps.state.subagentInProgress === true,
-		setActive: (active) => {
-			deps.state.subagentInProgress = active;
-		},
-		duplicateResult: duplicateSubagentCallResult,
-	});
-
-	return {
-		execute: (id, params, signal, onUpdate, ctx) =>
-			params.action
-				? execute(id, params, signal, onUpdate, ctx)
-				: executeWithBurstCollection(id, params, signal, onUpdate, ctx),
-	};
-}