@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/src/shared/status-format.ts

@@ -1,123 +1,232 @@
 import { loadConfig } from "../extension/config.ts";
-import type { AgentProcessExit, ActivityState, AsyncJobStep, ManagementAction, ManagementControl, ManagementRunState, SubagentLiveIntercomHealth } from "./types.ts";
+import type { ReadonlyDeep } from "type-fest";
+import type {
+  AgentProcessExit,
+  ActivityState,
+  AsyncJobStep,
+  ManagementAction,
+  ManagementControl,
+  ManagementRunState,
+  SubagentLiveIntercomHealth,
+} from "./types.ts";
 
-export function formatAgentProcessExit(exit: AgentProcessExit | undefined): string {
-	return exit ? `Agent process exited (${exit.signal ? `signal ${exit.signal}` : `code ${exit.code ?? "unrecorded"}`}). Command and descendant exit are not implied.`
-		: "Agent process exit not recorded. Command exit is unconfirmed.";
+export function formatAgentProcessExit(exit: Readonly<AgentProcessExit> | undefined): string {
+  return exit
+    ? `Agent process exited (${exit.signal !== null ? `signal ${exit.signal}` : `code ${exit.code ?? "unrecorded"}`}). Command and descendant exit are not implied.`
+    : "Agent process exit not recorded. Command exit is unconfirmed.";
 }
 
-export function formatRunAction(action: ManagementAction | "questions" | "answer", id: string | undefined, fields: Record<string, string | number | boolean> = {}, childSafe = false): string {
-	const legacyChild = childSafe && loadConfig().compactChildTools === false;
-	const parentAction = { status: "inspect", resume: "continue", interrupt: "stop" };
-	const name = legacyChild ? action : parentAction[action as keyof typeof parentAction] ?? action;
-	const args = Object.entries({ action: name, ...(id !== undefined ? { id } : {}), ...fields }).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
-	const call = `${legacyChild || action === "extend" ? "subagent" : "agent_runs"}({ ${args} })`;
-	return action === "extend" && !legacyChild ? `load_subagent({}), then ${call}` : call;
+export function formatRunAction(
+  action: ManagementAction | "questions" | "answer",
+  id: string | undefined,
+  fields: Readonly<Record<string, string | number | boolean>> = {},
+  childSafe = false,
+): string {
+  const legacyChild = childSafe && loadConfig().compactChildTools === false;
+  const name = legacyChild ? action : parentActionName(action);
+  const args = Object.entries({ action: name, ...(id !== undefined ? { id } : {}), ...fields })
+    .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+    .join(", ");
+  const call = `${legacyChild || action === "extend" ? "subagent" : "agent_runs"}({ ${args} })`;
+  return action === "extend" && !legacyChild ? `load_subagent({}), then ${call}` : call;
 }
 
-export function buildManagementControl(input: {
-	state: ManagementRunState;
-	runId: string;
-	index?: number;
-	intercomTarget?: string;
-	canExtend?: boolean;
-	canResume?: boolean;
-	canNudge?: boolean;
-	canInterrupt?: boolean;
-	canReview?: boolean;
-	unavailableActions?: Partial<Record<ManagementAction, string>>;
-	revivedFromRunId?: string;
-}): ManagementControl {
-	const capabilities: ManagementAction[] = ["status"];
-	if (input.state === "live") {
-		if (input.canNudge) capabilities.push("nudge");
-		if (input.canResume) capabilities.push("resume");
-		if (input.canInterrupt) capabilities.push("interrupt");
-	} else if (input.canResume) capabilities.push("resume");
-	if (input.state === "live" && input.canExtend) capabilities.push("extend");
-	if (input.canReview) capabilities.push("review");
-	return {
-		state: input.state,
-		runId: input.runId,
-		capabilities,
-		nextActions: capabilities.map((action) => ({
-			action,
-			runId: input.runId,
-			...(input.index !== undefined && (action === "nudge" || action === "resume") ? { index: input.index } : {}),
-			...(input.intercomTarget && (action === "nudge" || action === "resume") ? { intercomTarget: input.intercomTarget } : {}),
-		})),
-		...(input.unavailableActions ? { unavailableActions: input.unavailableActions } : {}),
-		...(input.revivedFromRunId ? { revivedFromRunId: input.revivedFromRunId, pendingReplyContextValid: false } : {}),
-	};
+function parentActionName(action: ManagementAction | "questions" | "answer"): string {
+  switch (action) {
+    case "status":
+      return "inspect";
+    case "resume":
+      return "continue";
+    case "interrupt":
+      return "stop";
+    case "answer":
+    case "extend":
+    case "nudge":
+    case "questions":
+    case "review":
+      return action;
+  }
 }
 
-type StepStatusLike = Pick<AsyncJobStep, "status">;
+type ManagementInput = ReadonlyDeep<{
+  state: ManagementRunState;
+  runId: string;
+  index?: number;
+  intercomTarget?: string;
+  canExtend?: boolean;
+  canResume?: boolean;
+  canNudge?: boolean;
+  canInterrupt?: boolean;
+  canReview?: boolean;
+  unavailableActions?: Partial<Record<ManagementAction, string>>;
+  revivedFromRunId?: string;
+}>;
+function managementCapabilities(input: ManagementInput): ManagementAction[] {
+  const capabilities: ManagementAction[] = ["status"];
+  if (input.state === "live") {
+    if (input.canNudge === true) {
+      capabilities.push("nudge");
+    }
+    if (input.canResume === true) {
+      capabilities.push("resume");
+    }
+    if (input.canInterrupt === true) {
+      capabilities.push("interrupt");
+    }
+  } else if (input.canResume === true) {
+    capabilities.push("resume");
+  }
+  if (input.state === "live" && input.canExtend === true) {
+    capabilities.push("extend");
+  }
+  if (input.canReview === true) {
+    capabilities.push("review");
+  }
+  return capabilities;
+}
+function managementNextAction(
+  action: ManagementAction,
+  input: ManagementInput,
+): ManagementControl["nextActions"][number] {
+  return {
+    action,
+    runId: input.runId,
+    ...(input.index !== undefined && (action === "nudge" || action === "resume")
+      ? { index: input.index }
+      : {}),
+    ...(input.intercomTarget !== undefined &&
+    input.intercomTarget !== "" &&
+    (action === "nudge" || action === "resume")
+      ? { intercomTarget: input.intercomTarget }
+      : {}),
+  };
+}
+export function buildManagementControl(input: ManagementInput): ManagementControl {
+  const capabilities = managementCapabilities(input);
+  return {
+    state: input.state,
+    runId: input.runId,
+    capabilities,
+    nextActions: capabilities.map((action) => managementNextAction(action, input)),
+    ...(input.unavailableActions ? { unavailableActions: input.unavailableActions } : {}),
+    ...(input.revivedFromRunId !== undefined && input.revivedFromRunId !== ""
+      ? { revivedFromRunId: input.revivedFromRunId, pendingReplyContextValid: false }
+      : {}),
+  };
+}
+
+type StepStatusLike = Readonly<Pick<AsyncJobStep, "status">>;
 
 function formatActivityAge(ms: number): string {
-	if (ms < 1000) return "now";
-	if (ms < 60000) return `${Math.floor(ms / 1000)}s`;
-	return `${Math.floor(ms / 60000)}m`;
+  if (ms < 1000) {
+    return "now";
+  }
+  if (ms < 60000) {
+    return `${Math.floor(ms / 1000)}s`;
+  }
+  return `${Math.floor(ms / 60000)}m`;
 }
 
-export function formatActivityLabel(lastActivityAt: number | undefined, activityState?: ActivityState, now = Date.now()): string | undefined {
-	if (lastActivityAt === undefined) {
-		if (activityState === "needs_attention") return "needs attention";
-		return undefined;
-	}
-	const age = formatActivityAge(Math.max(0, now - lastActivityAt));
-	if (activityState === "needs_attention") return `no activity for ${age}`;
-	return age === "now" ? "active now" : `active ${age} ago`;
+export function formatActivityLabel(
+  lastActivityAt: number | undefined,
+  activityState?: ActivityState,
+  now = Date.now(),
+): string | undefined {
+  if (lastActivityAt === undefined) {
+    if (activityState === "needs_attention") {
+      return "needs attention";
+    }
+    return undefined;
+  }
+  const age = formatActivityAge(Math.max(0, now - lastActivityAt));
+  if (activityState === "needs_attention") {
+    return `no activity for ${age}`;
+  }
+  return age === "now" ? "active now" : `active ${age} ago`;
 }
 
 function isCompletedStepStatus(status: AsyncJobStep["status"]): boolean {
-	return status === "complete" || status === "completed";
+  return status === "complete" || status === "completed";
 }
 
-export function aggregateStepStatus(steps: StepStatusLike[]): AsyncJobStep["status"] {
-	if (steps.some((step) => step.status === "running")) return "running";
-	if (steps.some((step) => step.status === "failed")) return "failed";
-	if (steps.some((step) => step.status === "blocked")) return "blocked";
-	if (steps.some((step) => step.status === "paused")) return "paused";
-	if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status))) return "complete";
-	return "pending";
+export function aggregateStepStatus(steps: readonly StepStatusLike[]): AsyncJobStep["status"] {
+  if (steps.some((step) => step.status === "running")) {
+    return "running";
+  }
+  if (steps.some((step) => step.status === "failed")) {
+    return "failed";
+  }
+  if (steps.some((step) => step.status === "blocked")) {
+    return "blocked";
+  }
+  if (steps.some((step) => step.status === "paused")) {
+    return "paused";
+  }
+  if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status))) {
+    return "complete";
+  }
+  return "pending";
 }
 
 export function formatAgentRunningLabel(count: number): string {
-	return count === 1 ? "1 agent running" : `${count} agents running`;
+  return count === 1 ? "1 agent running" : `${count} agents running`;
+}
+
+function intercomHealth(health: ReadonlyDeep<SubagentLiveIntercomHealth> | undefined): string {
+  if (!health) {
+    return "unknown";
+  }
+  if (health.status !== "registered") {
+    return health.status.replace(/_/g, " ");
+  }
+  return `registered${health.sessionStatus !== undefined && health.sessionStatus !== "" ? `, ${health.sessionStatus}` : ""}${health.acceptsAsks !== undefined ? `, accepts_asks:${health.acceptsAsks}` : ""}${health.pendingAsks !== undefined ? `, pending_asks:${health.pendingAsks}` : ""}`;
 }
 
