@bastani/atomic 0.9.11-alpha.8 → 0.9.11

package/dist/builtin/subagents/src/extension/startup-maintenance.ts

@@ -1,90 +1,154 @@
+import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { SubagentState } from "../shared/types.ts";
+import { createResultWatcher } from "../runs/background/result-watcher.ts";
+import { cleanupOldNestedRuntimeDirs } from "../runs/shared/nested-events.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
 import { cleanupOldChainDirs } from "../shared/settings.ts";
-import { cleanupOldNestedRuntimeDirs } from "../runs/shared/nested-events.ts";
-import { createResultWatcher } from "../runs/background/result-watcher.ts";
+import type { SubagentState } from "../shared/types.ts";
 
 export interface SubagentStartupMaintenance {
-  scheduleStartupCleanup(): void;
-  startResultWatcherDeferred(): void;
-  primeExistingResultsDeferred(): void;
-  cleanupSessionArtifactsDeferred(ctx: ExtensionContext): void;
-  stop(): void;
+	scheduleStartupCleanup(): void;
+	startResultWatcherDeferred(): void;
+	primeExistingResultsDeferred(): void;
+	cleanupSessionArtifactsDeferred(ctx: ExtensionContext): void;
+	stop(): void;
 }
 
+/** How long after startup to defer the slow global session-artifact scan. */
+export const STARTUP_ARTIFACT_SCAN_DELAY_MS = 10 * 60 * 1000;
+
 function scheduleMacrotask(task: () => void): () => void {
-  let cancelled = false;
-  const handle = setImmediate(() => {
-    if (!cancelled) task();
-  });
-  handle.unref?.();
-  return () => {
-    cancelled = true;
-    clearImmediate(handle);
-  };
+	let cancelled = false;
+	const handle = setImmediate(() => {
+		if (!cancelled) task();
+	});
+	handle.unref?.();
+	return () => {
+		cancelled = true;
+		clearImmediate(handle);
+	};
+}
+
+function scheduleDelayedTask(task: () => void, delayMs: number): () => void {
+	let cancelled = false;
+	const handle = setTimeout(() => {
+		if (!cancelled) task();
+	}, delayMs);
+	handle.unref?.();
+	return () => {
+		cancelled = true;
+		clearTimeout(handle);
+	};
 }
 
 function swallowCleanup(task: () => void): void {
-  try {
-    task();
-  } catch {
-  }
+	try {
+		task();
+	} catch {}
 }
 
 export function createSubagentStartupMaintenance(
-  pi: ExtensionAPI,
-  state: SubagentState,
-  options: {
-    resultsDir: string;
-    artifactCleanupDays: number;
-    resultTtlMs: number;
-    scheduleMacrotask?: (task: () => void) => () => void;
-  },
+	pi: ExtensionAPI,
+	state: SubagentState,
+	options: {
+		resultsDir: string;
+		artifactCleanupDays: number;
+		resultTtlMs: number;
+		scheduleMacrotask?: (task: () => void) => () => void;
+		scheduleDelayed?: (task: () => void, delayMs: number) => () => void;
+	},
 ): SubagentStartupMaintenance {
-  const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(
-    pi,
-    state,
-    options.resultsDir,
-    options.resultTtlMs,
-  );
-  const cancelTasks = new Set<() => void>();
-  const schedule = (task: () => void): void => {
-    const cancel = (options.scheduleMacrotask ?? scheduleMacrotask)(() => {
-      cancelTasks.delete(cancel);
-      task();
-    });
-    cancelTasks.add(cancel);
-  };
+	const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(
+		pi,
+		state,
+		options.resultsDir,
+		options.resultTtlMs,
+	);
+	const cancelTasks = new Set<() => void>();
+	// The sessions root derived from a host-provided (non-default, e.g. isolated
+	// programmatic agentDir) session directory. When set, the global artifact scan
+	// stays inside it instead of touching the real global/legacy sessions roots.
+	// A custom session dir that does not follow the <agentDir>/sessions/<safe-cwd>
+	// layout (the default layout the SDK derives for a programmatic agentDir, with
+	// <safe-cwd> encoding the current working directory) yields no roots at all, so
+	// cleanup never broadens into an arbitrary directory's siblings.
+	let contextSessionsRoots: readonly string[] | undefined;
+	const noteSessionContext = (ctx: ExtensionContext): void => {
+		try {
+			if (ctx.sessionManager.usesDefaultSessionDir()) {
+				// Only a valid default-session context intentionally restores the
+				// env/global cleanup roots.
+				contextSessionsRoots = undefined;
+				return;
+			}
+			const sessionDir = ctx.sessionManager.getSessionDir();
+			// A partial or throwing context keeps the last validated root: destructive
+			// cleanup must never broaden from an isolated root to the global roots on
+			// the strength of an unusable context.
+			if (!sessionDir) return;
+			const parent = path.dirname(sessionDir);
+			const safeCwd = `--${path
+				.resolve(ctx.cwd)
+				.replace(/^[/\\]/, "")
+				.replace(/[/\\:]/g, "-")}--`;
+			const followsAgentDirLayout = path.basename(parent) === "sessions" && path.basename(sessionDir) === safeCwd;
+			contextSessionsRoots = followsAgentDirLayout ? [parent] : [];
+		} catch {
+			// A stale or partial context leaves cleanup on the env/global fallback.
+		}
+	};
+	const schedule = (task: () => void): void => {
+		const cancel = (options.scheduleMacrotask ?? scheduleMacrotask)(() => {
+			cancelTasks.delete(cancel);
+			task();
+		});
+		cancelTasks.add(cancel);
+	};
+	const scheduleDelayed = (task: () => void, delayMs: number): void => {
+		const cancel = (options.scheduleDelayed ?? scheduleDelayedTask)(() => {
+			cancelTasks.delete(cancel);
+			task();
+		}, delayMs);
+		cancelTasks.add(cancel);
+	};
 
-  return {
-    scheduleStartupCleanup() {
-      schedule(() => {
-        swallowCleanup(cleanupOldChainDirs);
-        swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays));
-        swallowCleanup(() => cleanupOldNestedRuntimeDirs(options.artifactCleanupDays));
-      });
-    },
-    startResultWatcherDeferred() {
-      schedule(startResultWatcher);
-    },
-    primeExistingResultsDeferred() {
-      schedule(primeExistingResults);
-    },
-    cleanupSessionArtifactsDeferred(ctx) {
-      let sessionFile: string | null | undefined;
-      try {
-        sessionFile = ctx.sessionManager.getSessionFile();
-      } catch {
-        return;
-      }
-      if (!sessionFile) return;
-      schedule(() => swallowCleanup(() => cleanupOldArtifacts(getArtifactsDir(sessionFile), options.artifactCleanupDays)));
-    },
-    stop() {
-      for (const cancel of cancelTasks) cancel();
-      cancelTasks.clear();
-      stopResultWatcher();
-    },
-  };
+	return {
+		scheduleStartupCleanup() {
+			schedule(() => {
+				swallowCleanup(cleanupOldChainDirs);
+				swallowCleanup(() => cleanupOldNestedRuntimeDirs(options.artifactCleanupDays));
+				// The global session-artifact scan can touch thousands of historical session
+				// directories, so it waits until well after startup instead of running on the
+				// activation macrotask.
+				scheduleDelayed(
+					() => swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays, contextSessionsRoots)),
+					STARTUP_ARTIFACT_SCAN_DELAY_MS,
+				);
+			});
+		},
+		startResultWatcherDeferred() {
+			schedule(startResultWatcher);
+		},
+		primeExistingResultsDeferred() {
+			schedule(primeExistingResults);
+		},
+		cleanupSessionArtifactsDeferred(ctx) {
+			noteSessionContext(ctx);
+			let sessionFile: string | null | undefined;
+			try {
+				sessionFile = ctx.sessionManager.getSessionFile();
+			} catch {
+				return;
+			}
+			if (!sessionFile) return;
+			schedule(() =>
+				swallowCleanup(() => cleanupOldArtifacts(getArtifactsDir(sessionFile), options.artifactCleanupDays)),
+			);
+		},
+		stop() {
+			for (const cancel of cancelTasks) cancel();
+			cancelTasks.clear();
+			stopResultWatcher();
+		},
+	};
 }

