pi-cohort 7.1.2 → 7.2.0

package/src/runs/background/async-resume.ts

@@ -1,7 +1,12 @@
-import * as fs from "node:fs";
+import fs from "node:fs";
 import * as path from "node:path";
-import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus } from "../../shared/types.ts";
+import { ASYNC_DIR, LEGACY_ASYNC_DIR, RESULTS_DIR, type AsyncStatus } from "../../shared/types.ts";
 import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
+import { parsePiRuntime, type PiRuntimeIdentity } from "../shared/pi-spawn.ts";
+
+export function isLegacyAsyncDir(asyncDir: string): boolean {
+	try { assertInsideRoot(LEGACY_ASYNC_DIR, asyncDir, "Async run directory"); return true; } catch { return false; }
+}
 
 export interface AsyncResumeParams {
 	id?: string;
@@ -11,7 +16,7 @@ export interface AsyncResumeParams {
 }
 
 export interface AsyncResumeDeps {
-	asyncDirRoot?: string;
+	asyncDirRoot?: string | readonly string[];
 	resultsDir?: string;
 	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 	now?: () => number;
@@ -19,6 +24,7 @@ export interface AsyncResumeDeps {
 
 export type AsyncResumeTarget = {
 	kind: "revive";
+	runtime: PiRuntimeIdentity;
 	runId: string;
 	asyncDir?: string;
 	state: AsyncStatus["state"];
@@ -29,6 +35,7 @@ export type AsyncResumeTarget = {
 };
 
 interface AsyncResultFile {
+	runtime?: unknown;
 	id?: string;
 	runId?: string;
 	agent?: string;
@@ -82,6 +89,7 @@ function validateResultFile(value: unknown, resultPath: string): AsyncResultFile
 	const success = data.success;
 	if (success !== undefined && typeof success !== "boolean") throw new Error(`Invalid async result file '${resultPath}': success must be a boolean.`);
 	return {
+		runtime: data.runtime,
 		id: validateOptionalString(data, "id", resultPath),
 		runId: validateOptionalString(data, "runId", resultPath),
 		agent: validateOptionalString(data, "agent", resultPath),
@@ -124,9 +132,16 @@ function assertRunId(value: string | undefined, field: "id" | "runId"): string |
 	return value;
 }
 
+function canonicalPath(value: string): string {
+	const resolved = path.resolve(value);
+	if (fs.existsSync(resolved)) return fs.realpathSync(resolved);
+	const parent = path.dirname(resolved);
+	return parent === resolved ? resolved : path.join(canonicalPath(parent), path.basename(resolved));
+}
+
 function assertInsideRoot(root: string, target: string, label: string): void {
-	const rootPath = path.resolve(root);
-	const targetPath = path.resolve(target);
+	const rootPath = canonicalPath(root);
+	const targetPath = canonicalPath(target);
 	const relative = path.relative(rootPath, targetPath);
 	if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) return;
 	throw new Error(`${label} must be inside ${rootPath}.`);
@@ -146,22 +161,34 @@ 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 winningAsyncRunEntries(asyncDirRoot: string | readonly string[], prefix = ""): Array<{ id: string; root: string; asyncDir: string }> {
+	const winners = new Map<string, { id: string; root: string; asyncDir: string }>();
+	for (const root of typeof asyncDirRoot === "string" ? [asyncDirRoot] : asyncDirRoot) {
+		for (const id of prefixedRunIds(root, prefix)) {
+			if (!winners.has(id)) winners.set(id, { id, root, asyncDir: path.join(path.resolve(root), id) });
+		}
+	}
+	return [...winners.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export function findAsyncRunPrefixMatches(prefix: string, asyncDirRoot: string | readonly string[], resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
 	const requestedId = assertRunId(prefix, "id");
 	if (!requestedId) return [];
-	const asyncRoot = path.resolve(asyncDirRoot);
+	const entries = winningAsyncRunEntries(asyncDirRoot, requestedId);
+	const byId = new Map(entries.map((entry) => [entry.id, entry]));
 	const resultRoot = path.resolve(resultsDir);
 	const matchingIds = [...new Set([
-		...prefixedRunIds(asyncRoot, requestedId),
+		...byId.keys(),
 		...prefixedRunIds(resultRoot, requestedId, ".json"),
 	])].sort();
 	return matchingIds.map((id) => {
-		const asyncDir = path.join(asyncRoot, id);
-		assertInsideRoot(asyncRoot, asyncDir, "Async run directory");
+		const entry = byId.get(id);
+		const asyncDir = entry?.asyncDir;
+		if (entry) assertInsideRoot(entry.root, entry.asyncDir, "Async run directory");
 		return {
 			id,
 			location: {
-				asyncDir: fs.existsSync(asyncDir) ? asyncDir : null,
+				asyncDir: asyncDir && fs.existsSync(asyncDir) ? asyncDir : null,
 				resultPath: exactResultPath(resultRoot, id),
 				resolvedId: id,
 			},
@@ -169,7 +196,28 @@ export function findAsyncRunPrefixMatches(prefix: string, asyncDirRoot: string,
 	});
 }
 
-export function resolveAsyncRunLocation(params: AsyncResumeParams, asyncDirRoot: string, resultsDir: string): AsyncRunLocation {
+export function resolveAsyncRunLocation(params: AsyncResumeParams, asyncDirRoot: string | readonly string[], resultsDir: string): AsyncRunLocation {
+	if (typeof asyncDirRoot !== "string") {
+		if (params.dir) {
+			for (const root of asyncDirRoot) {
+				try { assertInsideRoot(root, params.dir, "Async run directory"); } catch { continue; }
+				return resolveAsyncRunLocation(params, root, resultsDir);
+			}
+			throw new Error("Async run directory must be inside an authorized async root.");
+		}
+		const id = assertRunId(params.id, "id") ?? assertRunId(params.runId, "runId");
+		if (!id) return { asyncDir: null, resultPath: null };
+		const exact = winningAsyncRunEntries(asyncDirRoot, id).find((entry) => entry.id === id);
+		if (exact) {
+			assertInsideRoot(exact.root, exact.asyncDir, "Async run directory");
+			return { asyncDir: exact.asyncDir, resultPath: exactResultPath(resultsDir, id), resolvedId: id };
+		}
+		const resultPath = exactResultPath(resultsDir, id);
+		if (resultPath) return { asyncDir: null, resultPath, resolvedId: id };
+		const matches = findAsyncRunPrefixMatches(id, asyncDirRoot, resultsDir);
+		if (matches.length > 1) throw new Error(`Ambiguous async run id prefix '${id}' matched: ${matches.map((match) => match.id).join(", ")}. Provide a longer id.`);
+		return matches[0]?.location ?? { asyncDir: null, resultPath: null, resolvedId: id };
+	}
 	const asyncRoot = path.resolve(asyncDirRoot);
 	const resultRoot = path.resolve(resultsDir);
 	const requestedId = assertRunId(params.id, "id") ?? assertRunId(params.runId, "runId");
@@ -234,23 +282,50 @@ function validateResumeSessionFile(runId: string, sessionFile: string): string {
 }
 
 export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncResumeDeps = {}): AsyncResumeTarget {
-	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
+	const asyncDirRoot = deps.asyncDirRoot ?? [ASYNC_DIR, LEGACY_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;
+	const statusPath = location.asyncDir ? path.join(location.asyncDir, "status.json") : undefined;
+	let status: AsyncStatus | null = null;
+	if (statusPath) {
+		let present = false;
+		try {
+			fs.lstatSync(statusPath);
+			present = true;
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+				throw new Error(`Failed to inspect async status file '${statusPath}': ${getErrorMessage(error)}`, { cause: error });
+			}
+		}
+		if (present) {
+			let value: unknown;
+			try {
+				value = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+			} catch (error) {
+				throw new Error(`Failed to read or parse async status file '${statusPath}': ${getErrorMessage(error)}`, { cause: error });
+			}
+			status = ensureObject(value, statusPath) as unknown as AsyncStatus;
+		}
+	}
+	if (status && (status.state === "queued" || status.state === "running") && location.asyncDir && !isLegacyAsyncDir(location.asyncDir)) {
+		status = reconcileAsyncRun(location.asyncDir, { resultsDir, kill: deps.kill, now: deps.now }).status ?? status;
+	}
 	validateStatusForResume(status, location.asyncDir ? path.join(location.asyncDir, "status.json") : "status.json");
 	const result = location.resultPath ? readResultFile(location.resultPath) : undefined;
+	const runtime = parsePiRuntime(status ? status.runtime : result?.runtime, statusPath ?? location.resultPath ?? "Async run");
+	if (status && result?.runtime !== undefined) {
+		const other = parsePiRuntime(result.runtime, location.resultPath!);
+		if (runtime.nodeExecPath !== other.nodeExecPath || runtime.piEntryPath !== other.piEntryPath || runtime.piPackageRoot !== other.piPackageRoot) throw new Error("Async status and result runtime identities conflict; a new run is required.");
+	}
 	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}'.`);
 
+	if (state === "queued") throw new Error(`Async run '${runId}' is queued and cannot be revived before startup.`);
 	const statusSteps = status?.steps ?? [];
 	const resultSteps = result?.results ?? [];
 	const stepCount = statusSteps.length || resultSteps.length || (result?.agent ? 1 : 0);
@@ -288,6 +363,7 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 
 	return {
 		kind: "revive",
+		runtime,
 		runId,
 		asyncDir: location.asyncDir ?? undefined,
 		state,

package/src/runs/background/async-status.ts

@@ -2,9 +2,10 @@ 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 { RESULTS_DIR, type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode, type TokenUsage } from "../../shared/types.ts";
+import { isLegacyAsyncDir, resolveAsyncRunLocation, winningAsyncRunEntries } from "./async-resume.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot } from "../shared/nested-events.ts";
+import { attachRootChildrenToSteps, findNestedRouteForRootId, isLegacyNestedRoute, projectNestedRegistryForRoot } from "../shared/nested-events.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { readRunnerLogTail, reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
@@ -133,7 +134,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 	let nestedChildren: NestedRunSummary[] = [];
 	if (nestedWarnings.length === 0) {
 		try {
-			nestedChildren = projectNestedRegistryForRoot(status.runId || path.basename(asyncDir))?.children ?? [];
+			nestedChildren = projectNestedRegistryForRoot(status.runId || path.basename(asyncDir), { readOnlyLegacy: true })?.children ?? [];
 		} catch (error) {
 			nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
 		}
@@ -242,10 +243,10 @@ function summarizePreStatusCrash(asyncDir: string, now: number): AsyncRunSummary
 	};
 }
 
-export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions = {}): AsyncRunSummary[] {
-	let entries: string[];
+export function listAsyncRuns(asyncDirRoot: string | readonly string[], options: AsyncRunListOptions = {}): AsyncRunSummary[] {
+	let entries: ReturnType<typeof winningAsyncRunEntries>;
 	try {
-		entries = fs.readdirSync(asyncDirRoot).filter((entry) => isAsyncRunDir(asyncDirRoot, entry));
+		entries = winningAsyncRunEntries(asyncDirRoot);
 	} catch (error) {
 		if (isNotFoundError(error)) return [];
 		throw new Error(`Failed to list async runs in '${asyncDirRoot}': ${getErrorMessage(error)}`, {
@@ -256,8 +257,10 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 	const allowedStates = options.states ? new Set(options.states) : undefined;
 	const runs: AsyncRunSummary[] = [];
 	for (const entry of entries) {
-		const asyncDir = path.join(asyncDirRoot, entry);
-		const reconciliation = options.reconcile === false
+		const asyncDir = resolveAsyncRunLocation({ id: entry.id }, entry.root, options.resultsDir ?? RESULTS_DIR).asyncDir;
+		if (!asyncDir || !isAsyncRunDir(entry.root, entry.id)) continue;
+		const stored = readStatus(asyncDir);
+		const reconciliation = options.reconcile === false || isLegacyAsyncDir(asyncDir) || (stored && stored.state !== "running" && stored.state !== "queued")
 			? undefined
 			: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
 		const status = (reconciliation?.status ?? readStatus(asyncDir)) as (AsyncStatus & { cwd?: string }) | null;
@@ -269,7 +272,7 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		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 && !isLegacyAsyncDir(asyncDir) && !isLegacyNestedRoute(nestedRoute)) reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
 		} catch (error) {
 			nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
 		}

package/src/runs/background/external-attempt.ts

@@ -8,10 +8,11 @@
  * before the task arg and forwards all other args unchanged.
  */
 import * as path from "node:path";
+import { PINNED_AGENT_DIR_OVERRIDE } from "../../shared/agent-dir.ts";
 import { fileURLToPath } from "node:url";
 import type { Message } from "@earendil-works/pi-ai";
 import type { Usage } from "../../shared/types.ts";
-import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
+import { getPiSpawnCommand, type PiRuntimeIdentity } from "../shared/pi-spawn.ts";
 import { isMutatingTool } from "../shared/long-running-guard.ts";
 import type { ExternalAttemptResult, ExternalExecution } from "../shared/external-execution.ts";
 import type { OnNewSessionMessage } from "../../execution-backend/session-watcher.ts";
@@ -36,6 +37,7 @@ interface SynthesizedChildEvent {
 export type OnSynthesizedChildEvent = (event: SynthesizedChildEvent) => void;
 
 export interface RunExternalBackgroundAttemptInput {
+	readonly runtime: PiRuntimeIdentity;
 	readonly owner: ExternalExecution;
 	readonly attemptId: string;
 	/**
@@ -148,13 +150,15 @@ export async function runExternalBackgroundAttempt(
 	args.push("--extension", REPORTING_EXTENSION_PATH);
 	if (taskArg !== undefined) args.push(taskArg);
 
-	const spawnSpec = getPiSpawnCommand(args);
+	const spawnSpec = getPiSpawnCommand(args, input.runtime);
 
 	const mergedEnv: Record<string, string> = {};
 	for (const [key, value] of Object.entries(environment)) {
 		if (value !== undefined) mergedEnv[key] = value;
 	}
 
+	if (PINNED_AGENT_DIR_OVERRIDE) mergedEnv.PI_CODING_AGENT_DIR = PINNED_AGENT_DIR_OVERRIDE;
+
 	const onNewSessionMessage: OnNewSessionMessage | undefined = onChildEvent
 		? (message) => synthesizeChildEvents(message, onChildEvent)
 		: undefined;

package/src/runs/background/run-id-resolver.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../shared/types.ts";
-import { findAsyncRunPrefixMatches, type AsyncRunLocation } from "./async-resume.ts";
+import { ASYNC_DIR, LEGACY_ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../shared/types.ts";
+import { findAsyncRunPrefixMatches, resolveAsyncRunLocation, winningAsyncRunEntries, type AsyncRunLocation } from "./async-resume.ts";
 import { assertSafeNestedId, findNestedRunMatchesById, type NestedRoute, type NestedRunMatch, type NestedRunResolutionScope } from "../shared/nested-events.ts";
 
 export type ResolvedSubagentRunId =
@@ -11,20 +11,17 @@ export type ResolvedSubagentRunId =
 
 export interface ResolveSubagentRunIdDeps {
 	state?: SubagentState;
-	asyncDirRoot?: string;
+	asyncDirRoot?: string | readonly string[];
 	resultsDir?: string;
 	nested?: NestedRunResolutionScope;
+	readOnlyLegacy?: boolean;
 }
 
-function exactAsyncLocation(id: string, asyncDirRoot: string, resultsDir: string): AsyncRunLocation | undefined {
-	const asyncDir = path.join(asyncDirRoot, id);
+function exactAsyncLocation(id: string, asyncDirRoot: string | readonly string[], resultsDir: string): AsyncRunLocation | undefined {
+	const exact = winningAsyncRunEntries(asyncDirRoot, id).find((entry) => entry.id === id);
 	const resultPath = path.join(resultsDir, `${id}.json`);
-	if (!fs.existsSync(asyncDir) && !fs.existsSync(resultPath)) return undefined;
-	return {
-		asyncDir: fs.existsSync(asyncDir) ? asyncDir : null,
-		resultPath: fs.existsSync(resultPath) ? resultPath : null,
-		resolvedId: id,
-	};
+	if (!exact && !fs.existsSync(resultPath)) return undefined;
+	return resolveAsyncRunLocation({ id }, asyncDirRoot, resultsDir);
 }
 
 function foregroundIds(state: SubagentState | undefined): string[] {
@@ -37,7 +34,7 @@ function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolu
 	const seen = new Set<string>();
 	const add = (route: NestedRoute | undefined) => {
 		if (!route) return;
-		const key = `${route.rootRunId}:${route.eventSink}:${route.controlInbox}`;
+		const key = JSON.stringify([route.rootRunId, route.capabilityToken, route.eventSink, route.controlInbox]);
 		if (seen.has(key)) return;
 		seen.add(key);
 		routes.push(route);
@@ -47,20 +44,21 @@ function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolu
 	return { routes };
 }
 
-function asyncPrefixMatches(prefix: string, asyncDirRoot: string, resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
+function asyncPrefixMatches(prefix: string, asyncDirRoot: string | readonly string[], resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
 	return findAsyncRunPrefixMatches(prefix, asyncDirRoot, resultsDir);
 }
 
 export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps = {}): ResolvedSubagentRunId | undefined {
 	assertSafeNestedId("id", id);
-	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
+	const asyncDirRoot = deps.asyncDirRoot ?? [ASYNC_DIR, LEGACY_ASYNC_DIR];
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
 
 	const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
 	if (deps.state?.foregroundControls.has(id)) return { kind: "foreground", id };
 	const exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
 	if (exactAsync) return { kind: "async", id, location: exactAsync };
-	const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});
+	const nestedOptions = { scope: nestedScope, readOnlyLegacy: deps.readOnlyLegacy };
+	const exactNested = findNestedRunMatchesById(id, nestedOptions);
 	if (exactNested.length > 1) throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);
 	if (exactNested[0]) return { kind: "nested", id, match: exactNested[0] };
 
@@ -71,11 +69,10 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	for (const match of asyncPrefixMatches(id, asyncDirRoot, resultsDir)) {
 		matches.push({ kind: "async", id: match.id, location: match.location });
 	}
-	for (const match of findNestedRunMatchesById(id, nestedScope ? { prefix: true, scope: nestedScope } : { prefix: true })) {
+	for (const match of findNestedRunMatchesById(id, { ...nestedOptions, prefix: true })) {
 		matches.push({ kind: "nested", id: match.run.id, match });
 	}
-	const unique = new Map(matches.map((match) => [`${match.kind}:${match.id}`, match]));
-	const values = [...unique.values()];
+	const values = matches;
 	if (values.length > 1) {
 		throw new Error(`Ambiguous subagent run id prefix '${id}' matched: ${values.map((match) => `${match.kind}:${match.id}`).join(", ")}. Provide a longer id.`);
 	}

package/src/runs/background/run-status.ts

@@ -1,16 +1,17 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { readStatus } from "../../shared/utils.ts";
 import { formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, listAsyncRuns } from "./async-status.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { formatModelThinking } from "../../shared/formatters.ts";
 import { formatActivityLabel } from "../../shared/status-format.ts";
-import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details, type NestedRunSummary, type SubagentState } from "../../shared/types.ts";
-import { resolveAsyncRunLocation } from "./async-resume.ts";
+import { ASYNC_DIR, LEGACY_ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details, type NestedRunSummary, type SubagentState } from "../../shared/types.ts";
+import { isLegacyAsyncDir, resolveAsyncRunLocation } from "./async-resume.ts";
 import { resolveSubagentRunId } from "./run-id-resolver.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { readRunnerLogTail, reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
-import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot, type NestedRunResolutionScope } from "../shared/nested-events.ts";
+import { attachRootChildrenToSteps, findNestedRouteForRootId, isLegacyNestedRoute, projectNestedRegistryForRoot, type NestedRunResolutionScope } from "../shared/nested-events.ts";
 
 interface RunStatusParams {
 	action?: "status";
@@ -20,7 +21,7 @@ interface RunStatusParams {
 }
 
 interface RunStatusDeps {
-	asyncDirRoot?: string;
+	asyncDirRoot?: string | readonly string[];
 	resultsDir?: string;
 	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 	now?: () => number;
@@ -98,7 +99,7 @@ function formatNestedExactStatus(rootRunId: string, run: NestedRunSummary): stri
 }
 
 export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDeps = {}): AgentToolResult<Details> {
-	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
+	const asyncDirRoot = deps.asyncDirRoot ?? [ASYNC_DIR, LEGACY_ASYNC_DIR];
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
 	if (!params.id && !params.runId && !params.dir) {
 		if (deps.nested) {
@@ -128,10 +129,10 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 	try {
 		const requestedId = params.id ?? params.runId;
 		if (!params.dir && requestedId) {
-			const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
+			const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested, readOnlyLegacy: true });
 			if (resolved?.kind === "nested") {
-				reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
-				const refreshed = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
+				if (!isLegacyNestedRoute(resolved.match.route)) reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
+				const refreshed = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested, readOnlyLegacy: true });
 				const nested = refreshed?.kind === "nested" ? refreshed : resolved;
 				return { content: [{ type: "text", text: formatNestedExactStatus(nested.match.rootRunId, nested.match.run) }], details: { mode: "single", results: [] } };
 			}
@@ -161,7 +162,17 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 	if (asyncDir) {
 		let reconciliation;
 		try {
-			reconciliation = reconcileAsyncRun(asyncDir, { resultsDir, kill: deps.kill, now: deps.now });
+			const statusPath = path.join(asyncDir, "status.json");
+			let stored: AsyncStatus | null = null;
+			try {
+				stored = readStatus(asyncDir);
+				if (fs.existsSync(statusPath) && (!stored || typeof stored !== "object" || Array.isArray(stored))) throw new Error(`Invalid async status '${statusPath}': expected an object.`);
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			}
+			reconciliation = isLegacyAsyncDir(asyncDir) || (stored && stored.state !== "running" && stored.state !== "queued")
+				? { status: stored, message: undefined, resultPath }
+				: reconcileAsyncRun(asyncDir, { resultsDir, kill: deps.kill, now: deps.now });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			return {
@@ -179,8 +190,8 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			let nestedWarning: string | undefined;
 			try {
 				const nestedRoute = findNestedRouteForRootId(status.runId);
-				if (nestedRoute) reconcileNestedAsyncDescendants(nestedRoute, { resultsDir, kill: deps.kill, now: deps.now });
-				nestedChildren = projectNestedRegistryForRoot(status.runId)?.children ?? [];
+				if (nestedRoute && !isLegacyAsyncDir(asyncDir) && !isLegacyNestedRoute(nestedRoute)) reconcileNestedAsyncDescendants(nestedRoute, { resultsDir, kill: deps.kill, now: deps.now });
+				nestedChildren = projectNestedRegistryForRoot(status.runId, { readOnlyLegacy: true })?.children ?? [];
 				attachRootChildrenToSteps(status.runId, status.steps, nestedChildren);
 			} catch (error) {
 				nestedWarning = `Nested status unavailable: ${error instanceof Error ? error.message : String(error)}`;

package/src/runs/background/stale-run-reconciler.ts

@@ -240,6 +240,9 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 			asyncDir,
 			sessionId: status.sessionId,
 			sessionFile: status.sessionFile,
+			sessionDir: status.sessionDir,
+			runtime: status.runtime,
+			cwd: status.cwd,
 		},
 	};
 }
@@ -326,8 +329,13 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 
 	const runId = effectiveStatus.runId || path.basename(asyncDir);
 	const resultPath = path.join(options.resultsDir ?? RESULTS_DIR, `${runId}.json`);
+	if (effectiveStatus.state === "queued") {
+		return { status: effectiveStatus, repaired: false, resultPath, message: "Unresolved async startup: queued run has not published running status; start a new run." };
+	}
+	if (terminal(effectiveStatus.state)) return { status: effectiveStatus, repaired: false, resultPath };
+
 	if (fs.existsSync(resultPath)) {
-		const terminalStatus = effectiveStatus.state === "running" || effectiveStatus.state === "queued"
+		const terminalStatus = effectiveStatus.state === "running"
 			? terminalStatusFromResult(effectiveStatus, resultPath, now)
 			: undefined;
 		if (terminalStatus) {