@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/{src-AELUUb5U.mjs → src-BhinCSpi.mjs}

@@ -1,21 +1,21 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { n as fs_promises_shim_exports } from "./fs-promises-shim-B2YFWkcd.mjs";
+import { n as fs_promises_shim_exports } from "./fs-promises-shim-CANAxFWh.mjs";
 import * as fs from "node:fs";
 import { Process } from "@oh-my-pi/pi-natives";
 import * as path$1 from "node:path";
 import * as os from "node:os";
 import assert from "node:assert/strict";
+import "node:timers/promises";
+import { expandWindowsLongPath } from "@oh-my-pi/pi-natives/path";
+import { parseEnv } from "node:util";
+import JSON5 from "json5";
 import { parse, stringify } from "yaml";
 import * as fsp from "fs/promises";
-import * as crypto$1 from "node:crypto";
 import { createHash, randomUUID } from "node:crypto";
 import { gzipSync } from "node:zlib";
-import JSON5 from "json5";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { isPromise } from "node:util/types";
-import inspector from "node:inspector";
-import { isMainThread } from "node:worker_threads";
 import * as tls from "node:tls";
 //#region src/tools/bash/which.ts
 /**
@@ -61,7 +61,7 @@ function findOnPath(command, env = process.env) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/abortable.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/abortable.ts
 var AbortError$1 = class extends Error {
 	constructor(signal) {
 		assert(signal.aborted, "Abort signal must be aborted");
@@ -154,54 +154,19 @@ function once(fn) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/peek-file.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/peek-file.ts
 /**
 * Read the first `maxBytes` of a file (offset 0) and pass that slice to `op`.
 *
-* Buffers are reused to avoid allocating on every peek: sync uses one growable
-* `Uint8Array`; async uses a small fixed pool of `Buffer`s with a bounded wait
-* queue, falling back to a fresh allocation when the pool and queue are saturated
-* or when `maxBytes` exceeds the pool slot size.
+* Synchronous peeks reuse one growable `Uint8Array`; asynchronous peeks allocate
+* their result window so callback-retained slices cannot be changed by a later read.
 */
-/** Async pool slot size; larger peeks allocate ad hoc. */
-const POOLED_BUFFER_SIZE = 512;
-const ASYNC_POOL_SIZE = 10;
-/** Cap waiter queue so heavy concurrency does not queue unbounded; overflow uses alloc. */
-const MAX_ASYNC_WAITERS = 4;
 const INITIAL_SYNC_BUFFER_SIZE = 1024;
-const EMPTY_BUFFER = Buffer.alloc(0);
-const asyncPool = Array.from({ length: ASYNC_POOL_SIZE }, () => Buffer.allocUnsafe(POOLED_BUFFER_SIZE));
-const availableAsyncPoolIndexes = Array.from({ length: ASYNC_POOL_SIZE }, (_, index) => index);
-const asyncPoolWaiters = [];
+const EMPTY_BUFFER = /* @__PURE__ */ new Uint8Array(0);
 new Uint8Array(INITIAL_SYNC_BUFFER_SIZE);
-/** Returns a pool slot index, or `-1` when the caller should use a standalone buffer. */
-function acquireAsyncPoolIndex() {
-	const index = availableAsyncPoolIndexes.pop();
-	if (index !== void 0) return index;
-	if (asyncPoolWaiters.length >= MAX_ASYNC_WAITERS) return -1;
-	const { promise, resolve } = Promise.withResolvers();
-	asyncPoolWaiters.push(resolve);
-	return promise;
-}
-function releaseAsyncPoolIndex(index) {
-	if (index < 0) return;
-	const waiter = asyncPoolWaiters.shift();
-	if (waiter) {
-		waiter(index);
-		return;
-	}
-	availableAsyncPoolIndexes.push(index);
-}
-async function withAsyncPoolBuffer(maxBytes, op) {
-	if (maxBytes <= 0) return op(EMPTY_BUFFER);
-	if (maxBytes > POOLED_BUFFER_SIZE) return op(Buffer.allocUnsafe(maxBytes));
-	const poolIndex = await acquireAsyncPoolIndex();
-	const buffer = poolIndex >= 0 ? asyncPool[poolIndex] : Buffer.allocUnsafe(maxBytes);
-	try {
-		return await op(buffer.subarray(0, maxBytes));
-	} finally {
-		releaseAsyncPoolIndex(poolIndex);
-	}
+function allocateWindow(length) {
+	const buffer = Buffer.allocUnsafe(length);
+	return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 }
 /**
 * Like {@link peekFileSync} but uses async I/O.
@@ -210,16 +175,15 @@ async function peekFile(filePath, maxBytes, op) {
 	if (maxBytes <= 0) return op(EMPTY_BUFFER);
 	const fileHandle = await fs.promises.open(filePath, "r");
 	try {
-		return await withAsyncPoolBuffer(maxBytes, async (buffer) => {
-			const { bytesRead } = await fileHandle.read(buffer, 0, buffer.byteLength, 0);
-			return op(buffer.subarray(0, bytesRead));
-		});
+		const buffer = allocateWindow(maxBytes);
+		const { bytesRead } = await fileHandle.read(buffer, 0, buffer.byteLength, 0);
+		return op(buffer.subarray(0, bytesRead));
 	} finally {
 		await fileHandle.close();
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/binary.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/binary.ts
 /**
 * Content-based binary/text classification for files that are about to be
 * decoded as UTF-8 text and shown to a model or user.
@@ -266,11 +230,11 @@ function isProbablyBinary(filePath, maxBytes = BINARY_SNIFF_BYTES) {
 	return peekFile(filePath, maxBytes, isProbablyBinaryHeader);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/package.json
-var version = "18.1.17";
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/package.json
+var version = "18.12.6";
 var engines = { "bun": ">=1.3.14" };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/fs-error.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/fs-error.ts
 function isFsError(err) {
 	return err instanceof Error && "code" in err && typeof err.code === "string";
 }
@@ -283,6 +247,16 @@ function isEnotdir(err) {
 function hasFsCode(err, code) {
 	return isFsError(err) && err.code === code;
 }
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/test-runtime.ts
+const BUN_TEST_ENTRY_PATTERN = /[._](?:test|spec)\.[cm]?[jt]sx?$/;
+/** True when the process is an explicitly marked test child or Bun is running a test entrypoint. */
+function isBunTestRuntime() {
+	if (Bun.env.PI_TEST_RUNTIME === "1") return true;
+	return (Bun.env.BUN_ENV === "test" || Bun.env.NODE_ENV === "test") && BUN_TEST_ENTRY_PATTERN.test(Bun.main);
+}
+/** Public homepage that inference gateways (OpenRouter, Vercel AI Gateway) credit omp traffic to. */
+const APP_URL = "https://omp.sh/";
 /** Version (e.g. "1.0.0") */
 const VERSION = version;
 /** Default User-Agent header string (e.g. "omp/17.2.12") */
@@ -341,6 +315,7 @@ function readProfileFromEnvSafe() {
 		return;
 	}
 }
+/** Profile-independent config root (~/.omp), shared by every omp profile. */
 function getBaseConfigRoot() {
 	return path$1.join(os.homedir(), getConfigDirName());
 }
@@ -373,26 +348,34 @@ function standardizeMacOSPath(p) {
 	} catch {}
 	return p;
 }