package/dist/builtin/subagents/src/intercom/intercom-bridge.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { APP_NAME, getProjectConfigDirs, getEnvValue } from "@bastani/atomic";
+import { APP_NAME, getEnvValue, getProjectConfigDirs } from "@bastani/atomic";
 import type { AgentConfig } from "../agents/agents.ts";
 import type { ExtensionConfig, IntercomBridgeConfig, IntercomBridgeMode } from "../shared/types.ts";
 import { getAgentDir } from "../shared/utils.ts";
@@ -87,7 +87,13 @@ export function resolveIntercomSessionTarget(sessionName: string | undefined, se
 }
 
 function sanitizeIntercomTargetPart(value: string): string {
-	return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+	return (
+		value
+			.trim()
+			.toLowerCase()
+			.replace(/[^a-z0-9_-]+/g, "-")
+			.replace(/^-+|-+$/g, "") || "agent"
+	);
 }
 
 export function resolveSubagentIntercomTarget(runId: string, agent: string, index?: number): string {
@@ -127,7 +133,8 @@ function readJsonBestEffort(filePath: string): unknown {
 	try {
 		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
 	} catch (error) {
-		const code = error && typeof error === "object" && "code" in error ? (error as NodeJS.ErrnoException).code : undefined;
+		const code =
+			error && typeof error === "object" && "code" in error ? (error as NodeJS.ErrnoException).code : undefined;
 		if (code !== "ENOENT") console.warn(`Failed to read JSON from '${filePath}'.`, error);
 		return null;
 	}
@@ -140,16 +147,20 @@ function packageHasPiExtension(packageRoot: string): boolean {
 		const pi = (pkg as { pi?: unknown }).pi;
 		if (pi && typeof pi === "object" && !Array.isArray(pi)) {
 			const extensions = (pi as { extensions?: unknown }).extensions;
-			return Array.isArray(extensions) && extensions.some((entry) => typeof entry === "string" && entry.trim() !== "");
+			return (
+				Array.isArray(extensions) && extensions.some((entry) => typeof entry === "string" && entry.trim() !== "")
+			);
 		}
 	}
 	return fs.existsSync(path.join(packageRoot, "extensions"));
 }
 
 function isSafePackagePath(value: string): boolean {
-	return value.length > 0
-		&& !path.isAbsolute(value)
-		&& value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..");
+	return (
+		value.length > 0 &&
+		!path.isAbsolute(value) &&
+		value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..")
+	);
 }
 
 function parseNpmPackageName(source: string): string | undefined {
@@ -162,7 +173,12 @@ function parseNpmPackageName(source: string): string | undefined {
 
 function packageEntrySource(entry: unknown): string | undefined {
 	if (typeof entry === "string") return entry;
-	if (entry && typeof entry === "object" && !Array.isArray(entry) && typeof (entry as { source?: unknown }).source === "string") {
+	if (
+		entry &&
+		typeof entry === "object" &&
+		!Array.isArray(entry) &&
+		typeof (entry as { source?: unknown }).source === "string"
+	) {
 		return (entry as { source: string }).source;
 	}
 	return undefined;
@@ -202,7 +218,15 @@ function getGlobalNpmRoot(): string | null {
 function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agentDir: string): string | undefined {
 	const projectConfigDir = input.cwd ? findNearestProjectConfigDir(path.resolve(input.cwd)) : undefined;
 	const settingsFiles = [
-		...(projectConfigDir ? [{ file: path.join(projectConfigDir, "settings.json"), configDir: projectConfigDir, scope: "project" as const }] : []),
+		...(projectConfigDir
+			? [
+					{
+						file: path.join(projectConfigDir, "settings.json"),
+						configDir: projectConfigDir,
+						scope: "project" as const,
+					},
+				]
+			: []),
 		{ file: path.join(agentDir, "settings.json"), configDir: agentDir, scope: "user" as const },
 	];
 	let resolvedGlobalNpmRoot = input.globalNpmRoot;
@@ -225,12 +249,13 @@ function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agent
 			const packageName = parseNpmPackageName(source);
 			if (packageName !== PI_INTERCOM_PACKAGE_NAME) continue;
 			const globalNpmRoot = scope === "user" ? resolveGlobalNpmRoot() : null;
-			const candidates = scope === "project"
-				? [path.join(configDir, "npm", "node_modules", packageName)]
-				: [
-					...(globalNpmRoot ? [path.join(globalNpmRoot, packageName)] : []),
-					path.join(agentDir, "npm", "node_modules", packageName),
-				];
+			const candidates =
+				scope === "project"
+					? [path.join(configDir, "npm", "node_modules", packageName)]
+					: [
+							...(globalNpmRoot ? [path.join(globalNpmRoot, packageName)] : []),
+							path.join(agentDir, "npm", "node_modules", packageName),
+						];
 			const packageRoot = candidates.find(packageHasPiExtension);
 			if (packageRoot) return path.resolve(packageRoot);
 		}
@@ -269,13 +294,14 @@ function expandTilde(filePath: string): string {
 function resolveInstructionTemplate(instructionFile: string, settingsDir: string): string {
 	if (!instructionFile) return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
 	const expandedPath = expandTilde(instructionFile);
-	const resolvedPath = path.isAbsolute(expandedPath)
-		? expandedPath
-		: path.resolve(settingsDir, expandedPath);
+	const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(settingsDir, expandedPath);
 	try {
 		return fs.readFileSync(resolvedPath, "utf-8");
 	} catch (error) {
-		console.warn(`Failed to read intercom bridge instructionFile at '${resolvedPath}'. Using default instructions.`, error);
+		console.warn(
+			`Failed to read intercom bridge instructionFile at '${resolvedPath}'. Using default instructions.`,
+			error,
+		);
 		return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
 	}
 }
@@ -299,7 +325,8 @@ export function diagnoseIntercomBridge(input: ResolveIntercomBridgeInput): Inter
 	let configStatus: ReturnType<typeof intercomConfigStatus> | undefined;
 	let reason: string | undefined;
 	if (mode === "off") reason = "bridge mode is off";
-	else if (mode === "fork-only" && input.context !== "fork") reason = "bridge mode is fork-only and context is not fork";
+	else if (mode === "fork-only" && input.context !== "fork")
+		reason = "bridge mode is fork-only and context is not fork";
 	else if (!orchestratorTarget) reason = "orchestrator target is not available";
 	else if (!piIntercomAvailable) reason = "pi-intercom extension was not found";
 	else {
@@ -353,7 +380,8 @@ export function resolveIntercomBridge(input: ResolveIntercomBridgeInput): Interc
 
 	const configPath = path.resolve(input.configPath ?? defaultIntercomConfigPath(agentDir));
 	const intercomStatus = intercomConfigStatus(configPath);
-	if (intercomStatus.error) console.warn(`Failed to parse intercom config at '${configPath}'. Assuming enabled.`, intercomStatus.error);
+	if (intercomStatus.error)
+		console.warn(`Failed to parse intercom config at '${configPath}'. Assuming enabled.`, intercomStatus.error);
 	if (!intercomStatus.enabled) {
 		return { active: false, mode, extensionDir, instruction: defaultInstruction };
 	}

package/dist/builtin/subagents/src/intercom/result-intercom.ts

@@ -3,16 +3,16 @@ import * as fs from "node:fs";
 import {
 	type Details,
 	type IntercomEventBus,
+	MAX_SUBAGENT_NESTING_DEPTH,
 	type NestedRunSummary,
 	type PublicNestedRunSummary,
 	type SingleResult,
+	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
+	SUBAGENT_RESULT_INTERCOM_EVENT,
 	type SubagentResultIntercomChild,
 	type SubagentResultIntercomPayload,
 	type SubagentResultStatus,
 	type SubagentRunMode,
-	MAX_SUBAGENT_NESTING_DEPTH,
-	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
-	SUBAGENT_RESULT_INTERCOM_EVENT,
 } from "../shared/types.ts";
 
 export function resolveSubagentResultStatus(input: {
@@ -101,27 +101,39 @@ function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth
 		...(run.endedAt !== undefined ? { endedAt: run.endedAt } : {}),
 		...(run.lastUpdate !== undefined ? { lastUpdate: run.lastUpdate } : {}),
 		...(run.error ? { error: run.error } : {}),
-		...(run.steps?.length ? { steps: run.steps.slice(0, 12).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 } : {}),
-			...(depth < MAX_SUBAGENT_NESTING_DEPTH && step.children?.length ? { children: step.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) } : {}),
-		})) } : {}),
-		...(depth < MAX_SUBAGENT_NESTING_DEPTH && run.children?.length ? { children: run.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) } : {}),
+		...(run.steps?.length
+			? {
+					steps: run.steps.slice(0, 12).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 } : {}),
+						...(depth < MAX_SUBAGENT_NESTING_DEPTH && step.children?.length
+							? { children: step.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) }
+							: {}),
+					})),
+				}
+			: {}),
+		...(depth < MAX_SUBAGENT_NESTING_DEPTH && run.children?.length
+			? { children: run.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) }
+			: {}),
 	};
 }
 
