@bastani/atomic 0.9.11-alpha.8 → 0.9.11

package/dist/builtin/subagents/src/runs/shared/mcp-direct-tool-allowlist.ts

@@ -15,7 +15,9 @@ const IMPORT_PATHS = {
 		path.join(os.homedir(), ".claude.json"),
 		path.join(os.homedir(), ".claude", "claude_desktop_config.json"),
 	],
-	"claude-desktop": [path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")],
+	"claude-desktop": [
+		path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+	],
 	codex: [path.join(os.homedir(), ".codex", "config.json")],
 	windsurf: [path.join(os.homedir(), ".windsurf", "mcp.json")],
 	vscode: [".vscode/mcp.json"],
@@ -76,7 +78,12 @@ export function resolveMcpDirectToolNames(mcpDirectTools: string[] | undefined,
 		const config = loadMcpConfig(cwd);
 		const cache = loadMetadataCache();
 		if (!cache) return [];
-		return resolveMcpDirectToolNamesFromConfig(config, cache, getToolPrefix(config.settings?.toolPrefix), mcpDirectTools);
+		return resolveMcpDirectToolNamesFromConfig(
+			config,
+			cache,
+			getToolPrefix(config.settings?.toolPrefix),
+			mcpDirectTools,
+		);
 	} catch (error) {
 		console.error("Failed to resolve direct MCP tool names for subagent child allowlist:", error);
 		return [];
@@ -139,11 +146,17 @@ function validateConfig(raw: unknown): McpConfig {
 	const obj = raw as Record<string, unknown>;
 	const servers = obj.mcpServers ?? obj["mcp-servers"] ?? {};
 	return {
-		mcpServers: servers && typeof servers === "object" && !Array.isArray(servers) ? servers as Record<string, ServerEntry> : {},
-		imports: Array.isArray(obj.imports) ? obj.imports.filter((value): value is ImportKind => isImportKind(value)) : undefined,
-		settings: obj.settings && typeof obj.settings === "object" && !Array.isArray(obj.settings)
-			? obj.settings as McpConfig["settings"]
+		mcpServers:
+			servers && typeof servers === "object" && !Array.isArray(servers)
+				? (servers as Record<string, ServerEntry>)
+				: {},
+		imports: Array.isArray(obj.imports)
+			? obj.imports.filter((value): value is ImportKind => isImportKind(value))
 			: undefined,
+		settings:
+			obj.settings && typeof obj.settings === "object" && !Array.isArray(obj.settings)
+				? (obj.settings as McpConfig["settings"])
+				: undefined,
 	};
 }
 
@@ -192,13 +205,18 @@ function resolveImportPath(importKind: ImportKind, cwd: string): string | null {
 function extractServers(config: unknown, kind: ImportKind): Record<string, ServerEntry> {
 	if (!config || typeof config !== "object" || Array.isArray(config)) return {};
 	const obj = config as Record<string, unknown>;
-	const servers = kind === "windsurf" || kind === "vscode"
-		? obj.mcpServers ?? obj["mcp-servers"]
-		: obj.mcpServers;
-	return servers && typeof servers === "object" && !Array.isArray(servers) ? servers as Record<string, ServerEntry> : {};
-}
-
-export function resolveMcpDirectToolNamesFromConfig(config: McpConfig, cache: MetadataCache, prefix: ToolPrefix, envOverride: string[]): string[] {
+	const servers = kind === "windsurf" || kind === "vscode" ? (obj.mcpServers ?? obj["mcp-servers"]) : obj.mcpServers;
+	return servers && typeof servers === "object" && !Array.isArray(servers)
+		? (servers as Record<string, ServerEntry>)
+		: {};
+}
+
+export function resolveMcpDirectToolNamesFromConfig(
+	config: McpConfig,
+	cache: MetadataCache,
+	prefix: ToolPrefix,
+	envOverride: string[],
+): string[] {
 	const names: string[] = [];
 	const seenNames = new Set<string>();
 	const { servers: selectedServers, tools: selectedTools } = parseMcpDirectToolSelections(envOverride);
@@ -207,9 +225,7 @@ export function resolveMcpDirectToolNamesFromConfig(config: McpConfig, cache: Me
 		const serverCache = cache.servers[serverName];
 		if (!isServerCacheValid(serverCache, definition)) continue;
 
-		const toolFilter = selectedServers.has(serverName)
-			? true
-			: selectedTools.get(serverName);
+		const toolFilter = selectedServers.has(serverName) ? true : selectedTools.get(serverName);
 		if (!toolFilter) continue;
 
 		for (const tool of Array.isArray(serverCache.tools) ? serverCache.tools : []) {
@@ -224,7 +240,8 @@ export function resolveMcpDirectToolNamesFromConfig(config: McpConfig, cache: Me
 
 		if (definition.exposeResources === false) continue;
 		for (const resource of Array.isArray(serverCache.resources) ? serverCache.resources : []) {
-			if (typeof resource?.name !== "string" || !resource.name || typeof resource.uri !== "string" || !resource.uri) continue;
+			if (typeof resource?.name !== "string" || !resource.name || typeof resource.uri !== "string" || !resource.uri)
+				continue;
 			const baseName = `get_${resourceNameToToolName(resource.name)}`;
 			if (toolFilter !== true && !toolFilter.has(baseName)) continue;
 			if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools)) continue;
@@ -238,7 +255,10 @@ export function resolveMcpDirectToolNamesFromConfig(config: McpConfig, cache: Me
 	return names;
 }
 
-export function parseMcpDirectToolSelections(selections: string[]): { servers: Set<string>; tools: Map<string, Set<string>> } {
+export function parseMcpDirectToolSelections(selections: string[]): {
+	servers: Set<string>;
+	tools: Map<string, Set<string>>;
+} {
 	const servers = new Set<string>();
 	const tools = new Map<string, Set<string>>();
 	for (let item of selections) {
@@ -364,5 +384,8 @@ function stableStringify(value: unknown): string {
 	}
 	if (Array.isArray(value)) return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
 	const obj = value as Record<string, unknown>;
-	return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+	return `{${Object.keys(obj)
+		.sort()
+		.map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`)
+		.join(",")}}`;
 }

package/dist/builtin/subagents/src/runs/shared/model-candidate-filter.ts

@@ -40,14 +40,18 @@ export function filterSpawnableModelCandidates(params: {
 			continue;
 		}
 		const provider = providerFromModel(candidate);
-		const shouldSkip = provider !== undefined
-			&& knownProviders.has(provider)
-			&& !providersWithAvailableAuth.has(provider);
+		const shouldSkip =
+			provider !== undefined && knownProviders.has(provider) && !providersWithAvailableAuth.has(provider);
 		if (!shouldSkip) {
 			filtered.push(candidate);
 			continue;
 		}
-		skippedAttempts.push(skippedModelAttempt(candidate, `Skipped ${candidate}: provider '${provider}' has no configured API key/auth in the current session.`));
+		skippedAttempts.push(
+			skippedModelAttempt(
+				candidate,
+				`Skipped ${candidate}: provider '${provider}' has no configured API key/auth in the current session.`,
+			),
+		);
 	}
 	return { candidates: filtered, skippedAttempts };
 }

package/dist/builtin/subagents/src/runs/shared/model-fallback.ts

@@ -1,4 +1,8 @@
-import { THINKING_LEVELS, splitKnownThinkingSuffix, type ModelInfo as AvailableModelInfo } from "../../shared/model-info.ts";
+import {
+	type ModelInfo as AvailableModelInfo,
+	splitKnownThinkingSuffix,
+	THINKING_LEVELS,
+} from "../../shared/model-info.ts";
 import type { Usage } from "../../shared/types.ts";
 
 export type { AvailableModelInfo };
@@ -46,7 +50,9 @@ export function buildModelCandidates(
 ): string[] {
 	const seen = new Set<string>();
 	const candidates: string[] = [];
-	const fallbackEntries = (fallbackModels ?? []).map((model, index) => applyFallbackThinkingLevel(model, fallbackThinkingLevels?.[index]));
+	const fallbackEntries = (fallbackModels ?? []).map((model, index) =>
+		applyFallbackThinkingLevel(model, fallbackThinkingLevels?.[index]),
+	);
 	for (const raw of [primaryModel, ...fallbackEntries, currentModel]) {
 		if (!raw) continue;
 		const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
@@ -106,11 +112,7 @@ const NON_RETRYABLE_FAILURE_PATTERNS: readonly RegExp[] = [
 	/interrupted/i,
 ];
 
-const CANCELLED_FAILURE_PATTERNS: readonly RegExp[] = [
-	/cancel/i,
-	/abort/i,
-	/interrupted/i,
-];
+const CANCELLED_FAILURE_PATTERNS: readonly RegExp[] = [/cancel/i, /abort/i, /interrupted/i];
 
 export type ModelFallbackFailureKind =
 	| "auth_on_candidate_provider"
@@ -150,7 +152,7 @@ const FALLBACKABLE_FAILURE_KINDS: ReadonlySet<ModelFallbackFailureKind> = new Se
 ]);
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value !== null && typeof value === "object" ? value as Record<string, unknown> : undefined;
+	return value !== null && typeof value === "object" ? (value as Record<string, unknown>) : undefined;
 }
 
 function field(value: unknown, key: string): unknown {
@@ -167,9 +169,7 @@ function errorName(value: unknown): string | undefined {
 }
 
 function directMessageFrom(value: unknown): string | undefined {
-	return stringField(value, "errorMessage")
-		?? stringField(value, "message")
-		?? stringField(value, "statusText");
+	return stringField(value, "errorMessage") ?? stringField(value, "message") ?? stringField(value, "statusText");
 }
 
 function integerFrom(value: unknown): number | undefined {
@@ -180,9 +180,11 @@ function integerFrom(value: unknown): number | undefined {
 }
 
 function statusFrom(value: unknown): number | undefined {
-	return integerFrom(field(value, "status"))
-		?? integerFrom(field(value, "statusCode"))
-		?? integerFrom(field(value, "httpStatus"));
+	return (
+		integerFrom(field(value, "status")) ??
+		integerFrom(field(value, "statusCode")) ??
+		integerFrom(field(value, "httpStatus"))
+	);
 }
 
 function codeFrom(value: unknown): string | number | undefined {
@@ -226,7 +228,8 @@ function normalizeCode(value: string | number | undefined): string | undefined {
 function kindFromStatus(status: number | undefined): ModelFallbackFailureKind | undefined {
 	switch (status) {
 		case 400:
-		case 413: case 422:
+		case 413:
+		case 422:
 			return "request_incompatible";
 		case 401:
 		case 403:
@@ -244,13 +247,22 @@ function kindFromStatus(status: number | undefined): ModelFallbackFailureKind |
 }
 
 const REQUEST_INCOMPATIBLE_CODES: ReadonlySet<string> = new Set([
-	"invalid_request", "invalid_request_error", "bad_request", "context_length_exceeded",
-	"request_too_large", "too_large", "request_entity_too_large", "max_tokens",
-	"max_context_length", "context_window_exceeded",
+	"invalid_request",
+	"invalid_request_error",
+	"bad_request",
+	"context_length_exceeded",
+	"request_too_large",
+	"too_large",
+	"request_entity_too_large",
+	"max_tokens",
+	"max_context_length",
+	"context_window_exceeded",
 ]);
 function requestIncompatibleKindFromCode(code: string | number | undefined): ModelFallbackFailureKind | undefined {
 	const normalizedCode = normalizeCode(code);
-	return normalizedCode !== undefined && REQUEST_INCOMPATIBLE_CODES.has(normalizedCode) ? "request_incompatible" : undefined;
+	return normalizedCode !== undefined && REQUEST_INCOMPATIBLE_CODES.has(normalizedCode)
+		? "request_incompatible"
+		: undefined;
 }
 function refusalKindFromCode(code: string | number | undefined): ModelFallbackFailureKind | undefined {
 	const normalizedCode = normalizeCode(code);
@@ -274,12 +286,53 @@ function refusalKindFromCode(code: string | number | undefined): ModelFallbackFa
 }
 
 const CODE_KINDS_BY_KIND: ReadonlyArray<readonly [ModelFallbackFailureKind, ReadonlySet<string>]> = [
-	["auth_on_candidate_provider", new Set(["auth", "auth_required", "authentication_required", "unauthorized", "forbidden", "invalid_api_key", "missing_api_key", "invalid_key"])],
-	["network_timeout", new Set(["etimedout", "econnreset", "econnrefused", "enotfound", "eai_again", "fetch_failed", "network_error", "timeout", "timeout_error", "und_err_connect_timeout"])],
-	["rate_limit", new Set(["rate_limit", "rate_limit_exceeded", "too_many_requests", "quota_exceeded", "insufficient_quota", "usage_limit", "usage_limit_reached", "usage_limit_exceeded"])],
+	[
+		"auth_on_candidate_provider",
+		new Set([
+			"auth",
+			"auth_required",
+			"authentication_required",
+			"unauthorized",
+			"forbidden",
+			"invalid_api_key",
+			"missing_api_key",
+			"invalid_key",
+		]),
+	],
+	[
+		"network_timeout",
+		new Set([
+			"etimedout",
+			"econnreset",
+			"econnrefused",
+			"enotfound",
+			"eai_again",
+			"fetch_failed",
+			"network_error",
+			"timeout",
+			"timeout_error",
+			"und_err_connect_timeout",
+		]),
+	],
+	[
+		"rate_limit",
+		new Set([
+			"rate_limit",
+			"rate_limit_exceeded",
+			"too_many_requests",
+			"quota_exceeded",
+			"insufficient_quota",
+			"usage_limit",
+			"usage_limit_reached",
+			"usage_limit_exceeded",
+		]),
+	],
 	["cancelled", new Set(["aborterror", "aborted", "cancelled", "canceled"])],
 	["model_unavailable", new Set(["model_not_found", "model_unavailable", "model_disabled", "unknown_model"])],
-	["provider_unavailable", new Set(["provider_error", "api_error", "service_unavailable", "temporarily_unavailable", "overloaded"])],
+	[
+		"provider_unavailable",
+		new Set(["provider_error", "api_error", "service_unavailable", "temporarily_unavailable", "overloaded"]),
+	],
 ];
 function kindFromCode(code: string | number | undefined): ModelFallbackFailureKind | undefined {
 	const normalizedCode = normalizeCode(code);
@@ -327,9 +380,16 @@ function fallbackKindFromMessage(message: string, name: string | undefined): Mod
 	const nameKind = kindFromCode(name);
 	if (nameKind !== undefined) return nameKind;
 	if (!RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(message))) return undefined;
-	if (/rate\s*limit|too many requests|\b429\b|quota|usage[\s_-]*limit|billing|credit/i.test(message)) return "rate_limit";
-	if (/auth|unauthori[sz]ed|\b40[13]\b|api key|token expired|forbidden|invalid key/i.test(message)) return "auth_on_candidate_provider";
-	if (/model.*(?:unavailable|disabled|not found|unknown)|(?:unavailable|disabled|not found|unknown).*model/i.test(message)) return "model_unavailable";
+	if (/rate\s*limit|too many requests|\b429\b|quota|usage[\s_-]*limit|billing|credit/i.test(message))
+		return "rate_limit";
+	if (/auth|unauthori[sz]ed|\b40[13]\b|api key|token expired|forbidden|invalid key/i.test(message))
+		return "auth_on_candidate_provider";
+	if (
+		/model.*(?:unavailable|disabled|not found|unknown)|(?:unavailable|disabled|not found|unknown).*model/i.test(
+			message,
+		)
+	)
+		return "model_unavailable";
 	if (/network|fetch failed|socket|connection refused|timeout|timed? out/i.test(message)) return "network_timeout";
 	return "provider_unavailable";
 }
@@ -370,10 +430,16 @@ function fallbackSignalForMessage(
 	const kind = fallbackKindFromMessage(message, errorName(value));
 	return kind === undefined ? undefined : makeSignal(kind, value, source);
 }
-function fallbackSignalFromMessage(value: unknown, source: ModelFallbackFailureSource | undefined): ModelFallbackFailureSignal | undefined {
+function fallbackSignalFromMessage(
+	value: unknown,
+	source: ModelFallbackFailureSource | undefined,
+): ModelFallbackFailureSignal | undefined {
 	return fallbackSignalForMessage(modelFailureMessage(value), value, source);
 }
-function fallbackSignalFromDirectMessage(value: unknown, source: ModelFallbackFailureSource | undefined): ModelFallbackFailureSignal | undefined {
+function fallbackSignalFromDirectMessage(
+	value: unknown,
+	source: ModelFallbackFailureSource | undefined,
+): ModelFallbackFailureSignal | undefined {
 	return fallbackSignalForMessage(directMessageFrom(value), value, source);
 }
 
@@ -381,9 +447,10 @@ function classifyAssistantRefusalSignal(
 	value: unknown,
 	source: ModelFallbackFailureSource | undefined,
 ): ModelFallbackFailureSignal | undefined {
-	const codeRefusalKind = refusalKindFromCode(codeFrom(value))
-		?? refusalKindFromCode(errorName(value))
-		?? refusalKindFromCode(finishReasonFrom(value));
+	const codeRefusalKind =
+		refusalKindFromCode(codeFrom(value)) ??
+		refusalKindFromCode(errorName(value)) ??
+		refusalKindFromCode(finishReasonFrom(value));
 	if (codeRefusalKind !== undefined) return makeSignal(codeRefusalKind, value, source);
 
 	const messageRefusalKind = refusalKindFromMessage(directMessageFrom(value) ?? "");
@@ -415,15 +482,15 @@ function structuredSignal(
 	let firstNestedFallbackSignal: ModelFallbackFailureSignal | undefined;
 	const nestedSeen = new Set(seen);
 	for (const diagnosticError of diagnosticErrors(value)) {
-		const diagnosticSignal = structuredSignal(diagnosticError, nestedSeen, "diagnostic")
-			?? fallbackSignalFromMessage(diagnosticError, "diagnostic");
+		const diagnosticSignal =
+			structuredSignal(diagnosticError, nestedSeen, "diagnostic") ??
+			fallbackSignalFromMessage(diagnosticError, "diagnostic");
 		if (diagnosticSignal === undefined) continue;
 		if (isRefusalSignal(diagnosticSignal)) return diagnosticSignal;
 		firstNestedFallbackSignal ??= diagnosticSignal;
 	}
 	const cause = causeOf(value);
-	const causeSignal = structuredSignal(cause, nestedSeen, source)
-		?? fallbackSignalFromMessage(cause, source);
+	const causeSignal = structuredSignal(cause, nestedSeen, source) ?? fallbackSignalFromMessage(cause, source);
 	if (causeSignal !== undefined) {
 		if (isRefusalSignal(causeSignal)) return causeSignal;
 		firstNestedFallbackSignal ??= causeSignal;
@@ -477,9 +544,7 @@ export function normalizeModelFailureSignal(error: unknown): ModelFallbackFailur
 	if (structured !== undefined) return structured;
 	const message = modelFailureMessage(error);
 	const name = errorName(error);
-	const fallbackKind = message.trim().length > 0
-		? fallbackKindFromMessage(message, name)
-		: undefined;
+	const fallbackKind = message.trim().length > 0 ? fallbackKindFromMessage(message, name) : undefined;
 	return {
 		kind: fallbackKind ?? "unknown",
 		message,

package/dist/builtin/subagents/src/runs/shared/nested-events-control.ts

@@ -1,24 +1,24 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import {
-	SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
-	SUBAGENT_PARENT_CONTROL_INBOX_ENV,
-	SUBAGENT_PARENT_EVENT_SINK_ENV,
-	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
-} from "./pi-args.ts";
-import {
-	MAX_NESTED_EVENT_BYTES,
 	assertSafeId,
 	clampNumber,
 	containedPath,
 	isSafeNestedId,
-	stringValue,
-	validateRouteShape,
+	MAX_NESTED_EVENT_BYTES,
 	type NestedControlRequestRecord,
 	type NestedControlResultRecord,
 	type NestedRoute,
+	stringValue,
+	validateRouteShape,
 } from "./nested-events-core.ts";
 import { writeRouteRecord } from "./nested-events-registry.ts";
+import {
+	SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
+	SUBAGENT_PARENT_CONTROL_INBOX_ENV,
+	SUBAGENT_PARENT_EVENT_SINK_ENV,
+	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
+} from "./pi-args.ts";
 
 export function parseNestedControlRequest(content: string, route: NestedRoute): NestedControlRequestRecord | undefined {
 	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) return undefined;
@@ -75,7 +75,10 @@ export function parseNestedControlResult(content: string, route: NestedRoute): N
 	};
 }
 
-export function writeNestedControlRequest(route: NestedRoute, request: Omit<NestedControlRequestRecord, "type" | "rootRunId" | "capabilityToken">): string {
+export function writeNestedControlRequest(
+	route: NestedRoute,
+	request: Omit<NestedControlRequestRecord, "type" | "rootRunId" | "capabilityToken">,
+): string {
 	validateRouteShape(route);
 	assertSafeId("requestId", request.requestId);
 	assertSafeId("targetRunId", request.targetRunId);
@@ -90,11 +93,16 @@ export function writeNestedControlRequest(route: NestedRoute, request: Omit<Nest
 	return writeRouteRecord(route.controlInbox, sanitized.ts, sanitized);
 }
 
-export function readNestedControlRequests(route: NestedRoute): Array<NestedControlRequestRecord & { filePath: string }> {
+export function readNestedControlRequests(
+	route: NestedRoute,
+): Array<NestedControlRequestRecord & { filePath: string }> {
 	validateRouteShape(route);
 	let entries: string[] = [];
 	try {
-		entries = fs.readdirSync(route.controlInbox).filter((entry) => entry.endsWith(".json")).sort();
+		entries = fs
+			.readdirSync(route.controlInbox)
+			.filter((entry) => entry.endsWith(".json"))
+			.sort();
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
 	}
@@ -107,14 +115,15 @@ export function readNestedControlRequests(route: NestedRoute): Array<NestedContr
 			if (!stat.isFile() || stat.size > MAX_NESTED_EVENT_BYTES) continue;
 			const request = parseNestedControlRequest(fs.readFileSync(filePath, "utf-8"), route);
 			if (request) requests.push({ ...request, filePath });
-		} catch {
-			continue;
-		}
+		} catch {}
 	}
 	return requests;
 }
 
-export function writeNestedControlResult(route: NestedRoute, result: Omit<NestedControlResultRecord, "type" | "rootRunId" | "capabilityToken">): void {
+export function writeNestedControlResult(
+	route: NestedRoute,
+	result: Omit<NestedControlResultRecord, "type" | "rootRunId" | "capabilityToken">,
+): void {
 	validateRouteShape(route);
 	assertSafeId("requestId", result.requestId);
 	assertSafeId("targetRunId", result.targetRunId);
@@ -133,7 +142,10 @@ export function readNestedControlResults(route: NestedRoute): NestedControlResul
 	validateRouteShape(route);
 	let entries: string[] = [];
 	try {
-		entries = fs.readdirSync(route.eventSink).filter((entry) => entry.endsWith(".json") || entry.endsWith(".jsonl")).sort();
+		entries = fs
+			.readdirSync(route.eventSink)
+			.filter((entry) => entry.endsWith(".json") || entry.endsWith(".jsonl"))
+			.sort();
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
 	}
@@ -150,9 +162,7 @@ export function readNestedControlResults(route: NestedRoute): NestedControlResul
 				const result = parseNestedControlResult(line, route);
 				if (result) results.push(result);
 			}
-		} catch {
-			continue;
-		}
+		} catch {}
 	}
 	return results;
 }

package/dist/builtin/subagents/src/runs/shared/nested-events-core.ts

@@ -1,20 +1,20 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { TEMP_ROOT_DIR, type NestedRouteInfo, type NestedRunSummary } from "../../shared/types.ts";
-import { isSafeNestedPathId, parseNestedPathEnv, type NestedPathEntry } from "./nested-path.ts";
+import { getEnvValue } from "@bastani/atomic";
+import { type NestedRouteInfo, type NestedRunSummary, TEMP_ROOT_DIR } from "../../shared/types.ts";
+import { isSafeNestedPathId, type NestedPathEntry, parseNestedPathEnv } from "./nested-path.ts";
 import {
 	SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
 	SUBAGENT_PARENT_CHILD_INDEX_ENV,
 	SUBAGENT_PARENT_CONTROL_INBOX_ENV,
 	SUBAGENT_PARENT_DEPTH_ENV,
 	SUBAGENT_PARENT_EVENT_SINK_ENV,
+	SUBAGENT_PARENT_MAX_DEPTH,
 	SUBAGENT_PARENT_PATH_ENV,
 	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
 	SUBAGENT_PARENT_RUN_ID_ENV,
-	SUBAGENT_PARENT_MAX_DEPTH,
 } from "./pi-args.ts";
-import { getEnvValue } from "@bastani/atomic";
 
 export const NESTED_EVENTS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-events");
 export const NESTED_RUNS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-runs");
@@ -94,9 +94,12 @@ export function commonRouteRoot(route: Pick<NestedRoute, "eventSink" | "controlI
 export function validateNestedRouteShape(route: NestedRoute): void {
 	assertSafeId("rootRunId", route.rootRunId);
 	assertSafeId("capabilityToken", route.capabilityToken);
-	if (!containedPath(NESTED_EVENTS_DIR, route.eventSink)) throw new Error("Nested event sink is outside the subagent nested event root.");
-	if (!containedPath(NESTED_EVENTS_DIR, route.controlInbox)) throw new Error("Nested control inbox is outside the subagent nested event root.");
-	if (commonRouteRoot(route) !== path.dirname(path.resolve(route.controlInbox))) throw new Error("Nested event sink and control inbox must share one route root.");
+	if (!containedPath(NESTED_EVENTS_DIR, route.eventSink))
+		throw new Error("Nested event sink is outside the subagent nested event root.");
+	if (!containedPath(NESTED_EVENTS_DIR, route.controlInbox))
+		throw new Error("Nested control inbox is outside the subagent nested event root.");
+	if (commonRouteRoot(route) !== path.dirname(path.resolve(route.controlInbox)))
+		throw new Error("Nested event sink and control inbox must share one route root.");
 }
 
 export function validateRouteShape(route: NestedRoute): void {
@@ -111,28 +114,40 @@ export function createNestedRoute(rootRunId: string): NestedRoute {
 	const controlInbox = path.join(routeRoot, "controls");
 	fs.mkdirSync(eventSink, { recursive: true, mode: 0o700 });
 	fs.mkdirSync(controlInbox, { recursive: true, mode: 0o700 });
-	fs.writeFileSync(path.join(routeRoot, ROUTE_FILE), `${JSON.stringify({ rootRunId, capabilityToken, createdAt: Date.now() })}\n`, { mode: 0o600 });
+	fs.writeFileSync(
+		path.join(routeRoot, ROUTE_FILE),
+		`${JSON.stringify({ rootRunId, capabilityToken, createdAt: Date.now() })}\n`,
+		{ mode: 0o600 },
+	);
 	return { rootRunId, eventSink, controlInbox, capabilityToken };
 }
 
-function newestMtimeMs(filePath: string): number {
-	let newest = fs.statSync(filePath).mtimeMs;
+/** Whether any entry in the tree rooted at filePath has an mtime at or after cutoff, stopping at the first hit. */
+export function hasEntryNewerThan(filePath: string, cutoff: number): boolean {
+	const stat = fs.statSync(filePath);
+	if (stat.mtimeMs >= cutoff) return true;
+	if (!stat.isDirectory()) return false;
+	return directoryHasEntryNewerThan(filePath, cutoff);
+}
+
+function directoryHasEntryNewerThan(dirPath: string, cutoff: number): boolean {
 	let entries: string[];
 	try {
-		entries = fs.readdirSync(filePath);
+		entries = fs.readdirSync(dirPath);
 	} catch {
-		return newest;
+		return false;
 	}
 	for (const entry of entries) {
-		const childPath = path.join(filePath, entry);
+		const childPath = path.join(dirPath, entry);
 		try {
 			const stat = fs.statSync(childPath);
-			newest = Math.max(newest, stat.isDirectory() ? newestMtimeMs(childPath) : stat.mtimeMs);
+			if (stat.mtimeMs >= cutoff) return true;
+			if (stat.isDirectory() && directoryHasEntryNewerThan(childPath, cutoff)) return true;
 		} catch {
 			// Nested runtime cleanup is best-effort housekeeping.
 		}
 	}
-	return newest;
+	return false;
 }
 
 function cleanupOldSubdirectories(root: string, maxAgeDays: number): void {
@@ -147,7 +162,7 @@ function cleanupOldSubdirectories(root: string, maxAgeDays: number): void {
 	for (const entry of entries) {
 		const entryPath = path.join(root, entry);
 		try {
-			if (newestMtimeMs(entryPath) < cutoff) fs.rmSync(entryPath, { recursive: true, force: true });
+			if (!hasEntryNewerThan(entryPath, cutoff)) fs.rmSync(entryPath, { recursive: true, force: true });
 		} catch {
 			// Keep startup resilient if a child process removes or rewrites an entry while scanning.
 		}
@@ -175,7 +190,10 @@ export function resolveNestedRouteFromEnv(env: NodeJS.ProcessEnv = process.env):
 	const route = { rootRunId, eventSink, controlInbox, capabilityToken };
 	validateRouteShape(route);
 	const routeFile = path.join(commonRouteRoot(route), ROUTE_FILE);
-	const metadata = JSON.parse(fs.readFileSync(routeFile, "utf-8")) as { rootRunId?: unknown; capabilityToken?: unknown };
+	const metadata = JSON.parse(fs.readFileSync(routeFile, "utf-8")) as {
+		rootRunId?: unknown;
+		capabilityToken?: unknown;
+	};
 	if (metadata.rootRunId !== rootRunId || metadata.capabilityToken !== capabilityToken) {
 		throw new Error("Nested event route metadata does not match the provided root id and capability token.");
 	}
@@ -191,14 +209,21 @@ export function resolveInheritedNestedRouteFromEnv(env: NodeJS.ProcessEnv = proc
 	}
 }
 
-export function resolveNestedParentAddressFromEnv(env: NodeJS.ProcessEnv = process.env): { parentRunId: string; parentStepIndex?: number; depth: number; path: NestedPathEntry[] } | undefined {
+export function resolveNestedParentAddressFromEnv(
+	env: NodeJS.ProcessEnv = process.env,
+): { parentRunId: string; parentStepIndex?: number; depth: number; path: NestedPathEntry[] } | undefined {
 	const parentRunId = readSubagentEnv(env, SUBAGENT_PARENT_RUN_ID_ENV);
 	if (!isSafeNestedId(parentRunId)) return undefined;
 	const rawIndex = readSubagentEnv(env, SUBAGENT_PARENT_CHILD_INDEX_ENV);
 	const parentStepIndex = rawIndex && /^\d+$/.test(rawIndex) ? Number(rawIndex) : undefined;
-	const depth = Math.min(Math.max(1, clampNumber(Number(readSubagentEnv(env, SUBAGENT_PARENT_DEPTH_ENV))) ?? 1), MAX_NESTED_DEPTH);
+	const depth = Math.min(
+		Math.max(1, clampNumber(Number(readSubagentEnv(env, SUBAGENT_PARENT_DEPTH_ENV))) ?? 1),
+		MAX_NESTED_DEPTH,
+	);
 	const parsedPath = parseNestedPathEnv(readSubagentEnv(env, SUBAGENT_PARENT_PATH_ENV));
-	const nestedPath = parsedPath.length ? parsedPath : [{ runId: parentRunId, ...(parentStepIndex !== undefined ? { stepIndex: parentStepIndex } : {}) }];
+	const nestedPath = parsedPath.length
+		? parsedPath
+		: [{ runId: parentRunId, ...(parentStepIndex !== undefined ? { stepIndex: parentStepIndex } : {}) }];
 	return { parentRunId, ...(parentStepIndex !== undefined ? { parentStepIndex } : {}), depth, path: nestedPath };
 }