@bastani/atomic 0.9.11-alpha.8 → 0.9.11

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

@@ -1,17 +1,28 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
-import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import { normalizeSkillInput } from "../../agents/skills.ts";
-import { injectSingleProgressInstruction, resolveSingleProgress, writeInitialProgressFile } from "../../shared/settings.ts";
-import { recordRun } from "../shared/run-history.ts";
-import { getSingleResultOutput, compactForegroundDetails } from "../../shared/utils.ts";
-import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
-import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.ts";
+import { INTERCOM_BRIDGE_MARKER, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
+import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.ts";
+import {
+	injectSingleProgressInstruction,
+	resolveSingleProgress,
+	writeInitialProgressFile,
+} from "../../shared/settings.ts";
 import {
-	INTERCOM_BRIDGE_MARKER,
-	resolveSubagentIntercomTarget,
-} from "../../intercom/intercom-bridge.ts";
+	type AgentProgress,
+	type ArtifactPaths,
+	resolveChildMaxSubagentDepth,
+	resolveSubagentDepthPolicy,
+	type SingleResult,
+	type SubagentToolResult,
+	workflowSessionMetadataFromContext,
+	wrapForkTask,
+} from "../../shared/types.ts";
+import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.ts";
+import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.ts";
+import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
+import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
+import { recordRun } from "../shared/run-history.ts";
 import {
 	finalizeSingleOutput,
 	injectSingleOutputInstruction,
@@ -20,17 +31,13 @@ import {
 	validateFileOnlyOutputMode,
 } from "../shared/single-output.ts";
 import {
-	resolveChildMaxSubagentDepth,
-	resolveSubagentDepthPolicy,
-	workflowSessionMetadataFromContext,
-	wrapForkTask,
-	type AgentProgress,
-	type ArtifactPaths,
-	type SingleResult,
-	type SubagentToolResult,
-} from "../../shared/types.ts";
+	createForegroundControlNotifier,
+	maybeBuildForegroundIntercomReceipt,
+	notifyDetachedForegroundChildExit,
+	rememberForegroundRun,
+	replaceForegroundRunChild,
+} from "./subagent-executor-status.ts";
 import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, notifyDetachedForegroundChildExit, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
 
 function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
 	const error = result.error || "Failed";
@@ -54,7 +61,10 @@ function cleanupTransientProgress(progressDir: string | undefined, artifactsEnab
 	}
 }
 