-export function compactNestedResultChildren(children: Array<NestedRunSummary | PublicNestedRunSummary> | undefined): PublicNestedRunSummary[] | undefined {
+export function compactNestedResultChildren(
+	children: Array<NestedRunSummary | PublicNestedRunSummary> | undefined,
+): PublicNestedRunSummary[] | undefined {
 	if (!children?.length) return undefined;
 	return children.slice(0, 16).map((child) => compactNestedRun(child));
 }
@@ -132,14 +144,24 @@ export function attachNestedChildrenToResultChildren(
 	nestedChildren: NestedRunSummary[] | undefined,
 ): SubagentResultIntercomChild[] {
 	const compact = compactNestedResultChildren(nestedChildren);
-	if (!compact?.length) return children.map((child) => ({ ...child, children: compactNestedResultChildren(child.children) }));
+	if (!compact?.length)
+		return children.map((child) => ({ ...child, children: compactNestedResultChildren(child.children) }));
 	return children.map((child, index) => {
 		const childIndex = child.index ?? index;
 		const alreadyAttachedIds = new Set(child.children?.map((nested) => nested.id) ?? []);
-		const attached = compact.filter((nested) => nested.parentRunId === runId && nested.parentStepIndex === childIndex && !alreadyAttachedIds.has(nested.id));
-		const fallbackAttached = children.length === 1
-			? compact.filter((nested) => nested.parentRunId === runId && nested.parentStepIndex === undefined && !alreadyAttachedIds.has(nested.id))
-			: [];
+		const attached = compact.filter(
+			(nested) =>
+				nested.parentRunId === runId && nested.parentStepIndex === childIndex && !alreadyAttachedIds.has(nested.id),
+		);
+		const fallbackAttached =
+			children.length === 1
+				? compact.filter(
+						(nested) =>
+							nested.parentRunId === runId &&
+							nested.parentStepIndex === undefined &&
+							!alreadyAttachedIds.has(nested.id),
+					)
+				: [];
 		const merged = compactNestedResultChildren([...(child.children ?? []), ...attached, ...fallbackAttached]);
 		return merged?.length ? { ...child, children: merged } : { ...child, children: undefined };
 	});
@@ -184,7 +206,9 @@ function asyncResumeGuidance(input: {
 	asyncId?: string;
 }): string | undefined {
 	if (input.source !== "async" || !input.asyncId) return undefined;
-	const resumable = input.children.filter((child) => typeof child.sessionPath === "string" && fs.existsSync(child.sessionPath));
+	const resumable = input.children.filter(
+		(child) => typeof child.sessionPath === "string" && fs.existsSync(child.sessionPath),
+	);
 	if (input.children.length === 1 && resumable.length === 1) {
 		return `Revive: subagent({ action: "resume", id: "${input.asyncId}", message: "..." })`;
 	}
@@ -223,16 +247,21 @@ function formatSubagentResultIntercomMessage(input: {
 	if (resumeGuidance) lines.push(resumeGuidance);
 	if (input.children.some((child) => child.intercomTarget)) {
 		lines.push("");
-		lines.push(input.source === "async"
-			? "Previous intercom targets below identify child sessions used while they were running. Inspect artifacts or session logs if resume is unavailable."
-			: "Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.");
+		lines.push(
+			input.source === "async"
+				? "Previous intercom targets below identify child sessions used while they were running. Inspect artifacts or session logs if resume is unavailable."
+				: "Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.",
+		);
 	}
 
 	for (let index = 0; index < input.children.length; index++) {
 		const child = input.children[index]!;
 		lines.push("");
 		lines.push(`${index + 1}. ${child.agent} — ${child.status}`);
-		if (child.intercomTarget) lines.push(`${input.source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`);
+		if (child.intercomTarget)
+			lines.push(
+				`${input.source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`,
+			);
 		if (child.artifactPath) lines.push(`Output artifact: ${child.artifactPath}`);
 		if (child.sessionPath) lines.push(`Session: ${child.sessionPath}`);
 		lines.push(...formatNestedResultLines(child.children));
@@ -243,7 +272,9 @@ function formatSubagentResultIntercomMessage(input: {
 	return lines.join("\n");
 }
 
-export function buildSubagentResultIntercomPayload(input: GroupedResultIntercomMessageInput): SubagentResultIntercomPayload {
+export function buildSubagentResultIntercomPayload(
+	input: GroupedResultIntercomMessageInput,
+): SubagentResultIntercomPayload {
 	const children = input.children.map((child) => ({
 		...child,
 		summary: child.summary.trim() || "(no output)",
@@ -278,7 +309,13 @@ export async function deliverSubagentResultIntercomEvent(
 	payload: SubagentResultIntercomPayload,
 	timeoutMs: number | false = 500,
 ): Promise<boolean> {
-	return deliverSubagentIntercomMessageEvent(events, payload.to, payload.message, timeoutMs, payload as unknown as Record<string, unknown>);
+	return deliverSubagentIntercomMessageEvent(
+		events,
+		payload.to,
+		payload.message,
+		timeoutMs,
+		payload as unknown as Record<string, unknown>,
+	);
 }
 
 export async function deliverSubagentIntercomMessageEvent(
@@ -338,11 +375,12 @@ export function formatSubagentResultReceipt(input: {
 	payload: SubagentResultIntercomPayload;
 }): string {
 	const counts = countStatuses(input.payload.children);
-	const modeLabel = input.mode === "single"
-		? "single subagent result"
-		: input.mode === "parallel"
-			? "parallel subagent results"
-			: "chain subagent results";
+	const modeLabel =
+		input.mode === "single"
+			? "single subagent result"
+			: input.mode === "parallel"
+				? "parallel subagent results"
+				: "chain subagent results";
 	const lines = [
 		`Delivered ${modeLabel} via intercom.`,
 		`Run: ${input.runId}`,

package/dist/builtin/subagents/src/runs/background/async-event-journal.ts

@@ -1,10 +1,13 @@
 import * as fs from "node:fs";
-import type { DrainableSource, JsonlWriteStream } from "../../shared/jsonl-writer.ts";
 import { acquireEventWriter } from "../../shared/event-jsonl-writer.ts";
+import type { DrainableSource, JsonlWriteStream } from "../../shared/jsonl-writer.ts";
 
 const DEFAULT_TELEMETRY_BYTES = 512 * 1024;
 const CAPPED_CHILD_EVENT_TYPES = new Set([
-	"message_update", "tool_execution_update", "subagent.child.stdout", "subagent.child.stderr",
+	"message_update",
+	"tool_execution_update",
+	"subagent.child.stdout",
+	"subagent.child.stderr",
 ]);
 
 interface ChildEventJournalContext {
@@ -81,10 +84,13 @@ export function createChildEventJournal(
 			const sanitized = sanitizeChildEvent(event);
 			const record = enrich(sanitized);
 			const lineBytes = Buffer.byteLength(`${JSON.stringify(record)}\n`, "utf-8");
-			const assistantEvent = event.type === "message_update" && event.assistantMessageEvent
-				&& typeof event.assistantMessageEvent === "object" && !Array.isArray(event.assistantMessageEvent)
-				? event.assistantMessageEvent as Record<string, unknown>
-				: undefined;
+			const assistantEvent =
+				event.type === "message_update" &&
+				event.assistantMessageEvent &&
+				typeof event.assistantMessageEvent === "object" &&
+				!Array.isArray(event.assistantMessageEvent)
+					? (event.assistantMessageEvent as Record<string, unknown>)
+					: undefined;
 			const nestedTerminal = assistantEvent?.type === "done" || assistantEvent?.type === "error";
 			const capped = !nestedTerminal && typeof event.type === "string" && CAPPED_CHILD_EVENT_TYPES.has(event.type);
 			if (capped && !writer.reserveTelemetry(lineBytes, maxTelemetryBytes)) {