@bastani/atomic 0.9.11-alpha.8 → 0.9.11

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

@@ -2,46 +2,46 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
-import { currentModelFullId } from "../shared/model-fallback.ts";
-import { readStatus } from "../../shared/utils.ts";
-import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../background/async-resume.ts";
-import { resolveSubagentRunId, type ResolvedSubagentRunId } from "../background/run-id-resolver.ts";
-import { toModelInfo } from "../../shared/model-info.ts";
-import { inheritedIntercomGroup } from "../shared/intercom-group.ts";
-import { resolveSingleProgress } from "../../shared/settings.ts";
-import {
-	createNestedRoute,
-	readNestedControlResults,
-	resolveInheritedNestedRouteFromEnv,
-	resolveNestedAsyncDir,
-	resolveNestedParentAddressFromEnv,
-	writeNestedControlRequest,
-	type NestedRunResolutionScope,
-} from "../shared/nested-events.ts";
-import { resolveControlConfig } from "../shared/subagent-control.ts";
-import { deliverSubagentIntercomMessageEvent } from "../../intercom/result-intercom.ts";
+import { resolveExecutionAgentScope } from "../../agents/agent-scope.ts";
 import {
 	applyIntercomBridgeToAgent,
 	resolveIntercomBridge,
 	resolveIntercomSessionTarget,
 	resolveSubagentIntercomTarget,
 } from "../../intercom/intercom-bridge.ts";
+import { deliverSubagentIntercomMessageEvent } from "../../intercom/result-intercom.ts";
 import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
+import { toModelInfo } from "../../shared/model-info.ts";
 import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
-import { resolveExecutionAgentScope } from "../../agents/agent-scope.ts";
+import { resolveSingleProgress } from "../../shared/settings.ts";
 import {
-	DEFAULT_ARTIFACT_CONFIG,
+	type ArtifactConfig,
 	checkSubagentDepth,
+	DEFAULT_ARTIFACT_CONFIG,
 	isWorkflowStageOrchestrationContext,
+	type NestedRunSummary,
 	resolveSubagentDepthPolicy,
 	resolveWorkflowStageMaxSubagentDepth,
-	workflowSessionMetadataFromContext,
-	subagentDepthBlockedMessage,
-	type ArtifactConfig,
-	type NestedRunSummary,
 	type SubagentState,
 	type SubagentToolResult,
+	subagentDepthBlockedMessage,
+	workflowSessionMetadataFromContext,
 } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../background/async-resume.ts";
+import { type ResolvedSubagentRunId, resolveSubagentRunId } from "../background/run-id-resolver.ts";
+import { inheritedIntercomGroup } from "../shared/intercom-group.ts";
+import { currentModelFullId } from "../shared/model-fallback.ts";
+import {
+	createNestedRoute,
+	type NestedRunResolutionScope,
+	readNestedControlResults,
+	resolveInheritedNestedRouteFromEnv,
+	resolveNestedAsyncDir,
+	resolveNestedParentAddressFromEnv,
+	writeNestedControlRequest,
+} from "../shared/nested-events.ts";
+import { resolveControlConfig } from "../shared/subagent-control.ts";
 import type { ResolvedExecutorDeps, SubagentParamsLike } from "./subagent-executor-types.ts";
 
 const ASYNC_INTERRUPT_SIGNAL: NodeJS.Signals = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
@@ -56,33 +56,87 @@ export function nestedResolutionScopeForExecutor(deps: ResolvedExecutorDeps): Ne
 	const address = route ? resolveNestedParentAddressFromEnv() : undefined;
 	return {
 		routes: route ? [route] : [],
-		...(address ? { descendantOf: { parentRunId: address.parentRunId, ...(address.parentStepIndex !== undefined ? { parentStepIndex: address.parentStepIndex } : {}) } } : {}),
+		...(address
+			? {
+					descendantOf: {
+						parentRunId: address.parentRunId,
+						...(address.parentStepIndex !== undefined ? { parentStepIndex: address.parentStepIndex } : {}),
+					},
+				}
+			: {}),
 	};
 }
 
