@bastani/atomic 0.9.11-alpha.8 → 0.9.11

package/dist/builtin/subagents/src/runs/background/async-job-tracker.ts

@@ -1,23 +1,23 @@
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { renderWidget, widgetRenderKey } from "../../tui/render.ts";
-import { formatControlNoticeMessage } from "../shared/subagent-control.ts";
+import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import {
 	type AsyncJobState,
 	type AsyncStartedEvent,
 	type ControlEvent,
-	type SubagentState,
 	POLL_INTERVAL_MS,
 	RESULTS_DIR,
 	SUBAGENT_CONTROL_EVENT,
 	SUBAGENT_CONTROL_INTERCOM_EVENT,
+	type SubagentState,
 } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { listAsyncRuns, type AsyncRunSummary } from "./async-status.ts";
+import { renderWidget, widgetRenderKey } from "../../tui/render.ts";
+import { hasLiveNestedDescendants, updateAsyncJobNestedProjection } from "../shared/nested-events.ts";
+import { formatControlNoticeMessage } from "../shared/subagent-control.ts";
+import { type AsyncRunSummary, listAsyncRuns } from "./async-status.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
-import { hasLiveNestedDescendants, updateAsyncJobNestedProjection } from "../shared/nested-events.ts";
 
 interface AsyncJobTrackerOptions {
 	completionRetentionMs?: number;
@@ -36,7 +36,11 @@ function cwdMatches(summaryCwd: string | undefined, currentCwd: string | undefin
 	return Boolean(summaryCwd && currentCwd && path.resolve(summaryCwd) === path.resolve(currentCwd));
 }
 
-function shouldHydrateRunForCurrentUi(summary: AsyncRunSummary, currentSessionId: string | null, currentCwd: string | undefined): boolean {
+function shouldHydrateRunForCurrentUi(
+	summary: AsyncRunSummary,
+	currentSessionId: string | null,
+	currentCwd: string | undefined,
+): boolean {
 	if (summary.sessionId && currentSessionId) return summary.sessionId === currentSessionId;
 	return cwdMatches(summary.cwd, currentCwd);
 }
@@ -69,17 +73,24 @@ function ctxCwd(ctx: ExtensionContext | null | undefined): string | undefined {
 function asyncRunSummaryToJobState(summary: AsyncRunSummary, existing?: AsyncJobState): AsyncJobState {
 	const chainStepCount = summary.chainStepCount ?? summary.steps.length;
 	const groups = normalizeParallelGroups(summary.parallelGroups, summary.steps.length, chainStepCount);
-	const activeGroup = summary.currentStep !== undefined
-		? groups.find((group) => summary.currentStep! >= group.start && summary.currentStep! < group.start + group.count)
-		: undefined;
+	const activeGroup =
+		summary.currentStep !== undefined
+			? groups.find(
+					(group) => summary.currentStep! >= group.start && summary.currentStep! < group.start + group.count,
+				)
+			: undefined;
 	const steps = activeGroup
-		? summary.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count).map((step, index) => ({ ...step, index: activeGroup.start + index }))
+		? summary.steps
+				.slice(activeGroup.start, activeGroup.start + activeGroup.count)
+				.map((step, index) => ({ ...step, index: activeGroup.start + index }))
 		: summary.steps.map((step, index) => ({ ...step, index: step.index ?? index }));
 	const agents = steps.map((step) => step.agent);
-	const stepsTotal = steps.length > 0 ? steps.length : existing?.stepsTotal ?? (agents.length > 0 ? agents.length : undefined);
-	const completedSteps = summary.state === "complete"
-		? steps.length
-		: steps.filter((step) => step.status === "complete" || step.status === "completed").length;
+	const stepsTotal =
+		steps.length > 0 ? steps.length : (existing?.stepsTotal ?? (agents.length > 0 ? agents.length : undefined));
+	const completedSteps =
+		summary.state === "complete"
+			? steps.length
+			: steps.filter((step) => step.status === "complete" || step.status === "completed").length;
 	return {
 		...existing,
 		asyncId: summary.id,
@@ -114,7 +125,12 @@ function asyncRunSummaryToJobState(summary: AsyncRunSummary, existing?: AsyncJob
 	};
 }
 
-export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: SubagentState, asyncDirRoot: string, options: AsyncJobTrackerOptions = {}): {
+export function createAsyncJobTracker(
+	pi: Pick<ExtensionAPI, "events">,
+	state: SubagentState,
+	asyncDirRoot: string,
+	options: AsyncJobTrackerOptions = {},
+): {
 	ensurePoller: () => void;
 	handleStarted: (data: unknown) => void;
 	handleComplete: (data: unknown) => void;
@@ -186,8 +202,15 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 					console.error(`Ignoring malformed async control event in '${eventsPath}':`, error);
 					continue;
 				}
-				if (!parsed || typeof parsed !== "object" || (parsed as { type?: unknown }).type !== "subagent.control") continue;
-				const record = parsed as { event?: ControlEvent; channels?: string[]; childIntercomTarget?: string; noticeText?: string; intercom?: { to?: string; message?: string } };
+				if (!parsed || typeof parsed !== "object" || (parsed as { type?: unknown }).type !== "subagent.control")
+					continue;
+				const record = parsed as {
+					event?: ControlEvent;
+					channels?: string[];
+					childIntercomTarget?: string;
+					noticeText?: string;
+					intercom?: { to?: string; message?: string };
+				};
 				if (!record.event || !Array.isArray(record.channels)) continue;
 				const payload = {
 					event: record.event,
@@ -199,7 +222,12 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 				if (record.channels.includes("event")) {
 					pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
 				}
-				if (record.event.type !== "active_long_running" && record.channels.includes("intercom") && record.intercom?.to && record.intercom.message) {
+				if (
+					record.event.type !== "active_long_running" &&
+					record.channels.includes("intercom") &&
+					record.intercom?.to &&
+					record.intercom.message
+				) {
 					pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
 						...payload,
 						to: record.intercom.to,
@@ -241,7 +269,12 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 				};
 				const reconcileNestedDescendants = () => {
 					try {
-						if (job.nestedRoute) reconcileNestedAsyncDescendants(job.nestedRoute, { resultsDir, kill: options.kill, now: options.now });
+						if (job.nestedRoute)
+							reconcileNestedAsyncDescendants(job.nestedRoute, {
+								resultsDir,
+								kill: options.kill,
+								now: options.now,
+							});
 					} catch (error) {
 						nestedRefreshFailed = true;
 						console.error(`Failed to refresh nested async descendants for '${job.asyncDir}':`, error);
@@ -271,7 +304,8 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 					if (status) {
 						const previousStatus = job.status;
 						job.status = status.state;
-						if (job.status !== "complete" && job.status !== "failed" && job.status !== "paused") cancelCleanup(job.asyncId);
+						if (job.status !== "complete" && job.status !== "failed" && job.status !== "paused")
+							cancelCleanup(job.asyncId);
 						job.sessionId = status.sessionId ?? job.sessionId;
 						job.activityState = status.activityState;
 						job.lastActivityAt = status.lastActivityAt ?? job.lastActivityAt;
@@ -286,14 +320,25 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 						job.startedAt = status.startedAt ?? job.startedAt;
 						if (status.lastUpdate !== undefined) job.updatedAt = status.lastUpdate;
 						if (status.steps?.length) {
-							const groups = normalizeParallelGroups(status.parallelGroups, status.steps.length, status.chainStepCount ?? status.steps.length);
+							const groups = normalizeParallelGroups(
+								status.parallelGroups,
+								status.steps.length,
+								status.chainStepCount ?? status.steps.length,
+							);
 							job.parallelGroups = groups.length ? groups : job.parallelGroups;
 							job.hasParallelGroups = groups.length > 0 || job.hasParallelGroups;
-							const activeGroup = status.currentStep !== undefined
-								? groups.find((group) => status.currentStep! >= group.start && status.currentStep! < group.start + group.count)
-								: undefined;
+							const activeGroup =
+								status.currentStep !== undefined
+									? groups.find(
+											(group) =>
+												status.currentStep! >= group.start &&
+												status.currentStep! < group.start + group.count,
+										)
+									: undefined;
 							const visibleSteps = activeGroup
-								? status.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count).map((step, index) => ({ ...step, index: activeGroup.start + index }))
+								? status.steps
+										.slice(activeGroup.start, activeGroup.start + activeGroup.count)
+										.map((step, index) => ({ ...step, index: activeGroup.start + index }))
 								: status.steps.map((step, index) => ({ ...step, index }));
 							job.activeParallelGroup = Boolean(activeGroup);
 							job.agents = visibleSteps.map((step) => step.agent);
@@ -301,14 +346,21 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 							refreshNestedProjection();
 							job.stepsTotal = visibleSteps.length;
 							job.runningSteps = visibleSteps.filter((step) => step.status === "running").length;
-							job.completedSteps = visibleSteps.filter((step) => step.status === "complete" || step.status === "completed").length;
+							job.completedSteps = visibleSteps.filter(
+								(step) => step.status === "complete" || step.status === "completed",
+							).length;
 							if (status.state === "complete") job.completedSteps = visibleSteps.length;
 						}
 						job.sessionDir = status.sessionDir ?? job.sessionDir;
 						job.outputFile = status.outputFile ?? job.outputFile;
 						job.totalTokens = status.totalTokens ?? job.totalTokens;
 						job.sessionFile = status.sessionFile ?? job.sessionFile;
-						if ((job.status === "complete" || job.status === "failed" || job.status === "paused") && !nestedRefreshFailed && !hasLiveNestedDescendants(job.nestedChildren) && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
+						if (
+							(job.status === "complete" || job.status === "failed" || job.status === "paused") &&
+							!nestedRefreshFailed &&
+							!hasLiveNestedDescendants(job.nestedChildren) &&
+							(previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))
+						) {
 							scheduleCleanup(job.asyncId);
 						}
 						if (widgetRenderKey(job) !== widgetStateBefore) widgetChanged = true;
@@ -380,12 +432,14 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 		} else if (info.agent) {
 			rawAgents = [info.agent];
 		}
-		const validParallelGroups = normalizeParallelGroups(info.parallelGroups, Number.MAX_SAFE_INTEGER, info.chainStepCount ?? Number.MAX_SAFE_INTEGER);
+		const validParallelGroups = normalizeParallelGroups(
+			info.parallelGroups,
+			Number.MAX_SAFE_INTEGER,
+			info.chainStepCount ?? Number.MAX_SAFE_INTEGER,
+		);
 		const firstGroup = validParallelGroups.find((group) => group.start === 0);
 		const firstGroupCount = firstGroup?.count;
-		const agents = firstGroupCount && firstGroupCount > 0
-			? rawAgents?.slice(0, firstGroupCount)
-			: rawAgents;
+		const agents = firstGroupCount && firstGroupCount > 0 ? rawAgents?.slice(0, firstGroupCount) : rawAgents;
 		state.asyncJobs.set(info.id, {
 			asyncId: info.id,
 			asyncDir,

package/dist/builtin/subagents/src/runs/background/async-resume.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus } from "../../shared/types.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
+import { ASYNC_DIR, type AsyncStatus, RESULTS_DIR } from "../../shared/types.ts";
 import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
 
 export interface AsyncResumeParams {
@@ -59,10 +59,16 @@ function ensureObject(value: unknown, source: string): Record<string, unknown> {
 	return value as Record<string, unknown>;
 }
 
-function validateOptionalString(value: Record<string, unknown>, field: string, source: string, displayField = field): string | undefined {
+function validateOptionalString(
+	value: Record<string, unknown>,
+	field: string,
+	source: string,
+	displayField = field,
+): string | undefined {
 	const fieldValue = value[field];
 	if (fieldValue === undefined) return undefined;
-	if (typeof fieldValue !== "string") throw new Error(`Invalid async result file '${source}': ${displayField} must be a string.`);
+	if (typeof fieldValue !== "string")
+		throw new Error(`Invalid async result file '${source}': ${displayField} must be a string.`);
 	return fieldValue;
 }
 
@@ -71,19 +77,27 @@ function validateResultFile(value: unknown, resultPath: string): AsyncResultFile
 	const resultsValue = data.results;
 	let results: AsyncResultFile["results"];
 	if (resultsValue !== undefined) {
-		if (!Array.isArray(resultsValue)) throw new Error(`Invalid async result file '${resultPath}': results must be an array.`);
+		if (!Array.isArray(resultsValue))
+			throw new Error(`Invalid async result file '${resultPath}': results must be an array.`);
 		results = resultsValue.map((entry, index) => {
 			const child = ensureObject(entry, `${resultPath} results[${index}]`);
 			const agent = validateOptionalString(child, "agent", resultPath, `results[${index}].agent`);
 			const sessionFile = validateOptionalString(child, "sessionFile", resultPath, `results[${index}].sessionFile`);
-			const intercomTarget = validateOptionalString(child, "intercomTarget", resultPath, `results[${index}].intercomTarget`);
+			const intercomTarget = validateOptionalString(
+				child,
+				"intercomTarget",
+				resultPath,
+				`results[${index}].intercomTarget`,
+			);
 			const success = child.success;
-			if (success !== undefined && typeof success !== "boolean") throw new Error(`Invalid async result file '${resultPath}': results[${index}].success must be a boolean.`);
+			if (success !== undefined && typeof success !== "boolean")
+				throw new Error(`Invalid async result file '${resultPath}': results[${index}].success must be a boolean.`);
 			return { agent, sessionFile, intercomTarget, ...(typeof success === "boolean" ? { success } : {}) };
 		});
 	}
 	const success = data.success;
-	if (success !== undefined && typeof success !== "boolean") throw new Error(`Invalid async result file '${resultPath}': success must be a boolean.`);
+	if (success !== undefined && typeof success !== "boolean")
+		throw new Error(`Invalid async result file '${resultPath}': success must be a boolean.`);
 	return {
 		id: validateOptionalString(data, "id", resultPath),
 		runId: validateOptionalString(data, "runId", resultPath),
@@ -137,9 +151,10 @@ function assertInsideRoot(root: string, target: string, label: string): void {
 
 function prefixedRunIds(dir: string, prefix: string, suffix = ""): string[] {
 	if (!fs.existsSync(dir)) return [];
-	return fs.readdirSync(dir)
+	return fs
+		.readdirSync(dir)
 		.filter((entry) => entry.startsWith(prefix) && (!suffix || entry.endsWith(suffix)))
-		.map((entry) => suffix ? entry.slice(0, -suffix.length) : entry)
+		.map((entry) => (suffix ? entry.slice(0, -suffix.length) : entry))
 		.sort();
 }
 
@@ -149,15 +164,18 @@ function exactResultPath(resultsDir: string, runId: string): string | null {
 	return fs.existsSync(resultPath) ? resultPath : null;
 }
 
-export function findAsyncRunPrefixMatches(prefix: string, asyncDirRoot: string, resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
+export function findAsyncRunPrefixMatches(
+	prefix: string,
+	asyncDirRoot: string,
+	resultsDir: string,
+): Array<{ id: string; location: AsyncRunLocation }> {
 	const requestedId = assertRunId(prefix, "id");
 	if (!requestedId) return [];
 	const asyncRoot = path.resolve(asyncDirRoot);
 	const resultRoot = path.resolve(resultsDir);
-	const matchingIds = [...new Set([
-		...prefixedRunIds(asyncRoot, requestedId),
-		...prefixedRunIds(resultRoot, requestedId, ".json"),
-	])].sort();
+	const matchingIds = [
+		...new Set([...prefixedRunIds(asyncRoot, requestedId), ...prefixedRunIds(resultRoot, requestedId, ".json")]),
+	].sort();
 	return matchingIds.map((id) => {
 		const asyncDir = path.join(asyncRoot, id);
 		assertInsideRoot(asyncRoot, asyncDir, "Async run directory");
@@ -172,7 +190,11 @@ export function findAsyncRunPrefixMatches(prefix: string, asyncDirRoot: string,
 	});
 }
 
-export function resolveAsyncRunLocation(params: AsyncResumeParams, asyncDirRoot: string, resultsDir: string): AsyncRunLocation {
+export function resolveAsyncRunLocation(
+	params: AsyncResumeParams,
+	asyncDirRoot: string,
+	resultsDir: string,
+): AsyncRunLocation {
 	const asyncRoot = path.resolve(asyncDirRoot);
 	const resultRoot = path.resolve(resultsDir);
 	const requestedId = assertRunId(params.id, "id") ?? assertRunId(params.runId, "runId");
@@ -201,13 +223,21 @@ export function resolveAsyncRunLocation(params: AsyncResumeParams, asyncDirRoot:
 	const matching = findAsyncRunPrefixMatches(requestedId, asyncRoot, resultRoot);
 	if (matching.length === 0) return { asyncDir: null, resultPath: null, resolvedId: requestedId };
 	if (matching.length > 1) {
-		throw new Error(`Ambiguous async run id prefix '${requestedId}' matched: ${matching.map((match) => match.id).join(", ")}. Provide a longer id.`);
+		throw new Error(
+			`Ambiguous async run id prefix '${requestedId}' matched: ${matching.map((match) => match.id).join(", ")}. Provide a longer id.`,
+		);
 	}
 	return matching[0]!.location;
 }
 
 function resultState(result: AsyncResultFile): AsyncStatus["state"] {
-	if (result.state === "complete" || result.state === "failed" || result.state === "paused" || result.state === "running" || result.state === "queued") {
+	if (
+		result.state === "complete" ||
+		result.state === "failed" ||
+		result.state === "paused" ||
+		result.state === "running" ||
+		result.state === "queued"
+	) {
 		return result.state;
 	}
 	return result.success ? "complete" : "failed";
@@ -216,21 +246,28 @@ function resultState(result: AsyncResultFile): AsyncStatus["state"] {
 function validateStatusForResume(status: AsyncStatus | null, source: string): void {
 	if (!status) return;
 	if (typeof status.runId !== "string") throw new Error(`Invalid async status '${source}': runId must be a string.`);
-	if (status.sessionId !== undefined && typeof status.sessionId !== "string") throw new Error(`Invalid async status '${source}': sessionId must be a string.`);
-	if (status.cwd !== undefined && typeof status.cwd !== "string") throw new Error(`Invalid async status '${source}': cwd must be a string.`);
-	if (status.sessionFile !== undefined && typeof status.sessionFile !== "string") throw new Error(`Invalid async status '${source}': sessionFile must be a string.`);
+	if (status.sessionId !== undefined && typeof status.sessionId !== "string")
+		throw new Error(`Invalid async status '${source}': sessionId must be a string.`);
+	if (status.cwd !== undefined && typeof status.cwd !== "string")
+		throw new Error(`Invalid async status '${source}': cwd must be a string.`);
+	if (status.sessionFile !== undefined && typeof status.sessionFile !== "string")
+		throw new Error(`Invalid async status '${source}': sessionFile must be a string.`);
 	if (status.steps !== undefined) {
 		if (!Array.isArray(status.steps)) throw new Error(`Invalid async status '${source}': steps must be an array.`);
 		status.steps.forEach((step, index) => {
-			if (!step || typeof step !== "object" || Array.isArray(step)) throw new Error(`Invalid async status '${source}': steps[${index}] must be an object.`);
-			if (typeof step.agent !== "string") throw new Error(`Invalid async status '${source}': steps[${index}].agent must be a string.`);
-			if (step.sessionFile !== undefined && typeof step.sessionFile !== "string") throw new Error(`Invalid async status '${source}': steps[${index}].sessionFile must be a string.`);
+			if (!step || typeof step !== "object" || Array.isArray(step))
+				throw new Error(`Invalid async status '${source}': steps[${index}] must be an object.`);
+			if (typeof step.agent !== "string")
+				throw new Error(`Invalid async status '${source}': steps[${index}].agent must be a string.`);
+			if (step.sessionFile !== undefined && typeof step.sessionFile !== "string")
+				throw new Error(`Invalid async status '${source}': steps[${index}].sessionFile must be a string.`);
 		});
 	}
 }
 
 function validateResumeSessionFile(runId: string, sessionFile: string): string {
-	if (path.extname(sessionFile) !== ".jsonl") throw new Error(`Async run '${runId}' session file must be a .jsonl file: ${sessionFile}`);
+	if (path.extname(sessionFile) !== ".jsonl")
+		throw new Error(`Async run '${runId}' session file must be a .jsonl file: ${sessionFile}`);
 	const resolved = path.resolve(sessionFile);
 	if (!fs.existsSync(resolved)) throw new Error(`Async run '${runId}' session file does not exist: ${sessionFile}`);
 	return resolved;
@@ -250,7 +287,12 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 	const status = reconciliation?.status ?? null;
 	validateStatusForResume(status, location.asyncDir ? path.join(location.asyncDir, "status.json") : "status.json");
 	const result = location.resultPath ? readResultFile(location.resultPath) : undefined;
-	const runId = status?.runId ?? result?.runId ?? result?.id ?? location.resolvedId ?? (location.asyncDir ? path.basename(location.asyncDir) : "unknown");
+	const runId =
+		status?.runId ??
+		result?.runId ??
+		result?.id ??
+		location.resolvedId ??
+		(location.asyncDir ? path.basename(location.asyncDir) : "unknown");
 	const state = status?.state ?? (result ? resultState(result) : undefined);
 	if (!state) throw new Error(`Status file not found for async run '${runId}'.`);
 
@@ -258,12 +300,14 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 	const resultSteps = result?.results ?? [];
 	const stepCount = statusSteps.length || resultSteps.length || (result?.agent ? 1 : 0);
 	const requestedIndex = params.index;
-	if (requestedIndex !== undefined && !Number.isInteger(requestedIndex)) throw new Error(`Async run '${runId}' index must be an integer.`);
+	if (requestedIndex !== undefined && !Number.isInteger(requestedIndex))
+		throw new Error(`Async run '${runId}' index must be an integer.`);
 	const terminalStepStatuses = new Set(["complete", "completed", "failed", "paused"]);
 
 	if (state === "running") {
 		if (requestedIndex !== undefined) {
-			if (requestedIndex < 0 || requestedIndex >= stepCount) throw new Error(`Async run '${runId}' has ${stepCount} children. Index ${requestedIndex} is out of range.`);
+			if (requestedIndex < 0 || requestedIndex >= stepCount)
+				throw new Error(`Async run '${runId}' has ${stepCount} children. Index ${requestedIndex} is out of range.`);
 			const selectedStep = statusSteps[requestedIndex];
 			if (selectedStep?.status === "running") {
 				return {
@@ -278,15 +322,23 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 					sessionFile: selectedStep.sessionFile ?? status?.sessionFile ?? result?.sessionFile,
 				};
 			}
-			if (selectedStep?.status === "pending") throw new Error(`Async run '${runId}' child ${requestedIndex} is pending and has not started yet. Wait for it to run or complete before resuming.`);
-			if (selectedStep && !terminalStepStatuses.has(selectedStep.status)) throw new Error(`Async run '${runId}' child ${requestedIndex} is ${selectedStep.status} and cannot be revived yet.`);
+			if (selectedStep?.status === "pending")
+				throw new Error(
+					`Async run '${runId}' child ${requestedIndex} is pending and has not started yet. Wait for it to run or complete before resuming.`,
+				);
+			if (selectedStep && !terminalStepStatuses.has(selectedStep.status))
+				throw new Error(
+					`Async run '${runId}' child ${requestedIndex} is ${selectedStep.status} and cannot be revived yet.`,
+				);
 		} else {
 			const running = statusSteps
 				.map((step, index) => ({ step, index }))
 				.filter(({ step }) => step.status === "running");
 			const selected = running.length === 1 ? running[0] : undefined;
 			if (!selected) {
-				throw new Error(`Async run '${runId}' has ${running.length} running children. Provide index to choose one.`);
+				throw new Error(
+					`Async run '${runId}' has ${running.length} running children. Provide index to choose one.`,
+				);
 			}
 			return {
 				kind: "live",
@@ -307,13 +359,16 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 	}
 	const index = requestedIndex ?? 0;
 	if (!Number.isInteger(index)) throw new Error(`Async run '${runId}' index must be an integer.`);
-	if (index < 0 || index >= stepCount) throw new Error(`Async run '${runId}' has ${stepCount} children. Index ${index} is out of range.`);
+	if (index < 0 || index >= stepCount)
+		throw new Error(`Async run '${runId}' has ${stepCount} children. Index ${index} is out of range.`);
 	const agent = statusSteps[index]?.agent ?? resultSteps[index]?.agent ?? result?.agent;
 	if (!agent) throw new Error(`Could not determine child agent for async run '${runId}'.`);
-	const sessionFile = statusSteps[index]?.sessionFile
-		?? resultSteps[index]?.sessionFile
-		?? (stepCount === 1 ? status?.sessionFile ?? result?.sessionFile : undefined);
-	if (!sessionFile) throw new Error(`Async run '${runId}' child ${index} does not have a persisted session file to resume from.`);
+	const sessionFile =
+		statusSteps[index]?.sessionFile ??
+		resultSteps[index]?.sessionFile ??
+		(stepCount === 1 ? (status?.sessionFile ?? result?.sessionFile) : undefined);
+	if (!sessionFile)
+		throw new Error(`Async run '${runId}' child ${index} does not have a persisted session file to resume from.`);
 	const resolvedSessionFile = validateResumeSessionFile(runId, sessionFile);
 
 	return {
@@ -341,5 +396,7 @@ export function buildRevivedAsyncTask(target: AsyncResumeTarget, message: string
 		"",
 		"Follow-up:",
 		message,
-	].filter((line): line is string => line !== undefined).join("\n");
+	]
+		.filter((line): line is string => line !== undefined)
+		.join("\n");
 }

package/dist/builtin/subagents/src/runs/background/async-status.ts

@@ -2,9 +2,21 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.ts";
 import { formatActivityLabel, formatParallelOutcome } from "../../shared/status-format.ts";
-import { type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode, type TokenUsage } from "../../shared/types.ts";
+import type {
+	ActivityState,
+	AsyncJobStep,
+	AsyncParallelGroupStatus,
+	AsyncStatus,
+	NestedRunSummary,
+	SubagentRunMode,
+	TokenUsage,
+} from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot } from "../shared/nested-events.ts";
+import {
+	attachRootChildrenToSteps,
+	findNestedRouteForRootId,
+	projectNestedRegistryForRoot,
+} from "../shared/nested-events.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
@@ -84,10 +96,12 @@ function getErrorMessage(error: unknown): string {
 }
 
 function isNotFoundError(error: unknown): boolean {
-	return typeof error === "object"
-		&& error !== null
-		&& "code" in error
-		&& (error as NodeJS.ErrnoException).code === "ENOENT";
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		"code" in error &&
+		(error as NodeJS.ErrnoException).code === "ENOENT"
+	);
 }
 
 function isAsyncRunDir(root: string, entry: string): boolean {
@@ -127,17 +141,34 @@ function outputFileMtime(outputFile: string | undefined): number | undefined {
 	}
 }
 
-function deriveAsyncActivityState(asyncDir: string, status: AsyncStatus): { activityState?: ActivityState; lastActivityAt?: number } {
-	if (status.state !== "running") return { activityState: status.activityState, lastActivityAt: status.lastActivityAt };
-	const outputPath = status.outputFile ? (path.isAbsolute(status.outputFile) ? status.outputFile : path.join(asyncDir, status.outputFile)) : undefined;
+function deriveAsyncActivityState(
+	asyncDir: string,
+	status: AsyncStatus,
+): { activityState?: ActivityState; lastActivityAt?: number } {
+	if (status.state !== "running")
+		return { activityState: status.activityState, lastActivityAt: status.lastActivityAt };
+	const outputPath = status.outputFile
+		? path.isAbsolute(status.outputFile)
+			? status.outputFile
+			: path.join(asyncDir, status.outputFile)
+		: undefined;
 	const currentStep = typeof status.currentStep === "number" ? status.steps?.[status.currentStep] : undefined;
 	return {
 		activityState: status.activityState,
-		lastActivityAt: status.lastActivityAt ?? outputFileMtime(outputPath) ?? currentStep?.lastActivityAt ?? currentStep?.startedAt ?? status.startedAt,
+		lastActivityAt:
+			status.lastActivityAt ??
+			outputFileMtime(outputPath) ??
+			currentStep?.lastActivityAt ??
+			currentStep?.startedAt ??
+			status.startedAt,
 	};
 }
 
-function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }, nestedWarnings: string[] = []): AsyncRunSummary {
+function statusToSummary(
+	asyncDir: string,
+	status: AsyncStatus & { cwd?: string },
+	nestedWarnings: string[] = [],
+): AsyncRunSummary {
 	if (status.sessionId !== undefined && typeof status.sessionId !== "string") {
 		throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': sessionId must be a string.`);
 	}
@@ -219,11 +250,16 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 function sortRuns(runs: AsyncRunSummary[]): AsyncRunSummary[] {
 	const rank = (state: AsyncRunSummary["state"]): number => {
 		switch (state) {
-			case "running": return 0;
-			case "queued": return 1;
-			case "failed": return 2;
-			case "paused": return 2;
-			case "complete": return 3;
+			case "running":
+				return 0;
+			case "queued":
+				return 1;
+			case "failed":
+				return 2;
+			case "paused":
+				return 2;
+			case "complete":
+				return 3;
 		}
 	};
 	return [...runs].sort((a, b) => {
@@ -254,15 +290,21 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		// Recency cutoff: skip reconcile/read/parse work for long-untouched runs
 		// (two stats instead of a full per-run reconciliation at startup).
 		if (cutoff !== undefined && !runDirTouchedSince(asyncDir, cutoff)) continue;
-		const reconciliation = options.reconcile === false
-			? undefined
-			: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
+		const reconciliation =
+			options.reconcile === false
+				? undefined
+				: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
 		const status = (reconciliation?.status ?? readStatus(asyncDir)) as (AsyncStatus & { cwd?: string }) | null;
 		if (!status) continue;
 		const nestedWarnings: string[] = [];
 		try {
 			const nestedRoute = findNestedRouteForRootId(status.runId || path.basename(asyncDir));
-			if (nestedRoute) reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
+			if (nestedRoute)
+				reconcileNestedAsyncDescendants(nestedRoute, {
+					resultsDir: options.resultsDir,
+					kill: options.kill,
+					now: options.now,
+				});
 		} catch (error) {
 			nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
 		}
@@ -276,9 +318,18 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 	return options.limit !== undefined ? sorted.slice(0, options.limit) : sorted;
 }
 
-function formatActivityFacts(input: { activityState?: ActivityState; lastActivityAt?: number; currentTool?: string; currentToolStartedAt?: number; currentPath?: string; turnCount?: number; toolCount?: number }): string | undefined {
+function formatActivityFacts(input: {
+	activityState?: ActivityState;
+	lastActivityAt?: number;
+	currentTool?: string;
+	currentToolStartedAt?: number;
+	currentPath?: string;
+	turnCount?: number;
+	toolCount?: number;
+}): string | undefined {
 	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt !== undefined) facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
+	if (input.currentTool && input.currentToolStartedAt !== undefined)
+		facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
 	else if (input.currentTool) facts.push(`tool ${input.currentTool}`);
 	if (input.currentPath) facts.push(shortenPath(input.currentPath));
 	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
@@ -305,20 +356,24 @@ export function formatAsyncRunOutputPath(run: Pick<AsyncRunSummary, "asyncDir" |
 	return path.isAbsolute(run.outputFile) ? run.outputFile : path.join(run.asyncDir, run.outputFile);
 }
 
-export function formatAsyncRunProgressLabel(run: Pick<AsyncRunSummary, "mode" | "state" | "currentStep" | "chainStepCount" | "parallelGroups" | "steps">): string {
+export function formatAsyncRunProgressLabel(
+	run: Pick<AsyncRunSummary, "mode" | "state" | "currentStep" | "chainStepCount" | "parallelGroups" | "steps">,
+): string {
 	const stepCount = run.steps.length || 1;
 	const chainStepCount = run.chainStepCount ?? stepCount;
 	const groups = normalizeParallelGroups(run.parallelGroups, run.steps.length, chainStepCount);
-	const activeGroup = run.currentStep !== undefined
-		? groups.find((group) => run.currentStep! >= group.start && run.currentStep! < group.start + group.count)
-		: undefined;
+	const activeGroup =
+		run.currentStep !== undefined
+			? groups.find((group) => run.currentStep! >= group.start && run.currentStep! < group.start + group.count)
+			: undefined;
 	if (activeGroup) {
 		const groupSteps = run.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count);
 		const groupLabel = formatParallelOutcome(groupSteps, activeGroup.count, { showRunning: run.state === "running" });
 		if (run.mode === "parallel") return groupLabel;
 		return `step ${activeGroup.stepIndex + 1}/${chainStepCount} · parallel group: ${groupLabel}`;
 	}
-	if (run.mode === "parallel") return formatParallelOutcome(run.steps, stepCount, { showRunning: run.state === "running" });
+	if (run.mode === "parallel")
+		return formatParallelOutcome(run.steps, stepCount, { showRunning: run.state === "running" });
 	if (run.mode === "chain" && run.currentStep !== undefined && groups.length > 0) {
 		const logicalStep = flatToLogicalStepIndex(run.currentStep, chainStepCount, groups);
 		return `step ${logicalStep + 1}/${chainStepCount}`;