@xiaoso/dsh-tool-plus 0.1.6 → 0.1.7-beta.0

package/lib/{src-BcD0_rQR.mjs → src-BwW51vA5.mjs}

@@ -17,7 +17,51 @@ import { isPromise } from "node:util/types";
 import inspector from "node:inspector";
 import { isMainThread } from "node:worker_threads";
 import * as tls from "node:tls";
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/abortable.ts
+//#region src/tools/bash/which.ts
+/**
+* Minimal PATH (+ PATHEXT on Windows) executable lookup — the plugin's single
+* implementation of `Bun.which` semantics on the Node runtime.
+*
+* Two callers, one scanner: DSH code that must resolve executables the way OMP
+* does (procmgr `resolveWindowsShell` for shell discovery, `REJECT_PROMPT_COMMAND`
+* in non-interactive-env) calls `findOnPath` directly, and the bun-shim installs
+* `Bun.which` on top of it — which is also how upstream pi-utils' `$which` lands
+* here (@oh-my-pi/pi-utils src/which.ts:201 calls `Bun.which` on non-darwin).
+* Single implementation — any new caller resolves executables through here,
+* never hand-rolls a PATH walk.
+* @module @xiaoso/dsh-tool-plus/bash/which
+*/
+/** Windows default extension order when PATHEXT is unset. */
+const WIN32_DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+/** True when `command` carries its own directory component. */
+function hasPathSeparator(command) {
+	return command.includes("/") || command.includes("\\");
+}
+/**
+* Resolve `command` against PATH the way `Bun.which` would: absolute/relative
+* candidates are returned as-is when they name an existing file; bare names
+* are looked up in each PATH dir (appending PATHEXT extensions on win32, in
+* order). Returns the first existing regular file, or `undefined`.
+*/
+function findOnPath(command, env = process.env) {
+	if (command.length === 0) return void 0;
+	if (hasPathSeparator(command)) try {
+		return fs.statSync(command).isFile() ? path.resolve(command) : void 0;
+	} catch {
+		return;
+	}
+	const dirs = (env.PATH ?? "").split(path.delimiter).filter(Boolean);
+	const extensions = process.platform === "win32" ? (env.PATHEXT && env.PATHEXT.length > 0 ? env.PATHEXT : WIN32_DEFAULT_PATHEXT).split(";").filter(Boolean) : [];
+	const candidates = process.platform === "win32" ? [command, ...extensions.map((ext) => command + ext)] : [command];
+	for (const dir of dirs) for (const candidate of candidates) {
+		const full = path.join(dir, candidate);
+		try {
+			if (fs.statSync(full).isFile()) return full;
+		} catch {}
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/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");
@@ -110,7 +154,7 @@ function once(fn) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/peek-file.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/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`.
 *
@@ -175,7 +219,7 @@ async function peekFile(filePath, maxBytes, op) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/binary.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/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.
@@ -190,7 +234,11 @@ async function peekFile(filePath, maxBytes, op) {
 * if (await isProbablyBinary(path)) return "[binary file omitted]";
 * const text = await Bun.file(path).text();
 */
-/** Header window sniffed for the binary heuristic; mirrors git's 8000-byte scan. */
+/**
+* Header window sniffed for the binary heuristic; mirrors git's 8000-byte scan.
+* Exported so callers that already hold the whole file in memory can sniff the
+* identical prefix through {@link isProbablyBinaryHeader} instead of reopening.
+*/
 const BINARY_SNIFF_BYTES = 8192;
 /**
 * Classify an in-memory byte header as binary (non-UTF-8-text).
@@ -218,9 +266,23 @@ function isProbablyBinary(filePath, maxBytes = BINARY_SNIFF_BYTES) {
 	return peekFile(filePath, maxBytes, isProbablyBinaryHeader);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/package.json
-var version = "17.3.5";
+//#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";
 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
+function isFsError(err) {
+	return err instanceof Error && "code" in err && typeof err.code === "string";
+}
+function isEnoent(err) {
+	return isFsError(err) && err.code === "ENOENT";
+}
+function isEnotdir(err) {
+	return isFsError(err) && err.code === "ENOTDIR";
+}
+function hasFsCode(err, code) {
+	return isFsError(err) && err.code === code;
+}
 /** Version (e.g. "1.0.0") */
 const VERSION = version;
 /** Default User-Agent header string (e.g. "omp/17.2.12") */
@@ -311,7 +373,29 @@ function standardizeMacOSPath(p) {
 	} catch {}
 	return p;
 }
-standardizeMacOSPath(process.cwd());
+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.isAbsolute(candidate)) continue;
+			try {
+				process.chdir(candidate);
+				projectDir = standardizeMacOSPath(candidate);
+				break;
+			} catch {}
+		}
+		if (projectDir === void 0) throw new Error("Unable to determine an accessible working directory");
+	}
+	return projectDir;
+}
 /** Get the config directory name relative to home (e.g. ".omp" or PI_CONFIG_DIR override). */
 function getConfigDirName() {
 	return process.env.PI_CONFIG_DIR || ".omp";
@@ -530,7 +614,7 @@ function getInstallId() {
 	return next;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/env.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/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
@@ -557,6 +641,17 @@ function isSafeEnvValue(value) {
 function isMacosMallocStackLoggingEnvName(name) {
 	return name === "MallocStackLogging" || name === "MallocStackLoggingNoCompact";
 }
+/**
+* True when running inside a WSL (Windows Subsystem for Linux) distribution.
+*
+* WSL reports `linux` for `process.platform`, so the only reliable signal is
+* the `WSL_DISTRO_NAME`/`WSL_INTEROP` variables the interop layer injects.
+* Callers use this to translate Windows drive paths to their `/mnt/<drive>`
+* mounts and to route clipboard access through `powershell.exe`.
+*/
+function isWsl(platform = process.platform, env = process.env) {
+	return platform === "linux" && Boolean(env.WSL_DISTRO_NAME || env.WSL_INTEROP);
+}
 function readLaunchEnv() {
 	if (process.platform === "linux") try {
 		const values = /* @__PURE__ */ new Map();
@@ -628,7 +723,7 @@ function parseEnvFile(filePath) {
 const homeEnv = parseEnvFile(path.join(os.homedir(), ".env"));
 const piEnv = parseEnvFile(path.join(getConfigRootDir(), ".env"));
 const agentEnv = parseEnvFile(path.join(getAgentDir(), ".env"));
-const projectEnv = parseEnvFile(path.join(process.cwd(), ".env"));
+const projectEnv = parseEnvFile(path.join(getProjectDir(), ".env"));
 for (const key of Object.keys(Bun.env)) {
 	const value = Bun.env[key];
 	if (!isSafeEnvName(key) || isMacosMallocStackLoggingEnvName(key) || value === void 0 || !isSafeEnvValue(value)) delete Bun.env[key];
@@ -1057,18 +1152,35 @@ function xxHash64Core(bytes, seed) {
 	h ^= h >> 32n;
 	return h & MASK64;
 }
-function bunHash(data) {
+/**
+* `Bun.hash(input, seed?)` — FNV-1a 32-bit stand-in, seeded form included.
+*
+* The seed is load-bearing: pi-utils folds `command` → `cwd` → `PATH` into one
+* cache key by re-seeding at each step (@oh-my-pi/pi-utils src/which.ts:207-209),
+* so a shim that drops the seed collapses every command sharing a PATH onto a
+* single `$which` cache slot (`$which("b")` returning `a`'s path). FNV steps are
+* bijections mod 2^32, so distinct seeds stay distinct for equal input — exactly
+* what a cache key needs. Single-argument values are unchanged (no seed → FNV
+* offset basis).
+*/
+function bunHash(data, seed) {
 	let bytes;
 	if (typeof data === "string") bytes = new TextEncoder().encode(data);
 	else if (data instanceof ArrayBuffer) bytes = new Uint8Array(data);
 	else bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-	let h = 2166136261;
+	let h = seedToBasis(seed);
 	for (const b of bytes) {
 		h ^= b;
 		h = Math.imul(h, 16777619) >>> 0;
 	}
 	return h >>> 0;
 }
+/** Seed → FNV-1a offset basis (non-finite numbers fall back to the default). */
+function seedToBasis(seed) {
+	if (seed === void 0) return 2166136261;
+	if (typeof seed === "bigint") return Number(BigInt.asUintN(32, seed)) >>> 0;
+	return Number.isFinite(seed) ? Math.trunc(seed) >>> 0 : 2166136261;
+}
 function isWideChar(c) {
 	return c >= 4352 && (c <= 4447 || c === 9001 || c === 9002 || c >= 11904 && c <= 42191 && c !== 12351 || c >= 44032 && c <= 55203 || c >= 63744 && c <= 64255 || c >= 65040 && c <= 65049 || c >= 65072 && c <= 65135 || c >= 65280 && c <= 65376 || c >= 65504 && c <= 65510 || c >= 127744 && c <= 129791 || c >= 131072 && c <= 262141);
 }
@@ -1399,6 +1511,13 @@ function bunStripANSI(text) {
 	}
 	return out;
 }
+function bunWhich(command, options) {
+	const cwd = options?.cwd;
+	return findOnPath(cwd !== void 0 && !path.isAbsolute(command) && (command.includes("/") || command.includes("\\")) ? path.resolve(cwd, command) : command, options?.PATH !== void 0 ? {
+		...process.env,
+		PATH: options.PATH
+	} : process.env) ?? null;
+}
 function installBunShim() {
 	patchBase64();
 	const g = globalThis;
@@ -1407,6 +1526,7 @@ function installBunShim() {
 		file: (p) => new BunFileShim(p),
 		write: bunWrite,
 		env: process.env,
+		which: bunWhich,
 		sleep: bunSleep,
 		hash: bunHash,
 		randomUUIDv7: bunRandomUUIDv7,
@@ -1518,7 +1638,7 @@ var CookieMap = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/logger/rotating-file.ts
+//#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;
@@ -1633,7 +1753,7 @@ var RotatingFileSink = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/logger.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/logger.ts
 /**
 * Centralized logger for omp.
 *
@@ -1708,20 +1828,25 @@ function pruneStaleProcessLogs(dir) {
 			} catch {}
 			continue;
 		}
-		try {
-			const key = `${pidText}:${logMatch[1]}`;
-			const staleLogs = staleLogsByProcessDay.get(key) ?? [];
-			staleLogs.push({
-				path: entryPath,
-				mtimeMs: fs.statSync(entryPath).mtimeMs,
-				rollover: Number(logMatch[3] ?? 0)
-			});
-			staleLogsByProcessDay.set(key, staleLogs);
-		} catch {}
+		const key = `${pidText}:${logMatch[1]}`;
+		const staleLogs = staleLogsByProcessDay.get(key) ?? [];
+		staleLogs.push({
+			path: entryPath,
+			rollover: Number(logMatch[3] ?? 0)
+		});
+		staleLogsByProcessDay.set(key, staleLogs);
 	}
 	for (const staleLogs of staleLogsByProcessDay.values()) {
-		staleLogs.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 staleLogs.slice(RETAINED_STALE_LOGS_PER_PROCESS_DAY)) try {
+		if (staleLogs.length <= RETAINED_STALE_LOGS_PER_PROCESS_DAY) continue;
+		const ranked = [];
+		for (const stale of staleLogs) try {
+			ranked.push({
+				...stale,
+				mtimeMs: fs.statSync(stale.path).mtimeMs
+			});
+		} 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 {}
 	}
@@ -1897,7 +2022,7 @@ function time(op, fn, ...args) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/frontmatter.ts
+//#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, "");
 }
@@ -2047,49 +2172,29 @@ function parseFrontmatter(content, options) {
 		};
 	}
 }
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/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";
-}
-function isEnoent(err) {
-	return isFsError(err) && err.code === "ENOENT";
-}
-function isEnotdir(err) {
-	return isFsError(err) && err.code === "ENOTDIR";
-}
-function hasFsCode(err, code) {
-	return isFsError(err) && err.code === code;
-}
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/json-parse.ts
-const QUOTE = 34;
-const BACKSLASH = 92;
-const U = 117;
-const SQUOTE = 39;
+const U$1 = 117;
+/** 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;
-(() => {
-	const e = [];
-	e[8] = "\\b";
-	e[9] = "\\t";
-	e[10] = "\\n";
-	e[12] = "\\f";
-	e[13] = "\\r";
-	for (let cp = 0; cp <= 31; cp++) e[cp] ??= `\\u${cp.toString(16).padStart(4, "0")}`;
-	return e;
-})();
-const HEX4_RE = /^[0-9a-fA-F]{4}$/;
 function isHexDigit(cp) {
 	return cp >= 48 && cp <= 57 || (cp | 32) >= 97 && (cp | 32) <= 102;
 }
+/** JSON insignificant whitespace (RFC 8259 §2). */
 function isWhitespace(cp) {
 	return cp === 32 || cp === 9 || cp === 10 || cp === 13;
 }
 function isIdentChar(cp) {
 	return cp >= 48 && cp <= 57 || (cp | 32) >= 97 && (cp | 32) <= 122 || cp === 95 || cp === 36;
 }
-/** Bareword literals: standard JSON plus Python `True`/`False`/`None`. */
+/** First char of a numeric token: sign, dot, or digit. */
+function isNumberStart(cp) {
+	return cp === 45 || cp === 43 || cp === 46 || cp >= 48 && cp <= 57;
+}
+/** Chars that may continue a relaxed numeric token: digits, sign, dot, exponent, radix prefix, hex digits. */
+function isNumberChar(cp) {
+	return cp >= 48 && cp <= 57 || cp === 45 || cp === 43 || cp === 46 || (cp | 32) >= 97 && (cp | 32) <= 102 || (cp | 32) === 120;
+}
+/** Keyword literals: standard JSON plus Python `True`/`False`/`None`. */
 const KEYWORDS = [
 	["true", true],
 	["false", false],
@@ -2109,216 +2214,129 @@ const NON_RECOVERABLE_BAREWORDS = {
 	"+Infinity": true,
 	undefined: true
 };
+/** Decode four hex digits at `pos`, or `-1` when fewer than four hex digits are available. */
+function hex4(s, pos) {
+	if (pos + 4 > s.length) return -1;
+	let value = 0;
+	for (let k = pos; k < pos + 4; k++) {
+		if (!isHexDigit(s.charCodeAt(k))) return -1;
+		value = value << 4 | parseInt(s[k], 16);
+	}
+	return value;
+}
 /**
-* Sentinel returned by partial-mode value parsing when an atomic value
-* (number / keyword) is incomplete at the streaming edge, so the enclosing
-* object/array rolls back to the last valid prefix instead of committing junk.
-*/
-const INCOMPLETE = Symbol("incomplete");
-/**
-* Recursive-descent parser for a forgiving superset of JSON. Beyond strict JSON
-* it accepts, and normalizes, the malformations LLM tool-call bodies leak in
-* practice:
-*
-* - single-quoted strings and unquoted object keys (JSON5);
-* - trailing / stray commas, and `//` + block comments;
-* - Python literals `True` / `False` / `None` and JS `NaN` / `Infinity`;
-* - raw control characters and invalid `\x` escapes inside strings (kept literally);
-* - unescaped quotes inside strings — a quote only closes a string when followed
-*   by a value terminator, recovering apostrophes such as `'it's'`;
-* - unquoted string values in object/array value position (strict mode only) —
-*   an unrecognized bareword such as `{"paths": packages/foo/*}` is recovered as
-*   a string up to the next `,` / `}` / `]` / newline.
-*
-* In `partial` mode an unterminated string/object/array (or a value cut off at
-* end-of-input) is auto-closed with whatever was parsed so far — for streaming.
-* In strict mode, end-of-input mid-value and trailing garbage both throw, so a
-* final parse never silently accepts a half-formed tool call.
+* Index of the first char at or after `i` that is not whitespace or part of a
+* `//` line / `/* *\/` block comment. A lone `/` at the end of input is not a
+* comment and is left in place.
 */
-var RelaxedJson = class {
-	#s;
-	#n;
-	#partial;
-	#i = 0;
-	constructor(source, partial) {
-		this.#s = source;
-		this.#n = source.length;
-		this.#partial = partial;
-	}
-	parse() {
-		this.#ws();
-		if (this.#i >= this.#n) {
-			if (this.#partial) return void 0;
-			throw new SyntaxError("Unexpected end of JSON input");
-		}
-		const value = this.#value(false);
-		if (value === INCOMPLETE) return void 0;
-		this.#ws();
-		if (!this.#partial && this.#i < this.#n) throw new SyntaxError(`Unexpected trailing characters at position ${this.#i}`);
-		return value;
-	}
-	#ws() {
-		const s = this.#s;
-		for (;;) {
-			while (this.#i < this.#n && isWhitespace(s.charCodeAt(this.#i))) this.#i++;
-			if (this.#i + 1 < this.#n && s.charCodeAt(this.#i) === 47) {
-				const next = s.charCodeAt(this.#i + 1);
-				if (next === 47) {
-					this.#i += 2;
-					while (this.#i < this.#n && s.charCodeAt(this.#i) !== 10) this.#i++;
-					continue;
-				}
-				if (next === 42) {
-					this.#i += 2;
-					while (this.#i + 1 < this.#n && !(s.charCodeAt(this.#i) === 42 && s.charCodeAt(this.#i + 1) === 47)) this.#i++;
-					this.#i = Math.min(this.#i + 2, this.#n);
-					continue;
-				}
-			}
-			break;
-		}
-	}
-	#value(allowBareword) {
-		const s = this.#s;
-		const c = s[this.#i];
-		if (c === "{") return this.#object();
-		if (c === "[") return this.#array();
-		if (c === "\"" || c === "'") return this.#string(s.charCodeAt(this.#i));
-		const cc = s.charCodeAt(this.#i);
-		if (cc === 45 || cc === 43 || cc === 46 || cc >= 48 && cc <= 57) return this.#number();
-		return this.#keyword(allowBareword);
-	}
-	#object() {
-		this.#i++;
-		const out = {};
-		for (;;) {
-			this.#ws();
-			if (this.#i >= this.#n) {
-				if (this.#partial) return out;
-				throw new SyntaxError("Unterminated object");
-			}
-			const c = this.#s[this.#i];
-			if (c === "}") {
-				this.#i++;
-				return out;
-			}
-			if (c === ",") {
-				this.#i++;
+function skipInsignificant(s, i) {
+	const n = s.length;
+	for (;;) {
+		while (i < n && isWhitespace(s.charCodeAt(i))) i++;
+		if (i + 1 < n && s.charCodeAt(i) === 47) {
+			const next = s.charCodeAt(i + 1);
+			if (next === 47) {
+				i += 2;
+				while (i < n && s.charCodeAt(i) !== 10) i++;
 				continue;
 			}
-			const key = this.#key();
-			this.#ws();
-			if (this.#i < this.#n && this.#s[this.#i] === ":") this.#i++;
-			else if (this.#partial) return out;
-			else throw new SyntaxError("Expected ':' in object");
-			this.#ws();
-			if (this.#i >= this.#n) {
-				if (this.#partial) return out;
-				throw new SyntaxError("Expected value after ':'");
-			}
-			const value = this.#value(true);
-			if (value === INCOMPLETE) return out;
-			out[key] = value;
-			this.#ws();
-			const d = this.#i < this.#n ? this.#s[this.#i] : "";
-			if (d === ",") {
-				this.#i++;
+			if (next === 42) {
+				i += 2;
+				while (i + 1 < n && !(s.charCodeAt(i) === 42 && s.charCodeAt(i + 1) === 47)) i++;
+				i = Math.min(i + 2, n);
 				continue;
 			}
-			if (d === "}") {
-				this.#i++;
-				return out;
-			}
-			if (this.#partial) return out;
-			throw new SyntaxError("Expected ',' or '}' in object");
 		}
+		return i;
+	}
+}
+/** Reading of the lookahead past a candidate closing quote. */
+var QuoteLook = /* @__PURE__ */ function(QuoteLook) {
+	/** A value terminator (or end of input) follows: the quote closes. */
+	QuoteLook[QuoteLook["Closes"] = 0] = "Closes";
+	/** Ordinary content follows: the quote is literal (inner-quote recovery). */
+	QuoteLook[QuoteLook["Inner"] = 1] = "Inner";
+	/** A lone `/` at the buffer edge may still grow into a comment and flip this quote from inner to closing. */
+	QuoteLook[QuoteLook["Undecided"] = 2] = "Undecided";
+	return QuoteLook;
+}(QuoteLook || {});
+/**
+* Cursor over the input with the tolerant token readers. `pos` is the current
+* offset; readers advance it. In `strict` mode a truncated or malformed token
+* throws `SyntaxError`; the lenient modes report progress or return
+* `undefined` so the caller can roll back.
+*/
+var JsonLexer = class {
+	src;
+	mode;
+	pos;
+	constructor(src, mode, pos = 0) {
+		this.src = src;
+		this.mode = mode;
+		this.pos = pos;
+	}
+	get atEnd() {
+		return this.pos >= this.src.length;
+	}
+	/** Char code at the cursor; `NaN` at end of input (so every comparison is false). */
+	peek() {
+		return this.src.charCodeAt(this.pos);
+	}
+	/** Skip whitespace plus `//` line and `/* *\/` block comments. */
+	ws() {
+		this.pos = skipInsignificant(this.src, this.pos);
 	}
-	#array() {
-		this.#i++;
-		const out = [];
-		for (;;) {
-			this.#ws();
-			if (this.#i >= this.#n) {
-				if (this.#partial) return out;
-				throw new SyntaxError("Unterminated array");
-			}
-			const c = this.#s[this.#i];
-			if (c === "]") {
-				this.#i++;
-				return out;
-			}
-			if (c === ",") {
-				this.#i++;
-				continue;
-			}
-			const value = this.#value(true);
-			if (value === INCOMPLETE) return out;
-			out.push(value);
-			this.#ws();
-			const d = this.#i < this.#n ? this.#s[this.#i] : "";
-			if (d === ",") {
-				this.#i++;
-				continue;
-			}
-			if (d === "]") {
-				this.#i++;
-				return out;
-			}
-			if (this.#partial) return out;
-			throw new SyntaxError("Expected ',' or ']' in array");
-		}
-	}
-	#key() {
-		const c = this.#s[this.#i];
-		if (c === "\"" || c === "'") return this.#string(this.#s.charCodeAt(this.#i));
-		const start = this.#i;
-		while (this.#i < this.#n) {
-			const ch = this.#s[this.#i];
-			if (ch === ":" || ch === "," || ch === "}" || isWhitespace(this.#s.charCodeAt(this.#i))) break;
-			this.#i++;
-		}
-		if (this.#i === start) {
-			if (this.#partial) return "";
-			throw new SyntaxError("Expected object key");
-		}
-		return this.#s.slice(start, this.#i);
-	}
-	#string(quote) {
-		const s = this.#s;
-		const n = this.#n;
-		let i = this.#i + 1;
+	/**
+	* Read a string starting at the opening `quote`, retaining the information
+	* an incremental consumer needs. Strict mode throws on an unterminated
+	* string; lenient modes consume to the end of input and report progress.
+	*/
+	string(quote) {
+		const s = this.src;
+		const n = s.length;
+		let i = this.pos + 1;
 		let out = "";
 		let runStart = i;
+		let unstableFrom = -1;
+		const lenient = quote === 39 || this.mode === "streaming";
 		while (i < n) {
 			const cc = s.charCodeAt(i);
-			if (cc !== BACKSLASH && cc !== quote) {
+			if (cc !== 92 && cc !== quote) {
 				i++;
 				continue;
 			}
 			if (cc === quote) {
-				if (!(quote === SQUOTE || this.#partial) || this.#closesString(i + 1)) {
+				const look = lenient ? this.#quoteLookahead(i + 1) : 0;
+				if (look === 0) {
 					out += s.slice(runStart, i);
-					this.#i = i + 1;
-					return out;
+					this.pos = i + 1;
+					return {
+						value: out,
+						stableLen: out.length,
+						complete: true
+					};
 				}
+				if (look === 2 && unstableFrom < 0) unstableFrom = out.length + (i - runStart);
 				i++;
 				continue;
 			}
 			out += s.slice(runStart, i);
+			const escapeStart = out.length;
 			i++;
 			if (i >= n) {
+				if (unstableFrom < 0) unstableFrom = escapeStart;
 				out += "\\";
 				runStart = i;
 				break;
 			}
 			switch (s.charCodeAt(i)) {
-				case QUOTE:
+				case 34:
 					out += "\"";
 					break;
-				case SQUOTE:
+				case 39:
 					out += "'";
 					break;
-				case BACKSLASH:
+				case 92:
 					out += "\\";
 					break;
 				case 47:
@@ -2339,12 +2357,16 @@ var RelaxedJson = class {
 				case 116:
 					out += "	";
 					break;
-				case U: {
-					const hex = s.slice(i + 1, i + 5);
-					if (HEX4_RE.test(hex)) {
-						out += String.fromCharCode(parseInt(hex, 16));
+				case U$1: {
+					const unit = hex4(s, i + 1);
+					if (unit >= 0) {
 						i += 4;
-					} else out += "\\u";
+						out += String.fromCharCode(unit);
+						if (unit >= 55296 && unit < 56320 && this.mode !== "strict" && i + 7 > n && unstableFrom < 0) unstableFrom = escapeStart;
+					} else {
+						if (i + 5 > n && this.mode !== "strict" && unstableFrom < 0) unstableFrom = escapeStart;
+						out += "\\u";
+					}
 					break;
 				}
 				default: out += `\\${s[i]}`;
@@ -2352,82 +2374,264 @@ var RelaxedJson = class {
 			i++;
 			runStart = i;
 		}
-		out += s.slice(runStart, i);
-		if (this.#partial) {
-			this.#i = i;
-			return out;
-		}
-		throw new SyntaxError("Unterminated string");
-	}
-	/** A quote closes a string only when the next non-space char ends a value. */
-	#closesString(from) {
-		const s = this.#s;
-		let k = from;
-		while (k < this.#n && isWhitespace(s.charCodeAt(k))) k++;
-		if (k >= this.#n) return true;
-		const c = s[k];
-		return c === "," || c === "}" || c === "]" || c === ":";
-	}
-	#number() {
-		const s = this.#s;
-		const start = this.#i;
-		while (this.#i < this.#n) {
-			const ch = s[this.#i];
-			if (ch >= "0" && ch <= "9" || ch === "-" || ch === "+" || ch === "." || ch === "e" || ch === "E" || ch === "x" || ch === "X" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F") this.#i++;
-			else break;
-		}
-		const token = s.slice(start, this.#i);
-		const num = Number(token);
-		if (Number.isNaN(num)) {
-			if (this.#partial) return INCOMPLETE;
-			throw new SyntaxError(`Invalid number: ${token}`);
-		}
-		return num;
+		if (this.mode === "strict") throw new SyntaxError("Unterminated string");
+		out += s.slice(runStart, n);
+		this.pos = i;
+		return {
+			value: out,
+			stableLen: unstableFrom < 0 ? out.length : unstableFrom,
+			complete: false
+		};
+	}
+	/**
+	* Classify the lookahead after a candidate closing quote: a quote closes a
+	* string only when the next significant char (past whitespace and comments)
+	* ends a value.
+	*/
+	#quoteLookahead(from) {
+		const s = this.src;
+		const k = skipInsignificant(s, from);
+		if (k >= s.length) return 0;
+		const c = s.charCodeAt(k);
+		if (c === 44 || c === 125 || c === 93 || c === 58) return 0;
+		if (c === 47 && k + 1 === s.length && this.mode !== "strict") return 2;
+		return 1;
+	}
+	/**
+	* Read a numeric token with JS `Number()` semantics (decimal with optional
+	* sign / leading or trailing dot / exponent, plus `0x` hex and `0b` binary).
+	* Non-finite or malformed tokens throw in strict mode and return
+	* `undefined` in lenient modes; the cursor is left past the token either way.
+	*/
+	number() {
+		const s = this.src;
+		const start = this.pos;
+		let i = start;
+		while (i < s.length && isNumberChar(s.charCodeAt(i))) i++;
+		this.pos = i;
+		const token = s.slice(start, i);
+		const value = Number(token);
+		if (Number.isFinite(value)) return value;
+		if (this.mode === "strict") throw new SyntaxError(`Invalid number: ${token}`);
 	}
-	#keyword(allowBareword) {
-		const s = this.#s;
-		const i = this.#i;
-		for (const [word, value] of KEYWORDS) if (s.startsWith(word, i) && !isIdentChar(s.charCodeAt(i + word.length))) {
-			this.#i += word.length;
+	/**
+	* Match a keyword literal at the cursor; consumes only on success and
+	* returns `undefined` otherwise. Requires a non-identifier boundary so
+	* `Truex` / `nullish` are not misread as the keyword followed by junk.
+	*/
+	keyword() {
+		const s = this.src;
+		for (const [word, value] of KEYWORDS) if (s.startsWith(word, this.pos) && !isIdentChar(s.charCodeAt(this.pos + word.length))) {
+			this.pos += word.length;
 			return value;
 		}
-		if (this.#partial) {
-			this.#i = this.#n;
-			return INCOMPLETE;
+	}
+	/** Read an unquoted object key: everything up to `:` / `,` / `}` / whitespace. May be empty. */
+	unquotedKey() {
+		const s = this.src;
+		const start = this.pos;
+		let i = start;
+		while (i < s.length) {
+			const cc = s.charCodeAt(i);
+			if (cc === 58 || cc === 44 || cc === 125 || isWhitespace(cc)) break;
+			i++;
 		}
-		if (allowBareword) return this.#bareword();
-		throw new SyntaxError(`Unexpected token at position ${this.#i}`);
+		this.pos = i;
+		return s.slice(start, i);
 	}
 	/**
-	* Strict-mode recovery of an unquoted string value, e.g.
-	* `{"paths": packages/foo/*}`: consume until `,` / `}` / `]` / newline and
-	* trim trailing whitespace. Recovery still throws — so a final parse never
-	* accepts a half-formed or non-finite argument — when the token:
+	* Recover an unquoted string value, e.g. `{"paths": packages/foo/*}`:
+	* consume until `,` / `}` / `]` / newline and trim trailing whitespace.
+	* Recovery still fails — so a final parse never accepts a half-formed or
+	* non-finite argument — when the token:
 	* - hits end-of-input before a delimiter (truncated value);
-	* - contains a `"`, `{`, `[`, or a key-like `:` — this parser accepts
-	*   unquoted keys, so a missed comma (`{"a": foo "b": 1}`, `{a: foo b: 1}`)
-	*   would otherwise silently swallow the following field. A colon followed
-	*   by `/` or `\` stays literal so URL and Windows-path values recover;
+	* - contains a `"`, `{`, `[`, or a key-like `:` — this grammar accepts
+	*   unquoted keys, so a missed comma (`{"a": foo "b": 1}`) would otherwise
+	*   silently swallow the following field. A colon followed by `/` or `\`
+	*   stays literal so URL and Windows-path values recover;
 	* - is a non-finite atom ({@link NON_RECOVERABLE_BAREWORDS}).
+	*
+	* Failure throws in strict mode and returns `undefined` in lenient modes.
 	*/
-	#bareword() {
-		const s = this.#s;
-		const start = this.#i;
+	bareword() {
+		const s = this.src;
+		const start = this.pos;
 		let i = start;
-		while (i < this.#n) {
+		while (i < s.length) {
 			const cc = s.charCodeAt(i);
 			if (cc === 44 || cc === 125 || cc === 93 || cc === 10 || cc === 13) break;
-			if (cc === QUOTE || cc === 123 || cc === 91 || cc === 58 && s.charCodeAt(i + 1) !== 47 && s.charCodeAt(i + 1) !== 92) throw new SyntaxError(`Unexpected token at position ${start}`);
+			if (cc === 34 || cc === 123 || cc === 91 || cc === 58 && s.charCodeAt(i + 1) !== 47 && s.charCodeAt(i + 1) !== 92) return this.#unexpected(start);
 			i++;
 		}
-		if (i >= this.#n) throw new SyntaxError(`Unexpected token at position ${start}`);
+		if (i >= s.length) return this.#unexpected(start);
 		let end = i;
 		while (end > start && isWhitespace(s.charCodeAt(end - 1))) end--;
 		const word = s.slice(start, end);
-		if (NON_RECOVERABLE_BAREWORDS[word]) throw new SyntaxError(`Unexpected token at position ${start}`);
-		this.#i = i;
+		if (NON_RECOVERABLE_BAREWORDS[word]) return this.#unexpected(start);
+		this.pos = i;
 		return word;
 	}
+	#unexpected(at) {
+		if (this.mode === "strict") throw new SyntaxError(`Unexpected token at position ${at}`);
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/json-parse.ts
+const U = 117;
+(() => {
+	const e = [];
+	e[8] = "\\b";
+	e[9] = "\\t";
+	e[10] = "\\n";
+	e[12] = "\\f";
+	e[13] = "\\r";
+	for (let cp = 0; cp <= 31; cp++) e[cp] ??= `\\u${cp.toString(16).padStart(4, "0")}`;
+	return e;
+})();
+/**
+* Sentinel returned by partial-mode value parsing when an atomic value
+* (number / keyword) is incomplete at the streaming edge, so the enclosing
+* object/array rolls back to the last valid prefix instead of committing junk.
+*/
+const INCOMPLETE = Symbol("incomplete");
+/**
+* Recursive-descent tree builder over the tolerant {@link JsonLexer} grammar
+* (single quotes, unquoted keys, comments, Python literals, stray commas,
+* literal invalid escapes, apostrophe recovery, bareword values).
+*
+* In `partial` mode (lexer mode `streaming`) an unterminated string/object/array
+* (or a value cut off at end-of-input) is auto-closed with whatever was parsed
+* so far, and an incomplete trailing atom rolls the enclosing container back
+* to its last valid prefix. In strict mode, end-of-input mid-value and trailing
+* garbage both throw, so a final parse never silently accepts a half-formed
+* tool call.
+*/
+var RelaxedJson = class {
+	#lex;
+	#partial;
+	constructor(source, partial) {
+		this.#lex = new JsonLexer(source, partial ? "streaming" : "strict");
+		this.#partial = partial;
+	}
+	parse() {
+		const lex = this.#lex;
+		lex.ws();
+		if (lex.atEnd) {
+			if (this.#partial) return void 0;
+			throw new SyntaxError("Unexpected end of JSON input");
+		}
+		const value = this.#value(false);
+		if (value === INCOMPLETE) return void 0;
+		lex.ws();
+		if (!this.#partial && !lex.atEnd) throw new SyntaxError(`Unexpected trailing characters at position ${lex.pos}`);
+		return value;
+	}
+	#value(allowBareword) {
+		const lex = this.#lex;
+		const c = lex.peek();
+		if (c === 123) return this.#object();
+		if (c === 91) return this.#array();
+		if (c === 34 || c === 39) return lex.string(c).value;
+		if (isNumberStart(c)) return lex.number() ?? INCOMPLETE;
+		const keyword = lex.keyword();
+		if (keyword !== void 0) return keyword;
+		if (this.#partial) {
+			lex.pos = lex.src.length;
+			return INCOMPLETE;
+		}
+		if (allowBareword) return lex.bareword();
+		throw new SyntaxError(`Unexpected token at position ${lex.pos}`);
+	}
+	#object() {
+		const lex = this.#lex;
+		lex.pos++;
+		const out = {};
+		for (;;) {
+			lex.ws();
+			if (lex.atEnd) {
+				if (this.#partial) return out;
+				throw new SyntaxError("Unterminated object");
+			}
+			const c = lex.peek();
+			if (c === 125) {
+				lex.pos++;
+				return out;
+			}
+			if (c === 44) {
+				lex.pos++;
+				continue;
+			}
+			const key = this.#key();
+			lex.ws();
+			if (lex.peek() === 58) lex.pos++;
+			else if (this.#partial) return out;
+			else throw new SyntaxError("Expected ':' in object");
+			lex.ws();
+			if (lex.atEnd) {
+				if (this.#partial) return out;
+				throw new SyntaxError("Expected value after ':'");
+			}
+			const value = this.#value(true);
+			if (value === INCOMPLETE) return out;
+			out[key] = value;
+			lex.ws();
+			const d = lex.peek();
+			if (d === 44) {
+				lex.pos++;
+				continue;
+			}
+			if (d === 125) {
+				lex.pos++;
+				return out;
+			}
+			if (this.#partial) return out;
+			throw new SyntaxError("Expected ',' or '}' in object");
+		}
+	}
+	#array() {
+		const lex = this.#lex;
+		lex.pos++;
+		const out = [];
+		for (;;) {
+			lex.ws();
+			if (lex.atEnd) {
+				if (this.#partial) return out;
+				throw new SyntaxError("Unterminated array");
+			}
+			const c = lex.peek();
+			if (c === 93) {
+				lex.pos++;
+				return out;
+			}
+			if (c === 44) {
+				lex.pos++;
+				continue;
+			}
+			const value = this.#value(true);
+			if (value === INCOMPLETE) return out;
+			out.push(value);
+			lex.ws();
+			const d = lex.peek();
+			if (d === 44) {
+				lex.pos++;
+				continue;
+			}
+			if (d === 93) {
+				lex.pos++;
+				return out;
+			}
+			if (this.#partial) return out;
+			throw new SyntaxError("Expected ',' or ']' in array");
+		}
+	}
+	#key() {
+		const lex = this.#lex;
+		const c = lex.peek();
+		if (c === 34 || c === 39) return lex.string(c).value;
+		const key = lex.unquotedKey();
+		if (key.length === 0 && !this.#partial) throw new SyntaxError("Expected object key");
+		return key;
+	}
 };
 /**
 * Final-parse a JSON value, repairing the common LLM malformations
@@ -2535,11 +2739,11 @@ function classifyJsonPrefix(text) {
 		i++;
 		while (i < n) {
 			const c = text.charCodeAt(i);
-			if (c === QUOTE) {
+			if (c === 34) {
 				i++;
 				return 1;
 			}
-			if (c === BACKSLASH) {
+			if (c === 92) {
 				i++;
 				if (i >= n) return 0;
 				const e = text.charCodeAt(i);
@@ -2625,7 +2829,7 @@ function classifyJsonPrefix(text) {
 					break;
 				}
 				let r;
-				if (c === QUOTE) r = scanString();
+				if (c === 34) r = scanString();
 				else if (c === 45 || c >= 48 && c <= 57) r = scanNumber();
 				else if (c === 116 || c === 102 || c === 110) r = scanKeyword();
 				else return "invalid";
@@ -2642,7 +2846,7 @@ function classifyJsonPrefix(text) {
 					expect = valueDone();
 					break;
 				}
-				if (c !== QUOTE) return "invalid";
+				if (c !== 34) return "invalid";
 				const r = scanString();
 				if (r === -1) return "invalid";
 				if (r === 0) return "prefix";
@@ -2683,7 +2887,7 @@ function classifyJsonPrefix(text) {
 }
 new Intl.Segmenter();
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/mime.ts
+//#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;
 const PNG_MAGIC = Buffer.from([
 	137,
@@ -2876,7 +3080,7 @@ function dlopen() {
 	return null;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/stderr-guard.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/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.
@@ -2941,6 +3145,10 @@ function restoreTerminalStderr() {
 }
 const callbackList = [];
 let cleanupStage = "idle";
+let cleanupPass = 0;
+let activeCleanupReason;
+let activeCleanupKeepAlive = false;
+let activeLatePromises;
 const CLEANUP_DEADLINE_MS = 1e4;
 /**
 * Symbol stamped by the extension-load guard onto the throwing replacement it
@@ -2975,13 +3183,26 @@ function exitProcess(code) {
 }
 let cleanupPromise;
 const fatalRecoveryHintProviders = /* @__PURE__ */ new Set();
+function invokeCleanup(registration, reason, keepAlive, pass) {
+	if (registration.cancelled || registration.lastPass === pass) return;
+	if (registration.exitOnly && keepAlive) return;
+	registration.lastPass = pass;
+	return registration.callback(reason);
+}
 /**
 * Internal: runs all registered cleanup callbacks for the given reason.
-* Ensures each callback is invoked at most once. Handles errors and prevents reentrancy.
+* Ensures each registration is invoked at most once per pass, handles errors,
+* and prevents reentrancy.
+*
+* `keepAlive` marks a manual cleanup that keeps the process running (see
+* {@link cleanup}). Such a pass returns the stage to `idle`; registrations stay
+* active for later resources and the eventual real exit. Exit-only callbacks
+* skip keep-alive passes without consuming their registration. An exit-driven
+* pass instead settles to `complete` and stays there.
 *
 * Returns a Promise that settles after all cleanups complete or error out.
 */
-function runCleanup(reason) {
+function runCleanup(reason, keepAlive = false) {
 	switch (cleanupStage) {
 		case "idle":
 			cleanupStage = "running";
@@ -2989,10 +3210,24 @@ function runCleanup(reason) {
 		case "running": return cleanupPromise ?? Promise.resolve();
 		case "complete": return Promise.resolve();
 	}
-	const promises = callbackList.toReversed().map((callback) => {
-		return Promise.try(() => callback(reason));
+	const pass = ++cleanupPass;
+	activeCleanupReason = reason;
+	activeCleanupKeepAlive = keepAlive;
+	const late = [];
+	activeLatePromises = late;
+	const settle = () => {
+		if (activeLatePromises === late) activeLatePromises = void 0;
+		if (cleanupPass !== pass) return;
+		cleanupStage = keepAlive ? "idle" : "complete";
+		if (keepAlive) {
+			activeCleanupReason = void 0;
+			activeCleanupKeepAlive = false;
+		}
+	};
+	const promises = callbackList.toReversed().map((registration) => {
+		return Promise.try(() => invokeCleanup(registration, reason, keepAlive, pass));
 	});
-	const cleanupSettled = Promise.allSettled(promises).then((results) => {
+	const cleanupSettled = Promise.allSettled(promises).then(async (results) => {
 		for (const result of results) if (result.status === "rejected") {
 			const err = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
 			error("Cleanup callback failed", {
@@ -3000,17 +3235,20 @@ function runCleanup(reason) {
 				stack: err.stack
 			});
 		}
-		cleanupStage = "complete";
+		while (late.length > 0) await Promise.allSettled(late.splice(0));
+		settle();
 	});
 	const deadline = Promise.withResolvers();
 	const deadlineTimer = setTimeout(() => {
 		error("Cleanup deadline exceeded; proceeding with exit", { reason });
-		cleanupStage = "complete";
+		settle();
 		deadline.resolve();
 	}, CLEANUP_DEADLINE_MS);
-	cleanupPromise = Promise.race([cleanupSettled, deadline.promise]).finally(() => {
+	const passPromise = Promise.race([cleanupSettled, deadline.promise]).finally(() => {
 		clearTimeout(deadlineTimer);
+		if (keepAlive && cleanupPass === pass && cleanupPromise === passPromise) cleanupPromise = void 0;
 	});
+	cleanupPromise = passPromise;
 	return cleanupPromise;
 }
 let inspectorOpened = false;
@@ -3023,21 +3261,86 @@ function classifyBrokenPipe(err) {
 	if (err.syscall === "send") return "ipc-send";
 	if (err.syscall === "write") return "stdio-write";
 }
-const EXPECTED_CLEANUP = Symbol.for("omp.expectedCleanupError");
+/** Whether an EPIPE came from an IPC `send()` to an optional worker. */
+function isIpcSendEpipe(err) {
+	return classifyBrokenPipe(err) === "ipc-send";
+}
 /**
-* Whether `reason` (or any error in its `cause` chain) was marked via
-* {@link markExpectedCleanupError}. Walks the chain because the unhandled
-* reason is often a wrapper (`AbortError`) with the marked abort reason as
-* its `cause`.
+* Whether an uncaught error is Bun's asynchronous `ERR_SOCKET_CLOSED` thrown
+* from inside `node:net` internals with no application frames on the stack.
+*
+* Bun ≥1.4 can fire the close callback of an already-closed `node:net` socket
+* on a fresh stack; the throw bypasses every callsite try/catch and surfaces
+* here as a process-level uncaughtException. Closing an already-closed socket
+* is inherently a no-op — the socket owner's own `error`/`close` handlers
+* still drive recovery — so tearing the session down for it is pure loss.
+* Only frameless internal stacks qualify: an `ERR_SOCKET_CLOSED` raised
+* through application code keeps the fatal path.
 */
-function isExpectedCleanupError(reason) {
+function isInternalSocketClosedError(err) {
+	if (!(err instanceof Error) || !("code" in err) || err.code !== "ERR_SOCKET_CLOSED") return false;
+	const frames = (err.stack ?? "").split("\n").slice(1);
+	if (frames.length === 0) return false;
+	let hasNetFrame = false;
+	return frames.every((frame) => {
+		const trimmed = frame.trim();
+		if (trimmed === "" || trimmed === "at unknown" || trimmed === "at native") return true;
+		if (!/\(node:[^)]*\)$/.test(trimmed) && !trimmed.startsWith("at node:")) return false;
+		hasNetFrame ||= trimmed.includes("node:net:");
+		return true;
+	}) && hasNetFrame;
+}
+/**
+* Detect Bun's advanced-serialization (structured-clone) IPC decode failure.
+*
+* When a worker subprocess spawned with `serialization: "advanced"` sends a
+* malformed or truncated frame, Bun raises the decode failure as a
+* process-level `uncaughtException` in the *parent* rather than routing it to
+* the channel's `ipc()` callback (oven-sh/bun#37287). The error is a bare
+* `TypeError: Unable to deserialize data.` whose only own property is `message`
+* — it carries no `code`, no `syscall`, and no `stack`. Matching all four traits
+* keeps unrelated application `TypeError`s (which always carry a populated
+* multi-frame stack) on the fatal path, so a genuine bug is never silently
+* swallowed.
+*
+* Every advanced-serialization channel in this process is an optional worker
+* subsystem (TTS, STT, tiny-title, mnemopi embeddings, JS eval), so one
+* worker's bad frame must fault only that worker — via its own `onExit`/error
+* path — never tear down the whole session. Callers log-and-continue instead of
+* taking the fatal path. Mirrors {@link classifyBrokenPipe} for the send side
+* (#2997, #9158).
+*/
+function isWorkerIpcDeserializeError(err) {
+	return err instanceof TypeError && err.message === "Unable to deserialize data." && !err.stack && !("code" in err) && !("syscall" in err);
+}
+/** Recycle callbacks for the active advanced-serialization worker IPC channels. */
+const workerIpcFaultHandlers = /* @__PURE__ */ new Set();
+/** Invoke every registered worker IPC fault handler, isolating handler throws. */
+function faultWorkerIpcChannels(err) {
+	for (const handler of workerIpcFaultHandlers) try {
+		handler(err);
+	} catch (handlerErr) {
+		warn("Worker IPC fault handler threw", { err: handlerErr });
+	}
+}
+const EXPECTED_CLEANUP = Symbol.for("omp.expectedCleanupError");
+function hasExpectedCleanupMarker(reason) {
 	let current = reason;
 	for (let depth = 0; depth < 8 && current !== null && typeof current === "object"; depth++) {
-		if (current[EXPECTED_CLEANUP] === true) return true;
-		current = current.cause;
+		if (Reflect.get(current, EXPECTED_CLEANUP) === true) return true;
+		current = Reflect.get(current, "cause");
 	}
 	return false;
 }
+/**
+* Whether `reason` (or any object in its bounded `cause` chain) was explicitly
+* marked via {@link markExpectedCleanupError}. Runtime error names and codes
+* are intentionally insufficient: unmarked `AbortError` and socket failures
+* can originate from application code and must remain fatal when unhandled.
+*/
+function isExpectedCleanupError(reason) {
+	return hasExpectedCleanupMarker(reason);
+}
 /** Interceptors consulted by the global `unhandledRejection` handler before the fatal path. */
 const rejectionInterceptors = /* @__PURE__ */ new Set();
 function escapeFatalHintText(value) {
@@ -3064,15 +3367,16 @@ function formatFatalError(label, err) {
 	const stackLines = (err.stack || "").split("\n").slice(1);
 	return `\n[${label}] ${name}: ${message}${stackLines.length > 0 ? `\n${stackLines.join("\n")}` : ""}\n`;
 }
-async function exitAfterFatal(label, logMessage, err, reason) {
+async function exitAfterFatal(output, logMessage, err, reason) {
 	const forcedExit = setTimeout(() => exitProcess(1), CLEANUP_DEADLINE_MS);
 	try {
+		const cleanup = runCleanup(reason);
 		restoreTerminalStderr();
 		try {
-			fs.writeSync(2, `${formatFatalError(label, err)}${formatFatalRecoveryHints()}`);
+			fs.writeSync(2, output);
 		} catch {}
 		error(logMessage, { err });
-		await runCleanup(reason);
+		await cleanup;
 	} finally {
 		clearTimeout(forcedExit);
 		exitProcess(1);
@@ -3087,12 +3391,26 @@ if (isMainThread) process.on("SIGINT", async () => {
 	inspector.open(void 0, void 0, false);
 	const url = inspector.url();
 	process.stderr.write(`Inspector opened: ${url}\n`);
-}).on("uncaughtException", async (err) => {
-	if (isExpectedCleanupError(err)) {
-		warn("Ignoring expected cleanup exception", { err });
+}).on("uncaughtException", async (thrown) => {
+	if (hasExpectedCleanupMarker(thrown)) {
+		warn("Ignoring expected cleanup exception", { err: thrown });
+		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 (isWorkerIpcDeserializeError(err)) {
+		warn("Malformed worker IPC frame; faulting active worker subsystems", { err });
+		faultWorkerIpcChannels(err);
+		return;
+	}
+	if (isInternalSocketClosedError(err)) {
+		warn("Ignoring async ERR_SOCKET_CLOSED from node:net internals; socket owner recovers itself", { err });
 		return;
 	}
-	await exitAfterFatal("Uncaught Exception", "Uncaught exception", err, "uncaught_exception");
+	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") {
@@ -3108,7 +3426,7 @@ if (isMainThread) process.on("SIGINT", async () => {
 	} catch (interceptorErr) {
 		warn("Unhandled-rejection interceptor threw; continuing with fatal path", { err: interceptorErr });
 	}
-	await exitAfterFatal("Unhandled Rejection", "Unhandled rejection", err, "unhandled_rejection");
+	await exitAfterFatal(`${formatFatalError("Unhandled Rejection", err)}${formatFatalRecoveryHints()}`, "Unhandled rejection", err, "unhandled_rejection");
 }).on("exit", async () => {
 	runCleanup("exit");
 }).on("SIGTERM", async () => {
@@ -3121,8 +3439,72 @@ if (isMainThread) process.on("SIGINT", async () => {
 else process.on("exit", () => {
 	runCleanup("exit");
 });
+/**
+* Registers a cleanup callback for shutdown, signals, fatal errors, and
+* repeatable manual cleanup passes.
+*
+* Registrations persist across keep-alive {@link cleanup} passes and run at
+* most once per pass. Set `exitOnly` for resources the continuing process still
+* holds (open databases, cached handles): keep-alive passes skip the callback
+* without consuming its registration, while the eventual real exit runs it.
+*
+* A callback registered during a running keep-alive pass joins future passes;
+* normal callbacks also run immediately for the current pass. Registrations
+* made during a real exit run immediately.
+*
+* Returns a function that permanently cancels the registration.
+*/
+function register(id, callback, options = {}) {
+	const registration = {
+		id,
+		callback,
+		exitOnly: options.exitOnly ?? false,
+		cancelled: false,
+		lastPass: 0
+	};
+	const cancel = () => {
+		registration.cancelled = true;
+		const index = callbackList.indexOf(registration);
+		if (index >= 0) callbackList.splice(index, 1);
+	};
+	const invokeLate = (reason, keepAlive) => {
+		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));
+				error("Cleanup callback failed", {
+					err,
+					id,
+					stack: err.stack
+				});
+			});
+			activeLatePromises?.push(tracked);
+		} catch (error$1) {
+			const err = error$1 instanceof Error ? error$1 : new Error(String(error$1));
+			error("Cleanup callback failed", {
+				err,
+				id,
+				stack: err.stack
+			});
+		}
+	};
+	if (cleanupStage === "idle") {
+		callbackList.push(registration);
+		return cancel;
+	}
+	const reason = activeCleanupReason ?? "manual";
+	if (cleanupStage === "running" && activeCleanupKeepAlive) {
+		callbackList.push(registration);
+		if (!registration.exitOnly) invokeLate(reason, true);
+		return cancel;
+	}
+	debug("Cleanup already started; running late callback once", { id });
+	invokeLate(reason, false);
+	return cancel;
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/which.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/which.ts
 const XCODE_BINS = /* @__PURE__ */ new Set([
 	"clang",
 	"clang++",
@@ -3217,7 +3599,7 @@ function darwinWhich(command, options) {
 	if (isXcodeBin(command)) return getMacosToolPaths().get(command) ?? null;
 	return null;
 }
-const whichFresh = os.platform() === "darwin" ? darwinWhich : Bun.which;
+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;
@@ -3252,7 +3634,7 @@ function $which(command, options) {
 	return result;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/template.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/template.ts
 /** A string that bypasses HTML escaping when interpolated. */
 var SafeString = class {
 	#value;
@@ -3703,7 +4085,7 @@ function compile$1(source, options = {}) {
 			root,
 			data: {
 				root,
-				...runtime.data ?? {}
+				...runtime.data
 			}
 		};
 		return renderNodes(nodes, frame, {
@@ -3741,7 +4123,7 @@ var TemplateEngine = class {
 				root,
 				data: {
 					root,
-					...runtime.data ?? {}
+					...runtime.data
 				}
 			};
 			return renderNodes(nodes, frame, {
@@ -3754,7 +4136,7 @@ var TemplateEngine = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/prompt.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/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
@@ -4197,7 +4579,7 @@ function _usingCtx() {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/ptree.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ptree.ts
 /**
 * Process tree management utilities for Bun subprocesses.
 *
@@ -4206,6 +4588,80 @@ function _usingCtx() {
 * - Cross-platform tree kill for process groups (Windows taskkill, Unix -pid).
 * - Convenience helpers: captureText / execText, AbortSignal, timeouts.
 */
+const LINUX_SUBREAPER_COMMAND_ENV = "OMP_PTREE_SUBREAPER_COMMAND";
+const LINUX_SUBREAPER_BUN_BE_BUN_ENV = "OMP_PTREE_SUBREAPER_BUN_BE_BUN";
+/**
+* Build the Linux child-subreaper entrypoint.
+*
+* @internal Exported so tests can force a missing first libc soname and verify
+* the loader continues to the next candidate.
+*/
+function createLinuxSubreaperScript(libcCandidates = ["libc.so.6", "libc.so"]) {
+	return `
+import { dlopen, FFIType } from "bun:ffi";
+
+let libc;
+for (const soname of ${JSON.stringify(libcCandidates)}) {
+	try {
+		libc = dlopen(soname, {
+			prctl: {
+				args: [FFIType.i32, FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u64],
+				returns: FFIType.i32,
+			},
+			waitpid: {
+				args: [FFIType.i32, FFIType.ptr, FFIType.i32],
+				returns: FFIType.i32,
+			},
+		});
+		break;
+	} catch {}
+}
+if (!libc) throw new Error("failed to load libc for Linux child supervision");
+
+if (libc.symbols.prctl(36, 1, 0, 0, 0) !== 0) {
+	throw new Error("failed to become a Linux child subreaper");
+}
+
+const commandJson = Bun.env.${LINUX_SUBREAPER_COMMAND_ENV};
+if (!commandJson) throw new Error("missing supervised command");
+const callerBunBeBun = Bun.env.${LINUX_SUBREAPER_BUN_BE_BUN_ENV};
+delete Bun.env.${LINUX_SUBREAPER_COMMAND_ENV};
+delete Bun.env.${LINUX_SUBREAPER_BUN_BE_BUN_ENV};
+if (callerBunBeBun === undefined) delete Bun.env.BUN_BE_BUN;
+else Bun.env.BUN_BE_BUN = callerBunBeBun;
+const command = JSON.parse(commandJson);
+const child = Bun.spawn(command, {
+	stdin: "inherit",
+	stdout: "pipe",
+	stderr: "pipe",
+	windowsHide: true,
+	env: Bun.env,
+});
+
+async function relay(stream, destination) {
+	const writer = destination.writer();
+	for await (const chunk of stream) writer.write(chunk);
+	await writer.flush();
+}
+
+function hasLiveChildren() {
+	let childPid;
+	do {
+		childPid = libc.symbols.waitpid(-1, null, 1);
+	} while (childPid > 0);
+	return childPid === 0;
+}
+
+const [exitCode] = await Promise.all([
+	child.exited,
+	relay(child.stdout, Bun.stdout),
+	relay(child.stderr, Bun.stderr),
+]);
+while (hasLiveChildren()) await Bun.sleep(10);
+process.exit(exitCode ?? 1);
+`;
+}
+const LINUX_SUBREAPER_SCRIPT = createLinuxSubreaperScript();
 /**
 * Base for all exceptions representing child process nonzero exit, killed, or
 * cancellation.
@@ -4266,10 +4722,21 @@ var ChildProcess = class {
 	#exitReasonPending;
 	#stderrDone;
 	#exited;
+	#openPipeReaders = 1;
+	#drainCutoff;
+	#resolveDrainCutoff;
+	#timeoutTimer;
 	#stderrStream;
-	constructor(proc, exposeStderr, retainFullStderr = exposeStderr) {
+	#terminating;
+	#terminateGroup;
+	#hardKillTree;
+	#windowsRootProcess;
+	constructor(proc, exposeStderr, retainFullStderr = exposeStderr, terminateGroup = false, hardKillTree = false) {
 		this.proc = proc;
 		this.exposeStderr = exposeStderr;
+		this.#terminateGroup = terminateGroup;
+		this.#hardKillTree = hardKillTree;
+		this.#windowsRootProcess = process.platform === "win32" ? Process.fromPid(proc.pid) ?? void 0 : void 0;
 		if (retainFullStderr) this.#stderrChunks = [];
 		const dec = new TextDecoder();
 		const trim = () => {
@@ -4281,19 +4748,34 @@ var ChildProcess = class {
 			this.#stderrStream = teeStream;
 			stderrStream = drainStream;
 		}
+		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();
 			try {
-				for await (const chunk of stderrStream) {
-					this.#stderrChunks?.push(chunk);
-					this.#stderrTail += dec.decode(chunk, { stream: true });
+				for (;;) {
+					const chunk = await Promise.race([reader.read().then((r) => ({
+						cutoff: false,
+						r
+					})), pipeCutoff.then(() => ({ cutoff: true }))]);
+					if (chunk.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 });
 					trim();
 				}
 			} catch {}
+			this.#openPipeReaders--;
 			this.#stderrTail += dec.decode();
 			trim();
 		})();
-		const { promise, resolve, reject } = Promise.withResolvers();
-		this.#exited = promise;
 		proc.exited.catch(() => null).then(async (exitCode) => {
 			if (this.#exitReasonPending) {
 				this.#exitReason = this.#exitReasonPending;
@@ -4305,6 +4787,11 @@ var ChildProcess = class {
 				return;
 			}
 			await this.#stderrDone;
+			if (this.#exitReasonPending) {
+				this.#exitReason = this.#exitReasonPending;
+				reject(this.#exitReasonPending);
+				return;
+			}
 			if (exitCode !== null) {
 				this.#exitReason = new NonZeroExitError(exitCode, this.#stderrTail);
 				resolve(exitCode);
@@ -4357,36 +4844,131 @@ var ChildProcess = class {
 		return this;
 	}
 	kill(reason, gracefulMs) {
-		if (reason && !this.#exitReasonPending) this.#exitReasonPending = reason;
-		if (!this.proc.killed) Process.fromPid(this.proc.pid)?.terminate(gracefulMs === void 0 ? void 0 : { gracefulMs })?.catch((e) => void 0);
+		if (reason && !this.#exitReasonPending) {
+			this.#exitReasonPending = reason;
+			if (this.proc.exitCode !== null) this.#exitReason = reason;
+		}
+		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();
+				return;
+			}
+		}
+		if (this.proc.exitCode !== null && this.#terminateGroup && this.#openPipeReaders > 0 && process.platform !== "win32") {
+			try {
+				process.kill(-this.proc.pid, "SIGKILL");
+			} catch {}
+			this.#terminating = Promise.resolve();
+			return;
+		}
+		if (this.proc.exitCode !== null && this.#windowsRootProcess && this.#openPipeReaders > 0) {
+			this.#windowsRootProcess.killTree();
+			this.#terminating = Promise.resolve();
+			return;
+		}
+		if (!this.proc.killed) {
+			const options = gracefulMs === void 0 ? this.#terminateGroup ? { group: true } : void 0 : {
+				gracefulMs,
+				group: this.#terminateGroup
+			};
+			this.#terminating = (this.#windowsRootProcess ?? Process.fromPid(this.proc.pid))?.terminate(options)?.catch((e) => void 0);
+		}
+	}
+	async #throwIfAborted() {
+		const exitReason = this.exitReason;
+		if (!exitReason?.aborted) return;
+		if (this.#terminating) await this.#terminating;
+		throw exitReason;
 	}
 	async text() {
-		const p = new Response(this.stdout).text();
+		const p = this.#readStream(this.proc.stdout);
 		if (this.#nothrow) return p;
 		const [text] = await Promise.all([p, this.exitedCleanly]);
+		await this.#throwIfAborted();
 		return text;
 	}
-	async blob() {
-		const p = new Response(this.stdout).blob();
+	/**
+	* Read a pipe fully, stopping early only at an explicit command deadline.
+	*/
+	async #readStream(stream) {
+		this.#openPipeReaders++;
+		const reader = stream.getReader();
+		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) {
+					await reader.cancel().catch(() => {});
+					break;
+				}
+				if (chunk.r.done) break;
+				out += dec.decode(chunk.r.value, { stream: true });
+			}
+		} catch {}
+		this.#openPipeReaders--;
+		return out + dec.decode();
+	}
+	async #readBytes() {
+		const reader = this.proc.stdout.getReader();
+		this.#openPipeReaders++;
+		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) {
+					await reader.cancel().catch(() => {});
+					break;
+				}
+				if (chunk.r.done) break;
+				chunks.push(chunk.r.value);
+				length += chunk.r.value.byteLength;
+			}
+		} catch {} finally {
+			this.#openPipeReaders--;
+			reader.releaseLock();
+		}
+		const bytes = new Uint8Array(length);
+		let offset = 0;
+		for (const chunk of chunks) {
+			bytes.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return bytes;
+	}
+	async #readOutputBytes(waitForCleanExit = false) {
+		const p = this.#readBytes();
 		if (this.#nothrow) return p;
-		const [blob] = await Promise.all([p, this.exitedCleanly]);
-		return blob;
+		const bytes = waitForCleanExit ? (await Promise.all([p, this.exitedCleanly]))[0] : await p;
+		await this.#throwIfAborted();
+		return bytes;
+	}
+	async blob() {
+		return new Blob([await this.#readOutputBytes(true)]);
 	}
 	async json() {
-		return new Response(this.stdout).json();
+		return JSON.parse(new TextDecoder().decode(await this.#readOutputBytes()));
 	}
 	async arrayBuffer() {
-		return new Response(this.stdout).arrayBuffer();
+		return (await this.#readOutputBytes()).buffer;
 	}
 	async bytes() {
-		const body = await new Response(this.stdout).bytes();
-		return body instanceof Uint8Array ? body : new Uint8Array(body);
+		return this.#readOutputBytes();
 	}
 	async wait(opts) {
 		const { allowNonZero = false, allowAbort = false, stderr: stderrMode = "buffer" } = opts ?? {};
 		const stderrChunks = this.#stderrChunks;
 		if (stderrMode === "full" && !stderrChunks) throw new Error("Full stderr capture must be requested when spawning the process (pass stderr: \"full\")");
-		const stdoutP = new Response(this.stdout).text();
+		const stdoutP = this.#readStream(this.proc.stdout);
 		const stderrP = stderrMode === "full" && stderrChunks ? this.#stderrDone.then(() => new TextDecoder().decode(Buffer.concat(stderrChunks))) : this.#stderrDone.then(() => this.#stderrTail);
 		const [stdout, stderr] = await Promise.all([stdoutP, stderrP]);
 		let exitError;
@@ -4396,8 +4978,10 @@ var ChildProcess = class {
 			if (err instanceof Exception) exitError = err;
 			else throw err;
 		}
+		this.#clearTimeout();
 		if (!exitError) exitError = this.exitReason;
 		if (!exitError && this.exitCode !== null && this.exitCode !== 0) exitError = new NonZeroExitError(this.exitCode, this.#stderrTail);
+		if (exitError?.aborted && this.#terminating) await this.#terminating;
 		const exitCode = this.exitCode ?? (exitError && !exitError.aborted ? exitError.exitCode : null);
 		const ok = exitCode === 0;
 		if (exitError) {
@@ -4417,12 +5001,20 @@ var ChildProcess = class {
 		signal.addEventListener("abort", onAbort, { once: true });
 		this.#exited.catch(() => {}).finally(() => signal.removeEventListener("abort", onAbort));
 	}
+	#clearTimeout() {
+		if (!this.#timeoutTimer) return;
+		clearTimeout(this.#timeoutTimer);
+		this.#timeoutTimer = void 0;
+	}
 	attachTimeout(ms) {
 		if (ms <= 0 || this.proc.killed) return;
 		this.#exited.catch(() => {});
-		Promise.race([Bun.sleep(ms).then(() => true), this.proc.exited.then(() => false, () => false)]).then((timedOut) => {
-			if (timedOut) this.kill(new TimeoutError(ms, this.#stderrTail));
-		});
+		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();
+		}, ms);
+		timer.unref?.();
+		this.#timeoutTimer = timer;
 	}
 	[Symbol.dispose]() {
 		if (this.proc.exitCode !== null) return;
@@ -4430,14 +5022,27 @@ var ChildProcess = class {
 	}
 };
 function spawnInternal(cmd, opts, retainFullStderr) {
-	const { timeout = -1, signal, stderr, ...rest } = opts ?? {};
-	const cp = new ChildProcess(Bun.spawn(cmd, {
+	const { timeout = -1, signal, stderr, detached, subreaper = false, ...rest } = opts ?? {};
+	const useSubreaper = subreaper && process.platform === "linux";
+	const commandEnv = rest.env ?? Bun.env;
+	const cp = new ChildProcess(Bun.spawn(useSubreaper ? [
+		process.execPath,
+		"-e",
+		LINUX_SUBREAPER_SCRIPT
+	] : cmd, {
 		stdin: "ignore",
 		stdout: "pipe",
 		stderr: "pipe",
 		windowsHide: true,
-		...rest
-	}), stderr === "full", retainFullStderr);
+		detached,
+		...rest,
+		env: useSubreaper ? {
+			...commandEnv,
+			BUN_BE_BUN: "1",
+			[LINUX_SUBREAPER_COMMAND_ENV]: JSON.stringify(cmd),
+			[LINUX_SUBREAPER_BUN_BE_BUN_ENV]: commandEnv.BUN_BE_BUN
+		} : rest.env
+	}), stderr === "full", retainFullStderr, detached === true, useSubreaper);
 	if (signal) cp.attachSignal(signal);
 	if (timeout > 0) cp.attachTimeout(timeout);
 	return cp;
@@ -4486,7 +5091,7 @@ function combineSignals(...signals) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/snowflake.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/snowflake.ts
 function randu32() {
 	return crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(1))[0];
 }
@@ -4565,29 +5170,9 @@ let Snowflake;
 	_Snowflake.getDate = getDate;
 })(Snowflake || (Snowflake = {}));
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/stream.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/stream.ts
 const trailingEvents = /* @__PURE__ */ new WeakSet();
 const LF = 10;
-function parseJsonlChunkCompat(input, beg, end) {
-	if (typeof input === "string") {
-		const { values, error, read, done } = Bun.JSONL.parseChunk(input);
-		return {
-			values,
-			error,
-			read,
-			done
-		};
-	}
-	const start = beg ?? 0;
-	const stop = end ?? input.length;
-	const { values, error, read, done } = Bun.JSONL.parseChunk(input, start, stop);
-	return {
-		values,
-		error,
-		read,
-		done
-	};
-}
 async function* readJsonl(stream, signal) {
 	const buffer = new ConcatSink();
 	const source = abortableSource(stream, signal);
@@ -4597,7 +5182,7 @@ async function* readJsonl(stream, signal) {
 			const tail = buffer.flush();
 			if (tail) {
 				buffer.clear();
-				const { values, error, done } = parseJsonlChunkCompat(tail, 0, tail.length);
+				const { values, error, done } = Bun.JSONL.parseChunk(tail, 0, tail.length);
 				if (values.length > 0) yield* values;
 				if (error) throw error;
 				if (!done) throw new Error("JSONL stream ended unexpectedly");
@@ -4687,8 +5272,14 @@ var ConcatSink = class {
 		return text;
 	}
 	*pullJSONL(chunk, beg, end) {
+		const newline = chunk.indexOf(LF, beg);
+		if (newline === -1 || newline >= end) {
+			if (this.isEmpty) this.reset(chunk.subarray(beg, end));
+			else this.append(chunk.subarray(beg, end));
+			return;
+		}
 		if (this.isEmpty) {
-			const { values, error, read, done } = parseJsonlChunkCompat(chunk, beg, end);
+			const { values, error, read, done } = Bun.JSONL.parseChunk(chunk, beg, end);
 			if (values.length > 0) yield* values;
 			if (error) throw error;
 			if (done) return;
@@ -4700,7 +5291,7 @@ var ConcatSink = class {
 		const space = this.#ensureCapacity(total);
 		space.set(chunk.subarray(beg, end), offset);
 		this.#length = total;
-		const { values, error, read, done } = parseJsonlChunkCompat(space.subarray(0, total), 0, total);
+		const { values, error, read, done } = Bun.JSONL.parseChunk(space, 0, total);
 		if (values.length > 0) yield* values;
 		if (error) throw error;
 		if (done) {
@@ -4859,7 +5450,7 @@ async function* readSseEvents(stream, signal) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/temp.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/temp.ts
 var TempDir = class TempDir {
 	#path;
 	constructor(path) {
@@ -4956,7 +5547,7 @@ function sleepSync(ms) {
 	Atomics.wait(kSleepBuffer, 0, 0, ms);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/tls-fetch.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/tls-fetch.ts
 /**
 * `NODE_EXTRA_CA_CERTS` shim for Bun's `fetch`.
 *
@@ -5065,7 +5656,7 @@ function wrapFetchForExtraCa(fetchImpl) {
 	}, fetchImpl.preconnect ? { preconnect: fetchImpl.preconnect } : {}, { [EXTRA_CA_FETCH_MARKER]: true });
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/index.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/index.ts
 function isPlainObject(val) {
 	return Object.getPrototypeOf(val) === Object.prototype || Array.isArray(val);
 }
@@ -5077,4 +5668,4 @@ function structuredCloneJSON(value) {
 	return JSON.parse(JSON.stringify(value));
 }
 //#endregion
-export { peekFile as $, formatAge as A, USER_AGENT as B, error as C, Cookie as D, $ as E, $envpos as F, getDocsRsCacheDir as G, getAgentDir as H, $flag as I, getLogsDir as J, getDocumentConversionCacheDir as K, $pickenv as L, formatCount as M, formatNumber as N, CookieMap as O, $env as P, isProbablyBinary as Q, isBunTestRuntime as R, debug as S, warn as T, getAutoQaDbPath as U, VERSION as V, getDebugLogPath as W, getRemoteDir as X, getPuppeteerDir as Y, getToolsDir as Z, parseStreamingJsonThrottled as _, readSseEvents as a, isEnotdir as b, combineSignals as c, $which as d, once as et, parseImageMetadata as f, parseStreamingJson as g, parseJsonWithRepair as h, readJsonl as i, formatBytes as j, installBunShim as k, exec as l, classifyJsonPrefix as m, wrapFetchForExtraCa as n, readSseJson as o, readImageMetadata as p, getInstallId as q, TempDir as r, Snowflake as s, structuredCloneJSON as t, untilAborted as tt, render as u, hasFsCode as v, time as w, parseFrontmatter as x, isEnoent as y, isTerminalHeadless as z };
+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 };