-function resolveForegroundResumeTarget(params: SubagentParamsLike, state: SubagentState): { runId: string; mode: "single" | "parallel" | "chain"; state: "complete"; agent: string; index: number; intercomTarget: string; cwd: string; sessionFile: string } | undefined {
+function resolveForegroundResumeTarget(
+	params: SubagentParamsLike,
+	state: SubagentState,
+):
+	| {
+			runId: string;
+			mode: "single" | "parallel" | "chain";
+			state: "complete";
+			agent: string;
+			index: number;
+			intercomTarget: string;
+			cwd: string;
+			sessionFile: string;
+	  }
+	| undefined {
 	const requested = (params.id ?? params.runId)?.trim();
 	if (!requested || !state.foregroundRuns?.size) return undefined;
 	const direct = state.foregroundRuns.get(requested);
-	const matches = direct ? [direct] : [...state.foregroundRuns.values()].filter((run) => run.runId.startsWith(requested));
+	const matches = direct
+		? [direct]
+		: [...state.foregroundRuns.values()].filter((run) => run.runId.startsWith(requested));
 	if (matches.length === 0) return undefined;
-	if (matches.length > 1) throw new Error(`Ambiguous foreground run id prefix '${requested}' matched: ${matches.map((run) => run.runId).join(", ")}. Provide a longer id.`);
+	if (matches.length > 1)
+		throw new Error(
+			`Ambiguous foreground run id prefix '${requested}' matched: ${matches.map((run) => run.runId).join(", ")}. Provide a longer id.`,
+		);
 	const run = matches[0]!;
-	if (run.children.length > 1 && params.index === undefined) throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Provide index to choose one.`);
+	if (run.children.length > 1 && params.index === undefined)
+		throw new Error(
+			`Foreground run '${run.runId}' has ${run.children.length} children. Provide index to choose one.`,
+		);
 	const index = params.index ?? 0;
 	if (!Number.isInteger(index)) throw new Error(`Foreground run '${run.runId}' index must be an integer.`);
-	if (index < 0 || index >= run.children.length) throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Index ${index} is out of range.`);
+	if (index < 0 || index >= run.children.length)
+		throw new Error(
+			`Foreground run '${run.runId}' has ${run.children.length} children. Index ${index} is out of range.`,
+		);
 	const child = run.children[index]!;
-	if (child.status === "detached") throw new Error(`Foreground run '${run.runId}' child ${index} is detached for intercom coordination and cannot be revived safely from the remembered foreground state. Reply to the supervisor request first; after the child exits, start a fresh follow-up if needed.`);
-	if (!child.sessionFile) throw new Error(`Foreground run '${run.runId}' child ${index} does not have a persisted session file to resume from.`);
-	if (path.extname(child.sessionFile) !== ".jsonl") throw new Error(`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`);
+	if (child.status === "detached")
+		throw new Error(
+			`Foreground run '${run.runId}' child ${index} is detached for intercom coordination and cannot be revived safely from the remembered foreground state. Reply to the supervisor request first; after the child exits, start a fresh follow-up if needed.`,
+		);
+	if (!child.sessionFile)
+		throw new Error(
+			`Foreground run '${run.runId}' child ${index} does not have a persisted session file to resume from.`,
+		);
+	if (path.extname(child.sessionFile) !== ".jsonl")
+		throw new Error(
+			`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`,
+		);
 	const sessionFile = path.resolve(child.sessionFile);
-	if (!fs.existsSync(sessionFile)) throw new Error(`Foreground run '${run.runId}' child ${index} session file does not exist: ${child.sessionFile}`);
-	return { runId: run.runId, mode: run.mode, state: "complete", agent: child.agent, index, intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index), cwd: run.cwd, sessionFile };
+	if (!fs.existsSync(sessionFile))
+		throw new Error(`Foreground run '${run.runId}' child ${index} session file does not exist: ${child.sessionFile}`);
+	return {
+		runId: run.runId,
+		mode: run.mode,
+		state: "complete",
+		agent: child.agent,
+		index,
+		intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index),
+		cwd: run.cwd,
+		sessionFile,
+	};
 }
 
 type AsyncResumeSourceTarget = ReturnType<typeof resolveAsyncResumeTarget> & { source: "async" };
