@bastani/atomic 0.9.15 → 0.9.16-alpha.1

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

@@ -17,7 +17,7 @@ import {
 	type SubagentState,
 	type SubagentToolResult,
 } from "../../shared/types.js";
-import { compactForegroundDetails, compactForegroundResult, getSingleResultOutput } from "../../shared/utils.js";
+import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.js";
 import {
 	formatControlIntercomMessage,
 	formatControlNoticeMessage,
@@ -77,128 +77,10 @@ export function foregroundStatusResult(control: ForegroundControl): SubagentTool
 	return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "management", results: [] } };
 }
 
-export function retainedForegroundStatusResult(state: SubagentState, runId: string): SubagentToolResult | undefined {
-	const run = state.foregroundRuns?.get(runId);
-	if (!run) return undefined;
-	const statuses = run.children.map((child) => child.status);
-	const stateLabel = statuses.includes("detached")
-		? "detached"
-		: statuses.includes("failed")
-			? "failed"
-			: statuses.includes("paused")
-				? "paused"
-				: statuses.every((status) => status === "completed")
-					? "completed"
-					: (statuses[0] ?? "unknown");
-	const lines = [`Run: ${run.runId}`, `State: ${stateLabel}`, `Mode: ${run.mode}`];
-	for (const child of run.children) {
-		lines.push(`Child ${child.index + 1}: ${child.agent} (${child.status})`);
-		const output = child.result ? getSingleResultOutput(child.result) : "";
-		if (output) lines.push(output);
-		else if (child.result?.error) lines.push(child.result.error);
-	}
-	return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "management", results: [] } };
-}
-
-const earlyDetachedResults = new WeakMap<SubagentState, Map<string, Map<number, SingleResult>>>();
-const MAX_EARLY_DETACHED_RUNS = 50;
-const MAX_EARLY_DETACHED_CHILDREN_PER_RUN = 50;
-
-function takeEarlyDetachedResult(state: SubagentState, runId: string, index: number): SingleResult | undefined {
-	const byRun = earlyDetachedResults.get(state);
-	const byIndex = byRun?.get(runId);
-	const result = byIndex?.get(index);
-	byIndex?.delete(index);
-	if (byIndex?.size === 0) byRun?.delete(runId);
-	return result;
-}
-
-export function rememberForegroundRun(
-	state: SubagentState,
-	input: {
-		runId: string;
-		mode: "single" | "parallel";
-		cwd: string;
-		results: SingleResult[];
-	},
-): void {
-	state.foregroundRuns ??= new Map();
-	state.foregroundRuns.set(input.runId, {
-		runId: input.runId,
-		mode: input.mode,
-		cwd: input.cwd,
-		updatedAt: Date.now(),
-		children: input.results.map((originalResult, index) => {
-			const result = takeEarlyDetachedResult(state, input.runId, index) ?? originalResult;
-			return {
-				agent: result.agent,
-				index,
-				status: resolveSubagentResultStatus({
-					status: result.status,
-					interrupted: result.interrupted,
-					detached: result.detached,
-				}),
-				...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
-				result,
-			};
-		}),
-	});
-	while (state.foregroundRuns.size > 50) {
-		const oldest = [...state.foregroundRuns.values()].sort((left, right) => left.updatedAt - right.updatedAt)[0];
-		if (!oldest) break;
-		state.foregroundRuns.delete(oldest.runId);
-	}
-}
-
-export function replaceForegroundRunChild(
-	state: SubagentState,
-	runId: string,
-	index: number,
-	result: SingleResult,
-	options: { onlyWhenDetached?: boolean } = {},
-): void {
-	const retainedResult = compactForegroundResult(result);
-	const run = state.foregroundRuns?.get(runId);
-	if (!run) {
-		let byRun = earlyDetachedResults.get(state);
-		if (!byRun) {
-			byRun = new Map();
-			earlyDetachedResults.set(state, byRun);
-		}
-		let byIndex = byRun.get(runId);
-		if (!byIndex) {
-			byIndex = new Map();
-			byRun.set(runId, byIndex);
-		}
-		byIndex.set(index, retainedResult);
-		while (byIndex.size > MAX_EARLY_DETACHED_CHILDREN_PER_RUN) {
-			const oldestIndex = byIndex.keys().next().value;
-			if (oldestIndex === undefined) break;
-			byIndex.delete(oldestIndex);
-		}
-		while (byRun.size > MAX_EARLY_DETACHED_RUNS) {
-			const oldestRun = byRun.keys().next().value;
-			if (oldestRun === undefined) break;
-			byRun.delete(oldestRun);
-		}
-		return;
-	}
-	const child = run.children.find((entry) => entry.index === index);
-	if (!child || (options.onlyWhenDetached !== false && child.status !== "detached")) return;
-	child.status = resolveSubagentResultStatus({
-		status: retainedResult.status,
-		interrupted: retainedResult.interrupted,
-		detached: retainedResult.detached,
-	});
-	child.result = retainedResult;
-	if (retainedResult.sessionFile) child.sessionFile = retainedResult.sessionFile;
-	run.updatedAt = Date.now();
-}
-
 export function emitControlNotification(input: {
 	pi: ExtensionAPI;
 	controlConfig: ExecutionContextData["controlConfig"];
-	intercomBridge: IntercomBridgeState;
+	intercomBridge: Pick<IntercomBridgeState, "active" | "orchestratorTarget">;
 	event: ControlEvent;
 }): void {
 	if (!shouldNotifyControlEvent(input.controlConfig, input.event)) return;
@@ -284,7 +166,7 @@ export function notifyDetachedForegroundChildExit(input: {
 			agent: result.agent,
 			status: result.status,
 			summary: resultSummaryForIntercom(result),
-			...(result.interrupted ? { state: "paused" } : {}),
+			...(result.interrupted ? { state: "interrupted" } : {}),
 			timestamp: Date.now(),
 			...(result.progressSummary?.durationMs !== undefined ? { durationMs: result.progressSummary.durationMs } : {}),
 			...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),

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

@@ -14,6 +14,8 @@ import type {
 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;
@@ -28,14 +30,16 @@ export interface TaskParam {
 	group?: string | true;
 }
 
+export type BurstTaskParam = TaskParam & {
+	[BURST_TASK_DISCOVERY_CWD]?: string;
+};
+
 export interface SubagentParamsLike {
 	action?: (typeof SUBAGENT_ACTIONS)[number];
 	id?: string;
 	runId?: string;
-	index?: number;
 	agent?: string;
 	task?: string;
-	message?: string;
 	config?: unknown;
 	tasks?: TaskParam[];
 	concurrency?: number;
@@ -94,6 +98,7 @@ export interface ExecutionContextData {
 	signal: AbortSignal;
 	onUpdate?: (r: SubagentToolResult) => void;
 	agents: AgentConfig[];
+	parallelAgentConfigs?: AgentConfig[];
 	runId: string;
 	shareEnabled: boolean;
 	sessionRoot: string;

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

@@ -1,55 +1,18 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
 import { handleManagementAction } from "../../agents/agent-management.js";
-import { resolveExecutionAgentScope } from "../../agents/agent-scope.js";
 import { clearPendingForegroundControlNotices } from "../../extension/control-notices.js";
 import { buildDoctorReport } from "../../extension/doctor.js";
-import {
-	INTERCOM_BRIDGE_MARKER,
-	resolveIntercomBridge,
-	resolveIntercomSessionTarget,
-	resolveSubagentIntercomTarget,
-} from "../../intercom/intercom-bridge.js";
-import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.js";
-import { getArtifactsDir } from "../../shared/artifacts.js";
-import { collectKnownModelProviders, toModelInfo } from "../../shared/model-info.js";
-import { createCandidateModelResolver } from "../../shared/model-resolution.js";
-import {
-	injectSingleProgressInstruction,
-	resolveSingleProgress,
-	writeInitialProgressFile,
-} from "../../shared/settings.js";
-import {
-	DEFAULT_ARTIFACT_CONFIG,
-	getCurrentSubagentDepth,
-	isWorkflowStageOrchestrationContext,
-	type SingleResult,
-	SUBAGENT_ACTIONS,
-	type SubagentToolResult,
-	workflowSessionMetadataFromContext,
-} from "../../shared/types.js";
-import {
-	inspectInProcessChildStatus,
-	interruptInProcessChild,
-	resumeInProcessChild,
-} from "../inprocess/control-status.js";
-import { inheritedIntercomGroup } from "../shared/intercom-group.js";
-import { currentModelFullId } from "../shared/model-fallback.js";
-import { resolveControlConfig } from "../shared/subagent-control.js";
+import { resolveIntercomSessionTarget } from "../../intercom/intercom-bridge.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 { resolveRequestedCwd } from "./subagent-executor-resume.js";
 import { resolveSubagentExecutorRuntimeDeps } from "./subagent-executor-runtime.js";
-import { createForwardSingleUpdate, runSinglePath } from "./subagent-executor-single.js";
-import {
-	foregroundStatusResult,
-	getForegroundControl,
-	notifyDetachedForegroundChildExit,
-	replaceForegroundRunChild,
-	retainedForegroundStatusResult,
-} from "./subagent-executor-status.js";
+import { runSinglePath } from "./subagent-executor-single.js";
+import { foregroundStatusResult, getForegroundControl } from "./subagent-executor-status.js";
 import {
 	type ExecutorDeps,
 	isManagementActionsRestricted,
@@ -57,129 +20,8 @@ import {
 	type SubagentParamsLike,
 } from "./subagent-executor-types.js";
 
-async function resumeRetainedForegroundChild(
-	params: SubagentParamsLike,
-	message: string,
-	ctx: ExtensionContext,
-	deps: ResolvedExecutorDeps,
-	onUpdate: ((r: SubagentToolResult) => void) | undefined,
-): Promise<SubagentToolResult | undefined> {
-	const requested = params.id ?? params.runId;
-	if (!requested) return undefined;
-	const run = deps.state.foregroundRuns?.get(requested);
-	if (!run) return undefined;
-	const child = run.children[params.index ?? 0];
-	if (!child) return undefined;
-	const agents = deps.discoverAgents(run.cwd, resolveExecutionAgentScope(params.agentScope)).agents;
-	const agentConfig = agents.find((agent) => agent.name === child.agent);
-	if (!agentConfig) {
-		return {
-			content: [{ type: "text", text: `Unknown agent for resume: ${child.agent}` }],
-			isError: true,
-			details: { mode: "single", results: [] },
-		};
-	}
-	const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
-	const sessionName = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
-	const intercomBridge = resolveIntercomBridge({
-		config: deps.config.intercomBridge,
-		context: params.context,
-		orchestratorTarget: sessionName,
-		cwd: run.cwd,
-	});
-	const supervisedTarget = intercomBridge.active
-		? resolveSubagentIntercomTarget(run.runId, child.agent, child.index)
-		: undefined;
-	const supervisorAuthorization = await requestSupervisorAuthorization(deps.pi.events, supervisedTarget);
-	const artifactConfig = { ...DEFAULT_ARTIFACT_CONFIG, enabled: params.artifacts !== false };
-	const artifactsDir = getArtifactsDir(parentSessionFile);
-	const progressDir = resolveSingleProgress(agentConfig, params.progress, message)
-		? path.join(artifactsDir, "progress", run.runId)
-		: undefined;
-	if (progressDir) {
-		writeInitialProgressFile(progressDir);
-		message = injectSingleProgressInstruction(message, progressDir);
-	}
-	const cleanupProgress = (): void => {
-		if (!progressDir || artifactConfig.enabled) return;
-		try {
-			fs.rmSync(progressDir, { recursive: true, force: true });
-		} catch {
-			// Scratch cleanup must never replace the child run's result or original error.
-		}
-	};
-	const forwardSingleUpdate = createForwardSingleUpdate(
-		onUpdate,
-		getForegroundControl(deps.state, run.runId),
-		child.agent,
-		child.index,
-	);
-	let result: SingleResult;
-	try {
-		result = await deps.runtime.runSync(run.cwd, agents, child.agent, message, {
-			cwd: run.cwd,
-			signal: ctx.signal,
-			interruptSignal: ctx.signal,
-			allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
-			intercomEvents: deps.pi.events,
-			runId: run.runId,
-			index: child.index,
-			sessionDir: child.sessionFile ? path.dirname(child.sessionFile) : undefined,
-			sessionFile: child.sessionFile,
-			share: params.share === true,
-			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-			artifactConfig,
-			maxOutput: params.maxOutput,
-			parentDepth: getCurrentSubagentDepth(ctx),
-			workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
-			workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
-			controlConfig: resolveControlConfig(deps.config.control, params.control),
-			intercomSessionName: intercomBridge.active
-				? resolveSubagentIntercomTarget(run.runId, child.agent, child.index)
-				: undefined,
-			orchestratorIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
-			intercomGroup: inheritedIntercomGroup(ctx),
-			supervisorAuthorization,
-			modelOverride: params.model,
-			availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
-			knownModelProviders: collectKnownModelProviders(ctx.modelRegistry),
-			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, ctx.model?.provider),
-			preferredModelProvider: ctx.model?.provider,
-			currentModel: currentModelFullId(ctx.model),
-			currentThinkingLevel: ctx.thinkingLevel,
-			onUpdate: forwardSingleUpdate,
-			onDetachedExit: (detachedResult) => {
-				cleanupProgress();
-				if (detachedResult) {
-					replaceForegroundRunChild(deps.state, run.runId, child.index, detachedResult);
-					notifyDetachedForegroundChildExit({
-						pi: deps.pi,
-						runId: run.runId,
-						mode: "single",
-						index: child.index,
-						result: detachedResult,
-					});
-				}
-			},
-		});
-	} catch (error) {
-		cleanupProgress();
-		throw error;
-	}
-	if (!result.detached) cleanupProgress();
-	replaceForegroundRunChild(deps.state, run.runId, child.index, result, { onlyWhenDetached: false });
-	return {
-		content: [{ type: "text", text: result.finalOutput ?? result.envelope ?? result.error ?? "" }],
-		details: { mode: "single", runId: run.runId, results: [result] },
-		...(result.status === "error" ? { isError: true } : {}),
-	};
-}
 const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete"]);
-/**
- * Management actions that only observe. Every other action either mutates agent
- * definitions or starts/continues agent execution, so a child without fanout
- * authorization is refused all of them.
- */
+/** Observing management actions do not start or mutate child execution. */
 const READ_ONLY_MANAGEMENT_ACTIONS = new Set(["list", "get", "status", "doctor"]);
 const FANOUT_REFUSAL_MESSAGE = "Subagent fanout is not authorized for this child.";
 
@@ -191,9 +33,8 @@ async function handleManagementRequest(input: {
 	requestCwd: string;
 	ctx: ExtensionContext;
 	deps: ResolvedExecutorDeps;
-	onUpdate?: (r: SubagentToolResult) => void;
 }): Promise<SubagentToolResult> {
-	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps, onUpdate } = input;
+	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps } = input;
 	const action = params.action;
 	if (!action) {
 		return {
@@ -216,9 +57,8 @@ async function handleManagementRequest(input: {
 			details: { mode: "management" as const, results: [] },
 		};
 	}
-	// `resume` revives a child and `interrupt` is privileged control over a
-	// running one; both continue agent execution, so only the observing actions
-	// reach their handlers for a child without fanout authorization.
+	// `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 }],
@@ -226,8 +66,7 @@ async function handleManagementRequest(input: {
 			details: { mode: "management" as const, results: [] },
 		};
 	}
-	// Delegation is one level deep: a session admitted as a subagent child may
-	// never start or continue another agent, whatever else it is authorized for.
+	// 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;
@@ -273,10 +112,6 @@ async function handleManagementRequest(input: {
 		if (inProcess) return inProcess;
 		const foreground = getForegroundControl(deps.state, targetRunId);
 		if (foreground) return foregroundStatusResult(foreground);
-		if (targetRunId) {
-			const retained = retainedForegroundStatusResult(deps.state, targetRunId);
-			if (retained) return retained;
-		}
 		return {
 			content: [
 				{
@@ -288,26 +123,6 @@ async function handleManagementRequest(input: {
 			details: { mode: "management", results: [] },
 		};
 	}
-	if (action === "resume") {
-		const targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
-		const message = paramsWithResolvedCwd.message ?? paramsWithResolvedCwd.task;
-		if (!targetRunId || !message) {
-			return {
-				content: [{ type: "text", text: "action='resume' requires id/runId and message." }],
-				isError: true,
-				details: { mode: "management", results: [] },
-			};
-		}
-		const inProcess = await resumeInProcessChild(targetRunId, message, { model: ctx.model });
-		if (inProcess) return inProcess;
-		const retained = await resumeRetainedForegroundChild(paramsWithResolvedCwd, message, ctx, deps, onUpdate);
-		if (retained) return retained;
-		return {
-			content: [{ type: "text", text: `No in-process child found for '${targetRunId}'.` }],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
 	if (action === "interrupt") {
 		const targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
 		if (targetRunId) {
@@ -366,18 +181,16 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		ctx: ExtensionContext,
 	): Promise<SubagentToolResult> => {
 		deps.state.baseCwd = ctx.cwd;
-		deps.state.foregroundRuns ??= new Map();
 		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, onUpdate });
+			return handleManagementRequest({ params, paramsWithResolvedCwd, requestCwd, ctx, deps });
 		}
-		// Fanout authorization gates delegation and every management action that can
-		// start or continue agent execution. Only `list`, `get`, `status`, and
-		// `doctor` stay available to an unauthorized child; `resume`, `interrupt`,
-		// and mutating management are refused inside handleManagementRequest.
+		// Fanout authorization gates delegation and privileged control. Only `list`,
+		// `get`, `status`, and `doctor` 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 }],
@@ -423,22 +236,19 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		);
 	};
 
-	const executeWithSingleDispatchGuard = async (
-		id: string,
-		params: SubagentParamsLike,
-		signal: AbortSignal,
-		onUpdate: ((r: SubagentToolResult) => void) | undefined,
-		ctx: ExtensionContext,
-	): Promise<SubagentToolResult> => {
-		if (params.action) return execute(id, params, signal, onUpdate, ctx);
-		if (deps.state.subagentInProgress === true) return duplicateSubagentCallResult(params);
-		deps.state.subagentInProgress = true;
-		try {
-			return await execute(id, params, signal, onUpdate, ctx);
-		} finally {
-			deps.state.subagentInProgress = false;
-		}
-	};
+	const executeWithBurstCollection = createExecutionBurstDispatcher({
+		execute,
+		isActive: () => deps.state.subagentInProgress === true,
+		setActive: (active) => {
+			deps.state.subagentInProgress = active;
+		},
+		duplicateResult: duplicateSubagentCallResult,
+	});
 
-	return { execute: executeWithSingleDispatchGuard };
+	return {
+		execute: (id, params, signal, onUpdate, ctx) =>
+			params.action
+				? execute(id, params, signal, onUpdate, ctx)
+				: executeWithBurstCollection(id, params, signal, onUpdate, ctx),
+	};
 }

package/dist/builtin/subagents/src/runs/inprocess/control-status.ts

@@ -1,17 +1,10 @@
 import type { SubagentToolResult } from "../../shared/types.js";
 import { findSubagentControl, listSubagentControls } from "./control-registry.js";
-import type { ModelCandidate } from "./runner.js";
 
 function canonicalChildren(control: NonNullable<ReturnType<typeof findSubagentControl>>) {
 	return [...control.listChildren()].sort((left, right) => left.path.localeCompare(right.path));
 }
 
-function resumeTarget(control: NonNullable<ReturnType<typeof findSubagentControl>>, id: string) {
-	if (id !== control.parent.path) return control.findChild(id);
-	const children = canonicalChildren(control);
-	return children.find((child) => child.status === "interrupted") ?? children[0];
-}
-
 function childLines(control: ReturnType<typeof findSubagentControl>, id?: string): string[] {
 	if (!control) return [];
 	if (id) {
@@ -77,30 +70,3 @@ export async function interruptInProcessChild(id: string): Promise<SubagentToolR
 		details: { mode: "management", results: [] },
 	};
 }
-
-export async function resumeInProcessChild(
-	id: string,
-	message: string,
-	candidate: ModelCandidate,
-): Promise<SubagentToolResult | undefined> {
-	const control = findSubagentControl(id);
-	if (!control) return undefined;
-	const target = resumeTarget(control, id);
-	if (!target) {
-		return {
-			content: [{ type: "text", text: `No in-process child found for '${id}'.` }],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
-	const outcome = await control.resumeChild(target.path, message, candidate);
-	const selection =
-		id === control.parent.path && control.listChildren().length > 1
-			? `Bare run id resolved to ${target.path}; interrupted children are preferred, then canonical path order.\n\n`
-			: "";
-	return {
-		content: [{ type: "text", text: `${selection}${outcome.envelope}` }],
-		isError: outcome.status === "error" || outcome.status === "interrupted" ? true : undefined,
-		details: { mode: "management", results: [] },
-	};
-}

package/dist/builtin/subagents/src/runs/inprocess/index.ts

@@ -1,14 +1,3 @@
-export type {
-	InProcessAttemptControlResult,
-	InProcessAttemptHandle,
-	InProcessAttemptResumeOutcome,
-} from "./attempt-handles.js";
-export {
-	clearInProcessAttemptHandles,
-	interruptInProcessAttempt,
-	registerInProcessAttempt,
-	resumeInProcessAttempt,
-} from "./attempt-handles.js";
 export type {
 	AdmissionRefusal,
 	AdmittedResult,
@@ -32,7 +21,6 @@ export {
 	continue_detached,
 	createSubagentControl,
 	deliver_child_result,
-	reload_cold_child,
 	run_child_attempt,
 	SubagentControlRuntime,
 	terminate_child_attempt,

package/dist/builtin/subagents/src/runs/inprocess/prompt-behavior.ts

@@ -11,7 +11,7 @@ export const CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS = [
 export const CHILD_FANOUT_BOUNDARY_INSTRUCTIONS = [
 	"You are a child subagent with explicit fanout responsibility for this assigned task.",
 	"The parent session owns final orchestration, completion decisions, and follow-up implementation launches.",
-	"Delegation is one level deep: the `subagent` tool refuses every launch, resume, and interrupt from inside a subagent.",
+	"Delegation is one level deep: the `subagent` tool refuses every launch and interrupt from inside a subagent.",
 	"Do the assigned fanout work yourself and report what you found; do not plan around delegating it.",
 	"If you need to edit files, call the actual edit/write tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text.",
 ].join("\n");