@astrofoundry/pi-astro 0.16.1 → 0.18.1

package/node_modules/pi-subagents/src/runs/background/async-job-tracker.ts

@@ -1,267 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { renderWidget } from "../../tui/render.ts";
-import { formatControlNoticeMessage } from "../shared/subagent-control.ts";
-import {
-	type AsyncJobState,
-	type AsyncStartedEvent,
-	type ControlEvent,
-	type SubagentState,
-	POLL_INTERVAL_MS,
-	RESULTS_DIR,
-	SUBAGENT_CONTROL_EVENT,
-	SUBAGENT_CONTROL_INTERCOM_EVENT,
-} from "../../shared/types.ts";
-import { readStatus } from "../../shared/utils.ts";
-import { normalizeParallelGroups } from "./parallel-groups.ts";
-import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
-
-interface AsyncJobTrackerOptions {
-	completionRetentionMs?: number;
-	pollIntervalMs?: number;
-	resultsDir?: string;
-	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
-	now?: () => number;
-}
-
-export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: SubagentState, asyncDirRoot: string, options: AsyncJobTrackerOptions = {}): {
-	ensurePoller: () => void;
-	handleStarted: (data: unknown) => void;
-	handleComplete: (data: unknown) => void;
-	resetJobs: (ctx?: ExtensionContext) => void;
-} {
-	const completionRetentionMs = options.completionRetentionMs ?? 10000;
-	const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
-	const resultsDir = options.resultsDir ?? RESULTS_DIR;
-	const rerenderWidget = (ctx: ExtensionContext, jobs = Array.from(state.asyncJobs.values())) => {
-		renderWidget(ctx, jobs);
-		ctx.ui.requestRender?.();
-	};
-	const scheduleCleanup = (asyncId: string) => {
-		const existingTimer = state.cleanupTimers.get(asyncId);
-		if (existingTimer) clearTimeout(existingTimer);
-		const timer = setTimeout(() => {
-			state.cleanupTimers.delete(asyncId);
-			state.asyncJobs.delete(asyncId);
-			if (state.lastUiContext) {
-				rerenderWidget(state.lastUiContext);
-			}
-		}, completionRetentionMs);
-		state.cleanupTimers.set(asyncId, timer);
-	};
-	const emitNewControlEvents = (job: AsyncJobState) => {
-		const eventsPath = path.join(job.asyncDir, "events.jsonl");
-		let fd: number;
-		try {
-			fd = fs.openSync(eventsPath, "r");
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-			console.error(`Failed to open async control events for '${job.asyncDir}':`, error);
-			return;
-		}
-		try {
-			const stat = fs.fstatSync(fd);
-			const cursor = stat.size < (job.controlEventCursor ?? 0) ? 0 : (job.controlEventCursor ?? 0);
-			if (stat.size <= cursor) return;
-			const buffer = Buffer.alloc(stat.size - cursor);
-			fs.readSync(fd, buffer, 0, buffer.length, cursor);
-			const lastNewline = buffer.lastIndexOf(0x0a);
-			if (lastNewline === -1) return;
-			job.controlEventCursor = cursor + lastNewline + 1;
-			for (const line of buffer.subarray(0, lastNewline).toString("utf-8").split("\n")) {
-				if (!line.trim()) continue;
-				let parsed: unknown;
-				try {
-					parsed = JSON.parse(line);
-				} catch (error) {
-					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 (!record.event || !Array.isArray(record.channels)) continue;
-				const payload = {
-					event: record.event,
-					source: "async" as const,
-					asyncDir: job.asyncDir,
-					childIntercomTarget: record.childIntercomTarget,
-					noticeText: record.noticeText ?? formatControlNoticeMessage(record.event, record.childIntercomTarget),
-				};
-				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) {
-					pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
-						...payload,
-						to: record.intercom.to,
-						message: record.intercom.message,
-					});
-				}
-			}
-		} catch (error) {
-			console.error(`Failed to read async control events for '${job.asyncDir}':`, error);
-		} finally {
-			fs.closeSync(fd);
-		}
-	};
-
-	const ensurePoller = () => {
-		if (state.poller) return;
-		state.poller = setInterval(() => {
-			if (state.asyncJobs.size === 0) {
-				if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext, []);
-				if (state.poller) {
-					clearInterval(state.poller);
-					state.poller = null;
-				}
-				return;
-			}
-
-			for (const job of state.asyncJobs.values()) {
-				try {
-					emitNewControlEvents(job);
-					const reconciliation = reconcileAsyncRun(job.asyncDir, {
-						resultsDir,
-						kill: options.kill,
-						now: options.now,
-						startedRun: {
-							runId: job.asyncId,
-							pid: job.pid,
-							sessionId: job.sessionId,
-							mode: job.mode,
-							agents: job.agents,
-							chainStepCount: job.chainStepCount,
-							parallelGroups: job.parallelGroups,
-							startedAt: job.startedAt,
-							sessionFile: job.sessionFile,
-						},
-					});
-					const status = reconciliation.status ?? readStatus(job.asyncDir);
-					if (status) {
-						const previousStatus = job.status;
-						job.status = status.state;
-						job.sessionId = status.sessionId ?? job.sessionId;
-						job.activityState = status.activityState;
-						job.lastActivityAt = status.lastActivityAt ?? job.lastActivityAt;
-						job.currentTool = status.currentTool;
-						job.currentToolStartedAt = status.currentToolStartedAt;
-						job.currentPath = status.currentPath;
-						job.turnCount = status.turnCount ?? job.turnCount;
-						job.toolCount = status.toolCount ?? job.toolCount;
-						job.mode = status.mode;
-						job.currentStep = status.currentStep ?? job.currentStep;
-						job.chainStepCount = status.chainStepCount ?? job.chainStepCount;
-						job.startedAt = status.startedAt ?? job.startedAt;
-						job.updatedAt = status.lastUpdate ?? Date.now();
-						if (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 visibleSteps = activeGroup
-								? 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);
-							job.steps = visibleSteps;
-							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;
-							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") && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
-							scheduleCleanup(job.asyncId);
-						}
-						continue;
-					}
-					job.status = job.status === "queued" ? "running" : job.status;
-					job.updatedAt = Date.now();
-				} catch (error) {
-					console.error(`Failed to read async status for '${job.asyncDir}':`, error);
-					job.status = "failed";
-					job.updatedAt = Date.now();
-					if (!state.cleanupTimers.has(job.asyncId)) {
-						scheduleCleanup(job.asyncId);
-					}
-				}
-			}
-
-			if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext);
-		}, pollIntervalMs);
-		state.poller.unref?.();
-	};
-
-	const handleStarted = (data: unknown) => {
-		const info = data as AsyncStartedEvent;
-		if (!info.id) return;
-		const now = Date.now();
-		const asyncDir = info.asyncDir ?? path.join(asyncDirRoot, info.id);
-		const rawAgents = info.agents?.length ? info.agents : info.chain && info.chain.length > 0 ? info.chain : info.agent ? [info.agent] : undefined;
-		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;
-		state.asyncJobs.set(info.id, {
-			asyncId: info.id,
-			asyncDir,
-			status: "queued",
-			pid: typeof info.pid === "number" ? info.pid : undefined,
-			...(typeof info.sessionId === "string" ? { sessionId: info.sessionId } : {}),
-			mode: info.mode ?? (info.chain ? "chain" : "single"),
-			agents,
-			chainStepCount: info.chainStepCount,
-			parallelGroups: validParallelGroups,
-			stepsTotal: firstGroupCount ?? agents?.length,
-			hasParallelGroups: validParallelGroups.length > 0,
-			activeParallelGroup: Boolean(firstGroupCount && firstGroupCount > 0),
-			startedAt: now,
-			updatedAt: now,
-		});
-		ensurePoller();
-		if (state.lastUiContext) {
-			rerenderWidget(state.lastUiContext);
-		}
-	};
-
-	const handleComplete = (data: unknown) => {
-		const result = data as { id?: string; success?: boolean; asyncDir?: string };
-		const asyncId = result.id;
-		if (!asyncId) return;
-		const job = state.asyncJobs.get(asyncId);
-		if (job) {
-			job.status = result.success ? "complete" : "failed";
-			job.updatedAt = Date.now();
-			if (result.asyncDir) job.asyncDir = result.asyncDir;
-		}
-		if (state.lastUiContext) {
-			rerenderWidget(state.lastUiContext);
-		}
-		scheduleCleanup(asyncId);
-	};
-
-	const resetJobs = (ctx?: ExtensionContext) => {
-		for (const timer of state.cleanupTimers.values()) {
-			clearTimeout(timer);
-		}
-		state.cleanupTimers.clear();
-		state.asyncJobs.clear();
-		state.foregroundControls?.clear();
-		state.lastForegroundControlId = null;
-		state.resultFileCoalescer.clear();
-		if (ctx?.hasUI) {
-			state.lastUiContext = ctx;
-			rerenderWidget(ctx, []);
-		}
-	};
-
-	return { ensurePoller, handleStarted, handleComplete, resetJobs };
-}