-type ForegroundResumeSourceTarget = NonNullable<ReturnType<typeof resolveForegroundResumeTarget>> & { kind: "revive"; source: "foreground" };
+type ForegroundResumeSourceTarget = NonNullable<ReturnType<typeof resolveForegroundResumeTarget>> & {
+	kind: "revive";
+	source: "foreground";
+};
 type NestedResumeSourceTarget = {
 	kind: "revive";
 	source: "nested";
@@ -141,7 +195,9 @@ function resolveResumeTarget(params: SubagentParamsLike, state: SubagentState):
 		const asyncExact = resumeTargetExact(asyncTarget, requested);
 		if (foregroundExact && !asyncExact) return foregroundTarget;
 		if (asyncExact && !foregroundExact) return asyncTarget;
-		throw new Error(`Resume id '${requested}' is ambiguous between foreground run '${foregroundTarget.runId}' and async run '${asyncTarget.runId}'. Provide a full run id.`);
+		throw new Error(
+			`Resume id '${requested}' is ambiguous between foreground run '${foregroundTarget.runId}' and async run '${asyncTarget.runId}'. Provide a full run id.`,
+		);
 	}
 	if (foregroundTarget) {
 		if (isExactResumeError(asyncError, "async", requested)) throw asyncError;
@@ -159,7 +215,10 @@ function resolveResumeTarget(params: SubagentParamsLike, state: SubagentState):
 	throw new Error("Run not found. Provide id or runId.");
 }
 
