@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.1

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

@@ -1,935 +1,50 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-	ASYNC_DIR,
-	RESULTS_DIR,
-	TEMP_ROOT_DIR,
-	type AsyncJobState,
-	type AsyncStatus,
-	type NestedRouteInfo,
-	type NestedRunSummary,
-	type NestedRunState,
-	type NestedStepSummary,
-	type SubagentRunMode,
-	type SubagentState,
-} from "../../shared/types.ts";
-import { isSafeNestedPathId, parseNestedPathEnv, sanitizeNestedPath, type NestedPathEntry } 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_PATH_ENV,
-	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
-	SUBAGENT_PARENT_RUN_ID_ENV,
-	SUBAGENT_PARENT_MAX_DEPTH,
-} from "./pi-args.ts";
-import { APP_NAME, getEnvValue } from "@bastani/atomic";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
-
-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");
-const ROUTE_FILE = "route.json";
-const REGISTRY_FILE = "registry.json";
-export const MAX_NESTED_EVENT_BYTES = 64 * 1024;
-export const MAX_NESTED_STEPS = 12;
-export const MAX_NESTED_CHILDREN = 16;
-export const MAX_NESTED_DEPTH = SUBAGENT_PARENT_MAX_DEPTH;
-export const MAX_PROCESSED_NESTED_EVENTS = 20_000;
-const REGISTRY_LOCK_DIR = ".registry.lock";
-const REGISTRY_LOCK_TIMEOUT_MS = 2_000;
-const REGISTRY_LOCK_STALE_MS = 30_000;
-const REGISTRY_LOCK_POLL_MS = 10;
-
-type NestedStatusEventType = "subagent.nested.started" | "subagent.nested.updated" | "subagent.nested.completed";
-type NestedControlResultEventType = "subagent.nested.control-result";
-
-export type NestedRoute = NestedRouteInfo;
-
-export interface NestedEventRecord {
-	type: NestedStatusEventType;
-	ts: number;
-	rootRunId: string;
-	parentRunId: string;
-	parentStepIndex?: number;
-	capabilityToken: string;
-	child: NestedRunSummary;
-}
-
-export interface NestedControlResultRecord {
-	type: NestedControlResultEventType;
-	ts: number;
-	rootRunId: string;
-	capabilityToken: string;
-	requestId: string;
-	targetRunId: string;
-	ok: boolean;
-	message: string;
-}
-
-export interface NestedControlRequestRecord {
-	type: "subagent.nested.control-request";
-	ts: number;
-	rootRunId: string;
-	capabilityToken: string;
-	requestId: string;
-	targetRunId: string;
-	action: "interrupt" | "resume";
-	message?: string;
-}
-
-export interface NestedRegistry {
-	rootRunId: string;
-	updatedAt: number;
-	children: NestedRunSummary[];
-	processedEvents: string[];
-}
-
-export function isSafeNestedId(value: unknown): value is string {
-	return isSafeNestedPathId(value);
-}
-
-export function assertSafeNestedId(label: string, value: string): void {
-	if (!isSafeNestedId(value)) throw new Error(`${label} must be a non-empty safe id token.`);
-}
-
-function assertSafeId(label: string, value: string): void {
-	assertSafeNestedId(label, value);
-}
-
-function containedPath(base: string, candidate: string): boolean {
-	const resolvedBase = path.resolve(base);
-	const resolvedCandidate = path.resolve(candidate);
-	return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`);
-}
-
-function commonRouteRoot(route: Pick<NestedRoute, "eventSink" | "controlInbox">): string {
-	return path.dirname(path.resolve(route.eventSink));
-}
-
-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.");
-}
-
-function validateRouteShape(route: NestedRoute): void {
-	validateNestedRouteShape(route);
-}
-
-export function createNestedRoute(rootRunId: string): NestedRoute {
-	assertSafeId("rootRunId", rootRunId);
-	const capabilityToken = randomUUID();
-	const routeRoot = path.join(NESTED_EVENTS_DIR, `${rootRunId}-${capabilityToken}`);
-	const eventSink = path.join(routeRoot, "events");
-	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 });
-	return { rootRunId, eventSink, controlInbox, capabilityToken };
-}
-
-function newestMtimeMs(filePath: string): number {
-	let newest = fs.statSync(filePath).mtimeMs;
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(filePath);
-	} catch {
-		return newest;
-	}
-	for (const entry of entries) {
-		const childPath = path.join(filePath, entry);
-		try {
-			const stat = fs.statSync(childPath);
-			newest = Math.max(newest, stat.isDirectory() ? newestMtimeMs(childPath) : stat.mtimeMs);
-		} catch {
-			// Nested runtime cleanup is best-effort housekeeping.
-		}
-	}
-	return newest;
-}
-
-function cleanupOldSubdirectories(root: string, maxAgeDays: number): void {
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(root);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-		throw error;
-	}
-	const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-	for (const entry of entries) {
-		const entryPath = path.join(root, entry);
-		try {
-			if (newestMtimeMs(entryPath) < cutoff) fs.rmSync(entryPath, { recursive: true, force: true });
-		} catch {
-			// Keep startup resilient if a child process removes or rewrites an entry while scanning.
-		}
-	}
-}
-
-export function cleanupOldNestedRuntimeDirs(maxAgeDays: number): void {
-	cleanupOldSubdirectories(NESTED_EVENTS_DIR, maxAgeDays);
-	cleanupOldSubdirectories(NESTED_RUNS_DIR, maxAgeDays);
-}
-
-function readSubagentEnv(env: NodeJS.ProcessEnv, name: string): string | undefined {
-	if (env === process.env) return getEnvValue(name);
-	// Atomic keeps reading legacy pi-prefixed env vars so older parent processes can route nested children.
-	const legacyName = name.replace(/^[A-Z0-9]+_/, "PI_");
-	return env[name] ?? (legacyName === name ? undefined : env[legacyName]);
-}
-
-export function resolveNestedRouteFromEnv(env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
-	const rootRunId = readSubagentEnv(env, SUBAGENT_PARENT_ROOT_RUN_ID_ENV);
-	const eventSink = readSubagentEnv(env, SUBAGENT_PARENT_EVENT_SINK_ENV);
-	const controlInbox = readSubagentEnv(env, SUBAGENT_PARENT_CONTROL_INBOX_ENV);
-	const capabilityToken = readSubagentEnv(env, SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV);
-	if (!rootRunId || !eventSink || !controlInbox || !capabilityToken) return undefined;
-	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 };
-	if (metadata.rootRunId !== rootRunId || metadata.capabilityToken !== capabilityToken) {
-		throw new Error("Nested event route metadata does not match the provided root id and capability token.");
-	}
-	return route;
-}
-
-export function resolveInheritedNestedRouteFromEnv(env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
-	try {
-		return resolveNestedRouteFromEnv(env);
-	} catch (error) {
-		console.error("Ignoring invalid nested subagent event route:", error);
-		return 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 parsedPath = parseNestedPathEnv(readSubagentEnv(env, SUBAGENT_PARENT_PATH_ENV));
-	const nestedPath = parsedPath.length ? parsedPath : [{ runId: parentRunId, ...(parentStepIndex !== undefined ? { stepIndex: parentStepIndex } : {}) }];
-	return { parentRunId, ...(parentStepIndex !== undefined ? { parentStepIndex } : {}), depth, path: nestedPath };
-}
-
-export function resolveNestedAsyncDir(rootRunId: string, run: NestedRunSummary): string | undefined {
-	if (!run.asyncDir) return undefined;
-	const resolved = path.resolve(run.asyncDir);
-	const nestedRoot = path.resolve(NESTED_RUNS_DIR, rootRunId, run.id);
-	const relative = path.relative(nestedRoot, resolved);
-	return resolved === nestedRoot || (!relative.startsWith("..") && !path.isAbsolute(relative)) ? resolved : undefined;
-}
-
-function clampNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function stringValue(value: unknown, max = 512): string | undefined {
-	return typeof value === "string" && value.length > 0 ? value.slice(0, max) : undefined;
-}
-
-function sanitizeTokenUsage(value: unknown): NestedRunSummary["totalTokens"] | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const raw = value as Record<string, unknown>;
-	const input = clampNumber(raw.input);
-	const output = clampNumber(raw.output);
-	const total = clampNumber(raw.total);
-	return input !== undefined && output !== undefined && total !== undefined
-		? { input, output, total }
-		: undefined;
-}
-
-function sanitizeState(value: unknown, fallback: NestedRunState): NestedRunState {
-	return value === "queued" || value === "running" || value === "complete" || value === "failed" || value === "paused"
-		? value
-		: fallback;
-}
-
-function sanitizeStep(input: unknown, depth: number): NestedStepSummary | undefined {
-	if (!input || typeof input !== "object") return undefined;
-	const raw = input as Record<string, unknown>;
-	const agent = stringValue(raw.agent, 128);
-	if (!agent) return undefined;
-	const status = raw.status === "pending" || raw.status === "running" || raw.status === "complete" || raw.status === "completed" || raw.status === "failed" || raw.status === "paused"
-		? raw.status
-		: "pending";
-	return {
-		agent,
-		status: status === "completed" ? "complete" : status,
-		...(stringValue(raw.sessionFile, 2048) ? { sessionFile: stringValue(raw.sessionFile, 2048) } : {}),
-		...(raw.activityState === "active_long_running" || raw.activityState === "needs_attention" ? { activityState: raw.activityState } : {}),
-		...(clampNumber(raw.lastActivityAt) !== undefined ? { lastActivityAt: clampNumber(raw.lastActivityAt) } : {}),
-		...(stringValue(raw.currentTool, 128) ? { currentTool: stringValue(raw.currentTool, 128) } : {}),
-		...(clampNumber(raw.currentToolStartedAt) !== undefined ? { currentToolStartedAt: clampNumber(raw.currentToolStartedAt) } : {}),
-		...(stringValue(raw.currentPath, 2048) ? { currentPath: stringValue(raw.currentPath, 2048) } : {}),
-		...(clampNumber(raw.turnCount) !== undefined ? { turnCount: clampNumber(raw.turnCount) } : {}),
-		...(clampNumber(raw.toolCount) !== undefined ? { toolCount: clampNumber(raw.toolCount) } : {}),
-		...(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) } : {}),
-		...(depth < MAX_NESTED_DEPTH && Array.isArray(raw.children) ? { children: raw.children.map((child) => sanitizeSummary(child, depth + 1)).filter((child): child is NestedRunSummary => Boolean(child)).slice(0, MAX_NESTED_CHILDREN) } : {}),
-	};
-}
-
-export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | undefined {
-	if (!input || typeof input !== "object") return undefined;
-	const raw = input as Record<string, unknown>;
-	if (!isSafeNestedId(raw.id) || !isSafeNestedId(raw.parentRunId)) return undefined;
-	const pathParts = sanitizeNestedPath(raw.path);
-	const steps = Array.isArray(raw.steps)
-		? raw.steps.map((step) => sanitizeStep(step, depth + 1)).filter((step): step is NestedStepSummary => Boolean(step)).slice(0, MAX_NESTED_STEPS)
-		: undefined;
-	const totalTokens = sanitizeTokenUsage(raw.totalTokens);
-	return {
-		id: raw.id,
-		parentRunId: raw.parentRunId,
-		...(clampNumber(raw.parentStepIndex) !== undefined ? { parentStepIndex: clampNumber(raw.parentStepIndex) } : {}),
-		...(stringValue(raw.parentAgent, 128) ? { parentAgent: stringValue(raw.parentAgent, 128) } : {}),
-		depth: Math.min(Math.max(0, clampNumber(raw.depth) ?? 0), MAX_NESTED_DEPTH),
-		path: pathParts,
-		state: sanitizeState(raw.state, "running"),
-		...(stringValue(raw.asyncDir, 2048) ? { asyncDir: stringValue(raw.asyncDir, 2048) } : {}),
-		...(clampNumber(raw.pid) !== undefined && clampNumber(raw.pid)! > 0 && Number.isInteger(clampNumber(raw.pid)) ? { pid: clampNumber(raw.pid) } : {}),
-		...(stringValue(raw.sessionId, 256) ? { sessionId: stringValue(raw.sessionId, 256) } : {}),
-		...(stringValue(raw.sessionFile, 2048) ? { sessionFile: stringValue(raw.sessionFile, 2048) } : {}),
-		...(stringValue(raw.intercomTarget, 256) ? { intercomTarget: stringValue(raw.intercomTarget, 256) } : {}),
-		...(stringValue(raw.ownerIntercomTarget, 256) ? { ownerIntercomTarget: stringValue(raw.ownerIntercomTarget, 256) } : {}),
-		...(stringValue(raw.leafIntercomTarget, 256) ? { leafIntercomTarget: stringValue(raw.leafIntercomTarget, 256) } : {}),
-		...(raw.ownerState === "live" || raw.ownerState === "gone" || raw.ownerState === "unknown" ? { ownerState: raw.ownerState } : {}),
-		...(stringValue(raw.controlInbox, 2048) ? { controlInbox: stringValue(raw.controlInbox, 2048) } : {}),
-		...(stringValue(raw.capabilityToken, 128) ? { capabilityToken: stringValue(raw.capabilityToken, 128) } : {}),
-		...(raw.mode === "single" || raw.mode === "parallel" || raw.mode === "chain" ? { mode: raw.mode } : {}),
-		...(stringValue(raw.agent, 128) ? { agent: stringValue(raw.agent, 128) } : {}),
-		...(Array.isArray(raw.agents) ? { agents: raw.agents.map((agent) => stringValue(agent, 128)).filter((agent): agent is string => Boolean(agent)).slice(0, MAX_NESTED_STEPS) } : {}),
-		...(clampNumber(raw.currentStep) !== undefined ? { currentStep: clampNumber(raw.currentStep) } : {}),
-		...(clampNumber(raw.chainStepCount) !== undefined ? { chainStepCount: clampNumber(raw.chainStepCount) } : {}),
-		...(raw.activityState === "active_long_running" || raw.activityState === "needs_attention" ? { activityState: raw.activityState } : {}),
-		...(clampNumber(raw.lastActivityAt) !== undefined ? { lastActivityAt: clampNumber(raw.lastActivityAt) } : {}),
-		...(stringValue(raw.currentTool, 128) ? { currentTool: stringValue(raw.currentTool, 128) } : {}),
-		...(clampNumber(raw.currentToolStartedAt) !== undefined ? { currentToolStartedAt: clampNumber(raw.currentToolStartedAt) } : {}),
-		...(stringValue(raw.currentPath, 2048) ? { currentPath: stringValue(raw.currentPath, 2048) } : {}),
-		...(clampNumber(raw.turnCount) !== undefined ? { turnCount: clampNumber(raw.turnCount) } : {}),
-		...(clampNumber(raw.toolCount) !== undefined ? { toolCount: clampNumber(raw.toolCount) } : {}),
-		...(totalTokens ? { totalTokens } : {}),
-		...(clampNumber(raw.startedAt) !== undefined ? { startedAt: clampNumber(raw.startedAt) } : {}),
-		...(clampNumber(raw.endedAt) !== undefined ? { endedAt: clampNumber(raw.endedAt) } : {}),
-		...(clampNumber(raw.lastUpdate) !== undefined ? { lastUpdate: clampNumber(raw.lastUpdate) } : {}),
-		...(stringValue(raw.error, 1024) ? { error: stringValue(raw.error, 1024) } : {}),
-		...(steps && steps.length > 0 ? { steps } : {}),
-		...(depth < MAX_NESTED_DEPTH && Array.isArray(raw.children) ? { children: raw.children.map((child) => sanitizeSummary(child, depth + 1)).filter((child): child is NestedRunSummary => Boolean(child)).slice(0, MAX_NESTED_CHILDREN) } : {}),
-	};
-}
-
-function parseRecord(content: string, route: NestedRoute): NestedEventRecord | undefined {
-	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) return undefined;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		return undefined;
-	}
-	if (!parsed || typeof parsed !== "object") return undefined;
-	const raw = parsed as Record<string, unknown>;
-	if (raw.type !== "subagent.nested.started" && raw.type !== "subagent.nested.updated" && raw.type !== "subagent.nested.completed") return undefined;
-	if (raw.rootRunId !== route.rootRunId || raw.capabilityToken !== route.capabilityToken) return undefined;
-	if (!isSafeNestedId(raw.parentRunId)) return undefined;
-	const ts = clampNumber(raw.ts);
-	if (ts === undefined) return undefined;
-	const child = sanitizeSummary(raw.child);
-	if (!child || child.id === route.rootRunId) return undefined;
-	const routedChild: NestedRunSummary = {
-		...child,
-		controlInbox: route.controlInbox,
-		capabilityToken: route.capabilityToken,
-		ownerState: child.ownerState ?? "unknown",
-	};
-	return {
-		type: raw.type,
-		ts,
-		rootRunId: route.rootRunId,
-		parentRunId: raw.parentRunId,
-		...(clampNumber(raw.parentStepIndex) !== undefined ? { parentStepIndex: clampNumber(raw.parentStepIndex) } : {}),
-		capabilityToken: route.capabilityToken,
-		child: routedChild,
-	};
-}
-
-export function parseNestedEventRecords(content: string, route: NestedRoute): NestedEventRecord[] {
-	if (!content.includes("\n")) {
-		const record = parseRecord(content.trim(), route);
-		return record ? [record] : [];
-	}
-	return content.split("\n")
-		.slice(0, content.endsWith("\n") ? undefined : -1)
-		.map((line) => line.trim() ? parseRecord(line, route) : undefined)
-		.filter((event): event is NestedEventRecord => Boolean(event));
-}
-
-function terminal(state: NestedRunState): boolean {
-	return state === "complete" || state === "failed" || state === "paused";
-}
-
-function mergeSummary(existing: NestedRunSummary | undefined, event: NestedEventRecord): NestedRunSummary {
-	const incomingState = event.type === "subagent.nested.completed" && event.child.state === "running" ? "complete" : event.child.state;
-	const incoming = { ...event.child, state: incomingState, lastUpdate: event.child.lastUpdate ?? event.ts };
-	if (!existing) return incoming;
-	const existingUpdate = existing.lastUpdate ?? 0;
-	const incomingUpdate = incoming.lastUpdate ?? event.ts;
-	if (incomingUpdate < existingUpdate) return existing;
-	if (terminal(existing.state) && !terminal(incoming.state)) return existing;
-	if (terminal(existing.state) && terminal(incoming.state) && incomingUpdate === existingUpdate) return existing;
-	return { ...existing, ...incoming, state: incoming.state, lastUpdate: Math.max(existingUpdate, incomingUpdate) };
-}
-
-function attachChild(children: NestedRunSummary[], event: NestedEventRecord): NestedRunSummary[] {
-	let updated = false;
-	const walk = (items: NestedRunSummary[]): NestedRunSummary[] => items.map((item) => {
-		if (item.id === event.parentRunId) {
-			const existingChildren = item.children ?? [];
-			const childIndex = existingChildren.findIndex((child) => child.id === event.child.id);
-			const nextChild = mergeSummary(childIndex >= 0 ? existingChildren[childIndex] : undefined, event);
-			const nextChildren = childIndex >= 0
-				? existingChildren.map((child, index) => index === childIndex ? nextChild : child)
-				: [...existingChildren, nextChild];
-			updated = true;
-			return { ...item, children: nextChildren.slice(0, MAX_NESTED_CHILDREN), lastUpdate: Math.max(item.lastUpdate ?? 0, event.ts) };
-		}
-		if (!item.children?.length) return item;
-		const nextChildren = walk(item.children);
-		return nextChildren === item.children ? item : { ...item, children: nextChildren };
-	});
-	const next = walk(children);
-	if (updated) return next;
-	const childIndex = next.findIndex((child) => child.id === event.child.id);
-	const nextChild = mergeSummary(childIndex >= 0 ? next[childIndex] : undefined, event);
-	return childIndex >= 0
-		? next.map((child, index) => index === childIndex ? nextChild : child)
-		: [...next, nextChild].slice(0, MAX_NESTED_CHILDREN);
-}
-
-export function applyNestedEvent(registry: NestedRegistry, event: NestedEventRecord): NestedRegistry {
-	return {
-		...registry,
-		updatedAt: Math.max(registry.updatedAt, event.ts),
-		children: attachChild(registry.children, event),
-	};
-}
-
-function registryPath(route: NestedRoute): string {
-	return path.join(commonRouteRoot(route), REGISTRY_FILE);
-}
-
-function registryLockPath(route: NestedRoute): string {
-	return path.join(commonRouteRoot(route), REGISTRY_LOCK_DIR);
-}
-
-function sleepSync(ms: number): void {
-	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
-function acquireRegistryLock(route: NestedRoute): () => void {
-	const lockPath = registryLockPath(route);
-	const deadline = Date.now() + REGISTRY_LOCK_TIMEOUT_MS;
-	while (true) {
-		try {
-			fs.mkdirSync(lockPath, { mode: 0o700 });
-			try {
-				fs.writeFileSync(path.join(lockPath, "owner.json"), `${JSON.stringify({ pid: process.pid, createdAt: Date.now() })}\n`, { mode: 0o600 });
-			} catch {
-				// Lock ownership metadata is diagnostic only.
-			}
-			return () => fs.rmSync(lockPath, { recursive: true, force: true });
-		} catch (error) {
-			const code = (error as NodeJS.ErrnoException).code;
-			if (code !== "EEXIST") throw error;
-			try {
-				const stat = fs.statSync(lockPath);
-				if (Date.now() - stat.mtimeMs > REGISTRY_LOCK_STALE_MS) {
-					fs.rmSync(lockPath, { recursive: true, force: true });
-					continue;
-				}
-			} catch (statError) {
-				if ((statError as NodeJS.ErrnoException).code !== "ENOENT") throw statError;
-				continue;
-			}
-			if (Date.now() >= deadline) throw new Error(`Timed out waiting for nested registry lock for root '${route.rootRunId}'.`);
-			sleepSync(REGISTRY_LOCK_POLL_MS);
-		}
-	}
-}
-
-export function findNestedRouteForRootId(rootRunId: string): NestedRoute | undefined {
-	assertSafeId("rootRunId", rootRunId);
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(NESTED_EVENTS_DIR);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		throw error;
-	}
-	for (const entry of entries) {
-		if (!entry.startsWith(`${rootRunId}-`)) continue;
-		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 (metadata.rootRunId !== rootRunId || typeof metadata.capabilityToken !== "string") continue;
-			const route = {
-				rootRunId,
-				eventSink: path.join(routeRoot, "events"),
-				controlInbox: path.join(routeRoot, "controls"),
-				capabilityToken: metadata.capabilityToken,
-			};
-			validateRouteShape(route);
-			return route;
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-				console.error(`Ignoring unreadable nested route metadata under '${routeRoot}':`, error);
-			}
-			continue;
-		}
-	}
-	return undefined;
-}
-
-export function projectNestedRegistryForRoot(rootRunId: string): NestedRegistry | undefined {
-	const route = findNestedRouteForRootId(rootRunId);
-	return route ? projectNestedEvents(route) : undefined;
-}
-
-export function findNestedRun(children: NestedRunSummary[] | undefined, id: string): NestedRunSummary | undefined {
-	if (!children?.length) return undefined;
-	for (const child of children) {
-		if (child.id === id) return child;
-		const nested = findNestedRun(child.children, id) ?? findNestedRun(child.steps?.flatMap((step) => step.children ?? []), id);
-		if (nested) return nested;
-	}
-	return undefined;
-}
-
-export interface NestedRunMatch {
-	rootRunId: string;
-	route: NestedRoute;
-	run: NestedRunSummary;
-}
-
-export interface NestedRunResolutionScope {
-	routes: NestedRoute[];
-	descendantOf?: { parentRunId: string; parentStepIndex?: number };
-}
-
-function collectNestedRuns(children: NestedRunSummary[] | undefined, output: NestedRunSummary[] = []): NestedRunSummary[] {
-	for (const child of children ?? []) {
-		output.push(child);
-		collectNestedRuns(child.children, output);
-		collectNestedRuns(child.steps?.flatMap((step) => step.children ?? []), output);
-	}
-	return output;
-}
-
-function collectScopedNestedRuns(children: NestedRunSummary[] | undefined, scope: NestedRunResolutionScope["descendantOf"], output: NestedRunSummary[] = []): NestedRunSummary[] {
-	if (!scope) return collectNestedRuns(children, output);
-	for (const child of children ?? []) {
-		if (child.parentRunId === scope.parentRunId && (scope.parentStepIndex === undefined || child.parentStepIndex === scope.parentStepIndex)) {
-			collectNestedRuns([child], output);
-			continue;
-		}
-		collectScopedNestedRuns(child.children, scope, output);
-		collectScopedNestedRuns(child.steps?.flatMap((step) => step.children ?? []), scope, output);
-	}
-	return output;
-}
-
-function listNestedRoutes(): NestedRoute[] {
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(NESTED_EVENTS_DIR);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw error;
-	}
-	const routes: 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;
-			const route = {
-				rootRunId: metadata.rootRunId,
-				eventSink: path.join(routeRoot, "events"),
-				controlInbox: path.join(routeRoot, "controls"),
-				capabilityToken: metadata.capabilityToken,
-			};
-			validateRouteShape(route);
-			routes.push(route);
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-				console.error(`Ignoring unreadable nested route metadata under '${routeRoot}':`, error);
-			}
-			continue;
-		}
-	}
-	return routes;
-}
-
-export function findNestedRunMatchesById(id: string, options: { prefix?: boolean; scope?: NestedRunResolutionScope } = {}): NestedRunMatch[] {
-	assertSafeId("id", id);
-	const matches: NestedRunMatch[] = [];
-	for (const route of options.scope?.routes ?? listNestedRoutes()) {
-		try {
-			const registry = projectNestedEvents(route);
-			for (const run of collectScopedNestedRuns(registry.children, options.scope?.descendantOf)) {
-				if (options.prefix ? run.id.startsWith(id) : run.id === id) matches.push({ rootRunId: route.rootRunId, route, run });
-			}
-		} catch {
-			continue;
-		}
-	}
-	return matches;
-}
-
-export function findNestedRunById(id: string): { rootRunId: string; run: NestedRunSummary } | undefined {
-	const match = findNestedRunMatchesById(id)[0];
-	return match ? { rootRunId: match.rootRunId, run: match.run } : undefined;
-}
-
-export function readNestedRegistry(route: NestedRoute): NestedRegistry {
-	validateRouteShape(route);
-	try {
-		const parsed = JSON.parse(fs.readFileSync(registryPath(route), "utf-8")) as NestedRegistry;
-		return {
-			rootRunId: route.rootRunId,
-			updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : 0,
-			children: Array.isArray(parsed.children) ? parsed.children.map((child) => sanitizeSummary(child)).filter((child): child is NestedRunSummary => Boolean(child)) : [],
-			processedEvents: Array.isArray(parsed.processedEvents) ? parsed.processedEvents.filter((item): item is string => typeof item === "string").slice(-MAX_PROCESSED_NESTED_EVENTS) : [],
-		};
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-		return { rootRunId: route.rootRunId, updatedAt: 0, children: [], processedEvents: [] };
-	}
-}
-
-export function projectNestedEvents(route: NestedRoute): NestedRegistry {
-	validateRouteShape(route);
-	const release = acquireRegistryLock(route);
-	try {
-		let registry = readNestedRegistry(route);
-		const seen = new Set(registry.processedEvents);
-		let changed = false;
-		let entries: string[] = [];
-		try {
-			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;
-		}
-		for (const entry of entries) {
-			if (seen.has(entry)) continue;
-			const eventPath = path.join(route.eventSink, entry);
-			if (!containedPath(route.eventSink, eventPath)) continue;
-			let content: string;
-			try {
-				const stat = fs.statSync(eventPath);
-				if (!stat.isFile() || stat.size > MAX_NESTED_EVENT_BYTES) continue;
-				content = fs.readFileSync(eventPath, "utf-8");
-			} catch {
-				continue;
-			}
-			for (const event of parseNestedEventRecords(content, route)) {
-				registry = applyNestedEvent(registry, event);
-				changed = true;
-			}
-			seen.add(entry);
-			changed = true;
-		}
-		if (changed) {
-			// Event files are immutable; retain enough filenames for worst-case bounded fanout without unbounded registry growth.
-			registry = { ...registry, processedEvents: [...seen].slice(-MAX_PROCESSED_NESTED_EVENTS) };
-			// Registry projection is lock-serialized across parent and fanout-child processes.
-			// Child and runner processes only create immutable event files, so parent status.json
-			// remains owned by the existing runner writer and is never rewritten here.
-			writeAtomicJson(registryPath(route), registry);
-		}
-		return registry;
-	} finally {
-		release();
-	}
-}
-
-function writeRouteRecord(dir: string, ts: number, payload: object): string {
-	const content = `${JSON.stringify(payload)}\n`;
-	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) throw new Error("Nested route record exceeds the maximum size.");
-	fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-	const name = `${String(ts).padStart(13, "0")}-${randomUUID()}.json`;
-	const tmp = path.join(dir, `.${name}.tmp`);
-	const finalPath = path.join(dir, name);
-	fs.writeFileSync(tmp, content, { mode: 0o600 });
-	fs.renameSync(tmp, finalPath);
-	return finalPath;
-}
-
-export function writeNestedEvent(route: NestedRoute, event: Omit<NestedEventRecord, "rootRunId" | "capabilityToken">): void {
-	// Child and runner processes append immutable route events; parent projection owns registry/status aggregation.
-	validateRouteShape(route);
-	const record: NestedEventRecord = {
-		...event,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-	};
-	const sanitized = parseRecord(JSON.stringify(record), route);
-	if (!sanitized) throw new Error("Nested event record failed validation.");
-	writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
-}
-
-export function parseNestedControlRequest(content: string, route: NestedRoute): NestedControlRequestRecord | undefined {
-	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) return undefined;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		return undefined;
-	}
-	if (!parsed || typeof parsed !== "object") return undefined;
-	const raw = parsed as Record<string, unknown>;
-	if (raw.type !== "subagent.nested.control-request") return undefined;
-	if (raw.rootRunId !== route.rootRunId || raw.capabilityToken !== route.capabilityToken) return undefined;
-	if (!isSafeNestedId(raw.requestId) || !isSafeNestedId(raw.targetRunId)) return undefined;
-	if (raw.action !== "interrupt" && raw.action !== "resume") return undefined;
-	const ts = clampNumber(raw.ts);
-	if (ts === undefined) return undefined;
-	return {
-		type: "subagent.nested.control-request",
-		ts,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-		requestId: raw.requestId,
-		targetRunId: raw.targetRunId,
-		action: raw.action,
-		...(stringValue(raw.message, 16_000) ? { message: stringValue(raw.message, 16_000) } : {}),
-	};
-}
-
-export function parseNestedControlResult(content: string, route: NestedRoute): NestedControlResultRecord | undefined {
-	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) return undefined;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		return undefined;
-	}
-	if (!parsed || typeof parsed !== "object") return undefined;
-	const raw = parsed as Record<string, unknown>;
-	if (raw.type !== "subagent.nested.control-result") return undefined;
-	if (raw.rootRunId !== route.rootRunId || raw.capabilityToken !== route.capabilityToken) return undefined;
-	if (!isSafeNestedId(raw.requestId) || !isSafeNestedId(raw.targetRunId)) return undefined;
-	const ts = clampNumber(raw.ts);
-	if (ts === undefined || typeof raw.ok !== "boolean") return undefined;
-	return {
-		type: "subagent.nested.control-result",
-		ts,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-		requestId: raw.requestId,
-		targetRunId: raw.targetRunId,
-		ok: raw.ok,
-		message: stringValue(raw.message, 16_000) ?? (raw.ok ? "Control request completed." : "Control request failed."),
-	};
-}
-
-export function writeNestedControlRequest(route: NestedRoute, request: Omit<NestedControlRequestRecord, "type" | "rootRunId" | "capabilityToken">): string {
-	validateRouteShape(route);
-	assertSafeId("requestId", request.requestId);
-	assertSafeId("targetRunId", request.targetRunId);
-	const record: NestedControlRequestRecord = {
-		type: "subagent.nested.control-request",
-		...request,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-	};
-	const sanitized = parseNestedControlRequest(JSON.stringify(record), route);
-	if (!sanitized) throw new Error("Nested control request failed validation.");
-	return writeRouteRecord(route.controlInbox, sanitized.ts, sanitized);
-}
-
-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();
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-	}
-	const requests: Array<NestedControlRequestRecord & { filePath: string }> = [];
-	for (const entry of entries) {
-		const filePath = path.join(route.controlInbox, entry);
-		if (!containedPath(route.controlInbox, filePath)) continue;
-		try {
-			const stat = fs.statSync(filePath);
-			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;
-		}
-	}
-	return requests;
-}
-
-export function writeNestedControlResult(route: NestedRoute, result: Omit<NestedControlResultRecord, "type" | "rootRunId" | "capabilityToken">): void {
-	validateRouteShape(route);
-	assertSafeId("requestId", result.requestId);
-	assertSafeId("targetRunId", result.targetRunId);
-	const record: NestedControlResultRecord = {
-		type: "subagent.nested.control-result",
-		...result,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-	};
-	const sanitized = parseNestedControlResult(JSON.stringify(record), route);
-	if (!sanitized) throw new Error("Nested control result failed validation.");
-	writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
-}
-
-export function readNestedControlResults(route: NestedRoute): NestedControlResultRecord[] {
-	validateRouteShape(route);
-	let entries: string[] = [];
-	try {
-		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;
-	}
-	const results: NestedControlResultRecord[] = [];
-	for (const entry of entries) {
-		const eventPath = path.join(route.eventSink, entry);
-		if (!containedPath(route.eventSink, eventPath)) continue;
-		try {
-			const stat = fs.statSync(eventPath);
-			if (!stat.isFile() || stat.size > MAX_NESTED_EVENT_BYTES) continue;
-			const content = fs.readFileSync(eventPath, "utf-8");
-			const lines = content.includes("\n") ? content.split("\n").filter((line) => line.trim()) : [content];
-			for (const line of lines) {
-				const result = parseNestedControlResult(line, route);
-				if (result) results.push(result);
-			}
-		} catch {
-			continue;
-		}
-	}
-	return results;
-}
-
-export function nestedRouteEnv(route: NestedRoute): Record<string, string> {
-	return {
-		[SUBAGENT_PARENT_EVENT_SINK_ENV]: route.eventSink,
-		[SUBAGENT_PARENT_CONTROL_INBOX_ENV]: route.controlInbox,
-		[SUBAGENT_PARENT_ROOT_RUN_ID_ENV]: route.rootRunId,
-		[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]: route.capabilityToken,
-	};
-}
-
-export function attachRootChildrenToSteps<T extends { children?: NestedRunSummary[]; index?: number }>(rootRunId: string, steps: T[] | undefined, children: NestedRunSummary[] | undefined): void {
-	if (!steps?.length) return;
-	for (const step of steps) {
-		step.children = undefined;
-	}
-	if (!children?.length) return;
-	for (const child of children) {
-		if (child.parentRunId !== rootRunId || child.parentStepIndex === undefined) continue;
-		const step = steps.find((candidate, index) => (candidate.index ?? index) === child.parentStepIndex);
-		if (!step) continue;
-		step.children ??= [];
-		step.children = [...step.children.filter((existing) => existing.id !== child.id), child].slice(0, MAX_NESTED_CHILDREN);
-	}
-}
-
-export function updateAsyncJobNestedProjection(job: AsyncJobState): void {
-	if (!job.nestedRoute) return;
-	const registry = projectNestedEvents(job.nestedRoute);
-	job.nestedChildren = registry.children;
-	attachRootChildrenToSteps(job.asyncId, job.steps, registry.children);
-}
-
-export function updateForegroundNestedProjection(control: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never): void {
-	if (!control.nestedRoute) return;
-	const registry = projectNestedEvents(control.nestedRoute);
-	control.nestedChildren = registry.children;
-}
-
-export function hasLiveNestedDescendants(children: NestedRunSummary[] | undefined): boolean {
-	if (!children?.length) return false;
-	for (const child of children) {
-		if (!terminal(child.state)) return true;
-		if (hasLiveNestedDescendants(child.children)) return true;
-		if (hasLiveNestedDescendants(child.steps?.flatMap((step) => step.children ?? []))) return true;
-	}
-	return false;
-}
-
-export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: string, fallback: { id: string; parentRunId: string; parentStepIndex?: number; depth: number; path?: Array<{ runId: string; stepIndex?: number; agent?: string }>; mode?: SubagentRunMode; ts: number }): NestedRunSummary {
-	return {
-		id: status.runId || fallback.id,
-		parentRunId: fallback.parentRunId,
-		...(fallback.parentStepIndex !== undefined ? { parentStepIndex: fallback.parentStepIndex } : {}),
-		depth: fallback.depth,
-		path: fallback.path ?? [{ runId: fallback.parentRunId, ...(fallback.parentStepIndex !== undefined ? { stepIndex: fallback.parentStepIndex } : {}) }],
-		asyncDir,
-		...(status.pid ? { pid: status.pid } : {}),
-		...(status.sessionId ? { sessionId: status.sessionId } : {}),
-		mode: status.mode ?? fallback.mode,
-		state: status.state,
-		...(status.currentStep !== undefined ? { currentStep: status.currentStep } : {}),
-		...(status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {}),
-		...(status.activityState ? { activityState: status.activityState } : {}),
-		...(status.lastActivityAt !== undefined ? { lastActivityAt: status.lastActivityAt } : {}),
-		...(status.currentTool ? { currentTool: status.currentTool } : {}),
-		...(status.currentToolStartedAt !== undefined ? { currentToolStartedAt: status.currentToolStartedAt } : {}),
-		...(status.currentPath ? { currentPath: status.currentPath } : {}),
-		...(status.turnCount !== undefined ? { turnCount: status.turnCount } : {}),
-		...(status.toolCount !== undefined ? { toolCount: status.toolCount } : {}),
-		...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
-		...(status.startedAt !== undefined ? { startedAt: status.startedAt } : { startedAt: fallback.ts }),
-		...(status.endedAt !== undefined ? { endedAt: status.endedAt } : {}),
-		lastUpdate: status.lastUpdate ?? fallback.ts,
-		...(status.sessionFile ? { sessionFile: status.sessionFile } : {}),
-		...(status.steps?.length ? { steps: status.steps.map((step) => ({
-			agent: step.agent,
-			status: step.status,
-			...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
-			...(step.activityState ? { activityState: step.activityState } : {}),
-			...(step.lastActivityAt !== undefined ? { lastActivityAt: step.lastActivityAt } : {}),
-			...(step.currentTool ? { currentTool: step.currentTool } : {}),
-			...(step.currentToolStartedAt !== undefined ? { currentToolStartedAt: step.currentToolStartedAt } : {}),
-			...(step.currentPath ? { currentPath: step.currentPath } : {}),
-			...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
-			...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
-			...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
-			...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
-			...(step.error ? { error: step.error } : {}),
-		})).slice(0, MAX_NESTED_STEPS) } : {}),
-	};
-}
-
-export function nestedArtifactEnv(rootRunId: string, parentRunId: string): Record<string, string> {
-	const envPrefix = APP_NAME.toUpperCase();
-	return {
-		[`${envPrefix}_SUBAGENT_NESTED_ROOT_RUN_ID`]: rootRunId,
-		[`${envPrefix}_SUBAGENT_NESTED_PARENT_RUN_ID`]: parentRunId,
-	};
-}
-
-export function isTopLevelAsyncDir(asyncDir: string): boolean {
-	const resolved = path.resolve(asyncDir);
-	return containedPath(ASYNC_DIR, resolved) && !containedPath(NESTED_RUNS_DIR, resolved);
-}
-
-export function nestedResultsPath(rootRunId: string, id: string): string {
-	assertSafeId("rootRunId", rootRunId);
-	assertSafeId("id", id);
-	return path.join(RESULTS_DIR, "nested", rootRunId, `${id}.json`);
-}
+export {
+	MAX_NESTED_CHILDREN,
+	MAX_NESTED_DEPTH,
+	MAX_NESTED_EVENT_BYTES,
+	MAX_NESTED_STEPS,
+	MAX_PROCESSED_NESTED_EVENTS,
+	NESTED_EVENTS_DIR,
+	NESTED_RUNS_DIR,
+	assertSafeNestedId,
+	cleanupOldNestedRuntimeDirs,
+	createNestedRoute,
+	isSafeNestedId,
+	resolveInheritedNestedRouteFromEnv,
+	resolveNestedAsyncDir,
+	resolveNestedParentAddressFromEnv,
+	resolveNestedRouteFromEnv,
+	validateNestedRouteShape,
+} from "./nested-events-core.ts";
+export type { NestedControlRequestRecord, NestedControlResultRecord, NestedEventRecord, NestedRegistry, NestedRoute } from "./nested-events-core.ts";
+export { applyNestedEvent, parseNestedEventRecords, sanitizeSummary } from "./nested-events-sanitize.ts";
+export {
+	findNestedRouteForRootId,
+	findNestedRun,
+	findNestedRunById,
+	findNestedRunMatchesById,
+	projectNestedEvents,
+	projectNestedRegistryForRoot,
+	readNestedRegistry,
+	writeNestedEvent,
+} from "./nested-events-registry.ts";
+export type { NestedRunMatch, NestedRunResolutionScope } from "./nested-events-registry.ts";
+export {
+	nestedRouteEnv,
+	parseNestedControlRequest,
+	parseNestedControlResult,
+	readNestedControlRequests,
+	readNestedControlResults,
+	writeNestedControlRequest,
+	writeNestedControlResult,
+} from "./nested-events-control.ts";
+export {
+	attachRootChildrenToSteps,
+	hasLiveNestedDescendants,
+	isTopLevelAsyncDir,
+	nestedArtifactEnv,
+	nestedResultsPath,
+	nestedSummaryFromAsyncStatus,
+	updateAsyncJobNestedProjection,
+	updateForegroundNestedProjection,
+} from "./nested-events-projection.ts";