@oh-my-pi/pi-coding-agent 16.2.5 → 16.2.7

package/src/session/session-loader.ts

@@ -1,8 +1,11 @@
+import * as fs from "node:fs";
+import * as readline from "node:readline";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { getBlobsDir, isEnoent, parseJsonlLenient } from "@oh-my-pi/pi-utils";
 import { BlobStore, isBlobRef, resolveImageData, resolveImageDataUrl } from "./blob-store";
 import { buildSessionContext } from "./session-context";
 import {
+	type CompactionEntry,
 	type FileEntry,
 	type RawFileEntry,
 	SESSION_TITLE_SLOT_BYTES,
@@ -20,6 +23,10 @@ import {
 	titleUpdateFromSlot,
 } from "./session-title-slot";
 
+const STREAM_LOAD_THRESHOLD_BYTES = 8 * 1024 * 1024;
+const ELIDED_COMPACTION_SUMMARY = "[Superseded compaction summary elided during session load]";
+const ELIDED_COMPACTION_SHORT_SUMMARY = "Superseded compaction elided";
+
 function splitTitleSlot(content: string): { body: string; slot: SessionTitleUpdate | undefined } {
 	const slot = titleUpdateFromSlot(parseTitleSlotFromContent(content));
 	if (!slot) return { body: content, slot: undefined };
@@ -54,6 +61,89 @@ export function parseSessionContent(content: string): {
 	return { entries: foldTitleSlot(entries, slot), titleSlot: slot };
 }
 
+function elideCompactionSummary(entry: CompactionEntry | undefined): boolean {
+	if (!entry) return false;
+	if (
+		entry.summary === ELIDED_COMPACTION_SUMMARY &&
+		entry.shortSummary === ELIDED_COMPACTION_SHORT_SUMMARY &&
+		entry.preserveData === undefined
+	) {
+		return false;
+	}
+	entry.summary = ELIDED_COMPACTION_SUMMARY;
+	entry.shortSummary = ELIDED_COMPACTION_SHORT_SUMMARY;
+	entry.preserveData = undefined;
+	return true;
+}
+
+function collectActiveBranchIds(entries: FileEntry[]): Set<string> {
+	const byId = new Map<string, SessionEntry>();
+	for (const entry of entries) {
+		const id = (entry as SessionEntry).id;
+		if (typeof id === "string") byId.set(id, entry as SessionEntry);
+	}
+	const branchIds = new Set<string>();
+	let cursor = entries[entries.length - 1] as SessionEntry | undefined;
+	while (cursor && typeof cursor.id === "string" && !branchIds.has(cursor.id)) {
+		branchIds.add(cursor.id);
+		const parentId = cursor.parentId;
+		cursor = parentId ? byId.get(parentId) : undefined;
+	}
+	return branchIds;
+}
+
+function elideSupersededCompactionEntries(entries: FileEntry[]): void {
+	const branchIds = collectActiveBranchIds(entries);
+	let previousCompaction: CompactionEntry | undefined;
+	for (const entry of entries) {
+		if (entry.type !== "compaction") continue;
+		if (!branchIds.has(entry.id)) continue;
+		elideCompactionSummary(previousCompaction);
+		previousCompaction = entry;
+	}
+}
+
+async function loadEntriesFromFileStream(filePath: string): Promise<{
+	entries: FileEntry[];
+	titleSlot: SessionTitleUpdate | undefined;
+}> {
+	const entries: FileEntry[] = [];
+	let titleSlot: SessionTitleUpdate | undefined;
+	let sawBodyLine = false;
+	const input = fs.createReadStream(filePath, { encoding: "utf8" });
+	const lines = readline.createInterface({ input, crlfDelay: Infinity });
+
+	try {
+		for await (const rawLine of lines) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			if (!sawBodyLine) {
+				const slot = parseTitleSlotLine(line);
+				if (slot) {
+					titleSlot = titleUpdateFromSlot(slot);
+					sawBodyLine = true;
+					continue;
+				}
+				sawBodyLine = true;
+			}
+
+			let entry: FileEntry;
+			try {
+				entry = JSON.parse(line) as FileEntry;
+			} catch {
+				continue;
+			}
+			entries.push(entry);
+		}
+	} catch (err) {
+		input.destroy();
+		if (isEnoent(err)) return { entries: [], titleSlot: undefined };
+		throw err;
+	}
+
+	return { entries: foldTitleSlot(entries, titleSlot), titleSlot };
+}
+
 /** Read only the fixed-size head window to detect a physical title slot. */
 export async function readTitleSlotFromFile(
 	filePath: string,
@@ -80,14 +170,19 @@ export async function loadEntriesFromFile(
 	filePath: string,
 	storage: SessionStorage = new FileSessionStorage(),
 ): Promise<FileEntry[]> {
-	let content: string;
+	let loaded: { entries: FileEntry[]; titleSlot: SessionTitleUpdate | undefined };
 	try {
-		content = await storage.readText(filePath);
+		const stat = storage.statSync(filePath);
+		loaded =
+			storage instanceof FileSessionStorage && stat.size >= STREAM_LOAD_THRESHOLD_BYTES
+				? await loadEntriesFromFileStream(filePath)
+				: parseSessionContent(await storage.readText(filePath));
 	} catch (err) {
 		if (isEnoent(err)) return [];
 		throw err;
 	}
-	const { entries } = parseSessionContent(content);
+	const { entries } = loaded;
+	elideSupersededCompactionEntries(entries);
 
 	// Validate session header
 	if (entries.length === 0) return entries;

package/src/session/session-manager.ts

@@ -1,6 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent, Usage } from "@oh-my-pi/pi-ai";
+import type {
+	ImageContent,
+	Message,
+	MessageAttribution,
+	ServiceTierByFamily,
+	TextContent,
+	Usage,
+} from "@oh-my-pi/pi-ai";
 import {
 	directoryExists,
 	getBlobsDir,
@@ -66,6 +73,8 @@ import {
 import { type SessionTitleUpdate, serializeTitleSlot } from "./session-title-slot";
 
 const JSONL_SUFFIX_LENGTH = ".jsonl".length;
+const SUPERSEDED_COMPACTION_SUMMARY = "[Superseded compaction summary elided after a newer compaction]";
+const SUPERSEDED_COMPACTION_SHORT_SUMMARY = "Superseded compaction elided";
 
 function mintSessionId(): string {
 	return Bun.randomUUIDv7();
@@ -502,6 +511,26 @@ export class SessionManager {
 		return this.#forceFileCreation || this.#fileIsCurrent || this.#historyContainsAssistantMessage();
 	}
 
+	#elideSupersededCompactionsOnBranch(leafId: string | null): boolean {
+		if (!leafId) return false;
+		let changed = false;
+		for (const entry of this.#index.pathTo(leafId)) {
+			if (entry.type !== "compaction") continue;
+			if (
+				entry.summary === SUPERSEDED_COMPACTION_SUMMARY &&
+				entry.shortSummary === SUPERSEDED_COMPACTION_SHORT_SUMMARY &&
+				entry.preserveData === undefined
+			) {
+				continue;
+			}
+			entry.summary = SUPERSEDED_COMPACTION_SUMMARY;
+			entry.shortSummary = SUPERSEDED_COMPACTION_SHORT_SUMMARY;
+			entry.preserveData = undefined;
+			changed = true;
+		}
+		return changed;
+	}
+
 	/**
 	 * Synchronously rewrite the whole file (header + entries) and keep no open
 	 * writer; the next append re-opens one. `writeTextSync` returns with the
@@ -1024,14 +1053,18 @@ export class SessionManager {
 	}
 
 	/**
-	 * Synchronously flush all in-memory entries to disk. Use when the process may
-	 * exit before an async flush settles (Ctrl+C in the TUI). Software-crash
-	 * durable; not atomic and not power-loss safe — a same-process crash never
-	 * lands mid-`writeFileSync`.
+	 * Synchronously makes the current append-only session durable. Avoid rewriting
+	 * an already-current file: large restored sessions can contain GiB of compacted
+	 * history, and Ctrl+C must not rebuild the whole JSONL string just to flush.
 	 */
 	flushSync(): void {
 		if (!this.#persist || !this.#sessionFile) return;
 		if (this.#diskFailure) throw this.#diskFailure;
+		if (this.#fileIsCurrent && !this.#rewriteRequired) {
+			const writerError = this.#writer?.getError();
+			if (writerError) throw writerError;
+			return;
+		}
 		this.#rewriteSynchronously();
 		if (this.#diskFailure) throw this.#diskFailure;
 	}
@@ -1260,7 +1293,7 @@ export class SessionManager {
 		return entry.id;
 	}
 
-	appendServiceTierChange(serviceTier: ServiceTier | null): string {
+	appendServiceTierChange(serviceTier: ServiceTierByFamily | null): string {
 		const entry: ServiceTierChangeEntry = { type: "service_tier_change", ...this.#freshEntryFields(), serviceTier };
 		this.#recordEntry(entry);
 		return entry.id;
@@ -1305,6 +1338,7 @@ export class SessionManager {
 		fromExtension?: boolean,
 		preserveData?: Record<string, unknown>,
 	): string {
+		const elidedSupersededCompactions = this.#elideSupersededCompactionsOnBranch(this.#index.leafId());
 		const entry: CompactionEntry<T> = {
 			type: "compaction",
 			...this.#freshEntryFields(),
@@ -1317,6 +1351,9 @@ export class SessionManager {
 			preserveData,
 		};
 		this.#recordEntry(entry);
+		if (elidedSupersededCompactions) {
+			void this.#rewriteAtomically().catch(err => this.#noteDiskFailure(err));
+		}
 		return entry.id;
 	}
 

package/src/slash-commands/builtin-registry.ts

@@ -73,17 +73,9 @@ function refreshStatusLine(ctx: InteractiveModeContext): void {
 	ctx.ui.requestRender();
 }
 
-/** `/fast status` label: "off", "on", or scope-qualified "on (… only)". */
+/** `/fast status` label for the active model: "on" when its family is priority, else "off". */
 function formatFastModeStatus(session: AgentSession): string {
-	if (!session.isFastModeEnabled()) return "off";
-	switch (session.serviceTier) {
-		case "openai-only":
-			return "on (OpenAI only)";
-		case "claude-only":
-			return "on (Claude only)";
-		default:
-			return "on";
-	}
+	return session.isFastModeEnabled() ? "on" : "off";
 }
 
 const AUTOCOMPLETE_DETAIL_LIMIT = 48;

package/src/subprocess/worker-client.ts

@@ -1,5 +1,12 @@
 import * as path from "node:path";
-import { $env, isBunTestRuntime, isCompiledBinary, logger, workerHostEntry } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	isBunTestRuntime,
+	isCompiledBinary,
+	logger,
+	stripWindowsExtendedLengthPathPrefix,
+	workerHostEntry,
+} from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
 
 /**
@@ -90,13 +97,14 @@ export const SMOKE_TEST_TIMEOUT_MS = 30_000;
  * embedding).
  */
 export function resolveWorkerSpawnCmd(workerArg: string): WorkerSpawnCommand {
-	if (isCompiledBinary()) return { cmd: [process.execPath, workerArg] };
+	const executable = stripWindowsExtendedLengthPathPrefix(process.execPath);
+	if (isCompiledBinary()) return { cmd: [executable, workerArg] };
 	const hostEntry = workerHostEntry();
 	if (hostEntry) {
-		return { cmd: [process.execPath, path.basename(hostEntry), workerArg], cwd: path.dirname(hostEntry) };
+		return { cmd: [executable, path.basename(hostEntry), workerArg], cwd: path.dirname(hostEntry) };
 	}
 	const packageRoot = path.resolve(import.meta.dir, "..", "..");
-	return { cmd: [process.execPath, "src/cli.ts", workerArg], cwd: packageRoot };
+	return { cmd: [executable, "src/cli.ts", workerArg], cwd: packageRoot };
 }
 
 /**

package/src/system-prompt.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+interface ProbeRunResult {
+	elapsedMs: number;
+	childElapsedMs: number;
+	cached: unknown;
+	count: number;
+}
+
+async function runProbeScenario(options: {
+	runs: number;
+	sleepSeconds?: number;
+	holdStdoutOpen?: boolean;
+	descendantHoldsStdout?: boolean;
+	validOutput?: string;
+}): Promise<ProbeRunResult> {
+	const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "omp-gpu-probe-"));
+	try {
+		const binDir = path.join(tempRoot, "bin");
+		const cacheRoot = path.join(tempRoot, "cache");
+		const probeCountPath = path.join(tempRoot, "probe-count");
+		await fs.mkdir(binDir, { recursive: true });
+		await fs.mkdir(path.join(cacheRoot, "omp"), { recursive: true });
+		const lspciPath = path.join(binDir, "lspci");
+		await Bun.write(
+			lspciPath,
+			'#!/usr/bin/env sh\nprintf x >> "$OMP_GPU_PROBE_COUNT"\nif [ -n "$OMP_GPU_PROBE_VALID_OUTPUT" ]; then printf "%s\\n" "$OMP_GPU_PROBE_VALID_OUTPUT"; fi\nif [ "$OMP_GPU_PROBE_DESCENDANT_HOLDS_STDOUT" = "true" ]; then sleep "$OMP_GPU_PROBE_SLEEP" & exit 0; fi\nif [ "$OMP_GPU_PROBE_HOLD_STDOUT_OPEN" = "true" ]; then sleep "$OMP_GPU_PROBE_SLEEP" & wait "$!"; fi\nif [ -n "$OMP_GPU_PROBE_SLEEP" ]; then exec sleep "$OMP_GPU_PROBE_SLEEP"; fi\nexit 0\n',
+		);
+		await fs.chmod(lspciPath, 0o755);
+
+		const scenarioPath = path.join(tempRoot, "scenario.ts");
+		await Bun.write(
+			scenarioPath,
+			`import { getGpuCachePath, refreshDirsFromEnv } from ${JSON.stringify(path.resolve(import.meta.dir, "../../utils/src/index.ts"))};
+import { buildSystemPrompt } from ${JSON.stringify(path.join(import.meta.dir, "system-prompt.ts"))};
+
+refreshDirsFromEnv();
+const buildOptions = {
+	contextFiles: [],
+	skills: [],
+	toolNames: [],
+	workspaceTree: {
+		rootPath: process.cwd(),
+		rendered: "",
+		truncated: false,
+		totalLines: 0,
+		agentsMdFiles: [],
+	},
+	activeRepoContext: null,
+};
+const startedAt = performance.now();
+for (let index = 0; index < Number(process.env.OMP_GPU_PROBE_RUNS ?? "1"); index += 1) {
+	await buildSystemPrompt(buildOptions);
+}
+const cacheFile = Bun.file(getGpuCachePath());
+const cached = await cacheFile.exists() ? await cacheFile.json() : null;
+const countFile = Bun.file(process.env.OMP_GPU_PROBE_COUNT ?? "");
+const count = await countFile.exists() ? (await countFile.text()).length : 0;
+console.log(JSON.stringify({ elapsedMs: Math.round(performance.now() - startedAt), cached, count }));
+`,
+		);
+
+		const env: Record<string, string | undefined> = {
+			...process.env,
+			PATH: `${binDir}:${process.env.PATH ?? ""}`,
+			XDG_CACHE_HOME: cacheRoot,
+			OMP_GPU_PROBE_COUNT: probeCountPath,
+			OMP_GPU_PROBE_RUNS: String(options.runs),
+		};
+		// Strip inherited dirs-resolver overrides so XDG_CACHE_HOME above wins and
+		// the test cannot touch the developer/CI profile's real gpu_cache.json.
+		for (const key of ["PI_CODING_AGENT_DIR", "OMP_PROFILE", "PI_PROFILE", "PI_CONFIG_DIR"]) {
+			delete env[key];
+		}
+		if (options.sleepSeconds === undefined) {
+			delete env.OMP_GPU_PROBE_SLEEP;
+		} else {
+			env.OMP_GPU_PROBE_SLEEP = String(options.sleepSeconds);
+		}
+		if (options.holdStdoutOpen) {
+			env.OMP_GPU_PROBE_HOLD_STDOUT_OPEN = "true";
+		} else {
+			delete env.OMP_GPU_PROBE_HOLD_STDOUT_OPEN;
+		}
+		if (options.descendantHoldsStdout) {
+			env.OMP_GPU_PROBE_DESCENDANT_HOLDS_STDOUT = "true";
+		} else {
+			delete env.OMP_GPU_PROBE_DESCENDANT_HOLDS_STDOUT;
+		}
+		if (options.validOutput !== undefined) {
+			env.OMP_GPU_PROBE_VALID_OUTPUT = options.validOutput;
+		} else {
+			delete env.OMP_GPU_PROBE_VALID_OUTPUT;
+		}
+
+		const childStartedAt = performance.now();
+		const child = Bun.spawn([process.execPath, scenarioPath], { stdout: "pipe", stderr: "pipe", env });
+		const [stdout, stderr, exitCode] = await Promise.all([
+			new Response(child.stdout).text(),
+			new Response(child.stderr).text(),
+			child.exited,
+		]);
+		const childElapsedMs = Math.round(performance.now() - childStartedAt);
+		if (exitCode !== 0) {
+			throw new Error(`GPU probe scenario failed with exit ${exitCode}: ${stderr}`);
+		}
+		return { ...JSON.parse(stdout.trim()), childElapsedMs };
+	} finally {
+		await fs.rm(tempRoot, { recursive: true, force: true });
+	}
+}
+
+describe.skipIf(process.platform !== "linux")("system prompt GPU probe", () => {
+	it("caches empty GPU probe results", async () => {
+		const result = await runProbeScenario({ runs: 2 });
+
+		expect(result.cached).toEqual({ gpu: null });
+		expect(result.count).toBe(1);
+	}, 15_000);
+
+	it("kills the GPU probe at the prep deadline", async () => {
+		const result = await runProbeScenario({ runs: 1, sleepSeconds: 7, holdStdoutOpen: true });
+
+		expect(result.cached).toEqual({ gpu: null });
+		expect(result.elapsedMs).toBeLessThan(6500);
+		// Codex#3838: the child process MUST exit shortly after the deadline,
+		// not linger until a descendant holding stdout (sleep 7) exits on its own.
+		expect(result.childElapsedMs).toBeLessThan(6500);
+	}, 15_000);
+
+	it("does not wait on stdout held by a descendant after a successful probe", async () => {
+		const result = await runProbeScenario({ runs: 1, sleepSeconds: 3, descendantHoldsStdout: true });
+
+		expect(result.cached).toEqual({ gpu: null });
+		// Probe exits 0 immediately but leaves a backgrounded sleep holding the stdout
+		// pipe. The success path MUST bound the drain wait, not block until sleep exits.
+		expect(result.elapsedMs).toBeLessThan(2000);
+		expect(result.childElapsedMs).toBeLessThan(2000);
+	}, 15_000);
+
+	it("keeps probe output captured before a descendant delays EOF", async () => {
+		const result = await runProbeScenario({
+			runs: 1,
+			sleepSeconds: 3,
+			descendantHoldsStdout: true,
+			validOutput: "00:02.0 VGA compatible controller: NVIDIA TestGPU",
+		});
+
+		// Probe exited 0 with valid output before bg sleep held stdout open.
+		// Captured stdout MUST be cached, not discarded as if the probe failed.
+		expect(result.cached).toEqual({ gpu: "02.0 VGA compatible controller: NVIDIA TestGPU" });
+		expect(result.elapsedMs).toBeLessThan(2000);
+		expect(result.childElapsedMs).toBeLessThan(2000);
+	}, 15_000);
+});

package/src/system-prompt.ts

@@ -7,7 +7,6 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample, TSchema } from "@oh-my-pi/pi-ai";
 import { renderToolInventory } from "@oh-my-pi/pi-ai/dialect";
 import { $env, getGpuCachePath, getProjectDir, hasFsCode, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
-import { $ } from "bun";
 import { contextFileCapability } from "./capability/context-file";
 import { systemPromptCapability } from "./capability/system-prompt";
 import { findConfigFile } from "./config";
@@ -112,21 +111,60 @@ function parseWmicTable(output: string, header: string): string | null {
 }
 
 const SYSTEM_PROMPT_PREP_TIMEOUT_MS = 5000;
+/** Kept below prep timeout so timed-out probes can still write the null cache before fallback. */
+const GPU_PROBE_TIMEOUT_MS = SYSTEM_PROMPT_PREP_TIMEOUT_MS - 500;
+/** Drop stdout from a probe descendant that inherited the pipe after the probe exited. */
+const GPU_PROBE_STDOUT_DRAIN_MS = 250;
+
+async function runGpuProbe(cmd: string[]): Promise<string | null> {
+	try {
+		const proc = Bun.spawn({
+			cmd,
+			stdout: "pipe",
+			stderr: "ignore",
+			stdin: "ignore",
+			timeout: GPU_PROBE_TIMEOUT_MS,
+			// SIGKILL so a probe ignoring SIGTERM (PATH wrapper, wedged WMI) still
+			// dies at the deadline and lets getCachedGpu reach the null-cache write.
+			killSignal: "SIGKILL",
+		});
+		const stdoutReader = proc.stdout.getReader();
+		let stdout = "";
+		const decoder = new TextDecoder();
+		const stdoutDone = (async () => {
+			while (true) {
+				const chunk = await stdoutReader.read();
+				if (chunk.done) break;
+				stdout += decoder.decode(chunk.value, { stream: true });
+			}
+			stdout += decoder.decode();
+		})();
+		const exitCode = await proc.exited;
+		// Even on exit 0, a probe wrapper can leave a descendant holding stdout open.
+		// Bound the EOF wait so getCachedGpu cannot outlive the probe in either path;
+		// keep whatever bytes the reader already captured before cancelling.
+		const drained = await Promise.race([
+			stdoutDone.then(() => "ok" as const).catch(() => "err" as const),
+			Bun.sleep(GPU_PROBE_STDOUT_DRAIN_MS).then(() => "timeout" as const),
+		]);
+		if (drained !== "ok") {
+			await stdoutReader.cancel().catch(() => undefined);
+			await stdoutDone.catch(() => undefined);
+		}
+		return exitCode === 0 ? stdout : null;
+	} catch {
+		return null;
+	}
+}
 
 async function getGpuModel(): Promise<string | null> {
 	switch (process.platform) {
 		case "win32": {
-			const output = await $`wmic path win32_VideoController get name`
-				.quiet()
-				.text()
-				.catch(() => null);
+			const output = await runGpuProbe(["wmic", "path", "win32_VideoController", "get", "name"]);
 			return output ? parseWmicTable(output, "Name") : null;
 		}
 		case "linux": {
-			const output = await $`lspci`
-				.quiet()
-				.text()
-				.catch(() => null);
+			const output = await runGpuProbe(["lspci"]);
 			if (!output) return null;
 			const gpus: Array<{ name: string; priority: number }> = [];
 			for (const line of output.split("\n")) {
@@ -176,20 +214,20 @@ function getTerminalName(): string | undefined {
 	return term ?? undefined;
 }
 
-/** Cached system info structure */
+/** Cached GPU probe result. */
 interface GpuCache {
-	gpu: string;
-}
-
-function getSystemInfoCachePath(): string {
-	return getGpuCachePath();
+	gpu: string | null;
 }
 
 async function loadGpuCache(): Promise<GpuCache | null> {
 	try {
-		const cachePath = getSystemInfoCachePath();
+		const cachePath = getGpuCachePath();
 		const content = await Bun.file(cachePath).json();
-		return content as GpuCache;
+		if (content && typeof content === "object" && "gpu" in content) {
+			const gpu = content.gpu;
+			return { gpu: typeof gpu === "string" ? gpu : null };
+		}
+		return null;
 	} catch {
 		return null;
 	}
@@ -197,7 +235,7 @@ async function loadGpuCache(): Promise<GpuCache | null> {
 
 async function saveGpuCache(info: GpuCache): Promise<void> {
 	try {
-		const cachePath = getSystemInfoCachePath();
+		const cachePath = getGpuCachePath();
 		await Bun.write(cachePath, JSON.stringify(info, null, "\t"));
 	} catch {
 		// Silently ignore cache write failures
@@ -206,15 +244,12 @@ async function saveGpuCache(info: GpuCache): Promise<void> {
 
 async function getCachedGpu(): Promise<string | undefined> {
 	const cached = await logger.time("getCachedGpu:loadGpuCache", loadGpuCache);
-	if (cached) return cached.gpu;
+	if (cached) return cached.gpu ?? undefined;
 	const gpu = await logger.time("getCachedGpu:getGpuModel", getGpuModel);
-	if (gpu) {
-		await logger.time("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
-	}
+	await logger.time("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
 	return gpu ?? undefined;
 }
-async function getEnvironmentInfo(): Promise<Array<{ label: string; value: string }>> {
-	const gpu = await getCachedGpu();
+function getEnvironmentInfo(gpu: string | undefined): Array<{ label: string; value: string }> {
 	let cpuModel: string | undefined;
 	try {
 		cpuModel = os.cpus()[0]?.model;
@@ -500,9 +535,13 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			agentsMdFiles: [],
 		} satisfies WorkspaceTree,
 		activeRepoContext: null as ActiveRepoContext | null,
+		gpu: undefined as string | undefined,
 	};
 
-	const deadline = Bun.sleep(SYSTEM_PROMPT_PREP_TIMEOUT_MS).then(() => "__timeout__" as const);
+	const { promise: deadline, resolve: fireDeadline } = Promise.withResolvers<"__timeout__">();
+	const deadlineTimer = setTimeout(() => fireDeadline("__timeout__"), SYSTEM_PROMPT_PREP_TIMEOUT_MS);
+	// Unref so a fast prep does not hold a one-shot CLI alive waiting for this timer.
+	deadlineTimer.unref();
 	const timedOut: string[] = [];
 	const failed: Array<{ name: string; error: unknown }> = [];
 
@@ -566,6 +605,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		providedActiveRepoContext !== undefined
 			? Promise.resolve(providedActiveRepoContext)
 			: logger.time("resolveActiveRepoContext", () => resolveActiveRepoContext(resolvedCwd));
+	const gpuPromise = logger.time("getCachedGpu", getCachedGpu);
 
 	const [
 		resolvedCustomPrompt,
@@ -575,6 +615,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills,
 		workspaceTree,
 		activeRepoContext,
+		gpu,
 	] = await Promise.all([
 		withDeadline(
 			"customPrompt",
@@ -597,7 +638,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		withDeadline("loadSkills", skillsPromise, prepDefaults.skills),
 		withDeadline("buildWorkspaceTree", workspaceTreePromise, prepDefaults.workspaceTree),
 		withDeadline("resolveActiveRepoContext", activeRepoContextPromise, prepDefaults.activeRepoContext),
+		withDeadline("getCachedGpu", gpuPromise, prepDefaults.gpu),
 	]);
+	clearTimeout(deadlineTimer);
 	const agentsMdFiles = Array.from(new Set(workspaceTree.agentsMdFiles)).sort().slice(0, AGENTS_MD_LIMIT);
 
 	if (timedOut.length > 0) {
@@ -675,7 +718,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	];
 	const injectedAlwaysApplyRules = dedupeAlwaysApplyRules(alwaysApplyRules, promptSources);
 
-	const environment = await logger.time("getEnvironmentInfo", getEnvironmentInfo);
+	const environment = getEnvironmentInfo(gpu);
 	const data = {
 		systemPromptCustomization: effectiveSystemPromptCustomization,
 		customPrompt: resolvedCustomPrompt,