-export function formatLiveIntercomActionLines(input: {
-	runId: string;
-	target: string;
-	index?: number;
-	health?: SubagentLiveIntercomHealth;
-	indent?: string;
-	childSafe?: boolean;
-}): string[] {
-	const fields = { ...(input.index !== undefined ? { index: input.index } : {}), message: "What are you blocked on?" };
-	const healthText = !input.health
-		? "unknown"
-		: input.health.status === "registered"
-			? `registered${input.health.sessionStatus ? `, ${input.health.sessionStatus}` : ""}${input.health.acceptsAsks !== undefined ? `, accepts_asks:${input.health.acceptsAsks}` : ""}${input.health.pendingAsks !== undefined ? `, pending_asks:${input.health.pendingAsks}` : ""}`
-			: input.health.status.replace(/_/g, " ");
-	const indent = input.indent ?? "";
-	return [
-		`${indent}Intercom: ${healthText} (${input.target})`,
-		`${indent}Nudge (preferred live coordination): ${formatRunAction("nudge", input.runId, fields, input.childSafe)}`,
-		`${indent}Ask (blocking wait only; parent must remain alive): intercom({ action: "ask", to: "${input.target}", delivery: "steer", message: "What are you blocked on?" })`,
-	];
+export function formatLiveIntercomActionLines(
+  input: ReadonlyDeep<{
+    runId: string;
+    target: string;
+    index?: number;
+    health?: SubagentLiveIntercomHealth;
+    indent?: string;
+    childSafe?: boolean;
+  }>,
+): string[] {
+  const fields = {
+    ...(input.index !== undefined ? { index: input.index } : {}),
+    message: "What are you blocked on?",
+  };
+  const healthText = intercomHealth(input.health);
+  const indent = input.indent ?? "";
+  return [
+    `${indent}Intercom: ${healthText} (${input.target})`,
+    `${indent}Nudge (preferred live coordination): ${formatRunAction("nudge", input.runId, fields, input.childSafe)}`,
+    `${indent}Ask (blocking wait only; parent must remain alive): intercom({ action: "ask", to: "${input.target}", delivery: "steer", message: "What are you blocked on?" })`,
+  ];
 }
 
-export function formatParallelOutcome(steps: StepStatusLike[], total: number, options: { showRunning?: boolean } = {}): string {
-	const running = steps.filter((step) => step.status === "running").length;
-	const succeeded = steps.filter((step) => isCompletedStepStatus(step.status)).length;
-	const failed = steps.filter((step) => step.status === "failed").length;
-	const paused = steps.filter((step) => step.status === "paused").length;
-	const blocked = steps.filter((step) => step.status === "blocked").length;
-	const parts = [`${succeeded}/${total} succeeded`];
-	if (options.showRunning !== false && running > 0) parts.unshift(formatAgentRunningLabel(running));
-	if (failed > 0) parts.push(`${failed} failed`);
-	if (paused > 0) parts.push(`${paused} paused`);
-	if (blocked > 0) parts.push(`${blocked} need human action`);
-	return parts.join(" · ");
+export function formatParallelOutcome(
+  steps: readonly StepStatusLike[],
+  total: number,
+  options: { readonly showRunning?: boolean } = {},
+): string {
+  const running = steps.filter((step) => step.status === "running").length;
+  const succeeded = steps.filter((step) => isCompletedStepStatus(step.status)).length;
+  const failed = steps.filter((step) => step.status === "failed").length;
+  const paused = steps.filter((step) => step.status === "paused").length;
+  const blocked = steps.filter((step) => step.status === "blocked").length;
+  const parts = [`${succeeded}/${total} succeeded`];
+  if (options.showRunning !== false && running > 0) {
+    parts.unshift(formatAgentRunningLabel(running));
+  }
+  if (failed > 0) {
+    parts.push(`${failed} failed`);
+  }
+  if (paused > 0) {
+    parts.push(`${paused} paused`);
+  }
+  if (blocked > 0) {
+    parts.push(`${blocked} need human action`);
+  }
+  return parts.join(" · ");
 }

package/src/shared/stream-json.d.ts

@@ -0,0 +1,10 @@
+import type { Many, none } from "stream-chain/defs.js";
+import type { ParserOptions, Token } from "stream-json/core/parser.js";
+
+// stream-json 3.7.0 exports the synchronous tokenizer used by its default
+// generator adapter, but omits this export from parser.d.ts.
+declare module "stream-json/core/parser.js" {
+  export function jsonParser(
+    options?: Readonly<ParserOptions>,
+  ): (chunk: string | typeof none) => Many<Token> | typeof none;
+}

package/src/shared/task-file-policy.ts

@@ -0,0 +1,35 @@
+import type { ResolvedStepBehavior } from "./types/workflow.ts";
+
+export function resolveTaskTextForFileUpdatePolicy(
+  task: string | undefined,
+  originalTask?: string,
+): string | undefined {
+  if (task === undefined || task.length === 0) {
+    return originalTask;
+  }
+  return originalTask !== undefined && originalTask.length > 0
+    ? task.replaceAll("{task}", () => originalTask)
+    : task;
+}
+export function taskDisallowsFileUpdates(task: string | undefined): boolean {
+  if (task === undefined || task.length === 0) {
+    return false;
+  }
+  return (
+    /\breview[- ]only\b/i.test(task) ||
+    /\bread[- ]only\s+(?:review|audit|inspection|pass)\b/i.test(task) ||
+    /\b(?:no|without)\s+(?:file\s+)?edits?\b/i.test(task) ||
+    /\b(?:do not|don't|must not)\s+(?:edit|modify|write|touch)\b/i.test(task) ||
+    /\bleave\s+files?\s+unchanged\b/i.test(task)
+  );
+}
+export function suppressProgressForReadOnlyTask(
+  behavior: ResolvedStepBehavior,
+  task: string | undefined,
+  originalTask?: string,
+): ResolvedStepBehavior {
+  const policyTask = resolveTaskTextForFileUpdatePolicy(task, originalTask);
+  return behavior.progress && taskDisallowsFileUpdates(policyTask)
+    ? { ...behavior, progress: false }
+    : behavior;
+}

package/src/shared/temp-root.ts

@@ -2,73 +2,104 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { isSafeNestedPathId } from "../runs/shared/nested-path.ts";
 import { ASYNC_DIR, RESULTS_DIR, TEMP_ROOT_DIR } from "./types.ts";
-import { listRunQuestions, LEGACY_QUESTIONS_DIR, QUESTIONS_DIR } from "../runs/shared/supervisor-questions.ts";
+import { hasErrorCode, isRecord } from "./unknown.ts";
+import {
+  listRunQuestions,
+  LEGACY_QUESTIONS_DIR,
+  QUESTIONS_DIR,
+} from "../runs/shared/supervisor-questions.ts";
 
 const MAX_RUN_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
 export function ensureTempRoot(): void {
-	fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true, mode: 0o700 });
-	const stat = fs.lstatSync(TEMP_ROOT_DIR);
-	if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`Unsafe pi-subagents temp root: ${TEMP_ROOT_DIR}`);
-	const uid = process.getuid?.();
-	if (uid !== undefined && stat.uid !== uid) throw new Error(`pi-subagents temp root is owned by another user: ${TEMP_ROOT_DIR}`);
-	fs.chmodSync(TEMP_ROOT_DIR, 0o700);
+  fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true, mode: 0o700 });
+  const stat = fs.lstatSync(TEMP_ROOT_DIR);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`Unsafe pi-subagents temp root: ${TEMP_ROOT_DIR}`);
+  }
+  const uid = process.getuid?.();
+  if (uid !== undefined && stat.uid !== uid) {
+    throw new Error(`pi-subagents temp root is owned by another user: ${TEMP_ROOT_DIR}`);
+  }
+  fs.chmodSync(TEMP_ROOT_DIR, 0o700);
 }
 
 export function ensureSafeTempPath(candidate: string): void {
-	const root = path.resolve(TEMP_ROOT_DIR);
-	const resolved = path.resolve(candidate);
-	const relative = path.relative(root, resolved);
-	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return;
-	ensureTempRoot();
-	let current = root;
-	for (const segment of relative.split(path.sep).filter(Boolean)) {
-		current = path.join(current, segment);
-		try {
-			const stat = fs.lstatSync(current);
-			if (stat.isSymbolicLink()) throw new Error(`Unsafe symlink in pi-subagents temp path: ${current}`);
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-			throw error;
-		}
-	}
+  const root = path.resolve(TEMP_ROOT_DIR);
+  const resolved = path.resolve(candidate);
+  const relative = path.relative(root, resolved);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return;
+  }
+  ensureTempRoot();
+  let current = root;
+  for (const segment of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    try {
+      const stat = fs.lstatSync(current);
+      if (stat.isSymbolicLink()) {
+        throw new Error(`Unsafe symlink in pi-subagents temp path: ${current}`);
+      }
+    } catch (error) {
+      if (hasErrorCode(error, "ENOENT")) {
+        return;
+      }
+      throw error;
+    }
+  }
 }
 
 // Missing, malformed, or non-object JSON means the entry is incomplete garbage and safe
 // to remove. Operational read failures throw so callers fail closed instead of deleting.
 async function readJsonObject(file: string): Promise<Record<string, unknown> | undefined> {
-	try {
-		const parsed: unknown = JSON.parse(await fs.promises.readFile(file, "utf-8"));
-		return parsed !== null && typeof parsed === "object" ? parsed as Record<string, unknown> : undefined;
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT" || error instanceof SyntaxError) return undefined;
-		throw error;
-	}
+  try {
+    const parsed: unknown = JSON.parse(await fs.promises.readFile(file, "utf-8"));
+    return isRecord(parsed) ? parsed : undefined;
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT") || error instanceof SyntaxError) {
+      return undefined;
+    }
+    throw error;
+  }
 }
 
 async function activeStatus(statusFile: string): Promise<boolean> {
-	const status = await readJsonObject(statusFile);
-	return status?.state === "running" || status?.state === "queued";
+  const status = await readJsonObject(statusFile);
+  return status?.state === "running" || status?.state === "queued";
 }
 