-function getAsyncInterruptTarget(state: SubagentState, runId: string | undefined): { asyncId: string; asyncDir: string } | undefined {
+function getAsyncInterruptTarget(
+	state: SubagentState,
+	runId: string | undefined,
+): { asyncId: string; asyncDir: string } | undefined {
 	if (runId) {
 		const direct = state.asyncJobs.get(runId);
 		if (direct) return { asyncId: direct.asyncId, asyncDir: direct.asyncDir };
@@ -178,9 +237,14 @@ export function interruptAsyncRun(state: SubagentState, runId: string | undefine
 	const target = getAsyncInterruptTarget(state, runId);
 	if (!target) return null;
 	const status = readStatus(target.asyncDir);
-	if (!status || status.state !== "running" || typeof status.pid !== "number") {
+	if (status?.state !== "running" || typeof status.pid !== "number") {
 		return {
-			content: [{ type: "text", text: `No running async run with an interrupt-capable pid was found for '${runId ?? "current"}'.` }],
+			content: [
+				{
+					type: "text",
+					text: `No running async run with an interrupt-capable pid was found for '${runId ?? "current"}'.`,
+				},
+			],
 			isError: true,
 			details: { mode: "management", results: [] },
 		};
@@ -223,28 +287,35 @@ function pathWithin(base: string, candidate: string): boolean {
 function validateNestedSessionFile(run: NestedRunSummary, trustedSessionRoots: string[]): string {
 	const sessionFile = nestedRunSessionFile(run);
 	if (!sessionFile) throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
-	if (path.extname(sessionFile) !== ".jsonl") throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${sessionFile}`);
+	if (path.extname(sessionFile) !== ".jsonl")
+		throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${sessionFile}`);
 	const resolved = path.resolve(sessionFile);
-	if (!path.isAbsolute(sessionFile)) throw new Error(`Nested run '${run.id}' session file must be absolute: ${sessionFile}`);
+	if (!path.isAbsolute(sessionFile))
+		throw new Error(`Nested run '${run.id}' session file must be absolute: ${sessionFile}`);
 	if (!fs.existsSync(resolved)) throw new Error(`Nested run '${run.id}' session file does not exist: ${sessionFile}`);
 	const stat = fs.lstatSync(resolved);
-	if (!stat.isFile() || stat.isSymbolicLink()) throw new Error(`Nested run '${run.id}' session file is not a regular file: ${sessionFile}`);
+	if (!stat.isFile() || stat.isSymbolicLink())
+		throw new Error(`Nested run '${run.id}' session file is not a regular file: ${sessionFile}`);
 	const realSessionFile = fs.realpathSync(resolved);
-	const trustedRoots = trustedSessionRoots
-		.filter((root) => fs.existsSync(root))
-		.map((root) => fs.realpathSync(root));
+	const trustedRoots = trustedSessionRoots.filter((root) => fs.existsSync(root)).map((root) => fs.realpathSync(root));
 	if (!trustedRoots.some((root) => pathWithin(root, realSessionFile))) {
 		throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${sessionFile}`);
 	}
 	if (!realSessionFile.split(path.sep).includes(run.id)) {
-		throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${sessionFile}`);
+		throw new Error(
+			`Nested run '${run.id}' session file is not under that nested run's session directory: ${sessionFile}`,
+		);
 	}
 	return realSessionFile;
 }
 
-function resolveNestedResumeTarget(match: ResolvedSubagentRunId & { kind: "nested" }, trustedSessionRoots: string[]): NestedResumeSourceTarget {
+function resolveNestedResumeTarget(
+	match: ResolvedSubagentRunId & { kind: "nested" },
+	trustedSessionRoots: string[],
+): NestedResumeSourceTarget {
 	const run = match.match.run;
-	if (run.state === "running" || run.state === "queued") throw new Error(`Nested run '${run.id}' is live; route the follow-up to the owner process instead.`);
+	if (run.state === "running" || run.state === "queued")
+		throw new Error(`Nested run '${run.id}' is live; route the follow-up to the owner process instead.`);
 	const agent = nestedRunAgent(run);
 	if (!agent) throw new Error(`Could not determine child agent for nested run '${run.id}'.`);
 	const state = run.state === "complete" || run.state === "failed" || run.state === "paused" ? run.state : "failed";
@@ -262,17 +333,27 @@ function resolveNestedResumeTarget(match: ResolvedSubagentRunId & { kind: "neste
 	};
 }
 
-async function waitForNestedControlResult(target: ResolvedSubagentRunId & { kind: "nested" }, requestId: string, timeoutMs = 1_000) {
+async function waitForNestedControlResult(
+	target: ResolvedSubagentRunId & { kind: "nested" },
+	requestId: string,
+	timeoutMs = 1_000,
+) {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() < deadline) {
-		const result = readNestedControlResults(target.match.route).find((candidate) => candidate.requestId === requestId && candidate.targetRunId === target.match.run.id);
+		const result = readNestedControlResults(target.match.route).find(
+			(candidate) => candidate.requestId === requestId && candidate.targetRunId === target.match.run.id,
+		);
 		if (result) return result;
 		await new Promise((resolve) => setTimeout(resolve, 50));
 	}
 	return undefined;
 }
 
-async function sendNestedControlRequest(target: ResolvedSubagentRunId & { kind: "nested" }, action: "interrupt" | "resume", message?: string) {
+async function sendNestedControlRequest(
+	target: ResolvedSubagentRunId & { kind: "nested" },
+	action: "interrupt" | "resume",
+	message?: string,
+) {
 	const requestId = randomUUID();
 	writeNestedControlRequest(target.match.route, {
 		ts: Date.now(),
@@ -284,39 +365,96 @@ async function sendNestedControlRequest(target: ResolvedSubagentRunId & { kind:
 	return waitForNestedControlResult(target, requestId);
 }
 
-function directNestedAsyncInterrupt(target: ResolvedSubagentRunId & { kind: "nested" }): SubagentToolResult | undefined {
+function directNestedAsyncInterrupt(
+	target: ResolvedSubagentRunId & { kind: "nested" },
+): SubagentToolResult | undefined {
 	const run = target.match.run;
 	const asyncDir = resolveNestedAsyncDir(target.match.rootRunId, run);
 	if (!asyncDir) return undefined;
 	const status = readStatus(asyncDir);
 	const pid = typeof status?.pid === "number" && status.pid > 0 ? status.pid : run.pid;
-	if (!status || status.state !== "running" || typeof pid !== "number" || pid <= 0) return undefined;
+	if (status?.state !== "running" || typeof pid !== "number" || pid <= 0) return undefined;
 	try {
 		process.kill(pid, ASYNC_INTERRUPT_SIGNAL);
-		return { content: [{ type: "text", text: `Interrupt requested for nested async run ${run.id}.` }], details: { mode: "management", results: [] } };
+		return {
+			content: [{ type: "text", text: `Interrupt requested for nested async run ${run.id}.` }],
+			details: { mode: "management", results: [] },
+		};
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		return { content: [{ type: "text", text: `Failed to interrupt nested async run ${run.id}: ${message}` }], isError: true, details: { mode: "management", results: [] } };
+		return {
+			content: [{ type: "text", text: `Failed to interrupt nested async run ${run.id}: ${message}` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
 	}
 }
 
-export async function interruptNestedRun(target: ResolvedSubagentRunId & { kind: "nested" }): Promise<SubagentToolResult> {
+export async function interruptNestedRun(
+	target: ResolvedSubagentRunId & { kind: "nested" },
+): Promise<SubagentToolResult> {
 	const run = target.match.run;
-	if (run.state === "complete") return { content: [{ type: "text", text: `Nested run ${run.id} is already complete and cannot be interrupted.` }], isError: true, details: { mode: "management", results: [] } };
-	if (run.state === "failed") return { content: [{ type: "text", text: `Nested run ${run.id} has failed and cannot be interrupted.` }], isError: true, details: { mode: "management", results: [] } };
-	if (run.state === "paused") return { content: [{ type: "text", text: `Nested run ${run.id} is already paused.` }], isError: true, details: { mode: "management", results: [] } };
+	if (run.state === "complete")
+		return {
+			content: [{ type: "text", text: `Nested run ${run.id} is already complete and cannot be interrupted.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	if (run.state === "failed")
+		return {
+			content: [{ type: "text", text: `Nested run ${run.id} has failed and cannot be interrupted.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	if (run.state === "paused")
+		return {
+			content: [{ type: "text", text: `Nested run ${run.id} is already paused.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
 	const result = await sendNestedControlRequest(target, "interrupt");
-	if (result) return { content: [{ type: "text", text: result.message }], isError: result.ok ? undefined : true, details: { mode: "management", results: [] } };
+	if (result)
+		return {
+			content: [{ type: "text", text: result.message }],
+			isError: result.ok ? undefined : true,
+			details: { mode: "management", results: [] },
+		};
 	const direct = directNestedAsyncInterrupt(target);
 	if (direct) return direct;
-	return { content: [{ type: "text", text: `Nested run ${run.id} owner is not reachable and no safe direct async interrupt fallback is available.` }], isError: true, details: { mode: "management", results: [] } };
+	return {
+		content: [
+			{
+				type: "text",
+				text: `Nested run ${run.id} owner is not reachable and no safe direct async interrupt fallback is available.`,
+			},
+		],
+		isError: true,
+		details: { mode: "management", results: [] },
+	};
 }
 
-async function resumeLiveNestedRun(input: { target: ResolvedSubagentRunId & { kind: "nested" }; message: string }): Promise<SubagentToolResult> {
+async function resumeLiveNestedRun(input: {
+	target: ResolvedSubagentRunId & { kind: "nested" };
+	message: string;
+}): Promise<SubagentToolResult> {
 	const run = input.target.match.run;
 	const result = await sendNestedControlRequest(input.target, "resume", input.message);
-	if (result) return { content: [{ type: "text", text: result.message }], isError: result.ok ? undefined : true, details: { mode: "management", results: [] } };
-	return { content: [{ type: "text", text: `Nested run ${run.id} appears live but its owner route is not reachable. Wait for completion, then retry action='resume'.` }], isError: true, details: { mode: "management", results: [] } };
+	if (result)
+		return {
+			content: [{ type: "text", text: result.message }],
+			isError: result.ok ? undefined : true,
+			details: { mode: "management", results: [] },
+		};
+	return {
+		content: [
+			{
+				type: "text",
+				text: `Nested run ${run.id} appears live but its owner route is not reachable. Wait for completion, then retry action='resume'.`,
+			},
+		],
+		isError: true,
+		details: { mode: "management", results: [] },
+	};
 }
 
 export async function resumeAsyncRun(input: {
@@ -338,13 +476,20 @@ export async function resumeAsyncRun(input: {
 	const parentSessionFile = input.ctx.sessionManager.getSessionFile() ?? null;
 	try {
 		const requestedId = input.params.id ?? input.params.runId;
-		const resolved = requestedId ? resolveSubagentRunId(requestedId, { state: input.deps.state, nested: nestedResolutionScopeForExecutor(input.deps) }) : undefined;
+		const resolved = requestedId
+			? resolveSubagentRunId(requestedId, {
+					state: input.deps.state,
+					nested: nestedResolutionScopeForExecutor(input.deps),
+				})
+			: undefined;
 		if (resolved?.kind === "nested") {
 			if (resolved.match.run.state === "running" || resolved.match.run.state === "queued") {
 				return resumeLiveNestedRun({ target: resolved, message: followUp });
 			}
 			const trustedSessionRoots = [
-				...(input.deps.config.defaultSessionDir ? [path.resolve(input.deps.expandTilde(input.deps.config.defaultSessionDir))] : []),
+				...(input.deps.config.defaultSessionDir
+					? [path.resolve(input.deps.expandTilde(input.deps.config.defaultSessionDir))]
+					: []),
 				...(parentSessionFile ? [input.deps.getSubagentSessionRoot(parentSessionFile)] : []),
 			];
 			target = resolveNestedResumeTarget(resolved, trustedSessionRoots);
@@ -353,7 +498,11 @@ export async function resumeAsyncRun(input: {
 		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
+		return {
+			content: [{ type: "text", text: message }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
 	}
 
 	if (target.kind === "live") {
@@ -366,12 +515,31 @@ export async function resumeAsyncRun(input: {
 		);
 		if (delivered) {
 			return {
-				content: [{ type: "text", text: [`Delivered follow-up to live async child.`, `Run: ${target.runId}`, `Intercom target: ${target.intercomTarget}`].join("\n") }],
+				content: [
+					{
+						type: "text",
+						text: [
+							`Delivered follow-up to live async child.`,
+							`Run: ${target.runId}`,
+							`Intercom target: ${target.intercomTarget}`,
+						].join("\n"),
+					},
+				],
 				details: { mode: "management", results: [] },
 			};
 		}
 		return {
-			content: [{ type: "text", text: [`Async child appears live but its intercom target is not registered.`, `Run: ${target.runId}`, `Intercom target: ${target.intercomTarget}`, `Wait for completion, then retry action='resume'.`].join("\n") }],
+			content: [
+				{
+					type: "text",
+					text: [
+						`Async child appears live but its intercom target is not registered.`,
+						`Run: ${target.runId}`,
+						`Intercom target: ${target.intercomTarget}`,
+						`Wait for completion, then retry action='resume'.`,
+					].join("\n"),
+				},
+			],
 			isError: true,
 			details: { mode: "management", results: [] },
 		};
@@ -381,13 +549,15 @@ export async function resumeAsyncRun(input: {
 	const { blocked, depth, maxDepth, workflowStageGuard } = checkSubagentDepth(resumeDepthPolicy.maxSubagentDepth);
 	if (blocked) {
 		return {
-			content: [{
-				type: "text",
-				text: subagentDepthBlockedMessage(depth, maxDepth, {
-					action: "resume",
-					workflowStageGuard: workflowStageGuard || resumeDepthPolicy.workflowStageSubagentGuard,
-				}),
-			}],
+			content: [
+				{
+					type: "text",
+					text: subagentDepthBlockedMessage(depth, maxDepth, {
+						action: "resume",
+						workflowStageGuard: workflowStageGuard || resumeDepthPolicy.workflowStageSubagentGuard,
+					}),
+				},
+			],
 			isError: true,
 			details: { mode: "management", results: [] },
 		};
@@ -397,7 +567,10 @@ export async function resumeAsyncRun(input: {
 	const effectiveCwd = target.cwd ?? input.requestCwd;
 	const scope = resolveExecutionAgentScope(input.params.agentScope);
 	const discoveredAgents = input.deps.discoverAgents(effectiveCwd, scope).agents;
-	const sessionName = resolveIntercomSessionTarget(input.deps.pi.getSessionName(), input.ctx.sessionManager.getSessionId());
+	const sessionName = resolveIntercomSessionTarget(
+		input.deps.pi.getSessionName(),
+		input.ctx.sessionManager.getSessionId(),
+	);
 	const intercomBridge = resolveIntercomBridge({
 		config: input.deps.config.intercomBridge,
 		context: input.params.context,
@@ -417,9 +590,7 @@ export async function resumeAsyncRun(input: {
 	}
 
 	const runId = randomUUID().slice(0, 8);
-	const revivedTarget = intercomBridge.active
-		? resolveSubagentIntercomTarget(runId, target.agent, 0)
-		: undefined;
+	const revivedTarget = intercomBridge.active ? resolveSubagentIntercomTarget(runId, target.agent, 0) : undefined;
 	const supervisorAuthorization = await requestSupervisorAuthorization(input.deps.pi.events, revivedTarget);
 	const artifactConfig: ArtifactConfig = { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts !== false };
 	const availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo);
@@ -451,7 +622,9 @@ export async function resumeAsyncRun(input: {
 		worktreeSetupHookTimeoutMs: input.deps.config.worktreeSetupHookTimeoutMs,
 		controlConfig: resolveControlConfig(input.deps.config.control, input.params.control),
 		controlIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
-		childIntercomTarget: intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(runId, agent, index) : undefined,
+		childIntercomTarget: intercomBridge.active
+			? (agent, index) => resolveSubagentIntercomTarget(runId, agent, index)
+			: undefined,
 		supervisorAuthorization,
 		availableModels,
 	});
@@ -468,8 +641,11 @@ export async function resumeAsyncRun(input: {
 		revivedTarget ? `Intercom target: ${revivedTarget} (if registered)` : undefined,
 		`Status if needed: subagent({ action: "status", id: "${revivedId}" })`,
 	].filter((line): line is string => Boolean(line));
-	return { content: [{ type: "text", text: input.deps.runtime.formatAsyncStartedMessage(lines.join("\n")) }], details: result.details };
+	return {
+		content: [{ type: "text", text: input.deps.runtime.formatAsyncStartedMessage(lines.join("\n")) }],
+		details: result.details,
+	};
 }
 
-export { createNestedRoute };
 export type { ResolvedSubagentRunId };
+export { createNestedRoute };

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

@@ -1,4 +1,9 @@
-import { executeAsyncChain, executeAsyncSingle, formatAsyncStartedMessage, isAsyncAvailable } from "../background/async-execution.ts";
+import {
+	executeAsyncChain,
+	executeAsyncSingle,
+	formatAsyncStartedMessage,
+	isAsyncAvailable,
+} from "../background/async-execution.ts";
 import { runSync } from "./execution.ts";
 import type { SubagentExecutorRuntimeDeps } from "./subagent-executor-types.ts";