@bastani/atomic 0.9.11-alpha.8 → 0.9.11

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

@@ -2,24 +2,28 @@ import * as path from "node:path";
 import { APP_NAME } from "@bastani/atomic";
 import {
 	ASYNC_DIR,
-	RESULTS_DIR,
 	type AsyncJobState,
 	type AsyncStatus,
 	type NestedRunSummary,
+	RESULTS_DIR,
 	type SubagentRunMode,
 	type SubagentState,
 } from "../../shared/types.ts";
 import {
+	assertSafeId,
+	containedPath,
 	MAX_NESTED_CHILDREN,
 	MAX_NESTED_STEPS,
 	NESTED_RUNS_DIR,
-	assertSafeId,
-	containedPath,
 } from "./nested-events-core.ts";
 import { projectNestedEvents } from "./nested-events-registry.ts";
 import { terminal } from "./nested-events-sanitize.ts";
 
-export function attachRootChildrenToSteps<T extends { children?: NestedRunSummary[]; index?: number }>(rootRunId: string, steps: T[] | undefined, children: NestedRunSummary[] | undefined): void {
+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;
@@ -30,7 +34,10 @@ export function attachRootChildrenToSteps<T extends { children?: NestedRunSummar
 		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);
+		step.children = [...step.children.filter((existing) => existing.id !== child.id), child].slice(
+			0,
+			MAX_NESTED_CHILDREN,
+		);
 	}
 }
 
@@ -41,7 +48,9 @@ export function updateAsyncJobNestedProjection(job: AsyncJobState): void {
 	attachRootChildrenToSteps(job.asyncId, job.steps, registry.children);
 }
 
-export function updateForegroundNestedProjection(control: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never): void {
+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;
@@ -57,13 +66,30 @@ export function hasLiveNestedDescendants(children: NestedRunSummary[] | undefine
 	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 {
+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 } : {}) }],
+		path: fallback.path ?? [
+			{
+				runId: fallback.parentRunId,
+				...(fallback.parentStepIndex !== undefined ? { stepIndex: fallback.parentStepIndex } : {}),
+			},
+		],
 		asyncDir,
 		...(status.pid ? { pid: status.pid } : {}),
 		...(status.sessionId ? { sessionId: status.sessionId } : {}),
@@ -83,21 +109,29 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 		...(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) } : {}),
+		...(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),
+				}
+			: {}),
 	};
 }
 

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

@@ -1,21 +1,21 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { NestedRunSummary } from "../../shared/types.ts";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import type { NestedRunSummary } from "../../shared/types.ts";
 import {
-	MAX_NESTED_EVENT_BYTES,
-	MAX_PROCESSED_NESTED_EVENTS,
-	NESTED_EVENTS_DIR,
-	REGISTRY_FILE,
-	ROUTE_FILE,
 	assertSafeId,
 	commonRouteRoot,
 	containedPath,
-	validateRouteShape,
+	MAX_NESTED_EVENT_BYTES,
+	MAX_PROCESSED_NESTED_EVENTS,
+	NESTED_EVENTS_DIR,
 	type NestedEventRecord,
 	type NestedRegistry,
 	type NestedRoute,
+	REGISTRY_FILE,
+	ROUTE_FILE,
+	validateRouteShape,
 } from "./nested-events-core.ts";
 import { applyNestedEvent, parseNestedEventRecords, parseRecord, sanitizeSummary } from "./nested-events-sanitize.ts";
 
@@ -43,7 +43,11 @@ function acquireRegistryLock(route: NestedRoute): () => void {
 		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 });
+				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.
 			}
@@ -61,7 +65,8 @@ function acquireRegistryLock(route: NestedRoute): () => void {
 				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}'.`);
+			if (Date.now() >= deadline)
+				throw new Error(`Timed out waiting for nested registry lock for root '${route.rootRunId}'.`);
 			sleepSync(REGISTRY_LOCK_POLL_MS);
 		}
 	}
@@ -80,7 +85,10 @@ export function findNestedRouteForRootId(rootRunId: string): NestedRoute | undef
 		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 };
+			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,
@@ -94,7 +102,6 @@ export function findNestedRouteForRootId(rootRunId: string): NestedRoute | undef
 			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
 				console.error(`Ignoring unreadable nested route metadata under '${routeRoot}':`, error);
 			}
-			continue;
 		}
 	}
 	return undefined;
@@ -109,7 +116,12 @@ export function findNestedRun(children: NestedRunSummary[] | undefined, id: stri
 	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);
+		const nested =
+			findNestedRun(child.children, id) ??
+			findNestedRun(
+				child.steps?.flatMap((step) => step.children ?? []),
+				id,
+			);
 		if (nested) return nested;
 	}
 	return undefined;
@@ -126,24 +138,41 @@ export interface NestedRunResolutionScope {
 	descendantOf?: { parentRunId: string; parentStepIndex?: number };
 }
 
-function collectNestedRuns(children: NestedRunSummary[] | undefined, output: NestedRunSummary[] = []): NestedRunSummary[] {
+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);
+		collectNestedRuns(
+			child.steps?.flatMap((step) => step.children ?? []),
+			output,
+		);
 	}
 	return output;
 }
 