+/** Keep the current directory's spelling while expanding Windows 8.3 aliases. */
+function standardizeProjectPath(p) {
+	return process.platform === "win32" ? expandWindowsLongPath(p) : standardizeMacOSPath(p);
+}
 let projectDir;
 /** Get the project directory. */
 function getProjectDir() {
-	if (projectDir === void 0) try {
-		projectDir = standardizeMacOSPath(process.cwd());
-	} catch {
-		const candidates = [
-			process.env.PWD,
-			os.homedir(),
-			os.tmpdir()
-		];
-		for (const candidate of candidates) {
-			if (!candidate || !path$1.isAbsolute(candidate)) continue;
-			try {
-				process.chdir(candidate);
-				projectDir = standardizeMacOSPath(candidate);
-				break;
-			} catch {}
+	if (projectDir === void 0) {
+		let cwd;
+		try {
+			cwd = process.cwd();
+		} catch {
+			const candidates = [
+				process.env.PWD,
+				os.homedir(),
+				os.tmpdir()
+			];
+			for (const candidate of candidates) {
+				if (!candidate || !path$1.isAbsolute(candidate)) continue;
+				try {
+					process.chdir(candidate);
+					cwd = candidate;
+					break;
+				} catch {}
+			}
+			if (cwd === void 0) throw new Error("Unable to determine an accessible working directory");
 		}
-		if (projectDir === void 0) throw new Error("Unable to determine an accessible working directory");
+		projectDir = standardizeProjectPath(cwd);
 	}
 	return projectDir;
 }
@@ -411,6 +394,7 @@ var DirResolver = class {
 	agentDir;
 	#rootDirs;
 	#agentDirs;
+	#baseRootDirs;
 	#rootCache = /* @__PURE__ */ new Map();
 	#agentCache = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
@@ -423,7 +407,8 @@ var DirResolver = class {
 		let xdgData;
 		let xdgState;
 		let xdgCache;
-		if ((process.platform === "linux" || process.platform === "darwin") && isDefault) {
+		const xdgPlatform = process.platform === "linux" || process.platform === "darwin";
+		if (xdgPlatform && isDefault) {
 			const resolveIf = (envVar) => {
 				const value = process.env[envVar];
 				if (!value) return void 0;
@@ -434,13 +419,22 @@ var DirResolver = class {
 						if (fs.existsSync(profilePath)) return profilePath;
 						return;
 					}
-					if (fs.existsSync(appRoot)) return appRoot;
+					return fs.existsSync(appRoot) ? appRoot : void 0;
 				} catch {}
 			};
 			xdgData = resolveIf("XDG_DATA_HOME");
 			xdgState = resolveIf("XDG_STATE_HOME");
 			xdgCache = resolveIf("XDG_CACHE_HOME");
 		}
+		const resolveBase = (envVar) => {
+			if (!xdgPlatform) return void 0;
+			const value = process.env[envVar];
+			if (!value) return void 0;
+			try {
+				const appRoot = path$1.join(value, "omp");
+				return fs.existsSync(appRoot) ? appRoot : void 0;
+			} catch {}
+		};
 		this.#rootDirs = {
 			data: xdgData ?? this.configRoot,
 			state: xdgState ?? this.configRoot,
@@ -451,6 +445,16 @@ var DirResolver = class {
 			state: xdgState ?? this.agentDir,
 			cache: xdgCache ?? this.agentDir
 		};
+		const baseRoot = getBaseConfigRoot();
+		this.#baseRootDirs = {
+			data: resolveBase("XDG_DATA_HOME") ?? baseRoot,
+			state: resolveBase("XDG_STATE_HOME") ?? baseRoot,
+			cache: resolveBase("XDG_CACHE_HOME") ?? baseRoot
+		};
+	}
+	/** Profile-independent config-root subdirectory, with optional XDG override. Shared across profiles. */
+	baseRootSubdir(subdir, xdg) {
+		return path$1.join(xdg ? this.#baseRootDirs[xdg] : getBaseConfigRoot(), subdir);
 	}
 	/** Config-root subdirectory, with optional XDG override. */
 	rootSubdir(subdir, xdg) {
@@ -528,10 +532,30 @@ function getConfigRootDir() {
 function getAgentDir() {
 	return dirs.agentDir;
 }
-/** Get the logs directory (~/.omp/logs). */
+/**
+* Get the logs directory (~/.omp/logs). `bun test` processes get
+* `<tmpdir>/omp-test-logs-<uid>` instead, so suites never write into the
+* developer's real logs; the uid suffix (as for the test session-owners dir)
+* keeps users of a shared `/tmp` from owning each other's directory.
+*/
 function getLogsDir() {
+	if (isBunTestRuntime()) {
+		const uid = typeof process.getuid === "function" ? process.getuid() : os.userInfo().username;
+		return path$1.join(os.tmpdir(), `omp-test-logs-${uid}`);
+	}
 	return dirs.rootSubdir("logs", "state");
 }
+/**
+* Local-timezone `YYYY-MM-DD` day key (zero-padded), formatted exactly like
+* the rotating log sink's file naming: log files are named `omp.<day>.<pid>.log`
+* with the LOCAL day, not the UTC day `toISOString()` yields. Anything that
+* computes "today's" log path or matches same-day log files by name must use
+* this key, or between local midnight and UTC midnight it points at files that
+* do not exist (e.g. 00:00–08:00 in UTC+8).
+*/
+function localDay(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
 /** Get the remote mount directory (~/.omp/remote). */
 function getRemoteDir() {
 	return dirs.rootSubdir("remote", "data");
@@ -552,6 +576,10 @@ function getAutoQaDbPath() {
 function getDocumentConversionCacheDir(agentDir) {
 	return dirs.agentSubdir(agentDir, path$1.join("cache", "document-conversions"), "cache");
 }
+/** Get the custom themes directory (~/.omp/agent/themes). */
+function getCustomThemesDir(agentDir) {
+	return dirs.agentSubdir(agentDir, "themes");
+}
 /** Get the tools directory (~/.omp/agent/tools). */
 function getToolsDir(agentDir) {
 	return dirs.agentSubdir(agentDir, "tools");
@@ -614,7 +642,38 @@ function getInstallId() {
 	return next;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/env.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/path.ts
+const WINDOWS_DRIVE_EXTENDED_PREFIX = /^\\\\[?]\\([A-Za-z]:[\\/].*)$/;
+const WINDOWS_UNC_EXTENDED_PREFIX = /^\\\\[?]\\UNC[\\/]([^\\/]+)[\\/](.+)$/i;
+const WINDOWS_DRIVE_EXTENDED_FORWARD_PREFIX = /^\/\/[?]\/([A-Za-z]:\/.*)$/;
+const WINDOWS_UNC_EXTENDED_FORWARD_PREFIX = /^\/\/[?]\/UNC\/([^/]+)\/(.+)$/i;
+const WINDOWS_DRIVE_NT_PREFIX = /^\\\\[?][?]\\([A-Za-z]:[\\/].*)$/;
+const WINDOWS_UNC_NT_PREFIX = /^\\\\[?][?]\\UNC[\\/]([^\\/]+)[\\/](.+)$/i;
+/** Removes Win32 extended-length prefixes before passing paths to Bun APIs. */
+function stripWindowsExtendedLengthPathPrefix(filePath, platform = process.platform) {
+	if (platform !== "win32") return filePath;
+	const uncMatch = WINDOWS_UNC_EXTENDED_PREFIX.exec(filePath) ?? WINDOWS_UNC_NT_PREFIX.exec(filePath);
+	if (uncMatch) return `\\\\${uncMatch[1]}\\${uncMatch[2]}`;
+	const driveMatch = WINDOWS_DRIVE_EXTENDED_PREFIX.exec(filePath) ?? WINDOWS_DRIVE_NT_PREFIX.exec(filePath);
+	if (driveMatch) return driveMatch[1];
+	const forwardUncMatch = WINDOWS_UNC_EXTENDED_FORWARD_PREFIX.exec(filePath);
+	if (forwardUncMatch) return `//${forwardUncMatch[1]}/${forwardUncMatch[2]}`;
+	const forwardDriveMatch = WINDOWS_DRIVE_EXTENDED_FORWARD_PREFIX.exec(filePath);
+	if (forwardDriveMatch) return forwardDriveMatch[1];
+	return filePath;
+}
+/**
+* Test whether a path is fully qualified and drive-independent.
+* On Windows, requires a drive letter with separator (e.g. `C:\`) or UNC (`\\server\share` or `//server/share`).
+* On POSIX, requires an absolute path.
+*/
+function isFullyQualifiedPath(filePath, platform = process.platform) {
+	if (!(platform === "win32" ? path$1.win32 : path$1.posix).isAbsolute(filePath)) return false;
+	if (platform === "win32") return /^[a-zA-Z]:[/\\]/.test(filePath) || /^[\\/]{2}[^\\/]/.test(filePath);
+	return true;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/env.ts
 const ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
 * Strict shell-identifier shape. Used for dotenv keys we accept into
@@ -672,49 +731,17 @@ function readLaunchEnv() {
 readLaunchEnv();
 const projectEnvNamesLoadedByOmp = /* @__PURE__ */ new Set();
 /**
-* Parse one dotenv line with Bun-compatible semantics: an optional `export`
-* prefix, full-line `#` comments, inline `#` comments after whitespace on
-* unquoted values, and single/double/backtick quoting (a `#` inside quotes
-* stays literal). Returns undefined for blank lines, comments, and malformed
-* names.
-*/
-function parseEnvLine(line) {
-	const trimmed = line.trim();
-	if (!trimmed || trimmed.startsWith("#")) return void 0;
-	const eqIndex = trimmed.indexOf("=");
-	if (eqIndex === -1) return void 0;
-	let key = trimmed.slice(0, eqIndex).trim();
-	const exported = key.match(/^export[ \t]+(.*)$/);
-	if (exported) key = exported[1].trim();
-	if (!isValidEnvName(key)) return void 0;
-	const raw = trimmed.slice(eqIndex + 1).replace(/^[ \t]+/, "");
-	const quote = raw[0];
-	if (quote === "\"" || quote === "'" || quote === "`") {
-		let close = raw.indexOf(quote, 1);
-		while (close !== -1 && raw[close - 1] === "\\") close = raw.indexOf(quote, close + 1);
-		return {
-			key,
-			value: close === -1 ? raw.slice(1) : raw.slice(1, close)
-		};
-	}
-	const commentIndex = raw.search(/[ \t]#/);
-	return {
-		key,
-		value: (commentIndex === -1 ? raw : raw.slice(0, commentIndex)).trimEnd()
-	};
-}
-/**
-* Parses a .env file synchronously into key-value string pairs using
-* {@link parseEnvLine} for Bun-compatible line semantics, then mirrors valid
+* Parses a complete .env file with the runtime's dotenv grammar, then retains
+* only shell-identifier names and spawn-safe values before mirroring valid
 * `OMP_` variables to their `PI_` aliases.
 */
 function parseEnvFile(filePath) {
 	const result = {};
 	try {
-		const content = fs.readFileSync(filePath, "utf-8");
-		for (const line of content.split("\n")) {
-			const parsed = parseEnvLine(line);
-			if (parsed && isSafeEnvValue(parsed.value)) result[parsed.key] = parsed.value;
+		const parsed = parseEnv(fs.readFileSync(filePath, "utf-8"));
+		for (const key in parsed) {
+			const value = parsed[key];
+			if (value !== void 0 && isValidEnvName(key) && isSafeEnvValue(value)) result[key] = value;
 		}
 	} catch {}
 	for (const k in result) if (k.startsWith("OMP_")) result[`PI_${k.slice(4)}`] = result[k];
@@ -768,12 +795,6 @@ function $envpos(name, defaultValue) {
 	if (Number.isNaN(parsed) || parsed <= 0) return defaultValue;
 	return parsed;
 }
-const BUN_TEST_ENTRY_PATTERN = /[._](?:test|spec)\.[cm]?[jt]sx?$/;
-/** True when the process is an explicitly marked test child or Bun is running a test entrypoint. */
-function isBunTestRuntime() {
-	if (Bun.env.PI_TEST_RUNTIME === "1") return true;
-	return (Bun.env.BUN_ENV === "test" || Bun.env.NODE_ENV === "test") && BUN_TEST_ENTRY_PATTERN.test(Bun.main);
-}
 let terminalHeadless = isBunTestRuntime();
 /**
 * True when real-terminal side effects must be suppressed: stdout escape/frame
@@ -1550,11 +1571,6 @@ function installBunShim() {
 }
 //#endregion
 //#region src/tools/shared/bun-named-shim.ts
-/**
-* DSH named-import shim for `import { ... } from "bun"` (pi-utils and other
-* always-bundled OMP packages). tsdown aliases "bun" to this module.
-* Runtime Bun global is installed separately by src/tools/shared/bun-shim.ts.
-*/
 /** Bun.YAML (pi-utils frontmatter) — yaml package under the hood. */
 const YAML = {
 	parse: (s) => parse(s),
@@ -1638,64 +1654,163 @@ var CookieMap = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/logger/rotating-file.ts
-/** Behavior-compatible reimplementation of winston-daily-rotate-file's used surface. */
-function isAuditEntry(value) {
-	if (value === null || typeof value !== "object") return false;
-	const entry = value;
-	return typeof entry.date === "number" && typeof entry.name === "string" && typeof entry.hash === "string";
-}
-/** Synchronous append sink with local-day and size rotation plus bounded retention. */
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/fs-open.ts
+/** Close-on-exec file opens for descriptors held past a child spawn. */
+/**
+* `O_CLOEXEC`, which neither Node nor Bun exposes in `fs.constants`.
+*
+* Kernel ABI values: `0o2000000` on Linux, `0x0100_0000` on Darwin. Windows has
+* no `exec` and its CRT handles are inherited only when a spawn explicitly asks
+* for it, so the bit is 0 there — as it is on any other platform, where adding
+* an unknown flag bit would be worse than leaving the descriptor inheritable.
+*/
+const O_CLOEXEC = process.platform === "linux" ? 524288 : process.platform === "darwin" ? 16777216 : 0;
+/**
+* `fs.openSync` with close-on-exec, matching Node's default.
+*
+* libuv adds `O_CLOEXEC` inside `uv__fs_open`, so on Node every `fs` descriptor
+* dies at `exec`. Bun's `fs.open*` did not before 1.4.3 (still allowed by the
+* `bun@>=1.4` pin), and descriptors it returns survive
+* into any child spawned through a path that does not close strays itself — the
+* bash tool's shell `fork`/`exec`s user commands and hands them the lot. Use
+* this for every descriptor kept open past such a spawn (session transcripts,
+* logs, spools); a child must never hold a writable handle to them (#13224).
+*
+* Flags are numeric only: the bit cannot be OR-ed into `"a"`/`"w+"` strings.
+*
+* @example
+* const fd = openCloexecSync(logPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND);
+*/
+function openCloexecSync(filePath, flags, mode) {
+	return fs.openSync(filePath, flags | O_CLOEXEC, mode);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/logger/rotating-file.ts
+/** Process-local rotating file sink: local-day and size rotation with bounded retention. */
+/**
+* Synchronous append sink with local-day and size rotation plus bounded retention.
+*
+* Construction performs no filesystem I/O: the first file is created when the
+* first record is written out, so a process that never logs leaves nothing on
+* disk. Every file name embeds the owning process's suffix (its PID), so the
+* set of files this sink created is tracked in memory; files left by earlier
+* processes are pruned by name pattern in the logger, not by this sink.
+*
+* With {@link RotatingFileOptions.batch}, records are buffered and written in
+* one `write` per batch. Buffered bytes already count toward the active file's
+* size, and the buffer is written to its file before any rotation, so file
+* selection matches an unbatched sink record for record.
+*/
 var RotatingFileSink = class {
 	#directory;
 	#filenamePrefix;
 	#filenameSuffix;
-	#auditFile;
 	#maxBytes;
 	#maxFiles;
-	#files;
+	#batch;
+	#onRotate;
+	/** Files this sink created, oldest first. */
+	#files = [];
 	#activeDay;
 	#activeIndex = 0;
 	#activePath;
+	/** Size of the active file including buffered records not yet written. */
 	#activeBytes = 0;
 	#closed = false;
+	#fd;
+	/** Records for the active file not yet written, each ending in EOL. */
+	#pending = "";
+	#pendingBytes = 0;
+	#flushTimer;
 	constructor(options) {
 		this.#directory = options.directory;
 		this.#filenamePrefix = options.filenamePrefix;
 		this.#filenameSuffix = options.filenameSuffix;
-		this.#auditFile = options.auditFile;
 		this.#maxBytes = options.maxBytes;
 		this.#maxFiles = options.maxFiles;
-		this.#files = this.#readAudit();
-		const now = /* @__PURE__ */ new Date();
-		this.#selectFile(this.#localDay(now));
-		const activePath = this.#activePath;
-		if (activePath) {
-			this.#registerFile(activePath, now.getTime());
-			fs.closeSync(fs.openSync(activePath, "a"));
+		this.#batch = options.batch;
+		this.#onRotate = options.onRotate;
+	}
+	#openFd(filePath) {
+		this.#closeFd();
+		this.#fd = openCloexecSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND);
+		try {
+			this.#onRotate?.(filePath);
+		} catch {}
+	}
+	#closeFd() {
+		if (this.#fd !== void 0) {
+			try {
+				fs.closeSync(this.#fd);
+			} catch {}
+			this.#fd = void 0;
 		}
 	}
-	/** Append one already-formatted log record. */
-	write(line) {
+	/**
+	* Append one already-formatted log record. A batching sink buffers it unless
+	* `flushNow` is set or the buffer reached its size threshold; either way the
+	* whole buffer, this record included, is then written in order. `day` is the
+	* record's `localDay` key, so callers that already took the record's `Date`
+	* reuse it.
+	*/
+	write(line, flushNow = false, day = localDay(/* @__PURE__ */ new Date())) {
 		if (this.#closed) return;
-		const now = /* @__PURE__ */ new Date();
-		this.#selectFile(this.#localDay(now));
-		const activePath = this.#activePath;
-		if (!activePath) return;
-		this.#registerFile(activePath, now.getTime());
+		this.#selectFile(day);
 		const record = `${line}${os.EOL}`;
-		fs.appendFileSync(activePath, record, "utf8");
-		this.#activeBytes += Buffer.byteLength(record);
+		const bytes = Buffer.byteLength(record, "utf8");
+		this.#pending += record;
+		this.#pendingBytes += bytes;
+		this.#activeBytes += bytes;
+		const batch = this.#batch;
+		if (flushNow || !batch || this.#pendingBytes >= batch.maxBytes) this.flush();
+		else if (this.#flushTimer === void 0) {
+			this.#flushTimer = setTimeout(this.#flushFromTimer, batch.intervalMs);
+			this.#flushTimer.unref();
+		}
+	}
+	/** Write every buffered record to the active file now. */
+	flush() {
+		if (this.#flushTimer !== void 0) {
+			clearTimeout(this.#flushTimer);
+			this.#flushTimer = void 0;
+		}
+		const activePath = this.#activePath;
+		if (this.#pendingBytes === 0 || !activePath) return;
+		const buf = Buffer.from(this.#pending, "utf8");
+		this.#pending = "";
+		this.#pendingBytes = 0;
+		if (this.#fd === void 0) {
+			this.#registerFile(activePath);
+			this.#openFd(activePath);
+		}
+		let off = 0;
+		while (off < buf.length) {
+			const written = fs.writeSync(this.#fd, buf, off);
+			if (written <= 0) break;
+			off += written;
+		}
 	}
-	/** Stop accepting records. Synchronous writes require no drain phase. */
+	#flushFromTimer = () => {
+		this.#flushTimer = void 0;
+		try {
+			this.flush();
+		} catch {}
+	};
+	/** Write buffered records, then stop accepting records. */
 	close() {
+		if (this.#closed) return;
+		try {
+			this.flush();
+		} catch {}
 		this.#closed = true;
-	}
-	#localDay(date) {
-		return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+		this.#closeFd();
 	}
 	#selectFile(day) {
-		if (day !== this.#activeDay) {
+		const dayChanged = day !== this.#activeDay;
+		if (!dayChanged && this.#activeBytes <= this.#maxBytes) return;
+		this.flush();
+		this.#closeFd();
+		if (dayChanged) {
 			this.#activeDay = day;
 			this.#activeIndex = 0;
 			this.#setActivePath(day, 0);
@@ -1714,46 +1829,120 @@ var RotatingFileSink = class {
 			this.#activeBytes = 0;
 		}
 	}
-	#registerFile(filePath, date) {
-		if (this.#files.some((file) => file.name === filePath)) return;
-		const hash = crypto$1.createHash("sha256").update(`${filePath}LOG_FILE${date}`).digest("hex");
-		this.#files.push({
-			date,
-			name: filePath,
-			hash
-		});
+	#registerFile(filePath) {
+		if (this.#files.includes(filePath)) return;
+		this.#files.push(filePath);
 		while (this.#files.length > this.#maxFiles) {
 			const removed = this.#files.shift();
 			if (!removed) break;
 			try {
-				fs.rmSync(removed.name, { force: true });
+				fs.rmSync(removed, { force: true });
 			} catch {}
 		}
-		this.#writeAudit();
-	}
-	#readAudit() {
-		try {
-			const parsed = JSON.parse(fs.readFileSync(this.#auditFile, "utf8"));
-			return Array.isArray(parsed.files) ? parsed.files.filter(isAuditEntry) : [];
-		} catch {
-			return [];
-		}
 	}
-	#writeAudit() {
-		const state = {
-			keep: {
-				days: false,
-				amount: this.#maxFiles
+};
+//#endregion
+//#region src/tools/shared/bun-ffi-shim.ts
+/**
+* DSH named-import shim for `bun:ffi` (pi-utils stderr-guard / process-name).
+* Both consumers degrade silently when dlopen is unavailable ("Never throws:
+* bun:ffi unavailability ... degrades silently"), so this shim returns null.
+*/
+const FFIType = {};
+function dlopen() {
+	return null;
+}
+const ptr = () => 0;
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/stderr-guard.ts
+/**
+* Terminal stderr guard: keeps unmanaged fd-2 writes off the terminal while a
+* TUI owns the viewport.
+*
+* Native runtimes and libraries can write directly to file descriptor 2 at
+* arbitrary times. Examples include macOS libmalloc diagnostics and Bun HTTP
+* decompression diagnostics on Linux. Those bytes bypass the renderer and
+* paint straight into the viewport.
+*
+* While the TUI owns the terminal, dup fd 2 aside and dup2 a redirect target
+* over it; restore the saved fd whenever terminal ownership is released
+* (external editor, Ctrl+Z suspend, shutdown, crash restore). This mirrors
+* openai/codex#24459, but redirects to the omp log file instead of /dev/null
+* so diagnostics stay greppable and Bun native-crash reports (which abort
+* before any JS cleanup can restore fd 2) are preserved.
+*
+* Only dup/dup2 go through bun:ffi. fcntl is deliberately avoided: it is
+* variadic, and the arm64-darwin ABI passes variadic arguments on the stack,
+* so a fixed-arity FFI signature would read garbage for the third argument.
+*/
+const STDERR_FILENO = 2;
+let libcFdOpsCache;
+function libcFdOps() {
+	if (libcFdOpsCache !== void 0) return libcFdOpsCache;
+	libcFdOpsCache = null;
+	if (process.platform === "win32") return null;
+	const candidates = process.platform === "darwin" ? ["libSystem.B.dylib", "/usr/lib/libSystem.B.dylib"] : ["libc.so.6", "libc.so"];
+	for (const candidate of candidates) try {
+		libcFdOpsCache = dlopen(candidate, {
+			dup: {
+				args: [FFIType.i32],
+				returns: FFIType.i32
 			},
-			auditLog: this.#auditFile,
-			files: this.#files,
-			hashType: "sha256"
-		};
-		fs.writeFileSync(this.#auditFile, JSON.stringify(state, void 0, 4), "utf8");
+			dup2: {
+				args: [FFIType.i32, FFIType.i32],
+				returns: FFIType.i32
+			}
+		}).symbols;
+		return libcFdOpsCache;
+	} catch {}
+	return libcFdOpsCache;
+}
+/** Saved dup of the real stderr while suppression is active, else null. */
+let savedStderrFd = null;
+/**
+* Point fd 2 at `logPath`, the log file the rotating sink is currently
+* writing.
+*
+* The logger calls this on every sink rotation. Without it fd 2 keeps the
+* descriptor opened at TUI start, so after local midnight raw stderr — this
+* process's and every child that inherited fd 2 — keeps landing in the
+* previous day's file, which the sink eventually prunes out from under it.
+*
+* The path is recorded even while suppression is inactive, so a later
+* {@link suppressTerminalStderr} redirects to the live file instead of
+* re-deriving a dated name. Best-effort: if the new file cannot be opened,
+* fd 2 keeps its current target.
+*/
+function setStderrRedirectTarget(logPath) {
+	if (savedStderrFd === null) return;
+	const libc = libcFdOps();
+	if (!libc) return;
+	let redirectFd;
+	try {
+		redirectFd = fs.openSync(logPath, "a");
+	} catch {
+		return;
 	}
-};
+	libc.dup2(redirectFd, STDERR_FILENO);
+	fs.closeSync(redirectFd);
+}
+/**
+* Re-point fd 2 at the saved terminal stderr. Safe to call unconditionally:
+* no-op when suppression is not active. Called at every terminal-ownership
+* release and by the postmortem fatal handlers before they print, so crash
+* reports reach the real terminal.
+*/
+function restoreTerminalStderr() {
+	if (savedStderrFd === null) return;
+	const saved = savedStderrFd;
+	savedStderrFd = null;
+	libcFdOps()?.dup2(saved, STDERR_FILENO);
+	try {
+		fs.closeSync(saved);
+	} catch {}
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/logger.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/logger.ts
 /**
 * Centralized logger for omp.
 *
@@ -1763,7 +1952,11 @@ var RotatingFileSink = class {
 * transport so a process supervisor (pm2, journald, k8s) captures the logs.
 *
 * Each entry includes `process.pid` so concurrent omp instances stay
-* traceable.
+* traceable. The file is created on the first record written. Records are
+* batched — one write per second or per 64 KiB — while `warn`/`error` records
+* are written at once together with everything buffered before them; exit,
+* fatal, and signal paths flush the rest. `OMP_LOG_LEVEL` optionally limits
+* the levels written to the file (default: all).
 */
 const logSinks = /* @__PURE__ */ new Set();
 function emitToSinks(level, message, context) {
@@ -1779,7 +1972,12 @@ function emitToSinks(level, message, context) {
 	} catch {}
 }
 const PROCESS_LOG_PATTERN = /^omp\.(\d{4}-\d{2}-\d{2})\.(\d+)\.log(?:\.(\d+))?$/;
+/** Per-process audit files written by earlier releases; current sinks track rotations in memory. */
 const PROCESS_AUDIT_PATTERN = /^\.omp\.(\d+)-audit\.json$/;
+/** Shared daily logs (plain, size-rolled, or gzipped) written by the winston-era logger. */
+const LEGACY_LOG_PATTERN = /^omp\.(\d{4}-\d{2}-\d{2})\.log(?:\.\d+)?(?:\.gz)?$/;
+/** Hash-named audit files written by winston-daily-rotate-file. */
+const LEGACY_AUDIT_PATTERN = /^\.[0-9a-f]{8,}-audit\.json$/;
 const RETAINED_STALE_LOGS_PER_PROCESS_DAY = 1;
 function processIsRunning(pid) {
 	try {
@@ -1791,9 +1989,11 @@ function processIsRunning(pid) {
 }
 /**
 * Retain one newest completed-process log per process/day within the current
-* and previous four local calendar days, and remove one-use audit files. Live
-* PID namespaces are never touched. The calendar-day boundary preserves daily
-* diagnostic coverage while bounding completed-process storage and scans.
+* and previous four local calendar days, remove completed-process audit files
+* left by earlier releases, and age out legacy shared daily logs and their
+* hash-named audits past the same window. Live PID namespaces are never
+* touched. The calendar-day boundary preserves daily diagnostic coverage while
+* bounding completed-process storage and scans.
 */
 function pruneStaleProcessLogs(dir) {
 	let entries;
@@ -1803,29 +2003,38 @@ function pruneStaleProcessLogs(dir) {
 		return;
 	}
 	const current = /* @__PURE__ */ new Date();
-	const currentDate = `${current.getFullYear()}-${String(current.getMonth() + 1).padStart(2, "0")}-` + String(current.getDate()).padStart(2, "0");
+	const currentDate = localDay(current);
 	const cutoff = new Date(current);
 	cutoff.setDate(cutoff.getDate() - 4);
-	const cutoffDate = `${cutoff.getFullYear()}-${String(cutoff.getMonth() + 1).padStart(2, "0")}-` + String(cutoff.getDate()).padStart(2, "0");
+	const cutoffDate = localDay(cutoff);
+	cutoff.setHours(0, 0, 0, 0);
+	const cutoffMs = cutoff.getTime();
 	const staleLogsByProcessDay = /* @__PURE__ */ new Map();
 	for (const entry of entries) {
 		if (!entry.isFile()) continue;
+		const entryPath = path$1.join(dir, entry.name);
+		const legacyMatch = LEGACY_LOG_PATTERN.exec(entry.name);
+		if (legacyMatch?.[1]) {
+			if (legacyMatch[1] < cutoffDate) removeBestEffort(entryPath);
+			continue;
+		}
+		if (LEGACY_AUDIT_PATTERN.test(entry.name)) {
+			try {
+				if (fs.statSync(entryPath).mtimeMs < cutoffMs) removeBestEffort(entryPath);
+			} catch {}
+			continue;
+		}
 		const logMatch = PROCESS_LOG_PATTERN.exec(entry.name);
 		const auditMatch = PROCESS_AUDIT_PATTERN.exec(entry.name);
 		const pidText = logMatch?.[2] ?? auditMatch?.[1];
 		if (!pidText || processIsRunning(Number(pidText))) continue;
-		const entryPath = path$1.join(dir, entry.name);
 		if (auditMatch) {
-			try {
-				fs.rmSync(entryPath, { force: true });
-			} catch {}
+			removeBestEffort(entryPath);
 			continue;
 		}
 		if (!logMatch?.[1]) continue;
 		if (logMatch[1] < cutoffDate || logMatch[1] > currentDate) {
-			try {
-				fs.rmSync(entryPath, { force: true });
-			} catch {}
+			removeBestEffort(entryPath);
 			continue;
 		}
 		const key = `${pidText}:${logMatch[1]}`;
@@ -1846,11 +2055,24 @@ function pruneStaleProcessLogs(dir) {
 			});
 		} catch {}
 		ranked.sort((a, b) => b.mtimeMs - a.mtimeMs || b.rollover - a.rollover || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-		for (const stale of ranked.slice(RETAINED_STALE_LOGS_PER_PROCESS_DAY)) try {
-			fs.rmSync(stale.path, { force: true });
-		} catch {}
+		for (const stale of ranked.slice(RETAINED_STALE_LOGS_PER_PROCESS_DAY)) removeBestEffort(stale.path);
 	}
 }
+function removeBestEffort(filePath) {
+	try {
+		fs.rmSync(filePath, { force: true });
+	} catch {}
+}
+const scheduledPruneDirs = /* @__PURE__ */ new Set();
+/** Run shared retention only after logger construction has returned to the event loop. */
+function schedulePruneStaleProcessLogs(dir) {
+	if (scheduledPruneDirs.has(dir)) return;
+	scheduledPruneDirs.add(dir);
+	setImmediate(() => {
+		scheduledPruneDirs.delete(dir);
+		pruneStaleProcessLogs(dir);
+	}).unref();
+}
 /** Ensure a logs directory exists; return the resolved path. */
 function ensureDir(dir) {
 	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -1876,6 +2098,27 @@ function jsonReplacer(_key, value) {
 	}
 	return value;
 }
+const ERROR_SCAN_BUDGET = 128;
+/**
+* Whether `value` may contain an {@link Error} that {@link jsonReplacer} must
+* unwrap. Walks what `JSON.stringify` serializes (arrays and own enumerable
+* keys); objects with a `toJSON` other than `Date` may return an Error, and an
+* exhausted budget answers true.
+*/
+function mayContainError(root) {
+	const stack = [root];
+	let budget = ERROR_SCAN_BUDGET;
+	while (stack.length > 0) {
+		const value = stack.pop();
+		if (value === null || typeof value !== "object") continue;
+		if (value instanceof Error) return true;
+		if (--budget < 0) return true;
+		if (value instanceof Date) continue;
+		if ("toJSON" in value && typeof value.toJSON === "function") return true;
+		for (const child of Object.values(value)) stack.push(child);
+	}
+	return false;
+}
 function padTimestampPart(value, width = 2) {
 	return String(value).padStart(width, "0");
 }
@@ -1886,42 +2129,81 @@ function formatLocalTimestamp(date) {
 	return `${padTimestampPart(date.getFullYear(), 4)}-${padTimestampPart(date.getMonth() + 1)}-${padTimestampPart(date.getDate())}T${padTimestampPart(date.getHours())}:${padTimestampPart(date.getMinutes())}:${padTimestampPart(date.getSeconds())}.${padTimestampPart(date.getMilliseconds(), 3)}${offsetSign}${padTimestampPart(Math.floor(absoluteOffset / 60))}:${padTimestampPart(absoluteOffset % 60)}`;
 }
 const FORMAT_TOKEN_PATTERN = /%[scdjifoO%]/;
-function normalizeLogInfo(level, message, context) {
+/** Serialize one log record: timestamp, level, pid, message, then context fields. */
+function formatLogRecord(level, message, context, timestamp) {
 	const metadata = !FORMAT_TOKEN_PATTERN.test(message) && context !== null && typeof context === "object" ? context : void 0;
-	const info = Object.assign({}, metadata, {
-		level,
-		message
-	});
-	if (metadata?.message) info.message = `${message} ${metadata.message}`;
-	if (metadata?.stack) info.stack = metadata.stack;
-	if (metadata?.cause) info.cause = metadata.cause;
-	return info;
-}
-function formatLogInfo(info) {
-	const timestamp = formatLocalTimestamp(/* @__PURE__ */ new Date());
-	info.timestamp = timestamp;
 	const entry = {
 		timestamp,
-		level: info.level,
+		level,
 		pid: process.pid,
-		message: info.message
+		message: metadata?.message ? `${message} ${metadata.message}` : message
 	};
-	for (const [key, value] of Object.entries(info)) if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = value;
-	return JSON.stringify(entry, jsonReplacer);
+	if (metadata) {
+		for (const key of Object.keys(metadata)) if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = metadata[key];
+		if (metadata.stack) entry.stack = metadata.stack;
+		if (metadata.cause) entry.cause = metadata.cause;
+	}
+	return mayContainError(entry) ? JSON.stringify(entry, jsonReplacer) : JSON.stringify(entry);
+}
+/** Longest a buffered file record waits before it is written. */
+const FILE_FLUSH_INTERVAL_MS = 1e3;
+/** Buffered bytes at which the file batch is written immediately. */
+const FILE_FLUSH_BYTES = 65536;
+let exitFlushInstalled = false;
+/** Set once the process is exiting: every later record is written immediately. */
+let exiting = false;
+function flushOnExit() {
+	exiting = true;
+	flush();
 }
 /** Build a rotating file sink with process-local rotation and shared retention. */
 function makeFileTransport(dir) {
 	const logsDir = ensureDir(dir ?? getLogsDir());
-	pruneStaleProcessLogs(logsDir);
+	schedulePruneStaleProcessLogs(logsDir);
+	if (!exitFlushInstalled) {
+		exitFlushInstalled = true;
+		process.on("exit", flushOnExit);
+	}
 	return new RotatingFileSink({
 		directory: logsDir,
 		filenamePrefix: "omp",
 		filenameSuffix: String(process.pid),
 		maxBytes: 10485760,
 		maxFiles: 5,
-		auditFile: path$1.join(logsDir, `.omp.${process.pid}-audit.json`)
+		batch: {
+			intervalMs: FILE_FLUSH_INTERVAL_MS,
+			maxBytes: FILE_FLUSH_BYTES
+		},
+		onRotate: setStderrRedirectTarget
 	});
 }
+const LOG_LEVEL_RANK = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3
+};
+/** `warn` and `error` records are written at once, with everything buffered before them. */
+const IMMEDIATE_FLUSH_RANK = LOG_LEVEL_RANK.warn;
+/**
+* Rank of the most verbose level the file transport persists: `OMP_LOG_LEVEL`
+* (error|warn|info|debug, case-insensitive), default `debug` (everything).
+*/
+function resolveFileLevelRank() {
+	const requested = process.env.OMP_LOG_LEVEL?.trim().toLowerCase();
+	return requested && Object.hasOwn(LOG_LEVEL_RANK, requested) ? LOG_LEVEL_RANK[requested] : LOG_LEVEL_RANK.debug;
+}
+/**
+* Write buffered file records to disk now. The file transport batches records
+* (one write per second or per 64 KiB) and writes `warn`/`error` records
+* immediately; process exit flushes on its own. Call this before handing the
+* log file to something that reads it in-process. Never throws.
+*/
+function flush() {
+	try {
+		activeTransports?.file?.flush();
+	} catch {}
+}
 /**
 * Desired transport configuration, applied when local logging is initialized.
 * Default: file ON (TUI-safe), console OFF.
@@ -1932,7 +2214,8 @@ let activeTransports;
 function buildTransports(opts) {
 	return {
 		file: opts.file ? makeFileTransport(typeof opts.file === "string" ? opts.file : void 0) : void 0,
-		console: opts.console === true
+		console: opts.console === true,
+		fileLevelRank: resolveFileLevelRank()
 	};
 }
 function getLocalTransports() {
@@ -1941,11 +2224,13 @@ function getLocalTransports() {
 }
 function emitLocally(level, message, context) {
 	const transports = getLocalTransports();
-	const info = normalizeLogInfo(level, message, context);
-	if (!transports.file && !transports.console) return;
-	const line = formatLogInfo(info);
-	if (transports.file) transports.file.write(line);
-	if (transports.console) fs.writeSync(1, `${formatLogInfo(info)}${os.EOL}`);
+	const rank = LOG_LEVEL_RANK[level];
+	const file = rank <= transports.fileLevelRank ? transports.file : void 0;
+	if (!file && !transports.console) return;
+	const now = /* @__PURE__ */ new Date();
+	const line = formatLogRecord(level, message, context, formatLocalTimestamp(now));
+	file?.write(line, rank <= IMMEDIATE_FLUSH_RANK || exiting, localDay(now));
+	if (transports.console) fs.writeSync(1, `${line}${os.EOL}`);
 }
 /**
 * Log an error message.
@@ -2022,9 +2307,12 @@ function time(op, fn, ...args) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/frontmatter.ts
-function stripHtmlComments(content) {
-	return content.replace(/<!--[\s\S]*?-->/g, "");
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/frontmatter.ts
+function stripLeadingHtmlComments(content) {
+	const leading = /^(?:(?:\s*<!--[\s\S]*?-->)+)/.exec(content);
+	if (!leading) return content;
+	const rest = content.slice(leading[0].length);
+	return /^\s*---/.test(rest) ? rest.replace(/^\s+/, "") : content;
 }
 /** Convert kebab-case to camelCase (e.g. "thinking-level" -> "thinkingLevel") */
 function kebabToCamel(key) {
@@ -2118,7 +2406,8 @@ function parseFrontmatter(content, options) {
 	const loc = location ?? source;
 	const frontmatter = { ...fallback };
 	const newlineNormalized = normalize ? content.replace(/\r\n?/g, "\n") : content;
-	const normalized = normalize && repair ? stripHtmlComments(newlineNormalized) : newlineNormalized;
+	const repairHtmlComments = normalize && repair;
+	const normalized = repairHtmlComments ? stripLeadingHtmlComments(newlineNormalized) : newlineNormalized;
 	if (!normalized.startsWith("---")) return {
 		frontmatter,
 		body: normalized
@@ -2128,7 +2417,8 @@ function parseFrontmatter(content, options) {
 		frontmatter,
 		body: normalized
 	};
-	const metadata = normalized.slice(4, endIndex);
+	const rawMetadata = normalized.slice(4, endIndex);
+	const metadata = repairHtmlComments ? rawMetadata.replace(/<!--[\s\S]*?-->/g, "") : rawMetadata;
 	const body = normalized.slice(endIndex + 4).trim();
 	try {
 		const loaded = parseYamlRecord(metadata, repair);
@@ -2173,6 +2463,15 @@ function parseFrontmatter(content, options) {
 	}
 }
 const U$1 = 117;
+/**
+* Minimum remaining string length for bulk-skipping ordinary characters in
+* {@link JsonLexer.string} with two engine `indexOf` scans (nearest quote or
+* backslash) instead of one `charCodeAt` per character. Below this the
+* `indexOf` setup costs more than the per-char loop on quote-dense input;
+* long string runs — the multi-KB tool-argument payloads that dominate
+* streaming re-parses — scan several times faster above it.
+*/
+const STRING_BULK_SCAN_MIN = 32;
 /** Valid chars after `\` in a strict JSON escape: `" \ / b f n r t u`. */
 const VALID_ESCAPE_CHAR = /* @__PURE__ */ new Uint8Array(128);
 for (const ch of "\"\\/bfnrtu") VALID_ESCAPE_CHAR[ch.charCodeAt(0)] = 1;
@@ -2270,6 +2569,17 @@ var JsonLexer = class {
 	src;
 	mode;
 	pos;
+	/**
+	* Shared across {@link string} calls: `src` has no backslash in
+	* `[#backslashFrom, #backslashAt)` and `#backslashAt` is a backslash or
+	* `src.length`. An escape-free run can extend past its string's closing
+	* quote to the end of the document, so searching per string would rescan
+	* the same tail for every sibling string (quadratic on objects with many
+	* short values). `src` is immutable, so the range never goes stale; a
+	* cursor outside it (e.g. a rollback) re-searches.
+	*/
+	#backslashFrom = 0;
+	#backslashAt = -1;
 	constructor(src, mode, pos = 0) {
 		this.src = src;
 		this.mode = mode;
@@ -2299,7 +2609,27 @@ var JsonLexer = class {
 		let runStart = i;
 		let unstableFrom = -1;
 		const lenient = quote === 39 || this.mode === "streaming";
+		const quoteChar = String.fromCharCode(quote);
+		let nextQuote = quoteChar.charCodeAt(0) === quote ? -1 : n;
+		let nextBackslash = -1;
 		while (i < n) {
+			const c0 = s.charCodeAt(i);
+			if (c0 !== 92 && c0 !== quote && n - i > STRING_BULK_SCAN_MIN) {
+				if (nextQuote < i) {
+					const q = s.indexOf(quoteChar, i);
+					nextQuote = q === -1 ? n : q;
+				}
+				if (nextBackslash < i) {
+					if (i < this.#backslashFrom || i > this.#backslashAt) {
+						const b = s.indexOf("\\", i);
+						this.#backslashFrom = i;
+						this.#backslashAt = b === -1 ? n : b;
+					}
+					nextBackslash = this.#backslashAt;
+				}
+				i = nextQuote < nextBackslash ? nextQuote : nextBackslash;
+				if (i >= n) break;
+			}
 			const cc = s.charCodeAt(i);
 			if (cc !== 92 && cc !== quote) {
 				i++;
@@ -2476,7 +2806,7 @@ var JsonLexer = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/json-parse.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/json-parse.ts
 const U = 117;
 (() => {
 	const e = [];
@@ -2655,16 +2985,25 @@ function parseJsonWithRepair(json) {
 function parseStreamingJson(partialJson) {
 	const trimmed = partialJson?.trimStart();
 	if (!trimmed) return {};
-	try {
+	const first = trimmed.charCodeAt(0);
+	if (first !== 123 && first !== 91 || canCloseContainer(trimmed)) try {
 		return JSON.parse(trimmed);
+	} catch {}
+	try {
+		return new RelaxedJson(trimmed, true).parse() ?? {};
 	} catch {
-		try {
-			return new RelaxedJson(trimmed, true).parse() ?? {};
-		} catch {
-			return {};
-		}
+		return {};
 	}
 }
+/** True when the last non-whitespace character is `}` or `]`. */
+function canCloseContainer(text) {
+	for (let i = text.length - 1; i >= 0; i--) {
+		const code = text.charCodeAt(i);
+		if (code === 32 || code === 9 || code === 10 || code === 13) continue;
+		return code === 125 || code === 93;
+	}
+	return false;
+}
 /**
 * Throttled variant of {@link parseStreamingJson} for the per-delta hot path.
 *
@@ -2885,10 +3224,71 @@ function classifyJsonPrefix(text) {
 	}
 	return expect === 7 ? "complete" : "prefix";
 }
-new Intl.Segmenter();
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/mime.ts
-const DEFAULT_IMAGE_METADATA_HEADER_BYTES = 262144;
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/loop-phase.ts
+/**
+* Process-global synchronous loop phases. The watchdog arms a late window and
+* reads attribution via {@link takeLoopPhaseAttribution}; attribution totals
+* only the innermost label's time inside that window. A label is named only
+* when its total outweighs all unlabeled time, otherwise the block remains
+* "unknown". Disarmed push/pop do not read the clock.
+*
+* This is deliberately a process-global stack and not part of the logger span
+* machinery: `main.ts` ends timing spans before the interactive TUI starts, so
+* `logger.openSpanPath()` is empty in a live session.
+*
+* Correctness constraint: each `pushLoopPhase` must be balanced by a
+* `popLoopPhase` within the SAME synchronous execution (always via `try`/
+* `finally`). The stack is global and shared, so a label held across an
+* `await`/async boundary — or interleaved between concurrent tasks — would
+* misattribute or leak phases. Instrument only synchronous spans; for async
+* work, push/pop around each synchronous chunk, not across the await.
+*/
+const stack = [];
+const defaultClock = () => performance.now();
+let windowStart = Number.POSITIVE_INFINITY;
+let segmentStart = windowStart;
+let clock = defaultClock;
+const totals = /* @__PURE__ */ new Map();
+let labeledMs = 0;
+function boundary(t) {
+	const ms = Math.max(0, t - Math.max(segmentStart, windowStart));
+	const label = stack[stack.length - 1];
+	if (label !== void 0 && ms > 0) {
+		totals.set(label, (totals.get(label) ?? 0) + ms);
+		labeledMs += ms;
+	}
+	segmentStart = t;
+}
+/** Arm an attribution window starting at `start` (a deadline on `now`'s clock). Called with no arguments it disarms and clears. */
+function resetLoopPhaseWindow(start = Number.POSITIVE_INFINITY, now = defaultClock) {
+	windowStart = segmentStart = start;
+	clock = now;
+	totals.clear();
+	labeledMs = 0;
+}
+/** Attribute the window [start, end] and disarm it. Returns undefined when no window is armed or no label outweighs unlabeled time. */
+function takeLoopPhaseAttribution(end) {
+	if (windowStart === Number.POSITIVE_INFINITY) return void 0;
+	const t = end ?? clock();
+	boundary(t);
+	const unknownMs = Math.max(0, t - windowStart - labeledMs);
+	let winner;
+	let winnerMs = 0;
+	for (const [label, ms] of totals) if (ms >= winnerMs) {
+		winner = label;
+		winnerMs = ms;
+	}
+	const result = winner !== void 0 && winnerMs > unknownMs ? {
+		label: winner,
+		ms: winnerMs
+	} : void 0;
+	resetLoopPhaseWindow();
+	return result;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/mime.ts
+const IMAGE_METADATA_HEADER_BYTES = 262144;
 const PNG_MAGIC = Buffer.from([
 	137,
 	80,
@@ -3065,83 +3465,24 @@ function parseWebpMetadata(header) {
 function parseImageMetadata(header) {
 	return parsePngMetadata(header) ?? parseJpegMetadata(header) ?? parseGifMetadata(header) ?? parseWebpMetadata(header);
 }
-function readImageMetadata(filePath, maxBytes = DEFAULT_IMAGE_METADATA_HEADER_BYTES) {
-	return peekFile(filePath, maxBytes, parseImageMetadata);
-}
-//#endregion
-//#region src/tools/shared/bun-ffi-shim.ts
-/**
-* DSH named-import shim for `bun:ffi` (pi-utils stderr-guard / process-name).
-* Both consumers degrade silently when dlopen is unavailable ("Never throws:
-* bun:ffi unavailability ... degrades silently"), so this shim returns null.
-*/
-const FFIType = {};
-function dlopen() {
-	return null;
-}
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/stderr-guard.ts
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 /**
-* Terminal stderr guard: keeps unmanaged fd-2 writes off the terminal while a
-* TUI owns the viewport.
-*
-* On macOS, runtime diagnostics are written by the platform directly to file
-* descriptor 2 at arbitrary times — e.g. libmalloc's "MallocStackLogging:
-* can't turn off malloc stack logging because it was not enabled" when the OS
-* broadcasts a memory-diagnostic event to long-lived processes. Those bytes
-* bypass the renderer and paint straight into the viewport. Stripping the
-* MallocStackLogging* env vars (cli.ts) only protects child processes; it
-* cannot stop libmalloc inside THIS process from logging.
-*
-* Fix (mirrors openai/codex#24459): while the TUI owns the terminal, dup fd 2
-* aside and dup2 a redirect target over it; restore the saved fd whenever
-* terminal ownership is released (external editor, Ctrl+Z suspend, shutdown,
-* crash restore). Unlike codex we redirect to the omp log file — not
-* /dev/null — so the diagnostics stay greppable and Bun native-crash reports
-* (which abort before any JS cleanup can restore fd 2) are preserved.
-*
-* Only dup/dup2 go through bun:ffi. fcntl is deliberately avoided: it is
-* variadic, and the arm64-darwin ABI passes variadic arguments on the stack,
-* so a fixed-arity FFI signature would read garbage for the third argument.
+* Validate standard base64 image data without decoding it. Padding may be omitted, but
+* present padding must be canonical, the trailing bits must be zero, and the data non-empty.
 */
-const STDERR_FILENO = 2;
-let libcFdOpsCache;
-function libcFdOps() {
-	if (libcFdOpsCache !== void 0) return libcFdOpsCache;
-	libcFdOpsCache = null;
-	if (process.platform === "win32") return null;
-	const candidates = process.platform === "darwin" ? ["libSystem.B.dylib", "/usr/lib/libSystem.B.dylib"] : ["libc.so.6", "libc.so"];
-	for (const candidate of candidates) try {
-		libcFdOpsCache = dlopen(candidate, {
-			dup: {
-				args: [FFIType.i32],
-				returns: FFIType.i32
-			},
-			dup2: {
-				args: [FFIType.i32, FFIType.i32],
-				returns: FFIType.i32
-			}
-		}).symbols;
-		return libcFdOpsCache;
-	} catch {}
-	return libcFdOpsCache;
-}
-/** Saved dup of the real stderr while suppression is active, else null. */
-let savedStderrFd = null;
-/**
-* Re-point fd 2 at the saved terminal stderr. Safe to call unconditionally:
-* no-op when suppression is not active. Called at every terminal-ownership
-* release and by the postmortem fatal handlers before they print, so crash
-* reports reach the real terminal.
-*/
-function restoreTerminalStderr() {
-	if (savedStderrFd === null) return;
-	const saved = savedStderrFd;
-	savedStderrFd = null;
-	libcFdOps()?.dup2(saved, STDERR_FILENO);
-	try {
-		fs.closeSync(saved);
-	} catch {}
+function base64ImageDataFailureReason(data) {
+	if (data.length === 0) return "empty image data";
+	const match = /^([A-Za-z0-9+/]+)(={0,2})$/.exec(data);
+	if (!match) return "invalid base64 image data";
+	const encoded = match[1];
+	const paddingLength = match[2].length;
+	const remainder = encoded.length % 4;
+	if (remainder === 1 || paddingLength === 1 && remainder !== 3 || paddingLength === 2 && remainder !== 2) return "invalid base64 image data";
+	const lastSextet = BASE64_ALPHABET.indexOf(encoded[encoded.length - 1]);
+	if (remainder === 2 && (lastSextet & 15) !== 0 || remainder === 3 && (lastSextet & 3) !== 0) return "invalid base64 image data";
+}
+function readImageMetadata(filePath, maxBytes = IMAGE_METADATA_HEADER_BYTES) {
+	return peekFile(filePath, maxBytes, parseImageMetadata);
 }
 const callbackList = [];
 let cleanupStage = "idle";
@@ -3163,6 +3504,25 @@ const CLEANUP_DEADLINE_MS = 1e4;
 */
 const NATIVE_PROCESS_EXIT = Symbol.for("omp.postmortem.nativeProcessExit");
 /**
+* Walk a guarded exit primitive down to the native it shadows.
+*
+* `withHostGuard` stamps each throwing replacement with the primitive it
+* shadows under {@link NATIVE_PROCESS_EXIT}; nested guard windows stack, so a
+* single unwrap can still land on another throwing stub. Follow the chain
+* (cycle-guarded) until a link carries no stamp — that link is native.
+*/
+function nativeHardExit(fn) {
+	let current = fn;
+	const seen = /* @__PURE__ */ new Set();
+	while (typeof current === "function" && !seen.has(current)) {
+		seen.add(current);
+		const behind = Reflect.get(current, NATIVE_PROCESS_EXIT);
+		if (typeof behind !== "function") return current;
+		current = behind;
+	}
+	return typeof current === "function" ? current : void 0;
+}
+/**
 * Hard-exit the process through the native primitive, resolved on every call.
 *
 * The native exit is deliberately re-resolved here rather than bound at module
@@ -3173,13 +3533,35 @@ const NATIVE_PROCESS_EXIT = Symbol.for("omp.postmortem.nativeProcessExit");
 * init could freeze the throwing stub forever and turn every later shutdown
 * (SIGHUP/SIGINT/fatal) into an unhandled-rejection loop (#7393). When the
 * guard is active the stub carries the native exit under
-* {@link NATIVE_PROCESS_EXIT}; unwrapping it lets a mid-guard signal still exit
-* (#6488). Otherwise the current `process.reallyExit`/`process.exit` is native.
+* {@link NATIVE_PROCESS_EXIT} (#6488).
+*
+* Both globals are reinstalled to their natives before exiting: Bun's
+* `process.exit` re-reads `process.reallyExit` at call time, so exiting through
+* one primitive while its sibling still holds the throwing stub re-enters the
+* guard and loops the rejection storm (#11789). After restoring, `reallyExit`
+* (the low-level primitive) is preferred; `process.exit` and finally `SIGKILL`
+* are fallbacks so a poisoned or absent chain can never leave the process alive.
+*
+* Buffered log records are written first: `reallyExit` skips the `exit` event
+* the logger otherwise flushes on, which would drop the last batch on every
+* signal and fatal exit.
 */
 function exitProcess(code) {
-	const current = typeof process.reallyExit === "function" ? process.reallyExit : process.exit;
-	const behind = Reflect.get(current, NATIVE_PROCESS_EXIT);
-	return (typeof behind === "function" ? behind : current).call(process, code);
+	flush();
+	const reallyExit = nativeHardExit(typeof process.reallyExit === "function" ? process.reallyExit : void 0);
+	const exit = nativeHardExit(process.exit);
+	if (reallyExit) process.reallyExit = reallyExit;
+	if (exit) process.exit = exit;
+	try {
+		reallyExit?.call(process, code);
+	} catch {}
+	try {
+		exit?.call(process, code);
+	} catch {}
+	try {
+		process.kill(process.pid, "SIGKILL");
+	} catch {}
+	throw new Error(`exitProcess(${code}) failed to terminate the process`);
 }
 let cleanupPromise;
 const fatalRecoveryHintProviders = /* @__PURE__ */ new Set();
@@ -3382,12 +3764,19 @@ async function exitAfterFatal(output, logMessage, err, reason) {
 		exitProcess(1);
 	}
 }
-if (isMainThread) process.on("SIGINT", async () => {
+/** Contain an EPIPE from an optional worker IPC `send()` (#2997, #9158). */
+function handleWorkerSendEpipe(err) {
+	if (!isIpcSendEpipe(err)) return false;
+	warn("Ignoring EPIPE from worker IPC send; optional subsystem will self-recover", { err });
+	return true;
+}
+if (Bun.isMainThread) process.on("SIGINT", async () => {
 	await runCleanup("sigint");
 	exitProcess(130);
-}).on("SIGUSR1", () => {
+}).on("SIGUSR1", async () => {
 	if (inspectorOpened) return;
 	inspectorOpened = true;
+	const { default: inspector } = await import("node:inspector");
 	inspector.open(void 0, void 0, false);
 	const url = inspector.url();
 	process.stderr.write(`Inspector opened: ${url}\n`);
@@ -3397,10 +3786,7 @@ if (isMainThread) process.on("SIGINT", async () => {
 		return;
 	}
 	const err = thrown instanceof Error ? thrown : new Error(String(thrown));
-	if (isIpcSendEpipe(err)) {
-		warn("Ignoring EPIPE from worker IPC send; optional subsystem will self-recover", { err });
-		return;
-	}
+	if (handleWorkerSendEpipe(err)) return;
 	if (isWorkerIpcDeserializeError(err)) {
 		warn("Malformed worker IPC frame; faulting active worker subsystems", { err });
 		faultWorkerIpcChannels(err);
@@ -3413,10 +3799,7 @@ if (isMainThread) process.on("SIGINT", async () => {
 	await exitAfterFatal(`${formatFatalError("Uncaught Exception", err)}${formatFatalRecoveryHints()}`, "Uncaught exception", err, "uncaught_exception");
 }).on("unhandledRejection", async (reason) => {
 	const err = reason instanceof Error ? reason : new Error(String(reason));
-	if (classifyBrokenPipe(err) === "ipc-send") {
-		warn("Ignoring EPIPE from worker IPC send; optional subsystem will self-recover", { err });
-		return;
-	}
+	if (handleWorkerSendEpipe(err)) return;
 	if (isExpectedCleanupError(reason)) {
 		warn("Ignoring expected cleanup rejection", { err });
 		return;
@@ -3471,8 +3854,8 @@ function register(id, callback, options = {}) {
 		try {
 			const pending = invokeCleanup(registration, reason, keepAlive, cleanupPass);
 			if (!pending) return;
-			const tracked = pending.catch((error$2) => {
-				const err = error$2 instanceof Error ? error$2 : new Error(String(error$2));
+			const tracked = pending.catch((error$3) => {
+				const err = error$3 instanceof Error ? error$3 : new Error(String(error$3));
 				error("Cleanup callback failed", {
 					err,
 					id,
@@ -3480,8 +3863,8 @@ function register(id, callback, options = {}) {
 				});
 			});
 			activeLatePromises?.push(tracked);
-		} catch (error$1) {
-			const err = error$1 instanceof Error ? error$1 : new Error(String(error$1));
+		} catch (error$2) {
+			const err = error$2 instanceof Error ? error$2 : new Error(String(error$2));
 			error("Cleanup callback failed", {
 				err,
 				id,
@@ -3504,7 +3887,7 @@ function register(id, callback, options = {}) {
 	return cancel;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/which.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/which.ts
 const XCODE_BINS = /* @__PURE__ */ new Set([
 	"clang",
 	"clang++",
@@ -3599,14 +3982,16 @@ function darwinWhich(command, options) {
 	if (isXcodeBin(command)) return getMacosToolPaths().get(command) ?? null;
 	return null;
 }
+function filterAbsoluteSearchPath(rawPath) {
+	if (!rawPath) return null;
+	return rawPath.split(path$1.delimiter).filter((dir) => dir.length > 0 && isFullyQualifiedPath(dir)).join(path$1.delimiter) || null;
+}
 const whichFresh = os.platform() === "darwin" ? darwinWhich : (command, options) => Bun.which(command, options);
 function cacheKey$1(command, options) {
 	if (!options) return command;
-	if (!options.cwd && !options.PATH) return command;
-	let h = Bun.hash(command);
-	if (options.cwd) h = Bun.hash(options.cwd, h);
-	if (options.PATH) h = Bun.hash(options.PATH, h);
-	return h;
+	const cwd = options?.cwd ?? "";
+	const binPath = options?.PATH ?? "";
+	return `${command.length}:${command}${cwd.length}:${cwd}${binPath.length}:${binPath}`;
 }
 /**
 * Locate binary on PATH (with flexible caching).
@@ -3617,10 +4002,18 @@ function cacheKey$1(command, options) {
 */
 function $which(command, options) {
 	const cachePolicy = options?.cache ?? 0;
-	const lookupOptions = options?.PATH !== void 0 || process.env.PATH === void 0 ? options : {
+	let lookupOptions = options?.PATH !== void 0 || process.env.PATH === void 0 ? options : {
 		...options,
 		PATH: process.env.PATH
 	};
+	if (options?.requireAbsolutePaths) {
+		const safePath = filterAbsoluteSearchPath(lookupOptions?.PATH);
+		if (!safePath) return null;
+		lookupOptions = {
+			...lookupOptions,
+			PATH: safePath
+		};
+	}
 	let key;
 	if (cachePolicy !== 1) {
 		key = cacheKey$1(command, lookupOptions);
@@ -3630,11 +4023,148 @@ function $which(command, options) {
 		}
 	}
 	const result = whichFresh(command, lookupOptions);
+	if (result && options?.requireAbsolutePaths && !isFullyQualifiedPath(result)) return null;
 	if (key != null && cachePolicy !== 3) toolCache.set(key, result);
 	return result;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/template.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/lru.ts
+function positiveInteger(value, name) {
+	if (value === void 0) return 0;
+	if (!Number.isInteger(value) || value < 0) throw new TypeError(`${name} must be a non-negative integer`);
+	return value;
+}
+/** A bounded least-recently-used cache with optional size and lifetime limits. */
+var LRUCache = class {
+	#entries = /* @__PURE__ */ new Map();
+	#max;
+	#maxSize;
+	#maxEntrySize;
+	#sizeCalculation;
+	#ttl;
+	#updateAgeOnGet;
+	#dispose;
+	#calculatedSize = 0;
+	/** Creates an empty cache. */
+	constructor(options) {
+		this.#max = positiveInteger(options.max, "max");
+		this.#maxSize = positiveInteger(options.maxSize, "maxSize");
+		const explicitMaxEntrySize = positiveInteger(options.maxEntrySize, "maxEntrySize");
+		this.#maxEntrySize = explicitMaxEntrySize || this.#maxSize;
+		this.#ttl = positiveInteger(options.ttl, "ttl");
+		if (this.#max === 0 && this.#maxSize === 0 && this.#ttl === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+		if ((this.#maxSize !== 0 || this.#maxEntrySize !== 0) && options.sizeCalculation === void 0) throw new TypeError("sizeCalculation is required when a size limit is set");
+		this.#sizeCalculation = options.sizeCalculation;
+		this.#updateAgeOnGet = options.updateAgeOnGet === true;
+		this.#dispose = options.dispose;
+	}
+	/** Number of entries, including stale entries not yet removed by `get`. */
+	get size() {
+		return this.#entries.size;
+	}
+	/** Aggregate calculated size of retained entries. */
+	get calculatedSize() {
+		return this.#calculatedSize;
+	}
+	/** Stores a value and makes it most recently used. */
+	set(key, value) {
+		if (value === void 0) {
+			this.delete(key);
+			return this;
+		}
+		const size = this.#entrySize(value, key);
+		const previous = this.#entries.get(key);
+		if (this.#maxEntrySize !== 0 && size > this.#maxEntrySize) {
+			if (previous !== void 0) this.#remove(key, previous, "set");
+			return this;
+		}
+		if (previous !== void 0) {
+			if (previous.value !== value) this.#dispose?.(previous.value, key, "set");
+			this.#calculatedSize -= previous.size;
+			this.#entries.delete(key);
+		}
+		while (this.#max !== 0 && this.#entries.size >= this.#max || this.#maxSize !== 0 && this.#calculatedSize + size > this.#maxSize) {
+			const oldest = this.#entries.entries().next().value;
+			if (oldest === void 0) break;
+			this.#remove(oldest[0], oldest[1], "evict");
+		}
+		this.#entries.set(key, {
+			value,
+			size,
+			start: this.#ttl === 0 ? 0 : performance.now()
+		});
+		this.#calculatedSize += size;
+		return this;
+	}
+	/** Returns a value and makes a fresh entry most recently used. */
+	get(key) {
+		const entry = this.#entries.get(key);
+		if (entry === void 0) return void 0;
+		if (this.#isStale(entry)) {
+			this.#remove(key, entry, "expire");
+			return;
+		}
+		if (this.#updateAgeOnGet && this.#ttl !== 0) entry.start = performance.now();
+		this.#entries.delete(key);
+		this.#entries.set(key, entry);
+		return entry.value;
+	}
+	/** Reports whether a fresh value is present without changing recency. */
+	has(key) {
+		const entry = this.#entries.get(key);
+		return entry !== void 0 && !this.#isStale(entry);
+	}
+	/** Returns a fresh value without changing recency or removing stale data. */
+	peek(key) {
+		const entry = this.#entries.get(key);
+		return entry === void 0 || this.#isStale(entry) ? void 0 : entry.value;
+	}
+	/** Removes a value, returning whether one was present. */
+	delete(key) {
+		const entry = this.#entries.get(key);
+		if (entry === void 0) return false;
+		this.#remove(key, entry, "delete");
+		return true;
+	}
+	/** Removes every value from least to most recently used. */
+	clear() {
+		for (const [key, entry] of this.#entries) this.#dispose?.(entry.value, key, "delete");
+		this.#entries.clear();
+		this.#calculatedSize = 0;
+	}
+	/** Iterates fresh keys from most to least recently used. */
+	*keys() {
+		const entries = [...this.#entries.entries()];
+		for (let index = entries.length - 1; index >= 0; index--) {
+			const [key, entry] = entries[index];
+			if (!this.#isStale(entry)) yield key;
+		}
+	}
+	/** Iterates fresh values from most to least recently used. */
+	*values() {
+		const entries = [...this.#entries.values()];
+		for (let index = entries.length - 1; index >= 0; index--) {
+			const entry = entries[index];
+			if (!this.#isStale(entry)) yield entry.value;
+		}
+	}
+	#entrySize(value, key) {
+		if (this.#sizeCalculation === void 0) return 0;
+		const size = this.#sizeCalculation(value, key);
+		if (!Number.isInteger(size) || size <= 0) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+		return size;
+	}
+	#isStale(entry) {
+		return this.#ttl !== 0 && performance.now() - entry.start > this.#ttl;
+	}
+	#remove(key, entry, reason) {
+		this.#dispose?.(entry.value, key, reason);
+		this.#entries.delete(key);
+		this.#calculatedSize -= entry.size;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/template.ts
 /** A string that bypasses HTML escaping when interpolated. */
 var SafeString = class {
 	#value;
@@ -3856,7 +4386,8 @@ function parseTemplate(source) {
 				stack.push({
 					node: nested,
 					target: parentTarget,
-					inverted: false
+					inverted: false,
+					chained: true
 				});
 			}
 			continue;
@@ -3874,13 +4405,15 @@ function parseTemplate(source) {
 			stack.push({
 				node,
 				target,
-				inverted
+				inverted,
+				chained: false
 			});
 			target = node.body;
 			continue;
 		}
 		if (raw.startsWith("/")) {
-			const current = stack.pop();
+			let current = stack.pop();
+			while (current?.chained) current = stack.pop();
 			if (!current || current.node.expression.name !== raw.slice(1).trim()) throw new Error(`Parse error: mismatched ${raw}`);
 			if (current.inverted) [current.node.body, current.node.inverse] = [current.node.inverse, current.node.body];
 			target = current.target;
@@ -4136,7 +4669,7 @@ var TemplateEngine = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/prompt.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/prompt.ts
 const OPENING_XML = /^<([a-z_-]+)(?:\s+[^>]*)?>$/;
 /**
 * Closing XML tag matcher, manual equivalent of `/^<\/([a-z_-]+)>$/` — avoids a
@@ -4508,7 +5041,7 @@ handlebars.registerHelper("includes", (collection, item) => {
 */
 handlebars.registerHelper("not", (value) => !value);
 handlebars.registerHelper("jsonStringify", (value) => JSON.stringify(value));
-const compiledTemplateCache = /* @__PURE__ */ new Map();
+const compiledTemplateCache = new LRUCache({ max: 256 });
 function compile(template) {
 	const cached = compiledTemplateCache.get(template);
 	if (cached) return cached;
@@ -4579,7 +5112,7 @@ function _usingCtx() {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ptree.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ptree.ts
 /**
 * Process tree management utilities for Bun subprocesses.
 *
@@ -4590,6 +5123,8 @@ function _usingCtx() {
 */
 const LINUX_SUBREAPER_COMMAND_ENV = "OMP_PTREE_SUBREAPER_COMMAND";
 const LINUX_SUBREAPER_BUN_BE_BUN_ENV = "OMP_PTREE_SUBREAPER_BUN_BE_BUN";
+const SUBREAPER_KILL_WINDOW_MS = 100;
+const SUBREAPER_KILL_POLL_MS = 5;
 /**
 * Build the Linux child-subreaper entrypoint.
 *
@@ -4723,11 +5258,13 @@ var ChildProcess = class {
 	#stderrDone;
 	#exited;
 	#openPipeReaders = 1;
-	#drainCutoff;
-	#resolveDrainCutoff;
+	#cutoff = false;
+	/** Readers of piped stdio; the timeout cancels them so pending reads settle. */
+	#pipeReaders = /* @__PURE__ */ new Set();
 	#timeoutTimer;
 	#stderrStream;
 	#terminating;
+	#hardKillSweep;
 	#terminateGroup;
 	#hardKillTree;
 	#windowsRootProcess;
@@ -4750,28 +5287,23 @@ var ChildProcess = class {
 		}
 		const { promise, resolve, reject } = Promise.withResolvers();
 		this.#exited = promise;
-		const drainCutoff = Promise.withResolvers();
-		this.#drainCutoff = drainCutoff.promise;
-		this.#resolveDrainCutoff = drainCutoff.resolve;
-		const pipeCutoff = this.#drainCutoff;
 		this.#stderrDone = (async () => {
 			const reader = stderrStream.getReader();
+			this.#pipeReaders.add(reader);
 			try {
 				for (;;) {
-					const chunk = await Promise.race([reader.read().then((r) => ({
-						cutoff: false,
-						r
-					})), pipeCutoff.then(() => ({ cutoff: true }))]);
-					if (chunk.cutoff) {
+					if (this.#cutoff) {
 						await reader.cancel().catch(() => {});
 						break;
 					}
-					if (chunk.r.done) break;
-					this.#stderrChunks?.push(chunk.r.value);
-					this.#stderrTail += dec.decode(chunk.r.value, { stream: true });
+					const r = await reader.read();
+					if (r.done) break;
+					this.#stderrChunks?.push(r.value);
+					this.#stderrTail += dec.decode(r.value, { stream: true });
 					trim();
 				}
 			} catch {}
+			this.#pipeReaders.delete(reader);
 			this.#openPipeReaders--;
 			this.#stderrTail += dec.decode();
 			trim();
@@ -4848,11 +5380,16 @@ var ChildProcess = class {
 			this.#exitReasonPending = reason;
 			if (this.proc.exitCode !== null) this.#exitReason = reason;
 		}
+		if (this.#hardKillSweep) return;
 		if (gracefulMs !== void 0 && gracefulMs < 0 && this.#hardKillTree && this.proc.exitCode === null) {
 			const root = Process.fromPid(this.proc.pid);
 			if (root) {
-				root.killTree(9);
-				this.#terminating = Promise.resolve();
+				const sweep = this.#hardKillSubreaperTree(root).catch((e) => void 0);
+				this.#hardKillSweep = sweep;
+				this.#terminating = sweep;
+				sweep.finally(() => {
+					if (this.#hardKillSweep === sweep) this.#hardKillSweep = void 0;
+				});
 				return;
 			}
 		}
@@ -4873,11 +5410,56 @@ var ChildProcess = class {
 				gracefulMs,
 				group: this.#terminateGroup
 			};
-			this.#terminating = (this.#windowsRootProcess ?? Process.fromPid(this.proc.pid))?.terminate(options)?.catch((e) => void 0);
+			this.#terminating = this.#terminateTree(options);
+		}
+	}
+	/**
+	* Native tree termination. A native handle that cannot be resolved or used
+	* — the PID left the process table, or a `bun test --isolate` realm whose
+	* napi classes another realm superseded ("Value is not an instance of class
+	* `Process`") — must not leave the child running, so signal it directly.
+	*/
+	#terminateTree(options) {
+		const gracefulMs = options?.gracefulMs ?? 1e3;
+		try {
+			const root = this.#windowsRootProcess ?? Process.fromPid(this.proc.pid);
+			if (root) return root.terminate(options).catch(() => this.#signalChild(gracefulMs));
+		} catch {}
+		return this.#signalChild(gracefulMs);
+	}
+	/** SIGTERM the child (its group when it leads one), then SIGKILL if it outlives `gracefulMs`. */
+	async #signalChild(gracefulMs) {
+		const signal = (name) => {
+			try {
+				if (this.#terminateGroup && process.platform !== "win32") process.kill(-this.proc.pid, name);
+				else this.proc.kill(name);
+			} catch {}
+		};
+		if (gracefulMs >= 0) {
+			signal("SIGTERM");
+			await Promise.race([this.proc.exited, Bun.sleep(gracefulMs)]);
+		}
+		if (this.proc.exitCode === null && this.proc.signalCode === null) signal("SIGKILL");
+	}
+	async #hardKillSubreaperTree(root) {
+		try {
+			const deadline = Date.now() + SUBREAPER_KILL_WINDOW_MS;
+			let emptySweeps = 0;
+			while (emptySweeps < 2 && Date.now() < deadline) {
+				const children = root.children();
+				if (children.length === 0) emptySweeps++;
+				else {
+					emptySweeps = 0;
+					for (const child of children) child.killTree(9);
+				}
+				if (emptySweeps < 2) await Bun.sleep(SUBREAPER_KILL_POLL_MS);
+			}
+		} finally {
+			root.killTree(9);
 		}
 	}
 	async #throwIfAborted() {
-		const exitReason = this.exitReason;
+		const exitReason = this.#exitReason ?? this.#exitReasonPending;
 		if (!exitReason?.aborted) return;
 		if (this.#terminating) await this.#terminating;
 		throw exitReason;
@@ -4895,45 +5477,43 @@ var ChildProcess = class {
 	async #readStream(stream) {
 		this.#openPipeReaders++;
 		const reader = stream.getReader();
+		this.#pipeReaders.add(reader);
 		const dec = new TextDecoder();
 		let out = "";
 		try {
 			for (;;) {
-				const chunk = await Promise.race([reader.read().then((r) => ({
-					cutoff: false,
-					r
-				})), this.#drainCutoff.then(() => ({ cutoff: true }))]);
-				if (chunk.cutoff) {
+				if (this.#cutoff) {
 					await reader.cancel().catch(() => {});
 					break;
 				}
-				if (chunk.r.done) break;
-				out += dec.decode(chunk.r.value, { stream: true });
+				const r = await reader.read();
+				if (r.done) break;
+				out += dec.decode(r.value, { stream: true });
 			}
 		} catch {}
+		this.#pipeReaders.delete(reader);
 		this.#openPipeReaders--;
 		return out + dec.decode();
 	}
 	async #readBytes() {
 		const reader = this.proc.stdout.getReader();
 		this.#openPipeReaders++;
+		this.#pipeReaders.add(reader);
 		const chunks = [];
 		let length = 0;
 		try {
 			for (;;) {
-				const chunk = await Promise.race([reader.read().then((r) => ({
-					cutoff: false,
-					r
-				})), this.#drainCutoff.then(() => ({ cutoff: true }))]);
-				if (chunk.cutoff) {
+				if (this.#cutoff) {
 					await reader.cancel().catch(() => {});
 					break;
 				}
-				if (chunk.r.done) break;
-				chunks.push(chunk.r.value);
-				length += chunk.r.value.byteLength;
+				const r = await reader.read();
+				if (r.done) break;
+				chunks.push(r.value);
+				length += r.value.byteLength;
 			}
 		} catch {} finally {
+			this.#pipeReaders.delete(reader);
 			this.#openPipeReaders--;
 			reader.releaseLock();
 		}
@@ -4996,10 +5576,11 @@ var ChildProcess = class {
 		};
 	}
 	attachSignal(signal) {
+		const cleanup = this.#exited.catch(() => {});
 		const onAbort = () => this.kill(new AbortError(signal.reason, "<cancelled>"));
 		if (signal.aborted) return void onAbort();
 		signal.addEventListener("abort", onAbort, { once: true });
-		this.#exited.catch(() => {}).finally(() => signal.removeEventListener("abort", onAbort));
+		cleanup.finally(() => signal.removeEventListener("abort", onAbort));
 	}
 	#clearTimeout() {
 		if (!this.#timeoutTimer) return;
@@ -5011,7 +5592,8 @@ var ChildProcess = class {
 		this.#exited.catch(() => {});
 		const timer = setTimeout(() => {
 			if (this.proc.exitCode === null || this.#openPipeReaders > 0 && (this.#terminateGroup || this.#windowsRootProcess)) this.kill(new TimeoutError(ms, this.#stderrTail), -1);
-			this.#resolveDrainCutoff();
+			this.#cutoff = true;
+			for (const reader of this.#pipeReaders) reader.cancel().catch(() => {});
 		}, ms);
 		timer.unref?.();
 		this.#timeoutTimer = timer;
@@ -5050,22 +5632,22 @@ function spawnInternal(cmd, opts, retainFullStderr) {
 /** Spawn, wait, and return captured output. */
 async function exec(cmd, opts) {
 	try {
-		var _usingCtx$1 = _usingCtx();
+		var _usingCtx$2 = _usingCtx();
 		const { input, stderr, allowAbort, allowNonZero, ...spawnOpts } = opts ?? {};
 		const stdin = typeof input === "string" ? Buffer.from(input) : input;
 		const resolved = stdin === void 0 ? spawnOpts : {
 			...spawnOpts,
 			stdin
 		};
-		return await _usingCtx$1.u(spawnInternal(cmd, resolved, stderr === "full")).wait({
+		return await _usingCtx$2.u(spawnInternal(cmd, resolved, stderr === "full")).wait({
 			stderr,
 			allowAbort,
 			allowNonZero
 		});
 	} catch (_) {
-		_usingCtx$1.e = _;
+		_usingCtx$2.e = _;
 	} finally {
-		_usingCtx$1.d();
+		_usingCtx$2.d();
 	}
 }
 /** Combine AbortSignals and timeout values into a single signal. */
@@ -5091,19 +5673,21 @@ function combineSignals(...signals) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/snowflake.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/snowflake.ts
 function randu32() {
 	return crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(1))[0];
 }
 const EPOCH = 14200704e5;
 const MAX_SEQ = 4194303;
+const MAX_DT = 2 ** 42 - 1;
 let Snowflake;
 (function(_Snowflake) {
 	const PATTERN = _Snowflake.PATTERN = /^[0-9a-f]{16}$/;
 	_Snowflake.EPOCH_TIMESTAMP = EPOCH;
 	_Snowflake.MAX_SEQUENCE = MAX_SEQ;
+	_Snowflake.MAX_TIMESTAMP = EPOCH + MAX_DT;
 	function formatParts(dt, seq) {
-		return (BigInt(dt) << 22n | BigInt(seq)).toString(16).padStart(16, "0");
+		return (BigInt(Math.min(Math.max(dt, 0), MAX_DT)) << 22n | BigInt(seq)).toString(16).padStart(16, "0");
 	}
 	_Snowflake.formatParts = formatParts;
 	class Source {
@@ -5170,9 +5754,11 @@ let Snowflake;
 	_Snowflake.getDate = getDate;
 })(Snowflake || (Snowflake = {}));
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/stream.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/stream.ts
 const trailingEvents = /* @__PURE__ */ new WeakSet();
 const LF = 10;
+const CR = 13;
+const CONCAT_SINK_RETAIN_BYTES = 1048576;
 async function* readJsonl(stream, signal) {
 	const buffer = new ConcatSink();
 	const source = abortableSource(stream, signal);
@@ -5193,9 +5779,19 @@ async function* readJsonl(stream, signal) {
 		throw err;
 	}
 }
+/**
+* Amortized byte accumulator for chunked stream readers.
+*
+* Holds the unconsumed tail of a stream in a single growing `Buffer` so that
+* appending N chunks costs O(total bytes) instead of re-copying the whole
+* prefix per chunk. Backs {@link readLines}, {@link readJsonl} and
+* {@link readSseEvents}; also usable directly when a reader needs its own
+* framing loop (see `consume` and `flush`).
+*/
 var ConcatSink = class {
 	#space;
 	#length = 0;
+	#skipLeadingLf = false;
 	#ensureCapacity(size) {
 		const space = this.#space;
 		if (space && space.length >= size) return space;
@@ -5205,6 +5801,20 @@ var ConcatSink = class {
 		this.#space = next;
 		return next;
 	}
+	/** Drop or right-size an oversized buffer after the buffered length shrank. */
+	#releaseCapacity() {
+		const space = this.#space;
+		if (!space || space.length <= CONCAT_SINK_RETAIN_BYTES) return;
+		const length = this.#length;
+		if (length === 0) {
+			this.#space = void 0;
+			return;
+		}
+		if (length * 4 > space.length) return;
+		const next = Buffer.allocUnsafe(length);
+		space.copy(next, 0, 0, length);
+		this.#space = next;
+	}
 	append(chunk) {
 		const n = chunk.length;
 		if (!n) return;
@@ -5213,24 +5823,44 @@ var ConcatSink = class {
 		this.#length += n;
 	}
 	reset(chunk) {
+		this.#length = 0;
+		this.#releaseCapacity();
 		const n = chunk.length;
-		if (!n) {
-			this.#length = 0;
-			return;
-		}
+		if (!n) return;
 		this.#ensureCapacity(n).set(chunk, 0);
 		this.#length = n;
 	}
 	get isEmpty() {
 		return this.#length === 0;
 	}
+	/**
+	* The buffered bytes as a live view — invalidated by the next `append`,
+	* `reset` or `consume`.
+	*/
 	flush() {
 		if (!this.#length) return void 0;
 		return this.#space.subarray(0, this.#length);
 	}
+	/** Drop the first `count` buffered bytes, keeping the remainder. */
+	consume(count) {
+		if (count <= 0) return;
+		if (count >= this.#length) this.#length = 0;
+		else {
+			this.#space.copyWithin(0, count, this.#length);
+			this.#length -= count;
+		}
+		this.#releaseCapacity();
+	}
 	clear() {
 		this.#length = 0;
+		this.#releaseCapacity();
 	}
+	/**
+	* Append a chunk and yield each complete LF-delimited line.
+	*
+	* Yielded lines are owned snapshots. Unlike {@link flush}, they remain
+	* valid after this sink or the input chunk is mutated.
+	*/
 	*appendAndFlushLines(chunk) {
 		let pos = 0;
 		while (pos < chunk.length) {
@@ -5241,30 +5871,37 @@ var ConcatSink = class {
 			}
 			const suffix = chunk.subarray(pos, nl);
 			pos = nl + 1;
-			if (this.isEmpty) yield suffix;
+			if (this.isEmpty) yield new Uint8Array(suffix);
 			else {
 				this.append(suffix);
 				const payload = this.flush();
 				if (payload) {
-					yield payload;
+					yield new Uint8Array(payload);
 					this.clear();
 				}
 			}
 		}
 	}
 	appendAndFlushText(chunk, decoder) {
-		const lastNewline = chunk.lastIndexOf(LF);
-		if (lastNewline === -1) {
-			this.append(chunk);
+		let start = 0;
+		if (this.#skipLeadingLf) {
+			if (chunk.length === 0) return void 0;
+			this.#skipLeadingLf = false;
+			if (chunk[0] === LF) start = 1;
+		}
+		const lastLineEnd = Math.max(chunk.lastIndexOf(LF), chunk.lastIndexOf(CR));
+		if (lastLineEnd < start) {
+			if (start < chunk.length) this.append(chunk.subarray(start));
 			return;
 		}
-		const completeEnd = lastNewline + 1;
+		const completeEnd = lastLineEnd + 1;
+		this.#skipLeadingLf = chunk[lastLineEnd] === CR && completeEnd === chunk.length;
 		let text;
 		if (this.isEmpty) {
-			const complete = completeEnd === chunk.length ? chunk : chunk.subarray(0, completeEnd);
+			const complete = start === 0 && completeEnd === chunk.length ? chunk : chunk.subarray(start, completeEnd);
 			text = decoder.decode(complete);
 		} else {
-			this.append(completeEnd === chunk.length ? chunk : chunk.subarray(0, completeEnd));
+			this.append(chunk.subarray(start, completeEnd));
 			text = decoder.decode(this.flush());
 			this.clear();
 		}
@@ -5294,13 +5931,13 @@ var ConcatSink = class {
 		const { values, error, read, done } = Bun.JSONL.parseChunk(space, 0, total);
 		if (values.length > 0) yield* values;
 		if (error) throw error;
-		if (done) {
-			this.#length = 0;
-			return;
+		if (done) this.#length = 0;
+		else {
+			const rem = total - read;
+			if (rem < total) space.copyWithin(0, read, total);
+			this.#length = rem;
 		}
-		const rem = total - read;
-		if (rem < total) space.copyWithin(0, read, total);
-		this.#length = rem;
+		this.#releaseCapacity();
 	}
 };
 function notifySseEventObserver(observer, event) {
@@ -5315,51 +5952,104 @@ function isRecoverableTrailingJson(data) {
 	const recovered = parseStreamingJson(data);
 	return typeof recovered === "object" && recovered !== null;
 }
-async function* readSseJson(stream, signal, onEvent) {
-	for await (const sse of readSseEvents(stream, signal)) {
+/**
+* Shared `data:`-line framing for {@link readSseJson} and
+* {@link readSseJsonOrText}: skips empty events, stops at the OpenAI `[DONE]`
+* sentinel (reporting it through `onDone`), notifies the diagnostic observer,
+* and treats a container-shaped stream tail as a clean end of iteration.
+*/
+async function* readSseFrames(stream, signal, onEvent, onDone) {
+	for await (const sse of readSseEvents(stream, signal, onEvent ? { captureRaw: true } : void 0)) {
 		const isTrailing = trailingEvents.has(sse);
 		notifySseEventObserver(onEvent, sse);
 		const data = sse.data;
 		if (data === "" || data === "[DONE]") {
-			if (data === "[DONE]") return;
+			if (data === "[DONE]") {
+				onDone?.();
+				return;
+			}
 			continue;
 		}
 		try {
-			yield JSON.parse(data);
+			yield {
+				ok: true,
+				value: JSON.parse(data)
+			};
 		} catch (err) {
 			if (err instanceof SyntaxError && isTrailing && isRecoverableTrailingJson(data)) return;
+			if (err instanceof SyntaxError) {
+				yield {
+					ok: false,
+					raw: data,
+					error: err
+				};
+				continue;
+			}
 			throw err;
 		}
 	}
 }
+async function* readSseJson(stream, signal, onEvent) {
+	for await (const frame of readSseFrames(stream, signal, onEvent)) {
+		if (!frame.ok) throw frame.error;
+		yield frame.value;
+	}
+}
+/**
+* Like {@link readSseJson}, but a `data:` frame that is not valid JSON is yielded
+* as its raw text instead of raising a `SyntaxError`. Cut-off container-shaped
+* stream tails stay recoverable, exactly as they are in {@link readSseJson}.
+*
+* Consumers that only understand objects must treat a `string` yield as a
+* transport-level failure (for example a `429 Too Many Requests` or an HTML
+* throttle page from a reverse proxy that already committed to the stream). This
+* exists because `readSseJson`'s baseline consumers span unrelated transports
+* whose error handling a text yield would subtly change; new call sites opt in.
+*
+* Note that the text lane is only the frames `JSON.parse` *rejected*: a frame
+* carrying a JSON-encoded string (`data: "429 Too Many Requests"`) parses, so it
+* is yielded as that string and is indistinguishable from a rejected frame by
+* type alone. Consumers branching on `typeof === "string"` therefore see both,
+* which is the safe direction — each is classified as text rather than trusted as
+* an event object.
+*/
+async function* readSseJsonOrText(stream, signal, onEvent, onDone) {
+	for await (const frame of readSseFrames(stream, signal, onEvent, onDone)) if (!frame.ok) yield frame.raw;
+	else yield frame.value;
+}
 const SSE_DECODER = new TextDecoder("utf-8");
+/**
+* `raw` of every event dispatched with capture off. Shared instead of one
+* fresh array per event; frozen so an in-place mutation throws rather than
+* leaking lines into every other event (consumers copy or reassign `raw`).
+*/
+const EMPTY_RAW = Object.freeze([]);
 function flushSseEvent(state) {
 	if (state.event === null && state.data === null && state.id === void 0 && state.retry === void 0) {
-		state.raw = [];
+		if (state.raw !== null) state.raw = [];
 		return null;
 	}
 	const event = {
 		event: state.event,
 		data: state.data ?? "",
-		raw: state.raw
+		raw: state.raw ?? EMPTY_RAW
 	};
 	if (state.id !== void 0) event.id = state.id;
 	if (state.retry !== void 0) event.retry = state.retry;
 	state.event = null;
 	state.data = null;
-	state.raw = [];
+	if (state.raw !== null) state.raw = [];
 	state.id = void 0;
 	state.retry = void 0;
 	return event;
 }
 function pushSseLine(line, state) {
-	if (line.charCodeAt(line.length - 1) === 13) line = line.slice(0, -1);
 	if (line.length === 0) return flushSseEvent(state);
 	if (line.charCodeAt(0) === 58) {
-		state.raw.push(line);
+		state.raw?.push(line);
 		return null;
 	}
-	state.raw.push(line);
+	state.raw?.push(line);
 	const colon = line.indexOf(":");
 	const fieldName = colon === -1 ? line : line.slice(0, colon);
 	let value = colon === -1 ? "" : line.slice(colon + 1);
@@ -5389,31 +6079,12 @@ function pushSseLine(line, state) {
 	}
 	return null;
 }
-/**
-* Stream raw Server-Sent Events from an HTTP response body.
-*
-* Yields one `ServerSentEvent` per blank-line dispatch. The consumer is
-* responsible for parsing `data` (e.g. JSON, plain text, error envelope).
-* Use `readSseJson` instead when every event is a single `data:` JSON object
-* and you don't need access to the `event:` field.
-*
-* Internally backed by a Buffer-based reader (`ConcatSink`) that batches all
-* complete lines in each source chunk into one UTF-8 decode.
-*
-* @example
-* ```ts
-* for await (const sse of readSseEvents(response.body!)) {
-*   if (sse.event === "ping") continue;
-*   const obj = JSON.parse(sse.data);
-* }
-* ```
-*/
-async function* readSseEvents(stream, signal) {
+async function* readSseEvents(stream, signal, options) {
 	const lineBuffer = new ConcatSink();
 	const state = {
 		event: null,
 		data: null,
-		raw: []
+		raw: options?.captureRaw === true ? [] : null
 	};
 	const source = abortableSource(stream, signal);
 	try {
@@ -5422,10 +6093,16 @@ async function* readSseEvents(stream, signal) {
 			if (text === void 0) continue;
 			let start = 0;
 			while (start < text.length) {
-				const newline = text.indexOf("\n", start);
-				const event = pushSseLine(text.slice(start, newline), state);
+				let lineEnd = start;
+				while (lineEnd < text.length) {
+					const code = text.charCodeAt(lineEnd);
+					if (code === LF || code === CR) break;
+					lineEnd++;
+				}
+				const event = pushSseLine(text.slice(start, lineEnd), state);
 				if (event) yield event;
-				start = newline + 1;
+				if (text.charCodeAt(lineEnd) === CR && text.charCodeAt(lineEnd + 1) === LF) lineEnd++;
+				start = lineEnd + 1;
 			}
 		}
 		if (!lineBuffer.isEmpty) {
@@ -5450,7 +6127,14 @@ async function* readSseEvents(stream, signal) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/temp.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/temp.ts
+/**
+* Owned temporary directory, removed via `remove()` or `using`/`await using`.
+*
+* Prefixes follow `mkdtemp`: `"@name-"` creates under the OS temp dir, any other
+* prefix is a path (a bare `"name-"` lands in the process cwd), and no prefix
+* means `"@pi-temp-"`.
+*/
 var TempDir = class TempDir {
 	#path;
 	constructor(path) {
@@ -5513,7 +6197,6 @@ const kRetryableRemoveErrorCodes = /* @__PURE__ */ new Set([
 	"EPERM",
 	"ENOTEMPTY"
 ]);
-const kSleepBuffer = new Int32Array(new SharedArrayBuffer(4));
 /** Removes a path recursively, retrying transient Windows deletion failures. */
 async function removeWithRetries(target) {
 	for (let attempt = 0;; attempt++) try {
@@ -5521,6 +6204,7 @@ async function removeWithRetries(target) {
 		return;
 	} catch (err) {
 		if (!shouldRetryRemove(err, attempt)) throw err;
+		if (attempt === 0) Bun.gc(true);
 		await Bun.sleep(kRemoveRetryDelayMs);
 	}
 }
@@ -5530,7 +6214,8 @@ function removeSyncWithRetries(target) {
 		return;
 	} catch (err) {
 		if (!shouldRetryRemove(err, attempt)) throw err;
-		sleepSync(kRemoveRetryDelayMs);
+		if (attempt === 0) Bun.gc(true);
+		Bun.sleepSync(kRemoveRetryDelayMs);
 	}
 }
 function shouldRetryRemove(err, attempt) {
@@ -5539,15 +6224,8 @@ function shouldRetryRemove(err, attempt) {
 function isRetryableRemoveError(err) {
 	return typeof err === "object" && err !== null && "code" in err && typeof err.code === "string" && kRetryableRemoveErrorCodes.has(err.code);
 }
-function sleepSync(ms) {
-	if ("sleepSync" in Bun && typeof Bun.sleepSync === "function") {
-		Bun.sleepSync(ms);
-		return;
-	}
-	Atomics.wait(kSleepBuffer, 0, 0, ms);
-}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/tls-fetch.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/tls-fetch.ts
 /**
 * `NODE_EXTRA_CA_CERTS` shim for Bun's `fetch`.
 *
@@ -5656,7 +6334,7 @@ function wrapFetchForExtraCa(fetchImpl) {
 	}, fetchImpl.preconnect ? { preconnect: fetchImpl.preconnect } : {}, { [EXTRA_CA_FETCH_MARKER]: true });
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/index.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/index.ts
 function isPlainObject(val) {
 	return Object.getPrototypeOf(val) === Object.prototype || Array.isArray(val);
 }
@@ -5667,5 +6345,41 @@ function structuredCloneJSON(value) {
 	} catch {}
 	return JSON.parse(JSON.stringify(value));
 }
+/**
+* Deep-copies a JSON-shaped tree (arrays and plain or null-prototype objects)
+* so later mutation of the source can never reach the copy. Strings and other
+* primitives are immutable and shared, so the cost is O(containers) instead of
+* `structuredClone`'s O(bytes) — the difference matters for hot paths that
+* re-copy large string payloads (e.g. streamed tool-call arguments) per delta.
+*
+* Copies own enumerable string keys only. Any other object (class instance,
+* Date, Map, inherited-prototype object) is copied with {@link structuredCloneJSON}.
+* Not cycle-safe: callers MUST pass acyclic data, as any JSON-serializable value is.
+*/
+function cloneJsonTree(value) {
+	return cloneJsonNode(value);
+}
+function isJsonRecord(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function cloneJsonNode(value) {
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(cloneJsonNode);
+	if (!isJsonRecord(value)) return structuredCloneJSON(value);
+	const out = {};
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		const child = cloneJsonNode(value[key]);
+		if (key === "__proto__") Object.defineProperty(out, key, {
+			value: child,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		else out[key] = child;
+	}
+	return out;
+}
 //#endregion
-export { isEnoent as $, formatCount as A, USER_AGENT as B, warn as C, installBunShim as D, CookieMap as E, $flag as F, getDocsRsCacheDir as G, getAgentDir as H, $pickenv as I, getLogsDir as J, getDocumentConversionCacheDir as K, isBunTestRuntime as L, truncate as M, $env as N, formatAge as O, $envpos as P, hasFsCode as Q, isTerminalHeadless as R, time as S, Cookie as T, getAutoQaDbPath as U, VERSION as V, getDebugLogPath as W, getRemoteDir as X, getPuppeteerDir as Y, getToolsDir as Z, parseStreamingJson as _, readSseEvents as a, findOnPath as at, debug as b, combineSignals as c, $which as d, isEnotdir as et, register as f, parseJsonWithRepair as g, classifyJsonPrefix as h, readJsonl as i, untilAborted as it, formatNumber as j, formatBytes as k, exec as l, readImageMetadata as m, wrapFetchForExtraCa as n, peekFile as nt, readSseJson as o, parseImageMetadata as p, getInstallId as q, TempDir as r, once as rt, Snowflake as s, structuredCloneJSON as t, isProbablyBinary as tt, render as u, parseStreamingJsonThrottled as v, $ as w, error as x, parseFrontmatter as y, isWsl as z };
+export { getAutoQaDbPath as $, FFIType as A, formatNumber as B, parseStreamingJson as C, error as D, debug as E, CookieMap as F, $pickenv as G, $env as H, installBunShim as I, stripWindowsExtendedLengthPathPrefix as J, isTerminalHeadless as K, formatAge as L, ptr as M, $ as N, time as O, Cookie as P, getAgentDir as Q, formatBytes as R, parseJsonWithRepair as S, parseFrontmatter as T, $envpos as U, truncate as V, $flag as W, USER_AGENT as X, APP_URL as Y, VERSION as Z, parseImageMetadata as _, findOnPath as _t, readJsonl as a, getLogsDir as at, takeLoopPhaseAttribution as b, readSseJsonOrText as c, getToolsDir as ct, exec as d, isEnoent as dt, getCustomThemesDir as et, render as f, isEnotdir as ft, base64ImageDataFailureReason as g, untilAborted as gt, register as h, once as ht, TempDir as i, getInstallId as it, dlopen as j, warn as k, Snowflake as l, isBunTestRuntime as lt, $which as m, peekFile as mt, structuredCloneJSON as n, getDocsRsCacheDir as nt, readSseEvents as o, getPuppeteerDir as ot, LRUCache as p, isProbablyBinary as pt, isWsl as q, wrapFetchForExtraCa as r, getDocumentConversionCacheDir as rt, readSseJson as s, getRemoteDir as st, cloneJsonTree as t, getDebugLogPath as tt, combineSignals as u, hasFsCode as ut, readImageMetadata as v, parseStreamingJsonThrottled as w, classifyJsonPrefix as x, resetLoopPhaseWindow as y, formatCount as z };