@bastani/atomic 0.9.10 → 0.9.11-alpha.10

package/dist/builtin/subagents/src/runs/shared/worktree.ts

@@ -90,16 +90,21 @@ function runGitChecked(cwd: string, args: string[]): string {
 }
 function originDefaultBranch(mainRoot: string): string | undefined {
 	const symbolic = runGit(mainRoot, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
-	let branch = symbolic.status === 0 && symbolic.stdout.trim().startsWith("origin/")
-		? symbolic.stdout.trim().slice("origin/".length) : undefined;
+	let branch =
+		symbolic.status === 0 && symbolic.stdout.trim().startsWith("origin/")
+			? symbolic.stdout.trim().slice("origin/".length)
+			: undefined;
 	if (!branch) {
 		const remote = runGit(mainRoot, ["remote", "show", "origin"]);
 		branch = remote.status === 0 ? remote.stdout.match(/^\s*HEAD branch:\s*(\S+)\s*$/m)?.[1] : undefined;
 	}
 	if (!branch || branch === "(unknown)") return undefined;
 	const remoteRef = `refs/remotes/origin/${branch}`;
-	if (runGit(mainRoot, ["show-ref", "--verify", "--quiet", remoteRef]).status !== 0
-		&& runGit(mainRoot, ["fetch", "origin", `${branch}:${remoteRef}`]).status !== 0) return undefined;
+	if (
+		runGit(mainRoot, ["show-ref", "--verify", "--quiet", remoteRef]).status !== 0 &&
+		runGit(mainRoot, ["fetch", "origin", `${branch}:${remoteRef}`]).status !== 0
+	)
+		return undefined;
 	return `origin/${branch}`;
 }
 function resolveRepoState(cwd: string): RepoState {
@@ -108,7 +113,8 @@ function resolveRepoState(cwd: string): RepoState {
 	const mainRoot = findCanonicalGitRoot(toplevel);
 	if (mainRoot === undefined) throw new Error(`unable to resolve canonical main Git repository root from ${toplevel}`);
 	const status = runGitChecked(toplevel, ["status", "--porcelain", "--untracked-files=no"]);
-	if (status.trim().length > 0) throw new Error("worktree isolation requires a clean git working tree. Commit or stash changes first.");
+	if (status.trim().length > 0)
+		throw new Error("worktree isolation requires a clean git working tree. Commit or stash changes first.");
 	const baseRef = originDefaultBranch(mainRoot) || "HEAD";
 	const baseCommit = runGitChecked(mainRoot, ["rev-parse", baseRef]).trim();
 	return { mainRoot, cwdRelative, baseCommit, baseRef };
@@ -135,10 +141,7 @@ export function findWorktreeTaskCwdConflict(
 	}
 	return undefined;
 }
-export function formatWorktreeTaskCwdConflict(
-	conflict: WorktreeTaskCwdConflict,
-	sharedCwd: string,
-): string {
+export function formatWorktreeTaskCwdConflict(conflict: WorktreeTaskCwdConflict, sharedCwd: string): string {
 	return `worktree isolation uses the shared cwd (${sharedCwd}); task ${conflict.index + 1} (${conflict.agent}) sets cwd to ${conflict.cwd}. Remove task-level cwd overrides or disable worktree.`;
 }
 function safePatchAgentName(agent: string): string {
@@ -164,9 +167,7 @@ function resolveRepoCwdRelative(cwd: string): string {
 		throw new Error("worktree isolation requires a git repository");
 	}
 	const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
-	const normalizedPrefix = rawPrefix
-		? path.normalize(rawPrefix.replace(/[\\/]+$/, ""))
-		: "";
+	const normalizedPrefix = rawPrefix ? path.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
 	return normalizedPrefix === "." ? "" : normalizedPrefix;
 }
 export function resolveExpectedWorktreeAgentCwd(cwd: string, runId: string, index: number): string {
@@ -248,10 +249,21 @@ function parseWorktreeSetupHookOutput(rawStdout: string): WorktreeSetupHookOutpu
 	}
 	return parsed as WorktreeSetupHookOutput;
 }
-function runWorktreeSetupHook(
-	hook: ResolvedWorktreeSetupHook,
-	input: WorktreeSetupHookInput,
-): string[] {
+/**
+ * Whether a `spawnSync` error is only the parent's stdin write losing its reader.
+ *
+ * A setup hook is handed its JSON input on stdin, but nothing requires a hook to
+ * read it and most do not. When such a hook exits before that write is flushed,
+ * the write fails with EPIPE even though the hook itself ran to completion — a
+ * race a loaded machine loses far more often than an idle one. Node still
+ * reports the child's real exit status and full stdout in that case, so the
+ * spawn result stays authoritative and only a spawn that never produced a status
+ * is a genuine failure.
+ */
+export function isSpuriousHookStdinWriteFailure(code: string | undefined, status: number | null): boolean {
+	return code === "EPIPE" && status !== null;
+}
+function runWorktreeSetupHook(hook: ResolvedWorktreeSetupHook, input: WorktreeSetupHookInput): string[] {
 	const result = spawnSync(hook.hookPath, [], {
 		cwd: input.worktreePath,
 		encoding: "utf-8",
@@ -260,11 +272,13 @@ function runWorktreeSetupHook(
 		shell: false,
 	});
 	if (result.error) {
-		const code = "code" in result.error ? result.error.code : undefined;
+		const code = "code" in result.error && typeof result.error.code === "string" ? result.error.code : undefined;
 		if (code === "ETIMEDOUT") {
 			throw new Error(`worktree setup hook timed out after ${hook.timeoutMs}ms`);
 		}
-		throw new Error(`worktree setup hook failed: ${result.error.message}`);
+		if (!isSpuriousHookStdinWriteFailure(code, result.status)) {
+			throw new Error(`worktree setup hook failed: ${result.error.message}`);
+		}
 	}
 	if (result.status !== 0) {
 		const details = result.stderr.trim() || result.stdout.trim() || "no output";
@@ -292,9 +306,17 @@ function waitForGitLockRelease(): void {
 	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
 }
 function cleanupSingleWorktree(repoCwd: string, worktree: Pick<WorktreeInfo, "path" | "branch">): void {
-	try { runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]); } catch { /* idempotent */ }
+	try {
+		runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]);
+	} catch {
+		/* idempotent */
+	}
 	waitForGitLockRelease();
-	try { runGitChecked(repoCwd, ["branch", "-D", worktree.branch]); } catch { /* idempotent */ }
+	try {
+		runGitChecked(repoCwd, ["branch", "-D", worktree.branch]);
+	} catch {
+		/* idempotent */
+	}
 }
 function createSingleWorktree(
 	mainRoot: string,
@@ -318,13 +340,27 @@ function createSingleWorktree(
 	try {
 		const syntheticPaths = performPostCreationSetup(runGit, mainRoot, worktreePath);
 		if (setupHook) {
-			syntheticPaths.push(...runWorktreeSetupHook(setupHook, {
-				version: 1, repoRoot: mainRoot, worktreePath, agentCwd, branch, index, runId, baseCommit, agent,
-			}));
+			syntheticPaths.push(
+				...runWorktreeSetupHook(setupHook, {
+					version: 1,
+					repoRoot: mainRoot,
+					worktreePath,
+					agentCwd,
+					branch,
+					index,
+					runId,
+					baseCommit,
+					agent,
+				}),
+			);
 		}
 		return {
-			path: worktreePath, agentCwd, branch, index,
-			nodeModulesLinked: syntheticPaths.includes("node_modules"), syntheticPaths,
+			path: worktreePath,
+			agentCwd,
+			branch,
+			index,
+			nodeModulesLinked: syntheticPaths.includes("node_modules"),
+			syntheticPaths,
 		};
 	} catch (error) {
 		cleanupSingleWorktree(mainRoot, { path: worktreePath, branch });
@@ -334,14 +370,21 @@ function createSingleWorktree(
 function removeSyntheticPath(worktree: WorktreeInfo, syntheticPath: string): void {
 	const resolved = path.resolve(worktree.path, syntheticPath);
 	const relative = path.relative(worktree.path, resolved);
-	if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+	if (
+		!relative ||
+		relative === "." ||
+		relative === ".." ||
+		relative.startsWith(`..${path.sep}`) ||
+		path.isAbsolute(relative)
+	) {
 		return;
 	}
 	let stat: fs.Stats;
 	try {
 		stat = fs.lstatSync(resolved);
 	} catch (error) {
-		const code = error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
+		const code =
+			error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
 		if (code === "ENOENT") return;
 		throw error;
 	}
@@ -423,24 +466,36 @@ function captureWorktreeDiff(
 function writeEmptyPatch(patchPath: string): void {
 	try {
 		fs.writeFileSync(patchPath, "", "utf-8");
-	} catch {
-	}
+	} catch {}
 }
 
 function hasWorktreeChanges(diff: WorktreeDiff): boolean {
 	return diff.filesChanged > 0 || diff.insertions > 0 || diff.deletions > 0 || diff.diffStat.trim().length > 0;
 }
-export function createWorktrees(cwd: string, runId: string, count: number, options?: CreateWorktreesOptions): WorktreeSetup {
+export function createWorktrees(
+	cwd: string,
+	runId: string,
+	count: number,
+	options?: CreateWorktreesOptions,
+): WorktreeSetup {
 	const repo = resolveRepoState(cwd);
 	ensureWorktreeIgnore(repo.mainRoot);
 	const setupHook = resolveWorktreeSetupHook(repo.mainRoot, options?.setupHook);
 	const worktrees: WorktreeInfo[] = [];
 	try {
 		for (let index = 0; index < count; index++) {
-			worktrees.push(createSingleWorktree(
-				repo.mainRoot, repo.cwdRelative, runId, index, repo.baseRef, repo.baseCommit,
-				setupHook, options?.agents?.[index],
-			));
+			worktrees.push(
+				createSingleWorktree(
+					repo.mainRoot,
+					repo.cwdRelative,
+					runId,
+					index,
+					repo.baseRef,
+					repo.baseCommit,
+					setupHook,
+					options?.agents?.[index],
+				),
+			);
 		}
 	} catch (error) {
 		cleanupWorktrees({ cwd: repo.mainRoot, worktrees, baseCommit: repo.baseCommit });

package/dist/builtin/subagents/src/shared/artifacts.ts

@@ -2,8 +2,13 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentConfigPaths } from "@bastani/atomic";
 import { appendToActiveEventWriter } from "./event-jsonl-writer.ts";
-import { TEMP_ARTIFACTS_DIR, type ArtifactPaths } from "./types.ts";
+import { publishFileExclusive, unlinkIfPresent } from "./exclusive-file-publication.ts";
+import { type ArtifactPaths, TEMP_ARTIFACTS_DIR } from "./types.ts";
+
 const CLEANUP_MARKER_FILE = ".last-cleanup";
+const CLEANUP_LOCK_FILE = ".cleanup.lock";
+const CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const CLEANUP_LOCK_STALE_MS = 60 * 60 * 1000;
 
 export function getArtifactsDir(sessionFile: string | null): string {
 	if (sessionFile) {
@@ -68,7 +73,7 @@ export function cleanupOldArtifacts(dir: string, maxAgeDays: number): void {
 
 	if (fs.existsSync(markerPath)) {
 		const stat = fs.statSync(markerPath);
-		if (now - stat.mtimeMs < 24 * 60 * 60 * 1000) return;
+		if (now - stat.mtimeMs < CLEANUP_INTERVAL_MS) return;
 	}
 
 	const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
@@ -82,22 +87,128 @@ export function cleanupOldArtifacts(dir: string, maxAgeDays: number): void {
 	fs.writeFileSync(markerPath, String(now));
 }
 
-export function cleanupAllArtifactDirs(maxAgeDays: number): void {
-	cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
+function markerIsFresh(markerPath: string, now: number): boolean {
+	try {
+		return now - fs.statSync(markerPath).mtimeMs < CLEANUP_INTERVAL_MS;
+	} catch {
+		return false;
+	}
+}
 
-	for (const sessionsBase of getAgentConfigPaths("sessions")) {
-		if (!fs.existsSync(sessionsBase)) continue;
+/**
+ * Take an exclusive lock at lockPath so concurrent activations never race the same
+ * sessions-root scan. A lock left behind by a crashed process is broken once stale.
+ * Returns an ownership token on success; release only removes a lock that still
+ * carries the caller's token, so a holder whose stale lock was taken over cannot
+ * erase the new holder's lock.
+ */
+function acquireCleanupLock(lockPath: string, now: number): string | null {
+	const token = `${process.pid}.${now}.${Math.random().toString(36).slice(2)}`;
+	const source = `${lockPath}.${token}.tmp`;
+	try {
+		fs.writeFileSync(source, token);
+		for (let attempt = 0; attempt < 2; attempt++) {
+			if (publishFileExclusive(source, lockPath) === "published") return token;
+			let lockMtimeMs: number;
+			try {
+				lockMtimeMs = fs.statSync(lockPath).mtimeMs;
+			} catch {
+				// The holder released between publish and stat; retry once.
+				continue;
+			}
+			if (now - lockMtimeMs < CLEANUP_LOCK_STALE_MS) return null;
+			if (!breakStaleLock(lockPath, lockMtimeMs)) return null;
+		}
+		return null;
+	} catch {
+		return null;
+	} finally {
+		try {
+			unlinkIfPresent(source);
+		} catch {
+			// Lock acquisition is best-effort; a leftover temp source is harmless.
+		}
+	}
+}
 
+/**
+ * Atomically claim a stale lock via rename, then verify it is still the lock
+ * observed during stale detection. A lock that changed identity in between
+ * belongs to a new holder: it is handed back and the takeover is treated as
+ * contention instead of deleting the fresh lock.
+ */
+function breakStaleLock(lockPath: string, observedMtimeMs: number): boolean {
+	const breakPath = `${lockPath}.break.${process.pid}.${Math.random().toString(36).slice(2)}`;
+	try {
+		fs.renameSync(lockPath, breakPath);
+	} catch {
+		// Another activation released or broke the lock first; contend for publish.
+		return false;
+	}
+	let displacedFreshLock = false;
+	try {
+		displacedFreshLock = fs.statSync(breakPath).mtimeMs !== observedMtimeMs;
+	} catch {
+		displacedFreshLock = false;
+	}
+	try {
+		if (displacedFreshLock) publishFileExclusive(breakPath, lockPath);
+	} catch {
+		// Best-effort hand-back. A holder whose lock could not be restored notices the
+		// loss at its next ownership recheck and aborts its scan.
+	}
+	try {
+		unlinkIfPresent(breakPath);
+	} catch {
+		// A leftover break file is harmless.
+	}
+	return !displacedFreshLock;
+}
+
+function ownsCleanupLock(lockPath: string, token: string): boolean {
+	try {
+		return fs.readFileSync(lockPath, "utf-8") === token;
+	} catch {
+		return false;
+	}
+}
+
+function releaseCleanupLock(lockPath: string, token: string): void {
+	try {
+		if (fs.readFileSync(lockPath, "utf-8") === token) fs.unlinkSync(lockPath);
+	} catch {
+		// Lock release is best-effort; a failure only means the lock goes stale and is
+		// broken by a later scan, and must never abort cleanup of the remaining roots.
+	}
+}
+
+function cleanupSessionsRoot(sessionsBase: string, maxAgeDays: number): void {
+	if (!fs.existsSync(sessionsBase)) return;
+
+	const now = Date.now();
+	const markerPath = path.join(sessionsBase, CLEANUP_MARKER_FILE);
+	if (markerIsFresh(markerPath, now)) return;
+
+	const lockPath = path.join(sessionsBase, CLEANUP_LOCK_FILE);
+	const lockToken = acquireCleanupLock(lockPath, now);
+	if (lockToken === null) return;
+	try {
 		let dirs: string[];
 		try {
 			dirs = fs.readdirSync(sessionsBase);
 		} catch {
 			// Session artifact cleanup is best-effort. If the sessions root cannot be read,
 			// skip cleanup instead of failing extension startup.
-			continue;
+			return;
 		}
 
 		for (const dir of dirs) {
+			if (dir === CLEANUP_MARKER_FILE || dir === CLEANUP_LOCK_FILE) continue;
+			// A holder displaced by a stale-lock takeover that could not be handed its
+			// lock back must not keep deleting alongside the new lock owner; recheck
+			// ownership before every destructive per-session cleanup and abort the
+			// scan as soon as the lock is lost.
+			if (!ownsCleanupLock(lockPath, lockToken)) return;
 			const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
 			try {
 				cleanupOldArtifacts(artifactsDir, maxAgeDays);
@@ -106,5 +217,24 @@ export function cleanupAllArtifactDirs(maxAgeDays: number): void {
 				// does not block cleanup for the rest.
 			}
 		}
+
+		try {
+			if (ownsCleanupLock(lockPath, lockToken)) fs.writeFileSync(markerPath, String(now));
+		} catch {
+			// Failing to record the marker only means the scan may repeat sooner.
+		}
+	} finally {
+		releaseCleanupLock(lockPath, lockToken);
+	}
+}
+
+export function cleanupAllArtifactDirs(maxAgeDays: number, sessionsRoots?: readonly string[]): void {
+	cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
+
+	// Host-provided sessions roots keep isolated/programmatic agent directories from
+	// leaking into the real global (and legacy) session roots; only the env/global
+	// derivation scans those.
+	for (const sessionsBase of sessionsRoots ?? getAgentConfigPaths("sessions")) {
+		cleanupSessionsRoot(sessionsBase, maxAgeDays);
 	}
 }

package/dist/builtin/subagents/src/shared/event-jsonl-writer.ts

@@ -74,7 +74,14 @@ function scanForTruncationMarker(filePath: string): boolean {
 }
 
 function hydrationFromStat(stat: fs.Stats, state: TelemetryState): TelemetryHydration {
-	return { dev: Number(stat.dev), ino: Number(stat.ino), size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, ...state };
+	return {
+		dev: Number(stat.dev),
+		ino: Number(stat.ino),
+		size: stat.size,
+		mtimeMs: stat.mtimeMs,
+		ctimeMs: stat.ctimeMs,
+		...state,
+	};
 }
 
 function existingTelemetryState(filePath: string, seed?: TelemetryState): TelemetryState {
@@ -96,11 +103,16 @@ function existingTelemetryState(filePath: string, seed?: TelemetryState): Teleme
 function cacheSettledWriter(writer: SharedEventWriter): void {
 	try {
 		const stat = fs.statSync(writer.filePath);
-		cacheHydration(writer.key, hydrationFromStat(stat, {
-			telemetryBytes: Math.max(stat.size, writer.telemetryBytes),
-			telemetryTruncated: writer.telemetryTruncated,
-		}));
-	} catch { hydrationCache.delete(writer.key); }
+		cacheHydration(
+			writer.key,
+			hydrationFromStat(stat, {
+				telemetryBytes: Math.max(stat.size, writer.telemetryBytes),
+				telemetryTruncated: writer.telemetryTruncated,
+			}),
+		);
+	} catch {
+		hydrationCache.delete(writer.key);
+	}
 }
 
 export function resetEventWriterHydrationCacheForTests(): void {
@@ -205,7 +217,12 @@ function createDeferredLease(
 	};
 }
 
-function createWriter(filePath: string, key: string, createWriteStream: StreamFactory, seed?: TelemetryState): SharedEventWriter | undefined {
+function createWriter(
+	filePath: string,
+	key: string,
+	createWriteStream: StreamFactory,
+	seed?: TelemetryState,
+): SharedEventWriter | undefined {
 	let stream: JsonlWriteStream;
 	try {
 		stream = createWriteStream(filePath);
@@ -213,11 +230,22 @@ function createWriter(filePath: string, key: string, createWriteStream: StreamFa
 		return undefined;
 	}
 	let resolveSettled = () => {};
-	const settled = new Promise<void>((resolve) => { resolveSettled = resolve; });
+	const settled = new Promise<void>((resolve) => {
+		resolveSettled = resolve;
+	});
 	const writer: SharedEventWriter = {
-		stream, sources: new Set(), refs: 0, backpressured: false,
+		stream,
+		sources: new Set(),
+		refs: 0,
+		backpressured: false,
 		...existingTelemetryState(filePath, seed),
-		closed: false, failed: false, filePath, key, closingLines: [], settled, resolveSettled,
+		closed: false,
+		failed: false,
+		filePath,
+		key,
+		closingLines: [],
+		settled,
+		resolveSettled,
 	};
 	stream.on?.("error", () => failWriter(writer));
 	writers.set(key, writer);
@@ -257,13 +285,20 @@ function acquireEventWriterInternal(
 			if (closePromise) return closePromise;
 			writer!.sources.delete(source);
 			writer!.refs -= 1;
-			if (writer!.refs > 0 || writer!.failed) return closePromise = Promise.resolve();
+			if (writer!.refs > 0 || writer!.failed) {
+				closePromise = Promise.resolve();
+				return closePromise;
+			}
 			writer!.closed = true;
 			try {
 				writer!.stream.end(() => {
 					if (!writer!.failed) {
 						for (const line of writer!.closingLines) {
-							try { fs.appendFileSync(writer!.filePath, line); } catch { /* telemetry failure is non-fatal */ }
+							try {
+								fs.appendFileSync(writer!.filePath, line);
+							} catch {
+								/* telemetry failure is non-fatal */
+							}
 						}
 						settleWriter(writer!);
 					}
@@ -271,7 +306,8 @@ function acquireEventWriterInternal(
 			} catch {
 				failWriter(writer!);
 			}
-			return closePromise = writer!.settled;
+			closePromise = writer!.settled;
+			return closePromise;
 		},
 	};
 }

package/dist/builtin/subagents/src/shared/fast-mode.ts

@@ -1,9 +1,9 @@
 import {
-	SettingsManager,
-	isCodexFastModeCandidateModelId,
-	shouldApplyCodexFastModeForScope,
 	type CodexFastModeResolvedSettings,
 	type CodexFastModeScope,
+	isCodexFastModeCandidateModelId,
+	SettingsManager,
+	shouldApplyCodexFastModeForScope,
 } from "@bastani/atomic";
 import { splitKnownThinkingSuffix } from "./model-info.ts";
 
@@ -64,17 +64,24 @@ export function resolveSubagentModelFastModeMap(input: ResolveSubagentModelFastM
 	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
 	const fastModes: Record<string, boolean> = {};
 	for (const model of input.models) {
-		if (!model || Object.prototype.hasOwnProperty.call(fastModes, model)) continue;
+		if (!model || Object.hasOwn(fastModes, model)) continue;
 		fastModes[model] = resolveSubagentModelFastMode({ model, cwd: input.cwd, settings, scope: input.scope });
 	}
 	return fastModes;
 }
 
-export function resolveSubagentModelFastModeMetadata(input: ResolveSubagentModelFastModeMetadataInput): SubagentModelFastModeMetadata {
+export function resolveSubagentModelFastModeMetadata(
+	input: ResolveSubagentModelFastModeMetadataInput,
+): SubagentModelFastModeMetadata {
 	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
 	const fastMode = resolveSubagentModelFastMode({ model: input.model, cwd: input.cwd, settings, scope: input.scope });
 	return {
 		...(fastMode ? { fastMode: true as const } : {}),
-		modelFastModes: resolveSubagentModelFastModeMap({ models: input.modelCandidates, cwd: input.cwd, settings, scope: input.scope }),
+		modelFastModes: resolveSubagentModelFastModeMap({
+			models: input.modelCandidates,
+			cwd: input.cwd,
+			settings,
+			scope: input.scope,
+		}),
 	};
 }

package/dist/builtin/subagents/src/shared/fork-context.ts

@@ -43,9 +43,10 @@ export function createForkContextResolver(
 		throw new Error("Forked subagent context requires a current leaf to fork from.");
 	}
 
-	const openSession = options.openSession
-		?? sessionManager.openSession
-		?? ((file: string, dir?: string) => SessionManager.open(file, dir));
+	const openSession =
+		options.openSession ??
+		sessionManager.openSession ??
+		((file: string, dir?: string) => SessionManager.open(file, dir));
 	const sessionDir = sessionManager.getSessionDir?.();
 	const cachedSessionFiles = new Map<number, string>();
 
@@ -55,7 +56,9 @@ export function createForkContextResolver(
 			if (cached) return cached;
 			try {
 				if (!fs.existsSync(parentSessionFile)) {
-					throw new Error(`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`);
+					throw new Error(
+						`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`,
+					);
 				}
 				const sourceManager = openSession(parentSessionFile, sessionDir);
 				const sessionFile = sourceManager.createBranchedSession(leafId);

package/dist/builtin/subagents/src/shared/formatters.ts

@@ -4,10 +4,10 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { Usage, SingleResult } from "./types.ts";
+import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
 import type { ChainStep } from "./settings.ts";
 import { isDynamicParallelStep, isParallelStep } from "./settings.ts";
-import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
+import type { SingleResult, Usage } from "./types.ts";
 
 /**
  * Format token count with k suffix for large numbers
@@ -70,7 +70,13 @@ export function buildChainSummary(
 	failedStep?: { index: number; error: string },
 ): string {
 	const stepNames = steps
-		.map((step) => (isParallelStep(step) ? `parallel[${step.parallel.length}]` : isDynamicParallelStep(step) ? `expand:${step.parallel.agent}` : step.agent))
+		.map((step) =>
+			isParallelStep(step)
+				? `parallel[${step.parallel.length}]`
+				: isDynamicParallelStep(step)
+					? `expand:${step.parallel.agent}`
+					: step.agent,
+		)
 		.join(" → ");
 
 	const totalDuration = results.reduce((sum, r) => sum + (r.progress?.durationMs || 0), 0);
@@ -80,7 +86,9 @@ export function buildChainSummary(
 	const hasProgress = fs.existsSync(progressPath);
 	const allSkills = new Set<string>();
 	for (const r of results) {
-		if (r.skills) r.skills.forEach((s) => allSkills.add(s));
+		if (r.skills) {
+			for (const skill of r.skills) allSkills.add(skill);
+		}
 	}
 	const skillsLine = allSkills.size > 0 ? `🔧 Skills: ${[...allSkills].join(", ")}` : "";
 
@@ -113,11 +121,8 @@ export function formatToolCall(name: string, args: Record<string, unknown>, expa
 		case "read":
 		case "write":
 		case "edit": {
-			const target = typeof args.path === "string"
-				? args.path
-				: typeof args.file_path === "string"
-					? args.file_path
-					: "";
+			const target =
+				typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : "";
 			return `${name} ${shortenPath(target)}`;
 		}
 		default: {

package/dist/builtin/subagents/src/shared/jsonl-writer.ts

@@ -36,7 +36,8 @@ export function createJsonlWriter(
 		};
 	}
 
-	const createWriteStream = deps.createWriteStream ?? ((targetPath: string) => fs.createWriteStream(targetPath, { flags: "a" }));
+	const createWriteStream =
+		deps.createWriteStream ?? ((targetPath: string) => fs.createWriteStream(targetPath, { flags: "a" }));
 	let stream: JsonlWriteStream | undefined;
 	try {
 		stream = createWriteStream(filePath);

package/dist/builtin/subagents/src/shared/model-info.ts

@@ -1,5 +1,5 @@
 export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-export type ThinkingLevel = typeof THINKING_LEVELS[number];
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
 export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
 
 export interface ModelInfo {
@@ -46,7 +46,10 @@ export function collectKnownModelProviders(registry: KnownProviderRegistryLike):
 /** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
  * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
  * (e.g. no model was specified, or the model has no suffix and no config was provided). */
-export function resolveEffectiveThinking(model: string | undefined, configThinking: string | undefined): string | undefined {
+export function resolveEffectiveThinking(
+	model: string | undefined,
+	configThinking: string | undefined,
+): string | undefined {
 	if (!model) return undefined;
 	const { thinkingSuffix } = splitKnownThinkingSuffix(model);
 	if (thinkingSuffix) return thinkingSuffix.slice(1);
@@ -64,7 +67,11 @@ export function splitKnownThinkingSuffix(model: string): { baseModel: string; th
 	};
 }
 
-export function findModelInfo(model: string | undefined, availableModels: ModelInfo[] | undefined, preferredProvider?: string): ModelInfo | undefined {
+export function findModelInfo(
+	model: string | undefined,
+	availableModels: ModelInfo[] | undefined,
+	preferredProvider?: string,
+): ModelInfo | undefined {
 	if (!model || !availableModels || availableModels.length === 0) return undefined;
 	const { baseModel } = splitKnownThinkingSuffix(model);
 	const exact = availableModels.find((entry) => entry.fullId === baseModel);