-function collectScopedNestedRuns(children: NestedRunSummary[] | undefined, scope: NestedRunResolutionScope["descendantOf"], output: NestedRunSummary[] = []): NestedRunSummary[] {
+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)) {
+		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);
+		collectScopedNestedRuns(
+			child.steps?.flatMap((step) => step.children ?? []),
+			scope,
+			output,
+		);
 	}
 	return output;
 }
@@ -160,7 +189,10 @@ function listNestedRoutes(): 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 };
+			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,
@@ -174,24 +206,25 @@ function listNestedRoutes(): NestedRoute[] {
 			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[] {
+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 });
+				if (options.prefix ? run.id.startsWith(id) : run.id === id)
+					matches.push({ rootRunId: route.rootRunId, route, run });
 			}
-		} catch {
-			continue;
-		}
+		} catch {}
 	}
 	return matches;
 }
@@ -208,8 +241,16 @@ export function readNestedRegistry(route: NestedRoute): 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) : [],
+			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;
@@ -226,7 +267,10 @@ export function projectNestedEvents(route: NestedRoute): NestedRegistry {
 		let changed = false;
 		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;
 		}
@@ -265,7 +309,8 @@ export function projectNestedEvents(route: NestedRoute): NestedRegistry {
 
 export 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.");
+	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`);
@@ -275,7 +320,10 @@ export function writeRouteRecord(dir: string, ts: number, payload: object): stri
 	return finalPath;
 }
 
-export function writeNestedEvent(route: NestedRoute, event: Omit<NestedEventRecord, "rootRunId" | "capabilityToken">): void {
+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 = {

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

@@ -1,17 +1,17 @@
 import type { NestedRunState, NestedRunSummary, NestedStepSummary } from "../../shared/types.ts";
-import { sanitizeNestedPath } from "./nested-path.ts";
 import {
+	clampNumber,
+	isSafeNestedId,
 	MAX_NESTED_CHILDREN,
 	MAX_NESTED_DEPTH,
 	MAX_NESTED_EVENT_BYTES,
 	MAX_NESTED_STEPS,
-	clampNumber,
-	isSafeNestedId,
-	stringValue,
 	type NestedEventRecord,
 	type NestedRegistry,
 	type NestedRoute,
+	stringValue,
 } from "./nested-events-core.ts";
+import { sanitizeNestedPath } from "./nested-path.ts";
 
 function sanitizeTokenUsage(value: unknown): NestedRunSummary["totalTokens"] | undefined {
 	if (!value || typeof value !== "object") return undefined;
@@ -19,9 +19,7 @@ function sanitizeTokenUsage(value: unknown): NestedRunSummary["totalTokens"] | u
 	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;
+	return input !== undefined && output !== undefined && total !== undefined ? { input, output, total } : undefined;
 }
 
 function sanitizeState(value: unknown, fallback: NestedRunState): NestedRunState {
@@ -35,24 +33,41 @@ function sanitizeStep(input: unknown, depth: number): NestedStepSummary | undefi
 	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";
+	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 } : {}),
+		...(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) } : {}),
+		...(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) } : {}),
+		...(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),
+				}
+			: {}),
 	};
 }
 
@@ -62,7 +77,10 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 	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)
+		? 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 {
@@ -74,24 +92,43 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 		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) } : {}),
+		...(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.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) } : {}),
+		...(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 } : {}),
+		...(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) } : {}),
+		...(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) } : {}),
@@ -101,7 +138,14 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 		...(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) } : {}),
+		...(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),
+				}
+			: {}),
 	};
 }
 
@@ -115,7 +159,12 @@ export function parseRecord(content: string, route: NestedRoute): NestedEventRec
 	}
 	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.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);
@@ -144,9 +193,10 @@ export function parseNestedEventRecords(content: string, route: NestedRoute): Ne
 		const record = parseRecord(content.trim(), route);
 		return record ? [record] : [];
 	}
-	return content.split("\n")
+	return content
+		.split("\n")
 		.slice(0, content.endsWith("\n") ? undefined : -1)
-		.map((line) => line.trim() ? parseRecord(line, route) : undefined)
+		.map((line) => (line.trim() ? parseRecord(line, route) : undefined))
 		.filter((event): event is NestedEventRecord => Boolean(event));
 }
 
@@ -155,7 +205,8 @@ export function terminal(state: NestedRunState): boolean {
 }
 
 function mergeSummary(existing: NestedRunSummary | undefined, event: NestedEventRecord): NestedRunSummary {
-	const incomingState = event.type === "subagent.nested.completed" && event.child.state === "running" ? "complete" : event.child.state;
+	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;
@@ -168,27 +219,33 @@ function mergeSummary(existing: NestedRunSummary | undefined, event: NestedEvent
 
 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 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.map((child, index) => (index === childIndex ? nextChild : child))
 		: [...next, nextChild].slice(0, MAX_NESTED_CHILDREN);
 }