pi-subagents 0.31.1 → 0.33.0

package/src/runs/shared/acceptance.ts

@@ -710,13 +710,15 @@ export function aggregateAcceptanceReport(input: {
 	};
 }
 
-function runVerifyCommand(command: AcceptanceVerifyCommand, defaultCwd: string): Promise<AcceptanceVerifyResult> {
+function runVerifyCommand(command: AcceptanceVerifyCommand, defaultCwd: string, options: { signal?: AbortSignal; abortMessage?: string } = {}): Promise<AcceptanceVerifyResult> {
 	return new Promise((resolve) => {
 		const startedAt = Date.now();
 		const cwd = command.cwd ? path.resolve(defaultCwd, command.cwd) : defaultCwd;
 		let stdout = "";
 		let stderr = "";
 		let timedOut = false;
+		let settled = false;
+		let hardKill: NodeJS.Timeout | undefined;
 		const child = spawn(command.command, {
 			cwd,
 			env: { ...process.env, ...(command.env ?? {}) },
@@ -724,12 +726,39 @@ function runVerifyCommand(command: AcceptanceVerifyCommand, defaultCwd: string):
 			stdio: ["ignore", "pipe", "pipe"],
 			windowsHide: true,
 		});
-		const timeout = setTimeout(() => {
+		const finish = (result: Omit<AcceptanceVerifyResult, "id" | "command" | "cwd" | "durationMs">) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			if (hardKill) clearTimeout(hardKill);
+			options.signal?.removeEventListener("abort", abortVerification);
+			resolve({
+				id: command.id,
+				command: command.command,
+				cwd,
+				durationMs: Date.now() - startedAt,
+				...result,
+			});
+		};
+		const abortVerification = () => {
+			if (settled || timedOut) return;
 			timedOut = true;
 			child.kill("SIGTERM");
-			setTimeout(() => child.kill("SIGKILL"), 1000).unref?.();
-		}, command.timeoutMs ?? 120_000);
+			hardKill = setTimeout(() => {
+				child.kill("SIGKILL");
+				finish({
+					exitCode: null,
+					status: "timed-out",
+					stdout: trimOutput(stdout),
+					stderr: trimOutput(stderr || options.abortMessage || "Acceptance verification timed out."),
+				});
+			}, 1000);
+			hardKill.unref?.();
+		};
+		const timeout = setTimeout(abortVerification, command.timeoutMs ?? 120_000);
 		timeout.unref?.();
+		if (options.signal?.aborted) abortVerification();
+		else options.signal?.addEventListener("abort", abortVerification, { once: true });
 		child.stdout.on("data", (chunk: Buffer) => {
 			stdout += chunk.toString();
 		});
@@ -737,30 +766,19 @@ function runVerifyCommand(command: AcceptanceVerifyCommand, defaultCwd: string):
 			stderr += chunk.toString();
 		});
 		child.on("close", (exitCode) => {
-			clearTimeout(timeout);
-			const durationMs = Date.now() - startedAt;
 			const passed = exitCode === 0 && !timedOut;
-			resolve({
-				id: command.id,
-				command: command.command,
-				cwd,
+			finish({
 				exitCode,
 				status: timedOut ? "timed-out" : passed ? "passed" : command.allowFailure ? "allowed-failure" : "failed",
 				stdout: trimOutput(stdout),
-				stderr: trimOutput(stderr),
-				durationMs,
+				stderr: trimOutput(stderr || (timedOut ? options.abortMessage ?? "" : "")),
 			});
 		});
 		child.on("error", (error) => {
-			clearTimeout(timeout);
-			resolve({
-				id: command.id,
-				command: command.command,
-				cwd,
-				exitCode: 1,
-				status: command.allowFailure ? "allowed-failure" : "failed",
-				stderr: error instanceof Error ? error.message : String(error),
-				durationMs: Date.now() - startedAt,
+			finish({
+				exitCode: timedOut ? null : 1,
+				status: timedOut ? "timed-out" : command.allowFailure ? "allowed-failure" : "failed",
+				stderr: timedOut ? trimOutput(stderr || options.abortMessage || "Acceptance verification timed out.") : error instanceof Error ? error.message : String(error),
 			});
 		});
 	});
@@ -772,6 +790,8 @@ export async function evaluateAcceptance(input: {
 	cwd: string;
 	report?: AcceptanceReport;
 	reviewResult?: AcceptanceReviewResult;
+	signal?: AbortSignal;
+	abortMessage?: string;
 }): Promise<AcceptanceLedger> {
 	const acceptance = input.acceptance;
 	const ledger: AcceptanceLedger = {
@@ -815,7 +835,10 @@ export async function evaluateAcceptance(input: {
 			return ledger;
 		}
 		ledger.verifyRuns = [];
-		for (const command of acceptance.verify) ledger.verifyRuns.push(await runVerifyCommand(command, input.cwd));
+		for (const command of acceptance.verify) {
+			ledger.verifyRuns.push(await runVerifyCommand(command, input.cwd, { signal: input.signal, abortMessage: input.abortMessage }));
+			if (input.signal?.aborted) break;
+		}
 		if (ledger.verifyRuns.some((run) => run.status === "failed" || run.status === "timed-out")) {
 			ledger.status = "rejected";
 			return ledger;

package/src/runs/shared/dynamic-fanout.ts

@@ -42,10 +42,10 @@ const ITEM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
 const RESERVED_TEMPLATE_NAMES = new Set(["task", "previous", "chain_dir", "outputs"]);
 const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label", "acceptance"]);
-const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance"]);
+const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "sessionFiles", "thinkingOverrides"]);
 const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
 const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
-const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "acceptance"]);
+const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "toolBudget", "acceptance"]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
 	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "maxSubagentDepth",

package/src/runs/shared/model-fallback.ts

@@ -1,5 +1,6 @@
 import type { ModelInfo as AvailableModelInfo } from "../../shared/model-info.ts";
 import type { Usage } from "../../shared/types.ts";
+import { checkModelScope, type ModelScopeConfig, type ModelScopeViolation, type ModelSource } from "./model-scope.ts";
 
 export type { AvailableModelInfo };
 
@@ -29,6 +30,144 @@ export interface ParentModel {
 	id: string;
 }
 
+/**
+ * Normalize a model id or provider segment for fuzzy comparison: case-fold,
+ * treat dots/underscores as dashes (so `4.5` matches `4-5`), and collapse
+ * repeated separators. Pure.
+ */
+export function normalizeModelSegment(segment: string): string {
+	return segment
+		.toLowerCase()
+		.replace(/[._]+/g, "-")
+		.replace(/-+/g, "-")
+		.replace(/^-|-$/g, "");
+}
+
+function isPlausibleDateStamp(year: string, month: string, day: string): boolean {
+	const yyyy = Number(year);
+	const mm = Number(month);
+	const dd = Number(day);
+	return yyyy >= 1900 && yyyy <= 2099 && mm >= 1 && mm <= 12 && dd >= 1 && dd <= 31;
+}
+
+/** Drop a trailing date stamp (`-20251001` or `-2025-10-01`) so dated and undated ids match. Pure. */
+function stripTrailingDateStamp(segment: string): string {
+	const dashed = /^(.*)-(\d{4})-(\d{2})-(\d{2})$/.exec(segment);
+	if (dashed && isPlausibleDateStamp(dashed[2]!, dashed[3]!, dashed[4]!)) return dashed[1]!;
+	const compact = /^(.*)-(\d{4})(\d{2})(\d{2})$/.exec(segment);
+	if (compact && isPlausibleDateStamp(compact[2]!, compact[3]!, compact[4]!)) return compact[1]!;
+	return segment;
+}
+
+function resolveBaseModelCandidate(
+	baseModel: string,
+	availableModels: AvailableModelInfo[],
+	preferredProvider?: string,
+): string | undefined {
+	if (baseModel.includes("/")) {
+		const exact = availableModels.find((entry) => entry.fullId === baseModel);
+		if (exact) return exact.fullId;
+	} else {
+		const exactMatches = availableModels.filter((entry) => entry.id === baseModel);
+		if (preferredProvider) {
+			const preferredMatch = exactMatches.find((entry) => entry.provider === preferredProvider);
+			if (preferredMatch) return preferredMatch.fullId;
+		}
+		if (exactMatches.length === 1) return exactMatches[0]!.fullId;
+	}
+
+	return fuzzyResolveModel(baseModel, availableModels, preferredProvider);
+}
+
+/**
+ * Fuzzy-resolve a base model id (thinking suffix already stripped) against the
+ * registry, tolerating separator, case, and optional date-stamp differences so
+ * users do not have to spell provider/model exactly. A qualified `provider/id`
+ * query only matches within the named provider — this never silently switches
+ * providers for security/cost-sensitive configs. Returns the matched `fullId`,
+ * or `undefined` when there is no match or the match is ambiguous across
+ * providers (and no `preferredProvider` disambiguates). Pure.
+ */
+export function fuzzyResolveModel(
+	baseModel: string,
+	availableModels: AvailableModelInfo[],
+	preferredProvider?: string,
+): string | undefined {
+	let queryProvider: string | undefined;
+	let queryIdRaw = baseModel;
+	const slashIdx = baseModel.indexOf("/");
+	if (slashIdx !== -1) {
+		queryProvider = normalizeModelSegment(baseModel.slice(0, slashIdx));
+		queryIdRaw = baseModel.slice(slashIdx + 1);
+	} else {
+		const providerSeparators = [":", "."];
+		for (const separator of providerSeparators) {
+			const separatorIdx = baseModel.indexOf(separator);
+			if (separatorIdx <= 0) continue;
+			const providerPart = normalizeModelSegment(baseModel.slice(0, separatorIdx));
+			if (!availableModels.some((entry) => normalizeModelSegment(entry.provider) === providerPart)) continue;
+			queryProvider = providerPart;
+			queryIdRaw = baseModel.slice(separatorIdx + 1);
+			break;
+		}
+	}
+	const queryId = normalizeModelSegment(queryIdRaw);
+	const queryIdNoDate = stripTrailingDateStamp(queryId);
+
+	const candidates = availableModels.filter((entry) => {
+		const entryId = normalizeModelSegment(entry.id);
+		if (entryId !== queryId && stripTrailingDateStamp(entryId) !== queryIdNoDate) return false;
+		if (queryProvider !== undefined && normalizeModelSegment(entry.provider) !== queryProvider) return false;
+		return true;
+	});
+	if (candidates.length === 0) return undefined;
+	if (preferredProvider) {
+		const preferredProviderNorm = normalizeModelSegment(preferredProvider);
+		const preferred = candidates.find((entry) => normalizeModelSegment(entry.provider) === preferredProviderNorm);
+		if (preferred) return preferred.fullId;
+	}
+	if (candidates.length === 1) return candidates[0]!.fullId;
+	return undefined;
+}
+
+/**
+ * Resolve a possibly-loose model id to a canonical `provider/id` (plus any
+ * thinking suffix). Exact registry matches win; fuzzy normalization
+ * (separator/case/date-stamp via {@link fuzzyResolveModel}) is a fallback so
+ * spelling differences still resolve. Never switches providers for a qualified
+ * query. Pure.
+ */
+export function resolveModelCandidate(
+	model: string | undefined,
+	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
+): string | undefined {
+	if (!model) return undefined;
+	if (!availableModels || availableModels.length === 0) return model;
+
+	const resolvedWhole = resolveBaseModelCandidate(model, availableModels, preferredProvider);
+	if (resolvedWhole) return resolvedWhole;
+
+	const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
+	if (!thinkingSuffix) return model;
+	const resolvedBase = resolveBaseModelCandidate(baseModel, availableModels, preferredProvider);
+	if (resolvedBase) return `${resolvedBase}${thinkingSuffix}`;
+	return model;
+}
+
+export interface ResolveSubagentModelOverrideOptions {
+	/** When set with `enforce: true`, out-of-scope models are rejected. */
+	scope?: ModelScopeConfig;
+	/** Origin of the requested model: explicit caller-supplied (hard error) vs inherited (warn). Defaults to `"inherited"`. */
+	source?: ModelSource;
+	/** Called for warn-severity violations instead of `console.warn`. */
+	onWarn?: (violation: ModelScopeViolation) => void;
+}
+
+function defaultScopeWarn(violation: ModelScopeViolation): void {
+	console.warn(`[pi-subagents] ${violation.message}`);
+}
+
 /**
  * Resolve the `--model` override passed to a spawned subagent.
  *
@@ -43,38 +182,39 @@ export interface ParentModel {
  * session's model.
  *
  * An explicitly requested model string is resolved via {@link resolveModelCandidate}.
+ * When `options.scope.enforce` is on, an out-of-scope resolved model throws for
+ * an explicit (`source: "explicit"`) request and warns for an inherited one.
  */
 export function resolveSubagentModelOverride(
 	requestedModel: string | boolean | undefined,
 	parentModel: ParentModel | undefined,
 	availableModels: AvailableModelInfo[] | undefined,
 	preferredProvider?: string,
+	options?: ResolveSubagentModelOverrideOptions,
 ): string | undefined {
 	const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
 	const explicit = trimmed && trimmed !== INHERIT_MODEL ? trimmed : undefined;
+	let resolved: string | undefined;
 	if (explicit === undefined) {
-		return parentModel ? `${parentModel.provider}/${parentModel.id}` : undefined;
+		resolved = parentModel ? `${parentModel.provider}/${parentModel.id}` : undefined;
+	} else {
+		resolved = resolveModelCandidate(explicit, availableModels, preferredProvider);
+	}
+	if (resolved && options?.scope?.enforce) {
+		const source: ModelSource = explicit === undefined ? "inherited" : (options.source ?? "inherited");
+		const violation = checkModelScope(resolved, options.scope, source);
+		if (violation) {
+			if (violation.severity === "error") throw new Error(violation.message);
+			(options.onWarn ?? defaultScopeWarn)(violation);
+		}
 	}
-	return resolveModelCandidate(explicit, availableModels, preferredProvider);
+	return resolved;
 }
 
-export function resolveModelCandidate(
-	model: string | undefined,
-	availableModels: AvailableModelInfo[] | undefined,
-	preferredProvider?: string,
-): string | undefined {
-	if (!model) return undefined;
-	if (model.includes("/")) return model;
-	if (!availableModels || availableModels.length === 0) return model;
-
-	const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
-	const matches = availableModels.filter((entry) => entry.id === baseModel);
-	if (preferredProvider) {
-		const preferredMatch = matches.find((entry) => entry.provider === preferredProvider);
-		if (preferredMatch) return `${preferredMatch.fullId}${thinkingSuffix}`;
-	}
-	if (matches.length !== 1) return model;
-	return `${matches[0]!.fullId}${thinkingSuffix}`;
+export interface BuildModelCandidatesOptions {
+	/** Fallback models are inherited agent config and warn, rather than error, when out of scope. */
+	scope?: ModelScopeConfig;
+	onWarn?: (violation: ModelScopeViolation) => void;
 }
 
 export function buildModelCandidates(
@@ -82,13 +222,20 @@ export function buildModelCandidates(
 	fallbackModels: string[] | undefined,
 	availableModels: AvailableModelInfo[] | undefined,
 	preferredProvider?: string,
+	options?: BuildModelCandidatesOptions,
 ): string[] {
 	const seen = new Set<string>();
 	const candidates: string[] = [];
-	for (const raw of [primaryModel, ...(fallbackModels ?? [])]) {
+	const rawCandidates = [primaryModel, ...(fallbackModels ?? [])];
+	for (let index = 0; index < rawCandidates.length; index++) {
+		const raw = rawCandidates[index];
 		if (!raw) continue;
 		const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
 		if (!normalized || seen.has(normalized)) continue;
+		if (index > 0 && options?.scope?.enforce) {
+			const violation = checkModelScope(normalized, options.scope, "inherited");
+			if (violation) (options.onWarn ?? defaultScopeWarn)(violation);
+		}
 		seen.add(normalized);
 		candidates.push(normalized);
 	}
@@ -126,6 +273,10 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
 	/\b502\b/,
 	/\b503\b/,
 	/\b504\b/,
+	/cold.?start/i,
+	/empty response/i,
+	/no output/i,
+	/model.*(?:load|fail|error)/i,
 ];
 
 export function isRetryableModelFailure(error: string | undefined): boolean {

package/src/runs/shared/model-scope.ts

@@ -0,0 +1,128 @@
+/**
+ * Optional model-scope enforcement for subagent model resolution.
+ *
+ * When `subagents.modelScope.enforce` is enabled in settings, a resolved model
+ * that does not match any `allow` pattern is rejected. The severity depends on
+ * where the model came from: an explicit caller-supplied model (`--model`,
+ * tool-call `model`, or a TUI clarify pick) is a hard error, while a model
+ * inherited from agent frontmatter / `defaultModel` / the parent session only
+ * emits a warning so existing configurations keep working.
+ *
+ * The decision logic ({@link checkModelScope}) is a pure function of its
+ * inputs so it can be unit-tested without touching the filesystem or config.
+ */
+
+import { splitKnownThinkingSuffix } from "../../shared/model-info.ts";
+
+export interface ModelScopeConfig {
+	enforce?: boolean;
+	/** Glob-style allow patterns (only `*` is special), matched against `provider/id`. */
+	allow?: string[];
+}
+
+/** Where a resolved model originated, deciding enforcement severity. */
+export type ModelSource = "explicit" | "inherited";
+
+export interface ModelScopeViolation {
+	/** Resolved model id (without thinking suffix) that fell outside the scope. */
+	model: string;
+	severity: "warn" | "error";
+	message: string;
+	allowedPatterns: string[];
+}
+
+function stripThinkingSuffix(model: string): string {
+	return splitKnownThinkingSuffix(model).baseModel;
+}
+
+/** Escape RegExp specials except `*`, then turn `*` into `.*`. */
+function globToRegExp(pattern: string): RegExp {
+	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${escaped}$`, "i");
+}
+
+/**
+ * Test whether a resolved model matches a single allow pattern. Both sides are
+ * compared case-insensitively against the full `provider/id` (thinking suffix
+ * stripped from the model).
+ */
+export function matchesScopePattern(model: string, pattern: string): boolean {
+	return globToRegExp(pattern).test(stripThinkingSuffix(model));
+}
+
+/**
+ * Pure scope decision. Returns a {@link ModelScopeViolation} when the model is
+ * out of scope and enforcement is on, otherwise `undefined`. Enforcement with
+ * no `allow` list is a no-op (the settings parser rejects that combination, but
+ * this stays defensive for callers that build configs programmatically).
+ */
+export function checkModelScope(
+	model: string | undefined,
+	scope: ModelScopeConfig | undefined,
+	source: ModelSource,
+): ModelScopeViolation | undefined {
+	if (!model || !scope?.enforce) return undefined;
+	const allow = scope.allow;
+	if (!allow || allow.length === 0) return undefined;
+	if (allow.some((pattern) => matchesScopePattern(model, pattern))) return undefined;
+
+	const baseModel = stripThinkingSuffix(model);
+	const severity: ModelScopeViolation["severity"] = source === "explicit" ? "error" : "warn";
+	return {
+		model: baseModel,
+		severity,
+		allowedPatterns: allow,
+		message:
+			`Model '${baseModel}' is outside the configured subagent model scope. ` +
+			`Allowed patterns: ${allow.join(", ")}.`,
+	};
+}
+
+/**
+ * Validate and normalize a raw `subagents.modelScope` value from settings.
+ * Throws a descriptive error for malformed configs (matching the surrounding
+ * settings-parsing style). Returns `undefined` when the field is absent.
+ */
+export function parseModelScopeConfig(
+	value: unknown,
+	meta: { filePath: string },
+): ModelScopeConfig | undefined {
+	if (value === undefined) return undefined;
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error(`Subagent settings in '${meta.filePath}' have invalid 'modelScope'; expected an object.`);
+	}
+
+	const input = value as Record<string, unknown>;
+	const config: ModelScopeConfig = {};
+
+	if ("enforce" in input) {
+		if (typeof input.enforce !== "boolean") {
+			throw new Error(`Subagent settings in '${meta.filePath}' have invalid 'modelScope.enforce'; expected a boolean.`);
+		}
+		config.enforce = input.enforce;
+	}
+
+	if ("allow" in input) {
+		if (!Array.isArray(input.allow)) {
+			throw new Error(`Subagent settings in '${meta.filePath}' have invalid 'modelScope.allow'; expected an array of strings.`);
+		}
+		const allow: string[] = [];
+		for (const entry of input.allow) {
+			if (typeof entry !== "string") {
+				throw new Error(`Subagent settings in '${meta.filePath}' have invalid 'modelScope.allow'; expected an array of strings.`);
+			}
+			const trimmed = entry.trim();
+			if (trimmed) allow.push(trimmed);
+		}
+		if (allow.length === 0) {
+			throw new Error(`Subagent settings in '${meta.filePath}' have invalid 'modelScope.allow'; expected a non-empty array of patterns.`);
+		}
+		config.allow = allow;
+	}
+
+	if (config.enforce === true && (!config.allow || config.allow.length === 0)) {
+		throw new Error(`Subagent settings in '${meta.filePath}' set modelScope.enforce without a non-empty 'allow' list; supply allowed model patterns or disable enforcement.`);
+	}
+
+	return Object.keys(config).length > 0 ? config : undefined;
+}

package/src/runs/shared/nested-events.ts

@@ -8,6 +8,7 @@ import {
 	type AsyncJobState,
 	type AsyncStatus,
 	type NestedRouteInfo,
+	type TurnBudgetState,
 	type NestedRunSummary,
 	type NestedRunState,
 	type NestedStepSummary,
@@ -184,6 +185,35 @@ function sanitizeTokenUsage(value: unknown): NestedRunSummary["totalTokens"] | u
 		: undefined;
 }
 
+function sanitizeCost(value: unknown): NestedRunSummary["totalCost"] | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	const inputTokens = clampNumber(raw.inputTokens);
+	const outputTokens = clampNumber(raw.outputTokens);
+	const costUsd = clampNumber(raw.costUsd);
+	return inputTokens !== undefined && outputTokens !== undefined && costUsd !== undefined
+		? { inputTokens, outputTokens, costUsd }
+		: undefined;
+}
+
+function sanitizeTurnBudget(value: unknown): TurnBudgetState | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	const maxTurns = clampNumber(raw.maxTurns);
+	const graceTurns = clampNumber(raw.graceTurns);
+	const turnCount = clampNumber(raw.turnCount);
+	const outcome = raw.outcome === "within-budget" || raw.outcome === "wrap-up-requested" || raw.outcome === "exceeded" ? raw.outcome : undefined;
+	if (maxTurns === undefined || graceTurns === undefined || turnCount === undefined || !outcome) return undefined;
+	return {
+		maxTurns,
+		graceTurns,
+		turnCount,
+		outcome,
+		...(clampNumber(raw.wrapUpRequestedAtTurn) !== undefined ? { wrapUpRequestedAtTurn: clampNumber(raw.wrapUpRequestedAtTurn) } : {}),
+		...(clampNumber(raw.exceededAtTurn) !== undefined ? { exceededAtTurn: clampNumber(raw.exceededAtTurn) } : {}),
+	};
+}
+
 function sanitizeState(value: unknown, fallback: NestedRunState): NestedRunState {
 	return value === "queued" || value === "running" || value === "complete" || value === "failed" || value === "paused"
 		? value
@@ -212,6 +242,10 @@ function sanitizeStep(input: unknown, depth: number): NestedStepSummary | undefi
 		...(clampNumber(raw.startedAt) !== undefined ? { startedAt: clampNumber(raw.startedAt) } : {}),
 		...(clampNumber(raw.endedAt) !== undefined ? { endedAt: clampNumber(raw.endedAt) } : {}),
 		...(stringValue(raw.error, 1024) ? { error: stringValue(raw.error, 1024) } : {}),
+		...(raw.timedOut === true ? { timedOut: true } : {}),
+		...(sanitizeTurnBudget(raw.turnBudget) ? { turnBudget: sanitizeTurnBudget(raw.turnBudget) } : {}),
+		...(raw.turnBudgetExceeded === true ? { turnBudgetExceeded: true } : {}),
+		...(raw.wrapUpRequested === true ? { wrapUpRequested: true } : {}),
 		...(depth < MAX_DEPTH && Array.isArray(raw.children) ? { children: raw.children.map((child) => sanitizeSummary(child, depth + 1)).filter((child): child is NestedRunSummary => Boolean(child)).slice(0, MAX_CHILDREN) } : {}),
 	};
 }
@@ -225,6 +259,7 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 		? raw.steps.map((step) => sanitizeStep(step, depth + 1)).filter((step): step is NestedStepSummary => Boolean(step)).slice(0, MAX_STEPS)
 		: undefined;
 	const totalTokens = sanitizeTokenUsage(raw.totalTokens);
+	const totalCost = sanitizeCost(raw.totalCost);
 	return {
 		id: raw.id,
 		parentRunId: raw.parentRunId,
@@ -256,9 +291,16 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 		...(clampNumber(raw.turnCount) !== undefined ? { turnCount: clampNumber(raw.turnCount) } : {}),
 		...(clampNumber(raw.toolCount) !== undefined ? { toolCount: clampNumber(raw.toolCount) } : {}),
 		...(totalTokens ? { totalTokens } : {}),
+		...(totalCost ? { totalCost } : {}),
 		...(clampNumber(raw.startedAt) !== undefined ? { startedAt: clampNumber(raw.startedAt) } : {}),
 		...(clampNumber(raw.endedAt) !== undefined ? { endedAt: clampNumber(raw.endedAt) } : {}),
 		...(clampNumber(raw.lastUpdate) !== undefined ? { lastUpdate: clampNumber(raw.lastUpdate) } : {}),
+		...(clampNumber(raw.timeoutMs) !== undefined ? { timeoutMs: clampNumber(raw.timeoutMs) } : {}),
+		...(clampNumber(raw.deadlineAt) !== undefined ? { deadlineAt: clampNumber(raw.deadlineAt) } : {}),
+		...(raw.timedOut === true ? { timedOut: true } : {}),
+		...(sanitizeTurnBudget(raw.turnBudget) ? { turnBudget: sanitizeTurnBudget(raw.turnBudget) } : {}),
+		...(raw.turnBudgetExceeded === true ? { turnBudgetExceeded: true } : {}),
+		...(raw.wrapUpRequested === true ? { wrapUpRequested: true } : {}),
 		...(stringValue(raw.error, 1024) ? { error: stringValue(raw.error, 1024) } : {}),
 		...(steps && steps.length > 0 ? { steps } : {}),
 		...(depth < MAX_DEPTH && Array.isArray(raw.children) ? { children: raw.children.map((child) => sanitizeSummary(child, depth + 1)).filter((child): child is NestedRunSummary => Boolean(child)).slice(0, MAX_CHILDREN) } : {}),
@@ -394,6 +436,42 @@ export function findNestedRouteForRootId(rootRunId: string): NestedRoute | undef
 	return undefined;
 }
 
+/**
+ * Scan the nested-events directory once and index every route by its root run
+ * id. Use this when resolving routes for many runs (e.g. listAsyncRuns) so the
+ * cost is O(routes) total instead of O(runs * routes) from calling
+ * findNestedRouteForRootId per run.
+ */
+export function buildNestedRouteIndex(): Map<string, NestedRoute> {
+	let entries: string[];
+	try {
+		entries = fs.readdirSync(NESTED_EVENTS_DIR);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return new Map();
+		throw error;
+	}
+	const index = new Map<string, NestedRoute>();
+	for (const entry of entries) {
+		const routeRoot = path.join(NESTED_EVENTS_DIR, entry);
+		try {
+			const metadata = JSON.parse(fs.readFileSync(path.join(routeRoot, ROUTE_FILE), "utf-8")) as { rootRunId?: unknown; capabilityToken?: unknown };
+			if (typeof metadata.rootRunId !== "string" || typeof metadata.capabilityToken !== "string") continue;
+			if (index.has(metadata.rootRunId)) continue;
+			const route: NestedRoute = {
+				rootRunId: metadata.rootRunId,
+				eventSink: path.join(routeRoot, "events"),
+				controlInbox: path.join(routeRoot, "controls"),
+				capabilityToken: metadata.capabilityToken,
+			};
+			validateRouteShape(route);
+			index.set(metadata.rootRunId, route);
+		} catch {
+			continue;
+		}
+	}
+	return index;
+}
+
 export function projectNestedRegistryForRoot(rootRunId: string): NestedRegistry | undefined {
 	const route = findNestedRouteForRootId(rootRunId);
 	return route ? projectNestedEvents(route) : undefined;
@@ -778,6 +856,13 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 		...(status.turnCount !== undefined ? { turnCount: status.turnCount } : {}),
 		...(status.toolCount !== undefined ? { toolCount: status.toolCount } : {}),
 		...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
+		...(status.timeoutMs !== undefined ? { timeoutMs: status.timeoutMs } : {}),
+		...(status.deadlineAt !== undefined ? { deadlineAt: status.deadlineAt } : {}),
+		...(status.timedOut !== undefined ? { timedOut: status.timedOut } : {}),
+		...(status.turnBudget ? { turnBudget: status.turnBudget } : {}),
+		...(status.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: status.turnBudgetExceeded } : {}),
+		...(status.wrapUpRequested !== undefined ? { wrapUpRequested: status.wrapUpRequested } : {}),
+		...(status.error ? { error: status.error } : {}),
 		...(status.startedAt !== undefined ? { startedAt: status.startedAt } : { startedAt: fallback.ts }),
 		...(status.endedAt !== undefined ? { endedAt: status.endedAt } : {}),
 		lastUpdate: status.lastUpdate ?? fallback.ts,
@@ -796,6 +881,10 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 			...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
 			...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
 			...(step.error ? { error: step.error } : {}),
+			...(step.timedOut !== undefined ? { timedOut: step.timedOut } : {}),
+			...(step.turnBudget ? { turnBudget: step.turnBudget } : {}),
+			...(step.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: step.turnBudgetExceeded } : {}),
+			...(step.wrapUpRequested !== undefined ? { wrapUpRequested: step.wrapUpRequested } : {}),
 		})).slice(0, MAX_STEPS) } : {}),
 	};
 }