-export async function runSinglePath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<SubagentToolResult> {
+export async function runSinglePath(
+	data: ExecutionContextData,
+	deps: ResolvedExecutorDeps,
+): Promise<SubagentToolResult> {
 	const {
 		params,
 		effectiveCwd,
@@ -71,7 +81,9 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 		controlConfig,
 	} = data;
 	const onControlEvent = createForegroundControlNotifier(data, deps);
-	const childIntercomTarget = data.intercomBridge.active ? resolveSubagentIntercomTarget(runId, params.agent!, 0) : undefined;
+	const childIntercomTarget = data.intercomBridge.active
+		? resolveSubagentIntercomTarget(runId, params.agent!, 0)
+		: undefined;
 	const allProgress: AgentProgress[] = [];
 	const allArtifactPaths: ArtifactPaths[] = [];
 	const agentConfig = agents.find((a) => a.name === params.agent);
@@ -109,7 +121,11 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 	const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, effectiveCwd);
 	const validationError = validateFileOnlyOutputMode(effectiveOutputMode, outputPath, `Single run (${params.agent})`);
 	if (validationError) {
-		return { content: [{ type: "text", text: validationError }], isError: true, details: { mode: "single", results: [] } };
+		return {
+			content: [{ type: "text", text: validationError }],
+			isError: true,
+			details: { mode: "single", results: [] },
+		};
 	}
 	// Single-agent progress is isolated by run so the injected contract cannot
 	// overwrite a project's own progress.md or collide with another child.
@@ -144,22 +160,22 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 
 	const forwardSingleUpdate = onUpdate
 		? (update: SubagentToolResult) => {
-			if (foregroundControl) {
-				const firstProgress = update.details?.progress?.[0];
-				foregroundControl.currentAgent = params.agent;
-				foregroundControl.currentIndex = firstProgress?.index ?? 0;
-				foregroundControl.currentActivityState = firstProgress?.activityState;
-				foregroundControl.lastActivityAt = firstProgress?.lastActivityAt;
-				foregroundControl.currentTool = firstProgress?.currentTool;
-				foregroundControl.currentToolStartedAt = firstProgress?.currentToolStartedAt;
-				foregroundControl.currentPath = firstProgress?.currentPath;
-				foregroundControl.turnCount = firstProgress?.turnCount;
-				foregroundControl.tokens = firstProgress?.tokens;
-				foregroundControl.toolCount = firstProgress?.toolCount;
-				foregroundControl.updatedAt = Date.now();
+				if (foregroundControl) {
+					const firstProgress = update.details?.progress?.[0];
+					foregroundControl.currentAgent = params.agent;
+					foregroundControl.currentIndex = firstProgress?.index ?? 0;
+					foregroundControl.currentActivityState = firstProgress?.activityState;
+					foregroundControl.lastActivityAt = firstProgress?.lastActivityAt;
+					foregroundControl.currentTool = firstProgress?.currentTool;
+					foregroundControl.currentToolStartedAt = firstProgress?.currentToolStartedAt;
+					foregroundControl.currentPath = firstProgress?.currentPath;
+					foregroundControl.turnCount = firstProgress?.turnCount;
+					foregroundControl.tokens = firstProgress?.tokens;
+					foregroundControl.toolCount = firstProgress?.toolCount;
+					foregroundControl.updatedAt = Date.now();
+				}
+				onUpdate(update);
 			}
-			onUpdate(update);
-		}
 		: undefined;
 
 	let r: SingleResult;
@@ -269,14 +285,21 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 
 	if (r.detached) {
 		return {
-			content: [{ type: "text", text: `Detached for intercom coordination: ${params.agent}. Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
+			content: [
+				{
+					type: "text",
+					text: `Detached for intercom coordination: ${params.agent}. Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.`,
+				},
+			],
 			details,
 		};
 	}
 
 	if (r.interrupted) {
 		return {
-			content: [{ type: "text", text: `Run paused after interrupt (${params.agent}). Waiting for explicit next action.` }],
+			content: [
+				{ type: "text", text: `Run paused after interrupt (${params.agent}). Waiting for explicit next action.` },
+			],
 			details,
 		};
 	}

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

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@bastani/atomic";
-import { compactForegroundDetails, compactForegroundResult, getSingleResultOutput } from "../../shared/utils.ts";
+import { type IntercomBridgeState, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import {
 	attachNestedChildrenToResultChildren,
 	buildSubagentResultIntercomPayload,
@@ -8,23 +8,27 @@ import {
 	resolveSubagentResultStatus,
 	stripDetailsOutputsForIntercomReceipt,
 } from "../../intercom/result-intercom.ts";
-import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
-import { formatControlIntercomMessage, formatControlNoticeMessage, shouldNotifyControlEvent } from "../shared/subagent-control.ts";
-import { deliverLocalCompletionNotification } from "../background/completion-notification.ts";
-import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
 import {
-	SUBAGENT_CONTROL_EVENT,
-	SUBAGENT_CONTROL_INTERCOM_EVENT,
 	type ControlEvent,
 	type Details,
 	type NestedRunSummary,
 	type SingleResult,
+	SUBAGENT_CONTROL_EVENT,
+	SUBAGENT_CONTROL_INTERCOM_EVENT,
 	type SubagentRunMode,
 	type SubagentState,
 	type SubagentToolResult,
 } from "../../shared/types.ts";
-import { resolveSubagentIntercomTarget, type IntercomBridgeState } from "../../intercom/intercom-bridge.ts";
-import type { ExecutorDeps, ExecutionContextData, ForegroundControl } from "./subagent-executor-types.ts";
+import { compactForegroundDetails, compactForegroundResult, getSingleResultOutput } from "../../shared/utils.ts";
+import { deliverLocalCompletionNotification } from "../background/completion-notification.ts";
+import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
+import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
+import {
+	formatControlIntercomMessage,
+	formatControlNoticeMessage,
+	shouldNotifyControlEvent,
+} from "../shared/subagent-control.ts";
+import type { ExecutionContextData, ExecutorDeps, ForegroundControl } from "./subagent-executor-types.ts";
 
 export function getForegroundControl(state: SubagentState, runId: string | undefined): ForegroundControl | undefined {
 	if (runId) return state.foregroundControls.get(runId);
@@ -41,7 +45,10 @@ export function getForegroundControl(state: SubagentState, runId: string | undef
 
 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`);
+	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`);
@@ -49,12 +56,14 @@ function formatForegroundActivity(control: ForegroundControl): string | undefine
 	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(" | ");
+		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(" | ");
+	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(" | ");
 }
 
@@ -70,7 +79,9 @@ export function foregroundStatusResult(control: ForegroundControl): SubagentTool
 		`Run: ${control.runId}`,
 		"State: running",
 		`Mode: ${control.mode}`,
-		control.currentAgent ? `Current: ${control.currentAgent}${control.currentIndex !== undefined ? ` step ${control.currentIndex + 1}` : ""}` : undefined,
+		control.currentAgent
+			? `Current: ${control.currentAgent}${control.currentIndex !== undefined ? ` step ${control.currentIndex + 1}` : ""}`
+			: undefined,
 		activity ? `Activity: ${activity}` : undefined,
 	].filter((line): line is string => Boolean(line));
 	lines.push(...formatNestedRunStatusLines(control.nestedChildren, { indent: "", commandHints: true, maxLines: 20 }));
@@ -82,11 +93,15 @@ export function retainedForegroundStatusResult(state: SubagentState, runId: stri
 	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 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})`);
@@ -101,7 +116,6 @@ const earlyDetachedResults = new WeakMap<SubagentState, Map<string, Map<number,
 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);
@@ -111,7 +125,10 @@ function takeEarlyDetachedResult(state: SubagentState, runId: string, index: num
 	return result;
 }
 
-export function rememberForegroundRun(state: SubagentState, input: { runId: string; mode: "single" | "parallel" | "chain"; cwd: string; results: SingleResult[] }): void {
+export function rememberForegroundRun(
+	state: SubagentState,
+	input: { runId: string; mode: "single" | "parallel" | "chain"; cwd: string; results: SingleResult[] },
+): void {
 	state.foregroundRuns ??= new Map();
 	state.foregroundRuns.set(input.runId, {
 		runId: input.runId,
@@ -123,7 +140,11 @@ export function rememberForegroundRun(state: SubagentState, input: { runId: stri
 			return {
 				agent: result.agent,
 				index,
-				status: resolveSubagentResultStatus({ exitCode: result.exitCode, interrupted: result.interrupted, detached: result.detached }),
+				status: resolveSubagentResultStatus({
+					exitCode: result.exitCode,
+					interrupted: result.interrupted,
+					detached: result.detached,
+				}),
 				...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
 				result,
 			};
@@ -136,7 +157,12 @@ export function rememberForegroundRun(state: SubagentState, input: { runId: stri
 	}
 }
 
-export function replaceForegroundRunChild(state: SubagentState, runId: string, index: number, result: SingleResult): void {
+export function replaceForegroundRunChild(
+	state: SubagentState,
+	runId: string,
+	index: number,
+	result: SingleResult,
+): void {
 	const retainedResult = compactForegroundResult(result);
 	const run = state.foregroundRuns?.get(runId);
 	if (!run) {
@@ -164,8 +190,12 @@ export function replaceForegroundRunChild(state: SubagentState, runId: string, i
 		return;
 	}
 	const child = run.children.find((entry) => entry.index === index);
-	if (!child || child.status !== "detached") return;
-	child.status = resolveSubagentResultStatus({ exitCode: retainedResult.exitCode, interrupted: retainedResult.interrupted, detached: retainedResult.detached });
+	if (child?.status !== "detached") return;
+	child.status = resolveSubagentResultStatus({
+		exitCode: retainedResult.exitCode,
+		interrupted: retainedResult.interrupted,
+		detached: retainedResult.detached,
+	});
 	child.result = retainedResult;
 	if (retainedResult.sessionFile) child.sessionFile = retainedResult.sessionFile;
 	run.updatedAt = Date.now();
@@ -190,7 +220,12 @@ export function emitControlNotification(input: {
 	if (input.controlConfig.notifyChannels.includes("event")) {
 		input.pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
 	}
-	if (input.event.type !== "active_long_running" && input.controlConfig.notifyChannels.includes("intercom") && input.intercomBridge.active && input.intercomBridge.orchestratorTarget) {
+	if (
+		input.event.type !== "active_long_running" &&
+		input.controlConfig.notifyChannels.includes("intercom") &&
+		input.intercomBridge.active &&
+		input.intercomBridge.orchestratorTarget
+	) {
 		input.pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
 			...payload,
 			to: input.intercomBridge.orchestratorTarget,
@@ -199,13 +234,17 @@ export function emitControlNotification(input: {
 	}
 }
 
-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,
-	});
+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 {
@@ -233,20 +272,26 @@ export function notifyDetachedForegroundChildExit(input: {
 	result: SingleResult;
 }): void {
 	const { pi, runId, index, result } = input;
-	void deliverLocalCompletionNotification(pi.events, {
-		id: runId,
-		runId,
-		agent: result.agent,
-		success: result.exitCode === 0 && !result.interrupted && !result.error,
-		summary: resultSummaryForIntercom(result),
-		exitCode: result.exitCode,
-		...(result.interrupted ? { state: "paused" } : {}),
-		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}`);
+	void deliverLocalCompletionNotification(
+		pi.events,
+		{
+			id: runId,
+			runId,
+			agent: result.agent,
+			success: result.exitCode === 0 && !result.interrupted && !result.error,
+			summary: resultSummaryForIntercom(result),
+			exitCode: result.exitCode,
+			...(result.interrupted ? { state: "paused" } : {}),
+			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}`,
+	);
 }
 
 async function emitForegroundResultIntercom(input: {
@@ -259,19 +304,25 @@ async function emitForegroundResultIntercom(input: {
 	nestedChildren?: NestedRunSummary[];
 }): 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({
-			exitCode: result.exitCode,
-			interrupted: result.interrupted,
-			detached: result.detached,
-		}),
-		summary: resultSummaryForIntercom(result),
-		index,
-		artifactPath: result.artifactPaths?.outputPath,
-		sessionPath: result.sessionFile,
-		intercomTarget: resolveSubagentIntercomTarget(input.runId, result.agent, index),
-	}]);
+	const children = input.results.flatMap((result, index) =>
+		result.detached
+			? []
+			: [
+					{
+						agent: result.agent,
+						status: resolveSubagentResultStatus({
+							exitCode: result.exitCode,
+							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,

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

@@ -2,9 +2,23 @@ import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import type { AgentConfig, AgentScope } from "../../agents/agents.ts";
 import type { IntercomBridgeState } from "../../intercom/intercom-bridge.ts";
 import type { ModelInfo } from "../../shared/model-info.ts";
-import type { ArtifactConfig, ControlConfig, MaxOutputConfig, NestedRouteInfo, ResolvedControlConfig, SubagentState, SubagentToolResult, SUBAGENT_ACTIONS } from "../../shared/types.ts";
 import type { ChainStep } from "../../shared/settings.ts";
-import type { executeAsyncChain, executeAsyncSingle, formatAsyncStartedMessage, isAsyncAvailable } from "../background/async-execution.ts";
+import type {
+	ArtifactConfig,
+	ControlConfig,
+	MaxOutputConfig,
+	NestedRouteInfo,
+	ResolvedControlConfig,
+	SUBAGENT_ACTIONS,
+	SubagentState,
+	SubagentToolResult,
+} from "../../shared/types.ts";
+import type {
+	executeAsyncChain,
+	executeAsyncSingle,
+	formatAsyncStartedMessage,
+	isAsyncAvailable,
+} from "../background/async-execution.ts";
 import type { runSync } from "./execution.ts";
 
 export interface TaskParam {
@@ -111,7 +125,10 @@ export interface PreparedExecutionContext {
 	foregroundMode: "single" | "parallel" | "chain";
 	execData: ExecutionContextData;
 	foregroundControl?: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
-	writeNestedForegroundEvent: (type: "subagent.nested.started" | "subagent.nested.completed", result?: SubagentToolResult) => void;
+	writeNestedForegroundEvent: (
+		type: "subagent.nested.started" | "subagent.nested.completed",
+		result?: SubagentToolResult,
+	) => void;
 }
 
 export interface ExecutionContextBuildResult {

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

@@ -1,6 +1,7 @@
 import * as path from "node:path";
+import { type ChainStep, isParallelStep, type ResolvedStepBehavior } from "../../shared/settings.ts";
+import type { ExtensionConfig, SubagentToolResult } from "../../shared/types.ts";
 import { resolveChildCwd } from "../../shared/utils.ts";
-import { isParallelStep, type ChainStep, type ResolvedStepBehavior } from "../../shared/settings.ts";
 import { resolveSingleOutputPath } from "../shared/single-output.ts";
 import {
 	createWorktrees,
@@ -10,7 +11,6 @@ import {
 	formatWorktreeTaskCwdConflict,
 	type WorktreeSetup,
 } from "../shared/worktree.ts";
-import type { ExtensionConfig, SubagentToolResult } from "../../shared/types.ts";
 import type { TaskParam } from "./subagent-executor-types.ts";
 
 export function buildParallelModeError(message: string): SubagentToolResult {
@@ -34,9 +34,7 @@ export function createParallelWorktreeSetup(
 		return {
 			setup: createWorktrees(cwd, runId, tasks.length, {
 				agents: tasks.map((task) => task.agent),
-				setupHook: setupHook
-					? { hookPath: setupHook, timeoutMs: setupHookTimeoutMs }
-					: undefined,
+				setupHook: setupHook ? { hookPath: setupHook, timeoutMs: setupHookTimeoutMs } : undefined,
 			}),
 		};
 	} catch (error) {
@@ -84,7 +82,11 @@ export function buildParallelWorktreeSuffix(
 ): string {
 	if (!worktreeSetup) return "";
 	const diffsDir = path.join(artifactsDir, "worktree-diffs");
-	const diffs = diffWorktrees(worktreeSetup, tasks.map((task) => task.agent), diffsDir);
+	const diffs = diffWorktrees(
+		worktreeSetup,
+		tasks.map((task) => task.agent),
+		diffsDir,
+	);
 	return formatWorktreeDiffSummary(diffs);
 }