package/node_modules/pi-subagents/src/runs/background/async-resume.ts

@@ -1,332 +0,0 @@
-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 { reconcileAsyncRun } from "./stale-run-reconciler.ts";
-
-export interface AsyncResumeParams {
-	id?: string;
-	runId?: string;
-	dir?: string;
-	index?: number;
-}
-
-export interface AsyncResumeDeps {
-	asyncDirRoot?: string;
-	resultsDir?: string;
-	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
-	now?: () => number;
-}
-
-export type AsyncResumeTarget = {
-	kind: "live" | "revive";
-	runId: string;
-	asyncDir?: string;
-	state: AsyncStatus["state"];
-	agent: string;
-	index: number;
-	intercomTarget: string;
-	cwd?: string;
-	sessionFile?: string;
-};
-
-interface AsyncResultFile {
-	id?: string;
-	runId?: string;
-	agent?: string;
-	mode?: string;
-	state?: string;
-	success?: boolean;
-	cwd?: string;
-	sessionFile?: string;
-	results?: Array<{ agent?: string; success?: boolean; sessionFile?: string; intercomTarget?: string }>;
-}
-
-export interface AsyncRunLocation {
-	asyncDir: string | null;
-	resultPath: string | null;
-	resolvedId?: string;
-}
-
-function getErrorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function ensureObject(value: unknown, source: string): Record<string, unknown> {
-	if (!value || typeof value !== "object" || Array.isArray(value)) {
-		throw new Error(`Async result file '${source}' must contain a JSON object.`);
-	}
-	return value as Record<string, unknown>;
-}
-
-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.`);
-	return fieldValue;
-}
-
-function validateResultFile(value: unknown, resultPath: string): AsyncResultFile {
-	const data = ensureObject(value, resultPath);
-	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.`);
-		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 success = child.success;
-			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.`);
-	return {
-		id: validateOptionalString(data, "id", resultPath),
-		runId: validateOptionalString(data, "runId", resultPath),
-		agent: validateOptionalString(data, "agent", resultPath),
-		mode: validateOptionalString(data, "mode", resultPath),
-		state: validateOptionalString(data, "state", resultPath),
-		cwd: validateOptionalString(data, "cwd", resultPath),
-		sessionFile: validateOptionalString(data, "sessionFile", resultPath),
-		...(typeof success === "boolean" ? { success } : {}),
-		...(results ? { results } : {}),
-	};
-}
-
-function readResultFile(resultPath: string): AsyncResultFile {
-	let raw: string;
-	try {
-		raw = fs.readFileSync(resultPath, "utf-8");
-	} catch (error) {
-		throw new Error(`Failed to read async result file '${resultPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-	try {
-		return validateResultFile(JSON.parse(raw), resultPath);
-	} catch (error) {
-		if (error instanceof SyntaxError) {
-			throw new Error(`Failed to parse async result file '${resultPath}': ${getErrorMessage(error)}`, {
-				cause: error,
-			});
-		}
-		throw error;
-	}
-}
-
-function assertRunId(value: string | undefined, field: "id" | "runId"): string | undefined {
-	if (value === undefined) return undefined;
-	if (value.trim() === "") throw new Error(`${field} must not be empty.`);
-	if (path.isAbsolute(value) || /[\\/]/.test(value) || value.includes("..")) {
-		throw new Error(`${field} must be an async run id or prefix, not a path.`);
-	}
-	return value;
-}
-
-function assertInsideRoot(root: string, target: string, label: string): void {
-	const rootPath = path.resolve(root);
-	const targetPath = path.resolve(target);
-	const relative = path.relative(rootPath, targetPath);
-	if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) return;
-	throw new Error(`${label} must be inside ${rootPath}.`);
-}
-
-function prefixedRunIds(dir: string, prefix: string, suffix = ""): string[] {
-	if (!fs.existsSync(dir)) return [];
-	return fs.readdirSync(dir)
-		.filter((entry) => entry.startsWith(prefix) && (!suffix || entry.endsWith(suffix)))
-		.map((entry) => suffix ? entry.slice(0, -suffix.length) : entry)
-		.sort();
-}
-
-function exactResultPath(resultsDir: string, runId: string): string | null {
-	const resultPath = path.join(resultsDir, `${runId}.json`);
-	assertInsideRoot(resultsDir, resultPath, "Async result file");
-	return fs.existsSync(resultPath) ? resultPath : null;
-}
-
-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");
-	if (params.dir) {
-		const asyncDir = path.resolve(params.dir);
-		assertInsideRoot(asyncRoot, asyncDir, "Async run directory");
-		const resolvedId = requestedId ?? path.basename(asyncDir);
-		if (requestedId && requestedId !== path.basename(asyncDir)) {
-			throw new Error(`Async run id '${requestedId}' does not match directory '${path.basename(asyncDir)}'.`);
-		}
-		return { asyncDir, resultPath: exactResultPath(resultRoot, resolvedId), resolvedId };
-	}
-	if (!requestedId) return { asyncDir: null, resultPath: null };
-
-	const directAsyncDir = path.join(asyncRoot, requestedId);
-	assertInsideRoot(asyncRoot, directAsyncDir, "Async run directory");
-	const directResultPath = exactResultPath(resultRoot, requestedId);
-	if (fs.existsSync(directAsyncDir) || directResultPath) {
-		return {
-			asyncDir: fs.existsSync(directAsyncDir) ? directAsyncDir : null,
-			resultPath: directResultPath,
-			resolvedId: requestedId,
-		};
-	}
-
-	const matchingIds = [...new Set([
-		...prefixedRunIds(asyncRoot, requestedId),
-		...prefixedRunIds(resultRoot, requestedId, ".json"),
-	])].sort();
-	if (matchingIds.length === 0) return { asyncDir: null, resultPath: null, resolvedId: requestedId };
-	if (matchingIds.length > 1) {
-		throw new Error(`Ambiguous async run id prefix '${requestedId}' matched: ${matchingIds.join(", ")}. Provide a longer id.`);
-	}
-	const resolvedId = matchingIds[0]!;
-	const asyncDir = path.join(asyncRoot, resolvedId);
-	assertInsideRoot(asyncRoot, asyncDir, "Async run directory");
-	return {
-		asyncDir: fs.existsSync(asyncDir) ? asyncDir : null,
-		resultPath: exactResultPath(resultRoot, resolvedId),
-		resolvedId,
-	};
-}
-
-function resultState(result: AsyncResultFile): AsyncStatus["state"] {
-	if (result.state === "complete" || result.state === "failed" || result.state === "paused" || result.state === "running" || result.state === "queued") {
-		return result.state;
-	}
-	return result.success ? "complete" : "failed";
-}
-
-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.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.`);
-		});
-	}
-}
-
-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}`);
-	const resolved = path.resolve(sessionFile);
-	if (!fs.existsSync(resolved)) throw new Error(`Async run '${runId}' session file does not exist: ${sessionFile}`);
-	return resolved;
-}
-
-export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncResumeDeps = {}): AsyncResumeTarget {
-	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
-	const location = resolveAsyncRunLocation(params, asyncDirRoot, resultsDir);
-	if (!location.asyncDir && !location.resultPath) {
-		throw new Error("Async run not found. Provide id or dir.");
-	}
-
-	const reconciliation = location.asyncDir
-		? reconcileAsyncRun(location.asyncDir, { resultsDir, kill: deps.kill, now: deps.now })
-		: undefined;
-	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 state = status?.state ?? (result ? resultState(result) : undefined);
-	if (!state) throw new Error(`Status file not found for async run '${runId}'.`);
-
-	const statusSteps = status?.steps ?? [];
-	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.`);
-	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.`);
-			const selectedStep = statusSteps[requestedIndex];
-			if (selectedStep?.status === "running") {
-				return {
-					kind: "live",
-					runId,
-					asyncDir: location.asyncDir ?? undefined,
-					state,
-					agent: selectedStep.agent,
-					index: requestedIndex,
-					intercomTarget: resolveSubagentIntercomTarget(runId, selectedStep.agent, requestedIndex),
-					cwd: status?.cwd ?? result?.cwd,
-					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.`);
-		} 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.`);
-			}
-			return {
-				kind: "live",
-				runId,
-				asyncDir: location.asyncDir ?? undefined,
-				state,
-				agent: selected.step.agent,
-				index: selected.index,
-				intercomTarget: resolveSubagentIntercomTarget(runId, selected.step.agent, selected.index),
-				cwd: status?.cwd ?? result?.cwd,
-				sessionFile: selected.step.sessionFile ?? status?.sessionFile ?? result?.sessionFile,
-			};
-		}
-	}
-
-	if (stepCount > 1 && requestedIndex === undefined) {
-		throw new Error(`Async run '${runId}' has ${stepCount} children. Provide index to choose one.`);
-	}
-	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.`);
-	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 resolvedSessionFile = validateResumeSessionFile(runId, sessionFile);
-
-	return {
-		kind: "revive",
-		runId,
-		asyncDir: location.asyncDir ?? undefined,
-		state,
-		agent,
-		index,
-		intercomTarget: resolveSubagentIntercomTarget(runId, agent, index),
-		cwd: status?.cwd ?? result?.cwd,
-		sessionFile: resolvedSessionFile,
-	};
-}
-
-export function buildRevivedAsyncTask(target: AsyncResumeTarget, message: string): string {
-	return [
-		"You are reviving a previous subagent conversation.",
-		"",
-		`Original run: ${target.runId}`,
-		`Original agent: ${target.agent}`,
-		target.sessionFile ? `Original session file: ${target.sessionFile}` : undefined,
-		"",
-		"Use the stored session context as background. Answer the orchestrator's follow-up below. Do not assume the original child process is still alive.",
-		"",
-		"Follow-up:",
-		message,
-	].filter((line): line is string => line !== undefined).join("\n");
-}