-async function removeOldEntries(root: string, now: number, keepActive?: (entryPath: string) => boolean | Promise<boolean>): Promise<void> {
-	let entries: fs.Dirent[];
-	try {
-		entries = await fs.promises.readdir(root, { withFileTypes: true });
-	} catch {
-		return;
-	}
-	for (const entry of entries) {
-		const entryPath = path.join(root, entry.name);
-		try {
-			const stat = await fs.promises.lstat(entryPath);
-			if (now - stat.mtimeMs <= MAX_RUN_AGE_MS) continue;
-			if (keepActive && entry.isDirectory() && await keepActive(entryPath)) continue;
-			await fs.promises.rm(entryPath, { recursive: entry.isDirectory(), force: true });
-		} catch {
-			// Startup retention cleanup is best effort; entries that fail closed are skipped.
-		}
-	}
+async function removeOldEntries(
+  root: string,
+  now: number,
+  keepActive?: (entryPath: string) => boolean | Promise<boolean>,
+): Promise<void> {
+  let entries: fs.Dirent[];
+  try {
+    entries = await fs.promises.readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const entryPath = path.join(root, entry.name);
+    try {
+      // Sequential retention bounds filesystem work and observes each entry before deletion.
+      // oxlint-disable-next-line no-await-in-loop
+      const stat = await fs.promises.lstat(entryPath);
+      if (now - stat.mtimeMs <= MAX_RUN_AGE_MS) {
+        continue;
+      }
+      // Finish the entry's activity decision before deleting it or considering another entry.
+      // oxlint-disable-next-line no-await-in-loop
+      if (keepActive && entry.isDirectory() && (await keepActive(entryPath))) {
+        continue;
+      }
+      // Only remove entries whose preceding activity check completed; keep I/O bounded.
+      // oxlint-disable-next-line no-await-in-loop
+      await fs.promises.rm(entryPath, { recursive: entry.isDirectory(), force: true });
+    } catch {
+      // Startup retention cleanup is best effort; entries that fail closed are skipped.
+    }
+  }
 }
 
 // A route is live while anything still writes into it (nested descendants can outlive a
@@ -77,31 +108,51 @@ async function removeOldEntries(root: string, now: number, keepActive?: (entryPa
 // bumping the route-root mtime; registry projection renames into routeRoot, which the
 // caller's mtime gate already covers.
 async function nestedRouteActive(routeRoot: string, now: number): Promise<boolean> {
-	for (const name of ["events", "controls"]) {
-		try {
-			if (now - (await fs.promises.stat(path.join(routeRoot, name))).mtimeMs <= MAX_RUN_AGE_MS) return true;
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-		}
-	}
-	const metadata = await readJsonObject(path.join(routeRoot, "route.json"));
-	if (!metadata || !isSafeNestedPathId(metadata.rootRunId)) return false;
-	return activeStatus(path.join(ASYNC_DIR, metadata.rootRunId, "status.json"));
+  for (const name of ["events", "controls"]) {
+    try {
+      // Inspect the two writer directories in order, short-circuiting on live activity.
+      // oxlint-disable-next-line no-await-in-loop
+      if (now - (await fs.promises.stat(path.join(routeRoot, name))).mtimeMs <= MAX_RUN_AGE_MS) {
+        return true;
+      }
+    } catch (error) {
+      if (!hasErrorCode(error, "ENOENT")) {
+        throw error;
+      }
+    }
+  }
+  const metadata = await readJsonObject(path.join(routeRoot, "route.json"));
+  if (!metadata || !isSafeNestedPathId(metadata.rootRunId)) {
+    return false;
+  }
+  return activeStatus(path.join(ASYNC_DIR, metadata.rootRunId, "status.json"));
 }
 
 function pendingQuestion(runDir: string): boolean {
-	return listRunQuestions(runDir).some((question) => question.state === "awaiting_input" || question.state === "answer_pending");
+  return listRunQuestions(runDir).some(
+    (question) => question.state === "awaiting_input" || question.state === "answer_pending",
+  );
 }
 
 export async function cleanupOldRunStorage(now = Date.now()): Promise<void> {
-	for (const [dir, keepActive] of [
-		[ASYNC_DIR, async (entryPath: string) => await activeStatus(path.join(entryPath, "status.json")) || pendingQuestion(path.join(QUESTIONS_DIR, path.basename(entryPath)))],
-		[LEGACY_QUESTIONS_DIR, pendingQuestion],
-		[RESULTS_DIR, undefined],
-		[path.join(TEMP_ROOT_DIR, "nested-subagent-runs"), undefined],
-		[path.join(TEMP_ROOT_DIR, "nested-subagent-events"), (entryPath: string) => nestedRouteActive(entryPath, now)],
-	] as const) {
-		ensureSafeTempPath(dir);
-		await removeOldEntries(dir, now, keepActive);
-	}
+  for (const [dir, keepActive] of [
+    [
+      ASYNC_DIR,
+      async (entryPath: string) =>
+        (await activeStatus(path.join(entryPath, "status.json"))) ||
+        pendingQuestion(path.join(QUESTIONS_DIR, path.basename(entryPath))),
+    ],
+    [LEGACY_QUESTIONS_DIR, pendingQuestion],
+    [RESULTS_DIR, undefined],
+    [path.join(TEMP_ROOT_DIR, "nested-subagent-runs"), undefined],
+    [
+      path.join(TEMP_ROOT_DIR, "nested-subagent-events"),
+      (entryPath: string) => nestedRouteActive(entryPath, now),
+    ],
+  ] as const) {
+    ensureSafeTempPath(dir);
+    // Finish one storage root's retention scan before opening another.
+    // oxlint-disable-next-line no-await-in-loop
+    await removeOldEntries(dir, now, keepActive);
+  }
 }