@xiaoso/dsh-tool-plus 0.1.0-beta.3 → 0.1.0-beta.4

package/lib/src-lDmkSRbm.mjs

@@ -0,0 +1,5006 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { n as fs_promises_shim_exports } from "./fs-promises-shim-B-9cMxz5.mjs";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { Process } from "@oh-my-pi/pi-natives";
+import * as os from "node:os";
+import assert from "node:assert/strict";
+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 node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/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");
+		const message = signal.reason instanceof Error ? signal.reason.message : "Cancelled";
+		super(`Aborted: ${message}`, { cause: signal.reason });
+		this.name = "AbortError";
+	}
+};
+/**
+* Abortable async iteration over a {@link ReadableStream}. Reads the source
+* reader directly and yields each chunk, so the consumer's `for await` drives a
+* single read loop with no intermediate stream or per-chunk enqueue.
+*
+* Unlike `stream.pipeThrough(..., { signal })`, this explicitly cancels the
+* source reader on abort or early `break`, propagating HTTP-client disconnects
+* and watchdog timeouts to the backend request instead of only stopping the
+* local consumer. On abort it throws {@link AbortError}; the lock is released
+* on completion, abort, throw, or early exit. The source is cancelled only on
+* abort or early exit — never on natural EOF.
+*/
+async function* abortableSource(stream, signal) {
+	if (signal?.aborted) throw new AbortError$1(signal);
+	const reader = stream.getReader();
+	let onAbort;
+	if (signal) {
+		onAbort = () => {
+			reader.cancel(signal.reason).catch(() => {});
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	}
+	let completed = false;
+	try {
+		for (;;) {
+			const result = await reader.read();
+			if (signal?.aborted) throw new AbortError$1(signal);
+			if (result.done) {
+				completed = true;
+				return;
+			}
+			yield result.value;
+		}
+	} finally {
+		if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+		if (!completed) try {
+			await reader.cancel();
+		} catch {}
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
+/**
+* Runs a promise-returning function (`pr`). If the given AbortSignal is aborted before or during
+* execution, the promise is rejected with a standard error.
+*
+* @param signal - Optional AbortSignal to cancel the operation
+* @param pr - Function returning a promise to run
+* @returns Promise resolving as `pr` would, or rejecting on abort
+*/
+function untilAborted(signal, pr) {
+	if (!signal) return typeof pr === "function" ? pr() : pr;
+	if (signal.aborted) return Promise.reject(new AbortError$1(signal));
+	const { promise, resolve, reject } = Promise.withResolvers();
+	const onAbort = () => reject(new AbortError$1(signal));
+	signal.addEventListener("abort", onAbort, { once: true });
+	(async () => {
+		try {
+			resolve(await (typeof pr === "function" ? pr() : pr));
+		} catch (err) {
+			reject(err);
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+		}
+	})();
+	return promise;
+}
+/**
+* Memoizes a function with no arguments, calling it once and caching the result.
+*
+* @param fn - Function to be called once
+* @returns A function that returns the cached result of `fn`
+*/
+function once(fn) {
+	let store = void 0;
+	return () => {
+		if (store) return store.value;
+		const value = fn();
+		store = { value };
+		return value;
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/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.
+*/
+/** 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 = [];
+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);
+	}
+}
+/**
+* Like {@link peekFileSync} but uses async I/O.
+*/
+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));
+		});
+	} finally {
+		await fileHandle.close();
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/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.
+*
+* The read tool and `@file` auto-read both materialize file bytes as UTF-8
+* strings. For a binary file (font, object, archive, packed blob) that decode
+* is lossy: NUL bytes and invalid sequences survive as control characters and
+* U+FFFD replacements, which corrupt terminal rendering and waste the context
+* window with mojibake. Sniff the header first and refuse instead.
+*
+* @example
+* 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. */
+const BINARY_SNIFF_BYTES = 8192;
+/**
+* Classify an in-memory byte header as binary (non-UTF-8-text).
+*
+* Binary when the header contains a NUL byte (true binary, plus UTF-16/UTF-32
+* text whose ASCII range is NUL-padded) or when it is not valid UTF-8. The
+* decode runs in streaming mode so a multibyte sequence truncated at the header
+* boundary is tolerated, while any genuinely invalid byte still fails — matching
+* the strict `fatal` decode the `local://`/`ssh://` read paths already use.
+*/
+function isProbablyBinaryHeader(header) {
+	if (header.indexOf(0) !== -1) return true;
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(header, { stream: true });
+		return false;
+	} catch {
+		return true;
+	}
+}
+/**
+* Sniff the first {@link BINARY_SNIFF_BYTES} of `filePath` and report whether it
+* is binary (non-UTF-8-text). See {@link isProbablyBinaryHeader} for the rule.
+*/
+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";
+var engines = { "bun": ">=1.3.14" };
+/** Version (e.g. "1.0.0") */
+const VERSION = version;
+/** Default User-Agent header string (e.g. "omp/17.2.12") */
+const USER_AGENT = `omp/${VERSION}`;
+engines.bun.replace(/[^0-9.]/g, "");
+const PROFILE_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+/**
+* Names Windows treats as reserved device aliases. Matches the basename
+* itself as well as any `BASENAME.<anything>` form, because Windows reserves
+* `CON.foo`/`PRN.txt`/etc. too — using them as a profile name would let
+* `setProfile` accept the input only for directory creation to fail later
+* with a confusing `ENOENT`/`EINVAL`. Case-insensitive: NTFS treats `CON`
+* and `con` identically.
+*/
+const WINDOWS_RESERVED_BASENAME_RE = /^(?:CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\..*)?$/i;
+/**
+* Normalize and validate a profile name. Returns `undefined` for the implicit
+* default (empty string, whitespace, or the explicit "default" sentinel) and
+* throws for syntactically invalid or platform-reserved names.
+*
+* Exported so consumers of `@oh-my-pi/pi-utils/dirs` (CLI bootstrap, tests,
+* downstream tools) can validate user input without re-deriving the rules.
+*/
+function normalizeProfileName(profile) {
+	const normalized = profile?.trim();
+	if (!normalized || normalized === "default") return void 0;
+	if (normalized === "." || normalized === ".." || normalized.endsWith(".") || !PROFILE_NAME_RE.test(normalized) || WINDOWS_RESERVED_BASENAME_RE.test(normalized)) throw new Error(`Invalid OMP profile "${profile}". Profile names must match ${PROFILE_NAME_RE.source}, cannot be "." or "..", cannot end with ".", and cannot be a Windows reserved device name (CON, PRN, AUX, NUL, COM0-9, LPT0-9, or any of those with an extension).`);
+	return normalized;
+}
+/**
+* Resolve the active profile from the two profile env vars. `OMP_PROFILE` is the
+* canonical variable and takes precedence; `PI_PROFILE` is the legacy
+* compatibility fallback, consulted only when `OMP_PROFILE` is undefined. An
+* explicitly-empty `OMP_PROFILE` therefore selects the default profile rather
+* than silently inheriting `PI_PROFILE`. Delegates validation/normalization to
+* {@link normalizeProfileName} (which throws on a syntactically invalid value).
+*/
+function resolveProfileEnv(omp, pi) {
+	return normalizeProfileName(omp !== void 0 ? omp : pi);
+}
+function getProfileFromEnv() {
+	return resolveProfileEnv(process.env.OMP_PROFILE, process.env.PI_PROFILE);
+}
+/**
+* Module-load profile resolution. Unlike {@link getProfileFromEnv}, an invalid
+* OMP_PROFILE/PI_PROFILE value does NOT throw here — a bad env var must not
+* crash a bare `import` of this module with an uncaught stack trace before the
+* CLI's error handling is in scope. The default profile is used instead; the
+* CLI re-validates the env (see `runCli` in coding-agent/src/cli.ts) so the
+* user still gets a clean "Invalid OMP profile" message.
+*/
+function readProfileFromEnvSafe() {
+	try {
+		return getProfileFromEnv();
+	} catch {
+		return;
+	}
+}
+function getBaseConfigRoot() {
+	return path.join(os.homedir(), getConfigDirName());
+}
+function getProfileConfigRoot(profile) {
+	const root = getBaseConfigRoot();
+	return profile ? path.join(root, "profiles", profile) : root;
+}
+function readPiProfileFromEnvSafe() {
+	try {
+		return normalizeProfileName(process.env.PI_PROFILE);
+	} catch {
+		return;
+	}
+}
+function getProfileAgentDir(profile) {
+	return path.join(getProfileConfigRoot(profile), "agent");
+}
+function isProfileDerivedAgentDir(profile, agentDirEnv) {
+	return profile !== void 0 && agentDirEnv === getProfileAgentDir(profile);
+}
+/**
+* On macOS, strip /private prefix only when both paths resolve to the same location.
+* This preserves aliases like /private/tmp -> /tmp without rewriting unrelated paths.
+*/
+function standardizeMacOSPath(p) {
+	if (process.platform !== "darwin" || !p.startsWith("/private/")) return p;
+	const stripped = p.slice(8);
+	try {
+		if (fs.realpathSync(p) === fs.realpathSync(stripped)) return stripped;
+	} catch {}
+	return p;
+}
+standardizeMacOSPath(process.cwd());
+/** 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";
+}
+/**
+* Resolves and caches all omp directory paths. On Linux, when XDG environment
+* variables are set, paths are redirected under $XDG_*_HOME/omp/. A new
+* instance is created whenever the agent directory changes, which naturally
+* invalidates all cached paths.
+*/
+var DirResolver = class {
+	configRoot;
+	agentDir;
+	#rootDirs;
+	#agentDirs;
+	#rootCache = /* @__PURE__ */ new Map();
+	#agentCache = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		const profile = normalizeProfileName(options.profile);
+		this.configRoot = getProfileConfigRoot(profile);
+		const defaultAgent = path.join(this.configRoot, "agent");
+		const agentDirOverride = profile ? void 0 : options.agentDirOverride;
+		this.agentDir = agentDirOverride ? path.resolve(agentDirOverride) : defaultAgent;
+		const isDefault = this.agentDir === defaultAgent;
+		let xdgData;
+		let xdgState;
+		let xdgCache;
+		if ((process.platform === "linux" || process.platform === "darwin") && isDefault) {
+			const resolveIf = (envVar) => {
+				const value = process.env[envVar];
+				if (!value) return void 0;
+				try {
+					const appRoot = path.join(value, "omp");
+					if (profile) {
+						const profilePath = path.join(appRoot, "profiles", profile);
+						if (fs.existsSync(profilePath)) return profilePath;
+						return;
+					}
+					if (fs.existsSync(appRoot)) return appRoot;
+				} catch {}
+			};
+			xdgData = resolveIf("XDG_DATA_HOME");
+			xdgState = resolveIf("XDG_STATE_HOME");
+			xdgCache = resolveIf("XDG_CACHE_HOME");
+		}
+		this.#rootDirs = {
+			data: xdgData ?? this.configRoot,
+			state: xdgState ?? this.configRoot,
+			cache: xdgCache ?? this.configRoot
+		};
+		this.#agentDirs = {
+			data: xdgData ?? this.agentDir,
+			state: xdgState ?? this.agentDir,
+			cache: xdgCache ?? this.agentDir
+		};
+	}
+	/** Config-root subdirectory, with optional XDG override. */
+	rootSubdir(subdir, xdg) {
+		const cached = this.#rootCache.get(subdir);
+		if (cached) return cached;
+		const base = xdg ? this.#rootDirs[xdg] : this.configRoot;
+		const result = path.join(base, subdir);
+		this.#rootCache.set(subdir, result);
+		return result;
+	}
+	/** Agent subdirectory, with optional XDG override. */
+	agentSubdir(userAgentDir, subdir, xdg) {
+		if (!userAgentDir || userAgentDir === this.agentDir) {
+			const cached = this.#agentCache.get(subdir);
+			if (cached) return cached;
+			const base = xdg ? this.#agentDirs[xdg] : this.agentDir;
+			const result = path.join(base, subdir);
+			this.#agentCache.set(subdir, result);
+			return result;
+		}
+		return path.join(userAgentDir, subdir);
+	}
+};
+/**
+* Decide which `PI_CODING_AGENT_DIR` value to capture as the pre-profile
+* baseline. A value equal to a profile's derived agent dir is profile-derived
+* (propagated by a parent's `setProfile`), so it must NOT be snapshotted as the
+* default-mode baseline — otherwise default mode would resolve to the profile's
+* agent dir. The profile source can be the active profile or a lower-priority
+* `PI_PROFILE` that was bypassed because `OMP_PROFILE` explicitly selected the
+* default profile. Returns `undefined` in those cases so reset falls back to the
+* standard `~/.omp/agent`.
+*/
+function resolvePreProfileAgentDir(profile, agentDirEnv, profileAgentDirSource = profile) {
+	return isProfileDerivedAgentDir(profile ?? profileAgentDirSource, agentDirEnv) ? void 0 : agentDirEnv;
+}
+let activeProfile = readProfileFromEnvSafe();
+/**
+* Resolve the agent-dir override for the current `activeProfile` from the live
+* environment. A named profile derives its own agent dir (no override); default
+* mode honors a non-profile `PI_CODING_AGENT_DIR` (see
+* {@link resolvePreProfileAgentDir}). Shared by the module-load resolver and
+* {@link refreshDirsFromEnv} so both apply identical logic.
+*/
+function resolveActiveAgentDirOverride() {
+	return activeProfile ? void 0 : resolvePreProfileAgentDir(void 0, process.env.PI_CODING_AGENT_DIR, readPiProfileFromEnvSafe());
+}
+let dirs = new DirResolver({
+	agentDirOverride: resolveActiveAgentDirOverride(),
+	profile: activeProfile
+});
+resolvePreProfileAgentDir(activeProfile, process.env.PI_CODING_AGENT_DIR, activeProfile ?? readPiProfileFromEnvSafe());
+os.homedir();
+/**
+* Rebuild the dirs resolver from the current environment, reusing the profile
+* resolved at module load. Directory-affecting keys (XDG_*_HOME and, in default
+* mode, `PI_CODING_AGENT_DIR`) loaded from a profile/agent `.env` only reach
+* `process.env` *after* this module froze the resolver at import time, so
+* `env.ts` calls this once after applying its `.env` files. The agent `.env`
+* location derives from the profile name + home before this runs, so the
+* rebuild re-reads only the directory vars, never the profile selection. The
+* `preProfileAgentDirEnv` snapshot is intentionally left untouched.
+*/
+function refreshDirsFromEnv() {
+	dirs = new DirResolver({
+		agentDirOverride: resolveActiveAgentDirOverride(),
+		profile: activeProfile
+	});
+}
+/** Get the config root directory (~/.omp). */
+function getConfigRootDir() {
+	return dirs.configRoot;
+}
+/** Get the agent config directory (~/.omp/agent). */
+function getAgentDir() {
+	return dirs.agentDir;
+}
+/** Get the logs directory (~/.omp/logs). */
+function getLogsDir() {
+	return dirs.rootSubdir("logs", "state");
+}
+/** Get the remote mount directory (~/.omp/remote). */
+function getRemoteDir() {
+	return dirs.rootSubdir("remote", "data");
+}
+/** Get DOCS_RS cache directory () */
+function getDocsRsCacheDir() {
+	return dirs.rootSubdir("webcache", "cache");
+}
+/** Get the auto-QA grievances SQLite database path (~/.omp/autoqa.db; XDG: $XDG_DATA_HOME/omp/autoqa.db). */
+function getAutoQaDbPath() {
+	return dirs.rootSubdir("autoqa.db", "data");
+}
+/** Get the document conversion cache directory (~/.omp/agent/cache/document-conversions; XDG default: $XDG_CACHE_HOME/omp/cache/document-conversions). */
+function getDocumentConversionCacheDir(agentDir) {
+	return dirs.agentSubdir(agentDir, path.join("cache", "document-conversions"), "cache");
+}
+/** Get the tools directory (~/.omp/agent/tools). */
+function getToolsDir(agentDir) {
+	return dirs.agentSubdir(agentDir, "tools");
+}
+/** Get the debug log path (~/.omp/agent/omp-debug.log). */
+function getDebugLogPath(agentDir) {
+	return dirs.agentSubdir(agentDir, `omp-debug.log`, "state");
+}
+let cachedInstallId = null;
+const INSTALL_ID_FILE = "install-id";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Persistent per-install UUID stored at `~/.omp/install-id`.
+*
+* Generated lazily on first call and persisted with `O_CREAT|O_EXCL` so
+* concurrent first-call races don't clobber each other (loser re-reads the
+* winner's id). Survives independently of agent state: deleting
+* `~/.omp/agent/` does not regenerate it. Server-side dedup for grievance
+* pushes (and similar telemetry) keys on this id.
+*
+* Anchored to the base config root (`~/.omp/install-id`) regardless of the
+* active profile: install identity is per-install, not per-profile, so every
+* profile shares one id and the global cache stays correct no matter the
+* profile / `getInstallId` call order.
+*/
+function getInstallId() {
+	if (cachedInstallId) return cachedInstallId;
+	const filePath = path.join(getBaseConfigRoot(), INSTALL_ID_FILE);
+	let observedInvalid = false;
+	try {
+		const existing = fs.readFileSync(filePath, "utf8").trim();
+		if (UUID_RE.test(existing)) {
+			cachedInstallId = existing;
+			return existing;
+		}
+		observedInvalid = existing.length > 0;
+	} catch {}
+	const next = crypto.randomUUID();
+	try {
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		if (observedInvalid) try {
+			fs.unlinkSync(filePath);
+		} catch {}
+		const fd = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
+		try {
+			fs.writeSync(fd, `${next}\n`);
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch (err) {
+		if (err.code === "EEXIST") try {
+			const existing = fs.readFileSync(filePath, "utf8").trim();
+			if (UUID_RE.test(existing)) {
+				cachedInstallId = existing;
+				return existing;
+			}
+		} catch {}
+	}
+	cachedInstallId = next;
+	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
+const ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Strict shell-identifier shape. Used for dotenv keys we accept into
+* `Bun.env` — those should be referenceable as `$NAME` from POSIX shells,
+* so we reject anything outside `[A-Za-z_][A-Za-z0-9_]*`.
+*/
+function isValidEnvName(name) {
+	return ENV_NAME_RE.test(name);
+}
+/**
+* The only names that are genuinely unsafe to forward to a native `execve`
+* spawn: empty, containing `=` (would corrupt the `KEY=VALUE` framing) or
+* NUL (terminates the C string mid-entry). Windows ships standard variables
+* whose names contain parentheses (e.g. `ProgramFiles(x86)`, `CommonProgramFiles(x86)`)
+* — those MUST survive the scrub so downstream resolvers (Git Bash discovery
+* in `procmgr.ts`, etc.) can still read them.
+*/
+function isSafeEnvName(name) {
+	return name.length > 0 && !name.includes("=") && !name.includes("\0");
+}
+function isSafeEnvValue(value) {
+	return !value.includes("\0");
+}
+function isMacosMallocStackLoggingEnvName(name) {
+	return name === "MallocStackLogging" || name === "MallocStackLoggingNoCompact";
+}
+function readLaunchEnv() {
+	if (process.platform === "linux") try {
+		const values = /* @__PURE__ */ new Map();
+		for (const entry of fs.readFileSync("/proc/self/environ", "utf8").split("\0")) {
+			const separator = entry.indexOf("=");
+			if (separator > 0) values.set(entry.slice(0, separator), entry.slice(separator + 1));
+		}
+		return values;
+	} catch {}
+	if (!process.execArgv.includes("--no-env-file")) return void 0;
+	const values = /* @__PURE__ */ new Map();
+	for (const key in Bun.env) {
+		const value = Bun.env[key];
+		if (value !== void 0) values.set(key, value);
+	}
+	return values;
+}
+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
+* `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;
+		}
+	} catch {}
+	for (const k in result) if (k.startsWith("OMP_")) result[`PI_${k.slice(4)}`] = result[k];
+	return result;
+}
+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"));
+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];
+}
+for (const file of [
+	projectEnv,
+	agentEnv,
+	piEnv,
+	homeEnv
+]) for (const key in file) if (!isMacosMallocStackLoggingEnvName(key) && !Bun.env[key]) {
+	Bun.env[key] = file[key];
+	if (file === projectEnv) projectEnvNamesLoadedByOmp.add(key);
+}
+refreshDirsFromEnv();
+/**
+* Intentional re-export of Bun.env.
+*
+* All users should import this env module (import { $env } from "@oh-my-pi/pi-utils")
+* before using environment variables. This ensures that .env files have been loaded and
+* overrides (project, home) have been applied, so $env always reflects the correct values.
+*/
+const $env = Bun.env;
+/**
+* Resolve the first environment variable value from the given keys.
+* @param keys - The keys to resolve.
+* @returns The first environment variable value, or undefined if no value is found.
+*/
+function $pickenv(...keys) {
+	for (const key of keys) {
+		const value = Bun.env[key]?.trim();
+		if (value) return value;
+	}
+}
+/**
+* Parses a positive decimal integer from `$env[name]`.
+* Empty, invalid, NaN, zero, or negative values return `defaultValue`.
+*/
+function $envpos(name, defaultValue) {
+	const raw = $env[name];
+	if (!raw) return defaultValue;
+	const parsed = Number.parseInt(raw, 10);
+	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
+* writes, stdin raw-mode + resume, CSI/OSC capability probes, SIGWINCH, window
+* title changes, and emergency restore. Defaults to {@link isBunTestRuntime} so
+* `bun test` launched inside a real TTY never paints the TUI, leaks probe
+* queries, or hijacks the developer's stdin; production runtimes stay
+* interactive.
+*
+* Terminal-contract tests that must exercise the real I/O path opt out with
+* `setTerminalHeadless(false)` and restore it afterwards.
+*/
+function isTerminalHeadless() {
+	return terminalHeadless;
+}
+const TRUTHY = {
+	"1": true,
+	Y: true,
+	y: true,
+	TRUE: true,
+	true: true,
+	YES: true,
+	yes: true,
+	ON: true,
+	on: true
+};
+/** Parse a boolean-ish env value ("1", "yes", "on", …); `def` when unset/empty. */
+function parseFlag(value, def = false) {
+	if (!value) return def;
+	return TRUTHY[value] === true;
+}
+function $flag(name, def = false) {
+	return parseFlag($env[name], def);
+}
+/**
+* Format a number with K/M/B suffix for compact display.
+* Uses 1 decimal for small leading digits when non-zero, rounded otherwise.
+* Examples: "999", "1K", "1.5K", "25K", "1M", "1.5M", "25M", "1.5B"
+*/
+function formatNumber(n) {
+	if (n < 1e3) return n.toString();
+	if (n < 1e4) return `${trim1(n / 1e3)}K`;
+	if (n < 1e6) return `${Math.round(n / 1e3)}K`;
+	if (n < 1e7) return `${trim1(n / 1e6)}M`;
+	if (n < 1e9) return `${Math.round(n / 1e6)}M`;
+	if (n < 1e10) return `${trim1(n / 1e9)}B`;
+	return `${Math.round(n / 1e9)}B`;
+}
+/** Format with up to 1 decimal place, dropping trailing `.0`. */
+function trim1(n) {
+	const s = n.toFixed(1);
+	return s.endsWith(".0") ? s.slice(0, -2) : s;
+}
+/**
+* Format a byte count to a human-readable string.
+* Examples: "512B", "1.5KB", "2.3MB", "1.2GB"
+*/
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)}KB`;
+	if (bytes < 1073741824) return `${(bytes / 1048576).toFixed(1)}MB`;
+	return `${(bytes / 1073741824).toFixed(1)}GB`;
+}
+/**
+* Truncate a string to maxLen characters, appending an ellipsis if truncated.
+* For display-width-aware truncation (terminals), use truncateToWidth from @oh-my-pi/pi-tui.
+*/
+function truncate(str, maxLen, ellipsis = "…") {
+	if (str.length <= maxLen) return str;
+	const sliceLen = Math.max(0, maxLen - ellipsis.length);
+	return `${str.slice(0, sliceLen)}${ellipsis}`;
+}
+/**
+* Format count with pluralized label (e.g., "3 files", "1 error").
+*/
+function formatCount(label, count) {
+	const safeCount = Number.isFinite(count) ? count : 0;
+	return `${safeCount} ${pluralize(label, safeCount)}`;
+}
+/**
+* Format age from seconds to human-readable string.
+*/
+function formatAge(ageSeconds) {
+	if (!ageSeconds) return "";
+	const mins = Math.floor(ageSeconds / 60);
+	const hours = Math.floor(mins / 60);
+	const days = Math.floor(hours / 24);
+	const weeks = Math.floor(days / 7);
+	const months = Math.floor(days / 30);
+	if (months > 0) return `${months}mo ago`;
+	if (weeks > 0) return `${weeks}w ago`;
+	if (days > 0) return `${days}d ago`;
+	if (hours > 0) return `${hours}h ago`;
+	if (mins > 0) return `${mins}m ago`;
+	return "just now";
+}
+/**
+* Pluralize a label based on the count.
+*/
+function pluralize(label, count) {
+	if (count === 1) return label;
+	if (/(?:ch|sh|s|x|z)$/i.test(label)) return `${label}es`;
+	if (/[^aeiou]y$/i.test(label)) return `${label.slice(0, -1)}ies`;
+	return `${label}s`;
+}
+//#endregion
+//#region src/tools/shared/bun-shim.ts
+/**
+* DSH Bun compatibility shim — installs a Node implementation of the `Bun`
+* global that OMP tool code (copied verbatim into adapter/omp) uses.
+*
+* OMP is a Bun project; its code calls `Bun.file`, `Bun.write`, `Bun.hash`,
+* `Bun.stringWidth`, `Bun.Glob`, `Bun.Archive`, `Bun.FileSink`, … This module
+* provides those APIs on Node 22, plus the `Buffer`/`Uint8Array` `toBase64`/
+* `fromBase64` extensions Bun adds. Every change here is recorded in step.md
+* ("Bun 兼容" section).
+*
+* `Bun.Image` is backed by `sharp` resolved at runtime (拍板#22, 2026-08-28:
+* 图像链路重建——sharp 兼容层取代构造即抛错的桩，fetch/read 的 resizeImage
+* 后端由此复活）。sharp 是宿主 DSH 的传递依赖（dsh-attachment-local 直接依
+* 赖），本包不打包、不安装，运行时经 createRequire/import 级联解析；解析不到
+* 时抛带指引的错误，`resizeImage` 的 try/catch 降级语义保持不变。
+*/
+function patchBase64() {
+	const bufProto = Buffer.prototype;
+	const u8Proto = Uint8Array.prototype;
+	if (typeof bufProto.toBase64 !== "function") bufProto.toBase64 = function() {
+		return this.toString("base64");
+	};
+	if (typeof bufProto.fromBase64 !== "function") Buffer.fromBase64 = function(s) {
+		return Buffer.from(s, "base64");
+	};
+	if (typeof u8Proto.toBase64 !== "function") u8Proto.toBase64 = function() {
+		return Buffer.from(this.buffer, this.byteOffset, this.byteLength).toString("base64");
+	};
+	if (typeof u8Proto.fromBase64 !== "function") u8Proto.fromBase64 = function(s) {
+		return new Uint8Array(Buffer.from(s, "base64"));
+	};
+}
+var BunFileShim = class {
+	path;
+	constructor(p) {
+		this.path = p;
+	}
+	get size() {
+		try {
+			return fs.statSync(this.path).size;
+		} catch {
+			return 0;
+		}
+	}
+	get name() {
+		return path.basename(this.path);
+	}
+	async exists() {
+		try {
+			await fsp.stat(this.path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async text() {
+		return fsp.readFile(this.path, "utf8");
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	async arrayBuffer() {
+		const b = await fsp.readFile(this.path);
+		return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+	}
+	async bytes() {
+		return fsp.readFile(this.path);
+	}
+	writer() {
+		return new FileSinkShim(this.path);
+	}
+	/** Bun extension: stat the file (patched Node implementation). */
+	async stat() {
+		const st = await fsp.stat(this.path);
+		return {
+			mtimeMs: st.mtimeMs,
+			size: st.size,
+			isDirectory: () => st.isDirectory()
+		};
+	}
+	/** Bun extension: delete the file. */
+	async unlink() {
+		await fsp.unlink(this.path);
+	}
+	/** Bun extension: write content to the file (overwrite). */
+	async write(content) {
+		await bunWrite(this.path, content);
+	}
+	/** Bun extension: a sub-range view of the file. */
+	slice(start, end) {
+		return new BunFileSliceShim(this.path, start ?? 0, end);
+	}
+	stream() {
+		return new ReadableStream({ start: async (controller) => {
+			controller.enqueue(await fsp.readFile(this.path));
+			controller.close();
+		} });
+	}
+};
+/** Sub-range view of a file (Bun's `BunFile.slice`). */
+var BunFileSliceShim = class extends BunFileShim {
+	#start;
+	#end;
+	constructor(filePath, start, end) {
+		super(filePath);
+		this.#start = start;
+		this.#end = end;
+	}
+	get size() {
+		const total = super.size;
+		return Math.max(0, (this.#end ?? total) - this.#start);
+	}
+	async #sliced() {
+		return (await fsp.readFile(this.path)).subarray(this.#start, this.#end);
+	}
+	async text() {
+		return new TextDecoder("utf-8", { fatal: false }).decode(await this.#sliced());
+	}
+	async bytes() {
+		return this.#sliced();
+	}
+	async arrayBuffer() {
+		const b = await this.#sliced();
+		return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+	}
+};
+var FileSinkShim = class {
+	#fd = null;
+	#filePath;
+	constructor(filePath) {
+		this.#filePath = filePath;
+	}
+	#open() {
+		fs.mkdirSync(path.dirname(this.#filePath), { recursive: true });
+		this.#fd = fs.openSync(this.#filePath, "a");
+	}
+	write(chunk) {
+		if (this.#fd === null) this.#open();
+		if (typeof chunk === "string") fs.writeSync(this.#fd, chunk);
+		else fs.writeSync(this.#fd, chunk);
+	}
+	flush() {}
+	end() {
+		this.close();
+	}
+	close() {
+		if (this.#fd !== null) {
+			fs.closeSync(this.#fd);
+			this.#fd = null;
+		}
+	}
+};
+async function bunWrite(dest, data) {
+	await fsp.mkdir(path.dirname(dest), { recursive: true });
+	if (typeof data === "string") await fsp.writeFile(dest, data);
+	else if (data instanceof Blob) await fsp.writeFile(dest, new Uint8Array(await data.arrayBuffer()));
+	else if (data instanceof ArrayBuffer) await fsp.writeFile(dest, new Uint8Array(data));
+	else await fsp.writeFile(dest, data);
+}
+function bunSleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function bunRandomUUIDv7() {
+	return randomUUID();
+}
+const PRIME64_1 = 11400714785074694791n;
+const PRIME64_2 = 14029467366897019727n;
+const PRIME64_3 = 1609587929392839161n;
+const PRIME64_4 = 9650029242287828579n;
+const PRIME64_5 = 2870177450012600261n;
+const MASK64 = 18446744073709551615n;
+function rotl64(x, r) {
+	return (x << BigInt(r) | x >> BigInt(64 - r)) & MASK64;
+}
+function xx64Round(acc, input) {
+	acc = acc + input * PRIME64_2 & MASK64;
+	acc = rotl64(acc, 31);
+	return acc * PRIME64_1 & MASK64;
+}
+function xx64MergeRound(acc, val) {
+	val = xx64Round(0n, val);
+	return (acc ^ val) * PRIME64_1 + PRIME64_4 & MASK64;
+}
+function xx64ReadU64(bytes, o) {
+	return BigInt(bytes[o]) | BigInt(bytes[o + 1]) << 8n | BigInt(bytes[o + 2]) << 16n | BigInt(bytes[o + 3]) << 24n | BigInt(bytes[o + 4]) << 32n | BigInt(bytes[o + 5]) << 40n | BigInt(bytes[o + 6]) << 48n | BigInt(bytes[o + 7]) << 56n;
+}
+function bunHashXxHash64(data, seed) {
+	let bytes;
+	if (typeof data === "string") bytes = new TextEncoder().encode(data);
+	else if (data instanceof ArrayBuffer) bytes = new Uint8Array(data);
+	else bytes = data;
+	return xxHash64Core(bytes, seed);
+}
+function xxHash64Core(bytes, seed) {
+	const s = seed ?? 0n;
+	const len = bytes.length;
+	let i = 0;
+	let h;
+	if (len >= 32) {
+		let v1 = s + PRIME64_1 + PRIME64_2 & MASK64;
+		let v2 = s + PRIME64_2 & MASK64;
+		let v3 = s + 0n & MASK64;
+		let v4 = s - PRIME64_1 & MASK64;
+		for (; i <= len - 32; i += 32) {
+			v1 = xx64Round(v1, xx64ReadU64(bytes, i));
+			v2 = xx64Round(v2, xx64ReadU64(bytes, i + 8));
+			v3 = xx64Round(v3, xx64ReadU64(bytes, i + 16));
+			v4 = xx64Round(v4, xx64ReadU64(bytes, i + 24));
+		}
+		h = rotl64(v1, 1) + rotl64(v2, 7) + rotl64(v3, 12) + rotl64(v4, 18) & MASK64;
+		h = xx64MergeRound(h, xx64ReadU64(bytes, i));
+		i += 8;
+		h = xx64MergeRound(h, xx64ReadU64(bytes, i));
+		i += 8;
+		h = xx64MergeRound(h, xx64ReadU64(bytes, i));
+		i += 8;
+		h = xx64MergeRound(h, xx64ReadU64(bytes, i));
+		i += 8;
+	} else h = s + PRIME64_5 & MASK64;
+	h = h + BigInt(len) & MASK64;
+	for (; i + 8 <= len; i += 8) {
+		h = xx64MergeRound(h, xx64ReadU64(bytes, i));
+		h = rotl64(h, 27) * PRIME64_1 + PRIME64_4 & MASK64;
+	}
+	if (i + 4 <= len) {
+		const v = BigInt(bytes[i]) | BigInt(bytes[i + 1]) << 8n | BigInt(bytes[i + 2]) << 16n | BigInt(bytes[i + 3]) << 24n;
+		h = (h ^ v * PRIME64_1) & MASK64;
+		h = rotl64(h, 23) * PRIME64_2 + PRIME64_3 & MASK64;
+		i += 4;
+	}
+	for (; i < len; i++) {
+		h = (h ^ BigInt(bytes[i]) * PRIME64_5) & MASK64;
+		h = rotl64(h, 11) * PRIME64_1 & MASK64;
+	}
+	h ^= h >> 33n;
+	h = h * PRIME64_2 & MASK64;
+	h ^= h >> 29n;
+	h = h * PRIME64_3 & MASK64;
+	h ^= h >> 32n;
+	return h & MASK64;
+}
+function bunHash(data) {
+	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;
+	for (const b of bytes) {
+		h ^= b;
+		h = Math.imul(h, 16777619) >>> 0;
+	}
+	return h >>> 0;
+}
+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);
+}
+function bunStringWidth(s) {
+	let width = 0;
+	for (const ch of s) {
+		const cp = ch.codePointAt(0);
+		width += isWideChar(cp) ? 2 : 1;
+	}
+	return width;
+}
+var GlobShim = class {
+	#re;
+	constructor(pattern) {
+		let src = "";
+		for (let i = 0; i < pattern.length; i++) {
+			const c = pattern[i];
+			if (c === "*") {
+				if (pattern[i + 1] === "*") {
+					src += ".*";
+					i++;
+				} else src += "[^/]*";
+			} else if (c === "?") src += "[^/]";
+			else src += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+		}
+		this.#re = new RegExp(`^${src}$`);
+	}
+	async *scan(opts = {}) {
+		const root = opts.cwd ?? process.cwd();
+		const onlyFiles = opts.onlyFiles ?? true;
+		for await (const abs of walkFiles(root, onlyFiles)) {
+			const rel = path.relative(root, abs).split(path.sep).join("/");
+			if (this.#re.test(rel)) yield opts.absolute ? abs : rel;
+		}
+	}
+	match(input) {
+		return this.#re.test(input);
+	}
+};
+async function* walkFiles(dir, onlyFiles) {
+	let entries;
+	try {
+		entries = await fsp.readdir(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const p = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (!onlyFiles) yield p;
+			yield* walkFiles(p, onlyFiles);
+		} else if (entry.isFile() || entry.isSymbolicLink()) yield p;
+	}
+}
+var CryptoHasherShim = class {
+	#hash;
+	constructor(algorithm) {
+		this.#hash = createHash(algorithm);
+	}
+	update(data) {
+		this.#hash.update(data);
+		return this;
+	}
+	digest(encoding) {
+		if (encoding === "buffer") return this.#hash.digest();
+		return this.#hash.digest(encoding);
+	}
+};
+function bunColor(color, format) {
+	const hex = /^#?([0-9a-f]{6})$/i.exec(color);
+	if (!hex) return "";
+	const r = parseInt(hex[1].slice(0, 2), 16);
+	const g = parseInt(hex[1].slice(2, 4), 16);
+	const b = parseInt(hex[1].slice(4, 6), 16);
+	if (format === "ansi16") return `\x1b[${(r + g + b) / 3 >= 128 ? 97 : 30}m`;
+	if (format === "ansi256") return `\x1b[38;5;${16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5)}m`;
+	return `\x1b[38;2;${r};${g};${b}m`;
+}
+let sharpLoaderPromise;
+async function loadSharp() {
+	if (!sharpLoaderPromise) sharpLoaderPromise = resolveSharp();
+	try {
+		return await sharpLoaderPromise;
+	} catch (error) {
+		sharpLoaderPromise = void 0;
+		throw error;
+	}
+}
+function normalizeSharp(mod) {
+	const candidate = mod?.default ?? mod;
+	const fn = candidate?.sharp ?? candidate;
+	return typeof fn === "function" ? fn : void 0;
+}
+async function resolveSharp() {
+	const errors = [];
+	try {
+		const sharp = normalizeSharp(await import("sharp"));
+		if (sharp) return sharp;
+		errors.push("import(\"sharp\"): no callable export");
+	} catch (error) {
+		errors.push(`import("sharp"): ${error.message.split("\n")[0]}`);
+	}
+	try {
+		const { createRequire } = await import("node:module");
+		const required = normalizeSharp(createRequire(import.meta.url)("sharp"));
+		if (required) return required;
+		errors.push("createRequire(\"sharp\"): no callable export");
+	} catch (error) {
+		errors.push(`createRequire("sharp"): ${error.message.split("\n")[0]}`);
+	}
+	try {
+		const { createRequire } = await import("node:module");
+		const { fileURLToPath } = await import("node:url");
+		const { existsSync } = await import("node:fs");
+		let dir = path.dirname(fileURLToPath(import.meta.url));
+		for (let depth = 0; depth < 10; depth++) {
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			if (existsSync(path.join(parent, "node_modules", "@deepseek-ai", "dsh", "node_modules", "sharp", "package.json"))) {
+				const sharp = normalizeSharp(createRequire(path.join(parent, "noop.js"))("sharp"));
+				if (sharp) return sharp;
+			}
+			dir = parent;
+		}
+	} catch {}
+	throw new Error(`DSH: Bun.Image 需要 sharp，但运行时解析失败（${errors.join("；")}）。sharp 应随宿主 @deepseek-ai/dsh（dsh-attachment-local）安装；图片缩放将按调用方的降级路径处理。`);
+}
+/** Map sharp's format vocabulary onto Bun.Image's (width/height/format[/hasAlpha]). */
+function mapImageMetadata(meta) {
+	const format = typeof meta.format === "string" ? meta.format : void 0;
+	return {
+		width: typeof meta.width === "number" ? meta.width : 0,
+		height: typeof meta.height === "number" ? meta.height : 0,
+		...format !== void 0 ? { format } : {},
+		...typeof meta.channels === "number" ? { hasAlpha: meta.channels === 2 || meta.channels === 4 } : {}
+	};
+}
+var BunImageShim = class BunImageShim {
+	#source;
+	#steps;
+	constructor(bytes, steps) {
+		this.#source = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;
+		this.#steps = steps ?? [];
+	}
+	#extend(step) {
+		return new BunImageShim(this.#source, [...this.#steps, step]);
+	}
+	async metadata() {
+		return mapImageMetadata(await (await loadSharp())(this.#source, { failOn: "error" }).metadata());
+	}
+	resize(widthOrOpts, height) {
+		if (typeof widthOrOpts === "object" && widthOrOpts !== null) return this.#extend({
+			op: "resize",
+			args: [widthOrOpts.width, widthOrOpts.height]
+		});
+		return this.#extend({
+			op: "resize",
+			args: [widthOrOpts, height]
+		});
+	}
+	/** Bun's resize() accepts { width, height, fit } — expose fit through to sharp. */
+	resizeWithFit(width, height, fit) {
+		return this.#extend({
+			op: "resize",
+			args: [
+				width,
+				height,
+				{ fit }
+			]
+		});
+	}
+	png() {
+		return this.#extend({
+			op: "png",
+			args: []
+		});
+	}
+	jpeg(opts) {
+		return this.#extend({
+			op: "jpeg",
+			args: [opts]
+		});
+	}
+	webp(opts) {
+		return this.#extend({
+			op: "webp",
+			args: [opts]
+		});
+	}
+	rotate() {
+		return this.#extend({
+			op: "rotate",
+			args: []
+		});
+	}
+	flip(flip) {
+		return this.#extend({
+			op: "flip",
+			args: [flip]
+		});
+	}
+	blur(radius) {
+		return this.#extend({
+			op: "blur",
+			args: [radius]
+		});
+	}
+	sharpen(radius) {
+		return this.#extend({
+			op: "sharpen",
+			args: [radius]
+		});
+	}
+	#build() {
+		return loadSharp().then((sharp) => {
+			let pipe = sharp(this.#source, { failOn: "error" });
+			for (const step of this.#steps) switch (step.op) {
+				case "resize": {
+					const [w, h, extra] = step.args;
+					pipe = pipe.resize(w ?? 0, h ?? 0, { fit: extra?.fit ?? "cover" });
+					break;
+				}
+				case "png":
+					pipe = pipe.png();
+					break;
+				case "jpeg":
+					pipe = pipe.jpeg(step.args[0] ?? void 0);
+					break;
+				case "webp": pipe = pipe.webp(step.args[0] ?? void 0);
+			}
+			return pipe.toBuffer();
+		});
+	}
+	async bytes() {
+		return this.#build();
+	}
+	async toBase64() {
+		return Buffer.from(await this.#build()).toString("base64");
+	}
+	async write(destPath) {
+		const data = await this.#build();
+		await fsp.writeFile(destPath, data);
+		return data.byteLength;
+	}
+};
+async function memberToBytes(content) {
+	if (typeof content === "string") return new TextEncoder().encode(content);
+	if (content instanceof Blob) return new Uint8Array(await content.arrayBuffer());
+	return content;
+}
+function encodeTarHeader(name, size) {
+	const buf = /* @__PURE__ */ new Uint8Array(512);
+	const enc = new TextEncoder();
+	const put = (offset, len, value) => {
+		buf.set(enc.encode(value).subarray(0, len), offset);
+	};
+	put(0, 100, name);
+	put(100, 8, "0000644\0");
+	put(108, 8, "0000000\0");
+	put(116, 8, "0000000\0");
+	put(124, 12, size.toString(8).padStart(11, "0") + "\0");
+	put(136, 12, "00000000000\0");
+	put(148, 8, "        ");
+	put(156, 1, "0");
+	put(257, 6, "ustar\0");
+	put(263, 2, "00");
+	let sum = 0;
+	for (const b of buf) sum += b;
+	const checksum = sum.toString(8).padStart(6, "0");
+	buf.set(enc.encode(checksum + "\0 "), 148);
+	return buf;
+}
+async function archiveWrite(destPath, record, opts) {
+	const chunks = [];
+	for (const [name, content] of Object.entries(record)) {
+		const data = await memberToBytes(content);
+		chunks.push(encodeTarHeader(name.replace(/\\/g, "/"), data.length), data);
+		const pad = data.length % 512;
+		if (pad !== 0) chunks.push(new Uint8Array(512 - pad));
+	}
+	chunks.push(/* @__PURE__ */ new Uint8Array(1024));
+	let buf = Buffer.concat(chunks.map((c) => Buffer.from(c.buffer, c.byteOffset, c.byteLength)));
+	if (opts?.compress === "gzip") buf = gzipSync(buf);
+	await fsp.mkdir(path.dirname(destPath), { recursive: true });
+	await fsp.writeFile(destPath, buf);
+}
+const ANSI_RE = /\x1b(?:\[[0-9;]*[A-Za-z]|\][^\x07]*(?:\x07|\x1b\\)|[()][0-9A-B]|[^\[\]()])/g;
+function bunStripANSI(text) {
+	return text.replace(ANSI_RE, "");
+}
+function installBunShim() {
+	patchBase64();
+	const g = globalThis;
+	if (g.Bun !== void 0) return;
+	g.Bun = {
+		file: (p) => new BunFileShim(p),
+		write: bunWrite,
+		env: process.env,
+		sleep: bunSleep,
+		hash: bunHash,
+		randomUUIDv7: bunRandomUUIDv7,
+		stringWidth: bunStringWidth,
+		Glob: GlobShim,
+		Archive: { write: archiveWrite },
+		FileSink: FileSinkShim,
+		Image: BunImageShim,
+		CryptoHasher: CryptoHasherShim,
+		color: bunColor,
+		stripANSI: bunStripANSI,
+		JSON,
+		JSON5,
+		Encoding: {},
+		native: void 0,
+		BunFile: BunFileShim,
+		version: "node-shim"
+	};
+	const bun = g.Bun;
+	bun.hash.xxHash64 = bunHashXxHash64;
+}
+//#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),
+	stringify: (v) => stringify(v)
+};
+/** Minimal Bun-shell result (pi-ai perplexity OAuth; never reached on non-macOS). */
+var BunShellResult = class {
+	get exitCode() {
+		return 1;
+	}
+	text() {
+		return "";
+	}
+	quiet() {
+		return this;
+	}
+	nothrow() {
+		return this;
+	}
+	cwd() {
+		return this;
+	}
+};
+/** Bun shell template tag (Bun `$`). Perplexity's macOS defaults read only. */
+function $(_strings, ..._expr) {
+	return new BunShellResult();
+}
+/** HTTP cookie (pi-ai OAuth flows). */
+var Cookie = class Cookie {
+	name;
+	value;
+	#expires;
+	constructor(name, value, expires) {
+		this.name = name;
+		this.value = value;
+		this.#expires = expires;
+	}
+	static parse(header) {
+		const segments = header.split(";");
+		const first = segments[0] ?? "";
+		const eq = first.indexOf("=");
+		const name = eq >= 0 ? first.slice(0, eq).trim() : first.trim();
+		const value = eq >= 0 ? first.slice(eq + 1).trim() : "";
+		let expires;
+		for (const segment of segments.slice(1)) {
+			const [key, val] = segment.trim().split("=");
+			if (key?.toLowerCase() === "expires") {
+				const t = Date.parse(val ?? "");
+				if (!Number.isNaN(t)) expires = new Date(t);
+			}
+		}
+		return new Cookie(name, value, expires);
+	}
+	isExpired() {
+		return this.#expires !== void 0 && this.#expires.getTime() < Date.now();
+	}
+};
+/** Ordered cookie jar (Bun CookieMap surface used by pi-ai OAuth). */
+var CookieMap = class {
+	#map = /* @__PURE__ */ new Map();
+	get size() {
+		return this.#map.size;
+	}
+	set(name, value) {
+		this.#map.set(name, value);
+	}
+	get(name) {
+		return this.#map.get(name);
+	}
+	delete(name) {
+		return this.#map.delete(name);
+	}
+	has(name) {
+		return this.#map.has(name);
+	}
+	clear() {
+		this.#map.clear();
+	}
+	*[Symbol.iterator]() {
+		yield* this.#map;
+	}
+};
+//#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
+/** 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. */
+var RotatingFileSink = class {
+	#directory;
+	#filenamePrefix;
+	#filenameSuffix;
+	#auditFile;
+	#maxBytes;
+	#maxFiles;
+	#files;
+	#activeDay;
+	#activeIndex = 0;
+	#activePath;
+	#activeBytes = 0;
+	#closed = false;
+	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"));
+		}
+	}
+	/** Append one already-formatted log record. */
+	write(line) {
+		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());
+		const record = `${line}${os.EOL}`;
+		fs.appendFileSync(activePath, record, "utf8");
+		this.#activeBytes += Buffer.byteLength(record);
+	}
+	/** Stop accepting records. Synchronous writes require no drain phase. */
+	close() {
+		this.#closed = true;
+	}
+	#localDay(date) {
+		return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+	}
+	#selectFile(day) {
+		if (day !== this.#activeDay) {
+			this.#activeDay = day;
+			this.#activeIndex = 0;
+			this.#setActivePath(day, 0);
+		}
+		while (this.#activeBytes > this.#maxBytes) {
+			this.#activeIndex++;
+			this.#setActivePath(day, this.#activeIndex);
+		}
+	}
+	#setActivePath(day, index) {
+		const suffix = index === 0 ? "" : `.${index}`;
+		this.#activePath = path.join(this.#directory, `${this.#filenamePrefix}.${day}.${this.#filenameSuffix}.log${suffix}`);
+		try {
+			this.#activeBytes = fs.statSync(this.#activePath).size;
+		} catch {
+			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
+		});
+		while (this.#files.length > this.#maxFiles) {
+			const removed = this.#files.shift();
+			if (!removed) break;
+			try {
+				fs.rmSync(removed.name, { 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
+			},
+			auditLog: this.#auditFile,
+			files: this.#files,
+			hashType: "sha256"
+		};
+		fs.writeFileSync(this.#auditFile, JSON.stringify(state, void 0, 4), "utf8");
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/logger.ts
+/**
+* Centralized logger for omp.
+*
+* Default: rotating `~/.omp/logs/omp.<DATE>.<PID>.log`, no console output (writing
+* to stdout/stderr would corrupt the TUI). Long-running headless services
+* (the auth broker, etc.) call {@link setTransports} to swap in a console
+* transport so a process supervisor (pm2, journald, k8s) captures the logs.
+*
+* Each entry includes `process.pid` so concurrent omp instances stay
+* traceable.
+*/
+const logSinks = /* @__PURE__ */ new Set();
+function emitToSinks(level, message, context) {
+	if (logSinks.size === 0) return;
+	const event = {
+		level,
+		message,
+		context,
+		timestamp: /* @__PURE__ */ new Date()
+	};
+	for (const sink of logSinks) try {
+		sink(event);
+	} catch {}
+}
+const PROCESS_LOG_PATTERN = /^omp\.(\d{4}-\d{2}-\d{2})\.(\d+)\.log(?:\.(\d+))?$/;
+const PROCESS_AUDIT_PATTERN = /^\.omp\.(\d+)-audit\.json$/;
+const RETAINED_STALE_LOGS_PER_PROCESS_DAY = 1;
+function processIsRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return !(error instanceof Error && "code" in error && (error.code === "ESRCH" || error.code === "EINVAL"));
+	}
+}
+/**
+* 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.
+*/
+function pruneStaleProcessLogs(dir) {
+	let entries;
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	const current = /* @__PURE__ */ new Date();
+	const currentDate = `${current.getFullYear()}-${String(current.getMonth() + 1).padStart(2, "0")}-` + String(current.getDate()).padStart(2, "0");
+	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 staleLogsByProcessDay = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!entry.isFile()) 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.join(dir, entry.name);
+		if (auditMatch) {
+			try {
+				fs.rmSync(entryPath, { force: true });
+			} catch {}
+			continue;
+		}
+		if (!logMatch?.[1]) continue;
+		if (logMatch[1] < cutoffDate || logMatch[1] > currentDate) {
+			try {
+				fs.rmSync(entryPath, { force: true });
+			} 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 {}
+	}
+	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 {
+			fs.rmSync(stale.path, { force: true });
+		} catch {}
+	}
+}
+/** Ensure a logs directory exists; return the resolved path. */
+function ensureDir(dir) {
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/**
+* JSON.stringify replacer that unwraps {@link Error} instances. Error's own
+* properties are non-enumerable, so a plain `JSON.stringify(err)` produces
+* `"{}"`. Without this, a context like `{ err }` lost every useful field and
+* forensic logs showed only an opaque empty object.
+*/
+function jsonReplacer(_key, value) {
+	if (value instanceof Error) {
+		const out = {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		const errAsRecord = value;
+		for (const k in errAsRecord) out[k] = errAsRecord[k];
+		if (value.cause !== void 0) out.cause = value.cause;
+		return out;
+	}
+	return value;
+}
+function padTimestampPart(value, width = 2) {
+	return String(value).padStart(width, "0");
+}
+function formatLocalTimestamp(date) {
+	const offsetMinutes = -date.getTimezoneOffset();
+	const absoluteOffset = Math.abs(offsetMinutes);
+	const offsetSign = offsetMinutes >= 0 ? "+" : "-";
+	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) {
+	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,
+		pid: process.pid,
+		message: info.message
+	};
+	for (const [key, value] of Object.entries(info)) if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = value;
+	return JSON.stringify(entry, jsonReplacer);
+}
+/** Build a rotating file sink with process-local rotation and shared retention. */
+function makeFileTransport(dir) {
+	const logsDir = ensureDir(dir ?? getLogsDir());
+	pruneStaleProcessLogs(logsDir);
+	return new RotatingFileSink({
+		directory: logsDir,
+		filenamePrefix: "omp",
+		filenameSuffix: String(process.pid),
+		maxBytes: 10485760,
+		maxFiles: 5,
+		auditFile: path.join(logsDir, `.omp.${process.pid}-audit.json`)
+	});
+}
+/**
+* Desired transport configuration, applied when local logging is initialized.
+* Default: file ON (TUI-safe), console OFF.
+*/
+let transportOpts = { file: true };
+/** Local transports, constructed lazily on first log emission. */
+let activeTransports;
+function buildTransports(opts) {
+	return {
+		file: opts.file ? makeFileTransport(typeof opts.file === "string" ? opts.file : void 0) : void 0,
+		console: opts.console === true
+	};
+}
+function getLocalTransports() {
+	activeTransports ??= buildTransports(transportOpts);
+	return activeTransports;
+}
+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}`);
+}
+/**
+* Log an error message.
+* @param message - The message to log.
+* @param context - The context to log.
+*/
+function error(message, context) {
+	try {
+		emitLocally("error", message, context);
+	} catch {}
+	emitToSinks("error", message, context);
+}
+/**
+* Log a warning message.
+* @param message - The message to log.
+* @param context - The context to log.
+*/
+function warn(message, context) {
+	try {
+		emitLocally("warn", message, context);
+	} catch {}
+	emitToSinks("warn", message, context);
+}
+/**
+* Log a debug message.
+* @param message - The message to log.
+* @param context - The context to log.
+*/
+function debug(message, context) {
+	try {
+		emitLocally("debug", message, context);
+	} catch {}
+	emitToSinks("debug", message, context);
+}
+/**
+* Streaming startup markers, enabled by `PI_DEBUG_STARTUP`. Unlike the
+* PI_TIMING tree (printed only after startup completes), these write one
+* synchronous stderr line as each phase begins/ends, so a hard hang still
+* shows the last phase that started. `fs.writeSync(2)` is used deliberately:
+* it cannot be reordered or buffered past a synchronous block of the event
+* loop (dlopen, sync fs on a dead mount, spawnSync).
+*/
+function startupMarker(text) {
+	if (!process.env.PI_DEBUG_STARTUP) return;
+	try {
+		fs.writeSync(2, `[startup] ${text}\n`);
+	} catch {}
+}
+new AsyncLocalStorage();
+function time(op, fn, ...args) {
+	if (fn === void 0) {
+		startupMarker(op);
+		return;
+	}
+	if (!process.env.PI_DEBUG_STARTUP) return fn(...args);
+	startupMarker(`${op}:start`);
+	const finish = (ok) => {
+		startupMarker(ok ? `${op}:done` : `${op}:fail`);
+	};
+	try {
+		const result = fn(...args);
+		if (isPromise(result)) return result.then((value) => {
+			finish(true);
+			return value;
+		}, (error) => {
+			finish(false);
+			throw error;
+		});
+		finish(true);
+		return result;
+	} catch (error) {
+		finish(false);
+		throw error;
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/frontmatter.ts
+function stripHtmlComments(content) {
+	return content.replace(/<!--[\s\S]*?-->/g, "");
+}
+/** Convert kebab-case to camelCase (e.g. "thinking-level" -> "thinkingLevel") */
+function kebabToCamel(key) {
+	if (!key.includes("-")) return key;
+	return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+/**
+* Recursively normalize object keys from kebab-case to camelCase — the
+* representation convention for frontmatter consumed inside this codebase.
+* Exported for loaders that parse with `rawKeys: true` to validate exact
+* spec-defined keys, then normalize for storage.
+*/
+function normalizeFrontmatterKeys(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) {
+		let changed = false;
+		const out = new Array(obj.length);
+		for (let i = 0; i < obj.length; i++) {
+			const v = obj[i];
+			const nv = normalizeFrontmatterKeys(v);
+			out[i] = nv;
+			if (nv !== v) changed = true;
+		}
+		return changed ? out : obj;
+	}
+	let changed = false;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const nk = key.includes("-") ? kebabToCamel(key) : key;
+		const nv = normalizeFrontmatterKeys(value);
+		result[nk] = nv;
+		if (nk !== key || nv !== value) changed = true;
+	}
+	return changed ? result : obj;
+}
+const PLAIN_SCALAR_KEY_VALUE = /^(\s*[A-Za-z_][\w-]*:\s+)(\S.*?)(\s*)$/;
+const FLOW_OR_EXPLICIT_VALUE_START = /* @__PURE__ */ new Set([
+	"\"",
+	"'",
+	"[",
+	"{",
+	"|",
+	">",
+	"!",
+	"&",
+	"*",
+	"#"
+]);
+function quoteAmbiguousPlainScalars(metadata) {
+	let changed = false;
+	const lines = metadata.split("\n").map((line) => {
+		const match = line.match(PLAIN_SCALAR_KEY_VALUE);
+		if (!match) return line;
+		const [, prefix, rawValue, suffix] = match;
+		const value = rawValue.trimEnd();
+		if (!value.includes(": ")) return line;
+		if (FLOW_OR_EXPLICIT_VALUE_START.has(value[0])) return line;
+		changed = true;
+		return `${prefix}${JSON.stringify(value)}${suffix}`;
+	});
+	return changed ? lines.join("\n") : void 0;
+}
+function parseYamlRecord(metadata, repairTabs) {
+	const loaded = YAML.parse(repairTabs ? metadata.replaceAll("	", "  ") : metadata);
+	if (loaded === null || loaded === void 0) return null;
+	if (typeof loaded !== "object" || Array.isArray(loaded)) return null;
+	return loaded;
+}
+var FrontmatterError = class extends Error {
+	source;
+	constructor(error, source) {
+		super(`Failed to parse YAML frontmatter (${source}): ${error.message}`, { cause: error });
+		this.source = source;
+		this.name = "FrontmatterError";
+	}
+	toString() {
+		const details = [this.message];
+		if (this.source !== void 0) details.push(`Source: ${JSON.stringify(this.source)}`);
+		if (this.cause && typeof this.cause === "object" && "stack" in this.cause && this.cause.stack) details.push(`Stack:\n${this.cause.stack}`);
+		else if (this.stack) details.push(`Stack:\n${this.stack}`);
+		return details.join("\n\n");
+	}
+};
+/**
+* Parse YAML frontmatter from markdown content
+* Returns { frontmatter, body } where body has frontmatter stripped
+*/
+function parseFrontmatter(content, options) {
+	const { location, source, fallback, normalize = true, level = "warn", repair = true, rawKeys = false } = options ?? {};
+	const finalizeKeys = (fm) => rawKeys ? fm : normalizeFrontmatterKeys(fm);
+	const loc = location ?? source;
+	const frontmatter = { ...fallback };
+	const newlineNormalized = normalize ? content.replace(/\r\n?/g, "\n") : content;
+	const normalized = normalize && repair ? stripHtmlComments(newlineNormalized) : newlineNormalized;
+	if (!normalized.startsWith("---")) return {
+		frontmatter,
+		body: normalized
+	};
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) return {
+		frontmatter,
+		body: normalized
+	};
+	const metadata = normalized.slice(4, endIndex);
+	const body = normalized.slice(endIndex + 4).trim();
+	try {
+		const loaded = parseYamlRecord(metadata, repair);
+		return {
+			frontmatter: finalizeKeys({
+				...frontmatter,
+				...loaded
+			}),
+			body
+		};
+	} catch (error) {
+		const quotedMetadata = repair ? quoteAmbiguousPlainScalars(metadata) : void 0;
+		if (quotedMetadata) try {
+			const loaded = parseYamlRecord(quotedMetadata, true);
+			return {
+				frontmatter: finalizeKeys({
+					...frontmatter,
+					...loaded
+				}),
+				body
+			};
+		} catch {}
+		const err = new FrontmatterError(error instanceof Error ? error : /* @__PURE__ */ new Error(`YAML: ${error}`), loc ?? `Inline '${truncate(content, 64)}'`);
+		if (level === "warn" || level === "fatal") warn("Failed to parse YAML frontmatter", { err: err.toString() });
+		if (level === "fatal") throw err;
+		for (const line of metadata.split("\n")) {
+			const match = line.match(/^([\w-]+):\s*(.*)$/);
+			if (!match) continue;
+			const raw = match[2].trim();
+			let value = raw;
+			if (raw.length > 0) try {
+				const parsed = YAML.parse(raw);
+				if (parsed !== null && typeof parsed !== "object") value = parsed;
+				else if (Array.isArray(parsed)) value = parsed;
+			} catch {}
+			frontmatter[match[1]] = value;
+		}
+		return {
+			frontmatter: finalizeKeys(frontmatter),
+			body
+		};
+	}
+}
+//#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 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;
+}
+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`. */
+const KEYWORDS = [
+	["true", true],
+	["false", false],
+	["null", null],
+	["True", true],
+	["False", false],
+	["None", null]
+];
+/**
+* JS-only atoms never recovered as bareword strings — a tool must not execute
+* with a non-finite or undefined argument masquerading as a string.
+*/
+const NON_RECOVERABLE_BAREWORDS = {
+	NaN: true,
+	Infinity: true,
+	"-Infinity": true,
+	"+Infinity": true,
+	undefined: true
+};
+/**
+* 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.
+*/
+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++;
+				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++;
+				continue;
+			}
+			if (d === "}") {
+				this.#i++;
+				return out;
+			}
+			if (this.#partial) return out;
+			throw new SyntaxError("Expected ',' or '}' in object");
+		}
+	}
+	#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;
+		let out = "";
+		let runStart = i;
+		while (i < n) {
+			const cc = s.charCodeAt(i);
+			if (cc !== BACKSLASH && cc !== quote) {
+				i++;
+				continue;
+			}
+			if (cc === quote) {
+				if (!(quote === SQUOTE || this.#partial) || this.#closesString(i + 1)) {
+					out += s.slice(runStart, i);
+					this.#i = i + 1;
+					return out;
+				}
+				i++;
+				continue;
+			}
+			out += s.slice(runStart, i);
+			i++;
+			if (i >= n) {
+				out += "\\";
+				runStart = i;
+				break;
+			}
+			switch (s.charCodeAt(i)) {
+				case QUOTE:
+					out += "\"";
+					break;
+				case SQUOTE:
+					out += "'";
+					break;
+				case BACKSLASH:
+					out += "\\";
+					break;
+				case 47:
+					out += "/";
+					break;
+				case 98:
+					out += "\b";
+					break;
+				case 102:
+					out += "\f";
+					break;
+				case 110:
+					out += "\n";
+					break;
+				case 114:
+					out += "\r";
+					break;
+				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));
+						i += 4;
+					} else out += "\\u";
+					break;
+				}
+				default: out += `\\${s[i]}`;
+			}
+			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;
+	}
+	#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;
+			return value;
+		}
+		if (this.#partial) {
+			this.#i = this.#n;
+			return INCOMPLETE;
+		}
+		if (allowBareword) return this.#bareword();
+		throw new SyntaxError(`Unexpected token at position ${this.#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:
+	* - 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;
+	* - is a non-finite atom ({@link NON_RECOVERABLE_BAREWORDS}).
+	*/
+	#bareword() {
+		const s = this.#s;
+		const start = this.#i;
+		let i = start;
+		while (i < this.#n) {
+			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}`);
+			i++;
+		}
+		if (i >= this.#n) throw new SyntaxError(`Unexpected token at position ${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;
+		return word;
+	}
+};
+/**
+* Final-parse a JSON value, repairing the common LLM malformations
+* ({@link RelaxedJson}). Tries strict `JSON.parse` first (fast path, exact JSON
+* semantics), then the relaxed parser. Throws when the input is unrepairable,
+* truncated, or carries trailing garbage — so callers can skip a bad tool call
+* rather than execute a half-formed one.
+*/
+function parseJsonWithRepair(json) {
+	try {
+		return JSON.parse(json);
+	} catch {
+		return new RelaxedJson(json, false).parse();
+	}
+}
+/**
+* Parse possibly-incomplete JSON during streaming. Always returns a value, never
+* throws: `{}` for empty/whitespace/unrecoverable buffers, and an auto-closed
+* best-effort object for truncated ones.
+*/
+function parseStreamingJson(partialJson) {
+	const trimmed = partialJson?.trimStart();
+	if (!trimmed) return {};
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		try {
+			return new RelaxedJson(trimmed, true).parse() ?? {};
+		} catch {
+			return {};
+		}
+	}
+}
+/**
+* Throttled variant of {@link parseStreamingJson} for the per-delta hot path.
+*
+* Tool calls arrive as a long sequence of small deltas — calling
+* `parseStreamingJson(buffer)` on every delta re-parses the entire buffer
+* each time, giving O(N²) work in the total buffer length. A fixed re-parse
+* floor alone does NOT fix this: with `minGrowthBytes` constant, a buffer of
+* length N is parsed N/minGrowthBytes times at an average cost of N/2, which
+* is still O(N²) (the constant just shrinks). Long `write` payloads — where
+* the buffer is the whole file — made this the dominant main-thread stall
+* during streaming.
+*
+* Instead the gate scales geometrically: once the buffer is large, a re-parse
+* requires growth proportional to the current length (`len / 32`, floored at
+* `minGrowthBytes`). Parse points then form a geometric progression, so a
+* buffer of length N is parsed O(log N) times for O(N log N) total work,
+* while small buffers keep the snappy fixed-cadence updates.
+*
+* Each provider tracks the last parsed length on its tool-call block, so the
+* final `toolcall_end` parse (which providers already perform unconditionally)
+* is the authoritative full parse — the throttle only delays mid-stream UI
+* updates, by at most ~3% of the accumulated content for large buffers.
+*
+* @returns the parsed object plus the new `parsedLen` to persist; or `null`
+*          when the buffer has not grown enough to warrant a re-parse.
+*/
+function parseStreamingJsonThrottled(partialJson, lastParsedLen, minGrowthBytes = 256) {
+	const len = partialJson?.length ?? 0;
+	if (len === 0) return null;
+	const growth = Math.max(minGrowthBytes, len >> 5);
+	if (lastParsedLen > 0 && len - lastParsedLen < growth) return null;
+	return {
+		value: parseStreamingJson(partialJson),
+		parsedLen: len
+	};
+}
+/** What the strict-prefix scanner expects at the current position. */
+var JsonExpect = /* @__PURE__ */ function(JsonExpect) {
+	JsonExpect[JsonExpect["Value"] = 0] = "Value";
+	JsonExpect[JsonExpect["ObjKeyOrEnd"] = 1] = "ObjKeyOrEnd";
+	JsonExpect[JsonExpect["ObjKey"] = 2] = "ObjKey";
+	JsonExpect[JsonExpect["ObjColon"] = 3] = "ObjColon";
+	JsonExpect[JsonExpect["ObjCommaOrEnd"] = 4] = "ObjCommaOrEnd";
+	JsonExpect[JsonExpect["ArrValueOrEnd"] = 5] = "ArrValueOrEnd";
+	JsonExpect[JsonExpect["ArrCommaOrEnd"] = 6] = "ArrCommaOrEnd";
+	JsonExpect[JsonExpect["End"] = 7] = "End";
+	return JsonExpect;
+}(JsonExpect || {});
+/**
+* Classify `text` as a strict-JSON value, prefix, or dead end.
+*
+* Providers use this to disambiguate identifierless streaming tool-call
+* deltas: a chunk starting with `{` is a *new* sibling call only if the
+* current call's argument buffer cannot absorb it — the buffer is already a
+* complete value, already unsalvageable (lossy hosts abandon buffers
+* mid-string, leaving raw control characters strict JSON forbids), or the
+* concatenation would break it. Unlike {@link parseStreamingJson} this is
+* deliberately strict: forgiving repair would mask exactly the corruption
+* signals the caller needs.
+*
+* A top-level number at end-of-input classifies as `"complete"` even though
+* more digits could extend it; tool-argument buffers are always objects, so
+* the ambiguity is immaterial here.
+*/
+function classifyJsonPrefix(text) {
+	const n = text.length;
+	let i = 0;
+	const stack = [];
+	let expect = 0;
+	/** Consume a string starting at the opening quote. 1 = ok, 0 = prefix, -1 = invalid. */
+	const scanString = () => {
+		i++;
+		while (i < n) {
+			const c = text.charCodeAt(i);
+			if (c === QUOTE) {
+				i++;
+				return 1;
+			}
+			if (c === BACKSLASH) {
+				i++;
+				if (i >= n) return 0;
+				const e = text.charCodeAt(i);
+				if (e >= 128 || !VALID_ESCAPE_CHAR[e]) return -1;
+				i++;
+				if (e === U) for (let k = 0; k < 4; k++, i++) {
+					if (i >= n) return 0;
+					if (!isHexDigit(text.charCodeAt(i))) return -1;
+				}
+				continue;
+			}
+			if (c < 32) return -1;
+			i++;
+		}
+		return 0;
+	};
+	/** Consume a number starting at `-` or a digit. 1 = token done, 0 = prefix, -1 = invalid. */
+	const scanNumber = () => {
+		if (text.charCodeAt(i) === 45) i++;
+		if (i >= n) return 0;
+		let c = text.charCodeAt(i);
+		if (c === 48) i++;
+		else if (c >= 49 && c <= 57) while (i < n && text.charCodeAt(i) >= 48 && text.charCodeAt(i) <= 57) i++;
+		else return -1;
+		if (i < n && text.charCodeAt(i) === 46) {
+			i++;
+			if (i >= n) return 0;
+			if (text.charCodeAt(i) < 48 || text.charCodeAt(i) > 57) return -1;
+			while (i < n && text.charCodeAt(i) >= 48 && text.charCodeAt(i) <= 57) i++;
+		}
+		c = i < n ? text.charCodeAt(i) : 0;
+		if (c === 101 || c === 69) {
+			i++;
+			if (i < n && (text.charCodeAt(i) === 43 || text.charCodeAt(i) === 45)) i++;
+			if (i >= n) return 0;
+			if (text.charCodeAt(i) < 48 || text.charCodeAt(i) > 57) return -1;
+			while (i < n && text.charCodeAt(i) >= 48 && text.charCodeAt(i) <= 57) i++;
+		}
+		return 1;
+	};
+	/** Consume `true`/`false`/`null`. 1 = done, 0 = prefix, -1 = invalid. */
+	const scanKeyword = () => {
+		for (const word of [
+			"true",
+			"false",
+			"null"
+		]) {
+			if (word.charCodeAt(0) !== text.charCodeAt(i)) continue;
+			const available = Math.min(word.length, n - i);
+			if (!word.startsWith(text.slice(i, i + available))) return -1;
+			i += available;
+			return available === word.length ? 1 : 0;
+		}
+		return -1;
+	};
+	/** A value just finished; the next expectation follows from the stack. */
+	const valueDone = () => stack.length === 0 ? 7 : stack[stack.length - 1] ? 4 : 6;
+	while (i < n) {
+		const c = text.charCodeAt(i);
+		if (isWhitespace(c)) {
+			i++;
+			continue;
+		}
+		switch (expect) {
+			case 0:
+			case 5: {
+				if (c === 93 && expect === 5) {
+					stack.pop();
+					i++;
+					expect = valueDone();
+					break;
+				}
+				if (c === 123) {
+					stack.push(true);
+					i++;
+					expect = 1;
+					break;
+				}
+				if (c === 91) {
+					stack.push(false);
+					i++;
+					expect = 5;
+					break;
+				}
+				let r;
+				if (c === QUOTE) 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";
+				if (r === -1) return "invalid";
+				if (r === 0) return "prefix";
+				expect = valueDone();
+				break;
+			}
+			case 1:
+			case 2: {
+				if (c === 125 && expect === 1) {
+					stack.pop();
+					i++;
+					expect = valueDone();
+					break;
+				}
+				if (c !== QUOTE) return "invalid";
+				const r = scanString();
+				if (r === -1) return "invalid";
+				if (r === 0) return "prefix";
+				expect = 3;
+				break;
+			}
+			case 3:
+				if (c !== 58) return "invalid";
+				i++;
+				expect = 0;
+				break;
+			case 4:
+				if (c === 125) {
+					stack.pop();
+					i++;
+					expect = valueDone();
+					break;
+				}
+				if (c !== 44) return "invalid";
+				i++;
+				expect = 2;
+				break;
+			case 6:
+				if (c === 93) {
+					stack.pop();
+					i++;
+					expect = valueDone();
+					break;
+				}
+				if (c !== 44) return "invalid";
+				i++;
+				expect = 0;
+				break;
+			case 7: return "invalid";
+		}
+	}
+	return expect === 7 ? "complete" : "prefix";
+}
+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
+const DEFAULT_IMAGE_METADATA_HEADER_BYTES = 262144;
+const PNG_MAGIC = Buffer.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+const JPEG_MAGIC = Buffer.from([
+	255,
+	216,
+	255
+]);
+const WEBP_RIFF_MAGIC = Buffer.from([
+	82,
+	73,
+	70,
+	70
+]);
+const WEBP_MAGIC = Buffer.from([
+	87,
+	69,
+	66,
+	80
+]);
+const PNG_IHDR = Buffer.from("IHDR");
+const GIF87A = Buffer.from("GIF87a");
+const GIF89A = Buffer.from("GIF89a");
+const WEBP_VP8X = Buffer.from("VP8X");
+const WEBP_VP8L = Buffer.from("VP8L");
+const WEBP_VP8 = Buffer.from("VP8 ");
+function magicEquals(header, offset, magic) {
+	if (header.length < offset + magic.length) return false;
+	return magic.equals(header.subarray(offset, offset + magic.length));
+}
+function parsePngMetadata(header) {
+	if (!magicEquals(header, 0, PNG_MAGIC)) return null;
+	if (!magicEquals(header, 12, PNG_IHDR)) return { mimeType: "image/png" };
+	if (header.length < 26) return { mimeType: "image/png" };
+	const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+	const width = view.getUint32(16, false);
+	const height = view.getUint32(20, false);
+	const colorType = view.getUint8(25);
+	if (colorType === 0) return {
+		mimeType: "image/png",
+		width,
+		height,
+		channels: 1,
+		hasAlpha: false
+	};
+	if (colorType === 2) return {
+		mimeType: "image/png",
+		width,
+		height,
+		channels: 3,
+		hasAlpha: false
+	};
+	if (colorType === 3) return {
+		mimeType: "image/png",
+		width,
+		height,
+		channels: 3
+	};
+	if (colorType === 4) return {
+		mimeType: "image/png",
+		width,
+		height,
+		channels: 2,
+		hasAlpha: true
+	};
+	if (colorType === 6) return {
+		mimeType: "image/png",
+		width,
+		height,
+		channels: 4,
+		hasAlpha: true
+	};
+	return {
+		mimeType: "image/png",
+		width,
+		height
+	};
+}
+function parseJpegMetadata(header) {
+	if (!magicEquals(header, 0, JPEG_MAGIC)) return null;
+	if (header.length < 4) return { mimeType: "image/jpeg" };
+	const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+	let offset = 2;
+	while (offset + 9 < header.length) {
+		if (header[offset] !== 255) {
+			offset += 1;
+			continue;
+		}
+		let markerOffset = offset + 1;
+		while (markerOffset < header.length && header[markerOffset] === 255) markerOffset += 1;
+		if (markerOffset >= header.length) break;
+		const marker = header[markerOffset];
+		const segmentOffset = markerOffset + 1;
+		if (marker === 216 || marker === 217 || marker === 1 || marker >= 208 && marker <= 215) {
+			offset = segmentOffset;
+			continue;
+		}
+		if (segmentOffset + 1 >= header.length) break;
+		const segmentLength = view.getUint16(segmentOffset, false);
+		if (segmentLength < 2) break;
+		if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+			if (segmentOffset + 7 >= header.length) break;
+			const height = view.getUint16(segmentOffset + 3, false);
+			const width = view.getUint16(segmentOffset + 5, false);
+			const channels = header[segmentOffset + 7];
+			return {
+				mimeType: "image/jpeg",
+				width,
+				height,
+				channels: Number.isFinite(channels) ? channels : void 0,
+				hasAlpha: false
+			};
+		}
+		offset = segmentOffset + segmentLength;
+	}
+	return { mimeType: "image/jpeg" };
+}
+function parseGifMetadata(header) {
+	if (!magicEquals(header, 0, GIF87A) && !magicEquals(header, 0, GIF89A)) return null;
+	if (header.length < 10) return { mimeType: "image/gif" };
+	const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+	return {
+		mimeType: "image/gif",
+		width: view.getUint16(6, true),
+		height: view.getUint16(8, true),
+		channels: 3
+	};
+}
+function parseWebpMetadata(header) {
+	if (!magicEquals(header, 0, WEBP_RIFF_MAGIC)) return null;
+	if (!magicEquals(header, 8, WEBP_MAGIC)) return null;
+	if (header.length < 30) return { mimeType: "image/webp" };
+	if (magicEquals(header, 12, WEBP_VP8X)) {
+		const hasAlpha = (header[20] & 16) !== 0;
+		return {
+			mimeType: "image/webp",
+			width: (header[24] | header[25] << 8 | header[26] << 16) + 1,
+			height: (header[27] | header[28] << 8 | header[29] << 16) + 1,
+			channels: hasAlpha ? 4 : 3,
+			hasAlpha
+		};
+	}
+	const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+	if (magicEquals(header, 12, WEBP_VP8L)) {
+		if (header.length < 25) return { mimeType: "image/webp" };
+		const bits = view.getUint32(21, true);
+		const width = (bits & 16383) + 1;
+		const height = (bits >> 14 & 16383) + 1;
+		const hasAlpha = (bits >> 28 & 1) === 1;
+		return {
+			mimeType: "image/webp",
+			width,
+			height,
+			channels: hasAlpha ? 4 : 3,
+			hasAlpha
+		};
+	}
+	if (magicEquals(header, 12, WEBP_VP8)) return {
+		mimeType: "image/webp",
+		width: view.getUint16(26, true) & 16383,
+		height: view.getUint16(28, true) & 16383,
+		channels: 3,
+		hasAlpha: false
+	};
+	return { mimeType: "image/webp" };
+}
+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@17.3.5/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.
+*
+* 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.
+*/
+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 {}
+}
+const callbackList = [];
+let cleanupStage = "idle";
+const CLEANUP_DEADLINE_MS = 1e4;
+/**
+* Symbol stamped by the extension-load guard onto the throwing replacement it
+* installs over `process.exit` / `process.reallyExit`, carrying the native
+* primitive that replacement shadows.
+*
+* Host-owned shutdown ({@link exitProcess}) reads through it so a signal that
+* lands while the guard is active still terminates the process (#6488), while
+* a signal that lands after the guard has restored the native exit also
+* terminates cleanly (#7393). `Symbol.for` so it survives duplicate module
+* instances across bundles/realms.
+*/
+const NATIVE_PROCESS_EXIT = Symbol.for("omp.postmortem.nativeProcessExit");
+/**
+* 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
+* load: the extension/hook loader's `withHostGuard` transiently swaps
+* `process.reallyExit`/`process.exit` for a stub that throws
+* `ExtensionExitError`, and the shipped bundle defers this module's evaluation
+* until first access — which can land inside that guard window, so binding at
+* 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.
+*/
+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);
+}
+let cleanupPromise;
+const fatalRecoveryHintProviders = /* @__PURE__ */ new Set();
+/**
+* Internal: runs all registered cleanup callbacks for the given reason.
+* Ensures each callback is invoked at most once. Handles errors and prevents reentrancy.
+*
+* Returns a Promise that settles after all cleanups complete or error out.
+*/
+function runCleanup(reason) {
+	switch (cleanupStage) {
+		case "idle":
+			cleanupStage = "running";
+			break;
+		case "running": return cleanupPromise ?? Promise.resolve();
+		case "complete": return Promise.resolve();
+	}
+	const promises = callbackList.toReversed().map((callback) => {
+		return Promise.try(() => callback(reason));
+	});
+	const cleanupSettled = Promise.allSettled(promises).then((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", {
+				err,
+				stack: err.stack
+			});
+		}
+		cleanupStage = "complete";
+	});
+	const deadline = Promise.withResolvers();
+	const deadlineTimer = setTimeout(() => {
+		error("Cleanup deadline exceeded; proceeding with exit", { reason });
+		cleanupStage = "complete";
+		deadline.resolve();
+	}, CLEANUP_DEADLINE_MS);
+	cleanupPromise = Promise.race([cleanupSettled, deadline.promise]).finally(() => {
+		clearTimeout(deadlineTimer);
+	});
+	return cleanupPromise;
+}
+let inspectorOpened = false;
+/**
+* Classify EPIPE errors from worker IPC and stdio without treating unrelated
+* broken pipes as globally recoverable.
+*/
+function classifyBrokenPipe(err) {
+	if (!("code" in err) || err.code !== "EPIPE" || !("syscall" in err)) return void 0;
+	if (err.syscall === "send") return "ipc-send";
+	if (err.syscall === "write") return "stdio-write";
+}
+const EXPECTED_CLEANUP = Symbol.for("omp.expectedCleanupError");
+/**
+* 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`.
+*/
+function isExpectedCleanupError(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;
+	}
+	return false;
+}
+/** Interceptors consulted by the global `unhandledRejection` handler before the fatal path. */
+const rejectionInterceptors = /* @__PURE__ */ new Set();
+function escapeFatalHintText(value) {
+	return value.replace(/[\u0000-\u001f\u007f-\u009f]/gu, (char) => {
+		return `\\u${(char.codePointAt(0) ?? 0).toString(16).padStart(4, "0")}`;
+	});
+}
+function formatFatalRecoveryHints() {
+	const lines = [];
+	const seenCommands = /* @__PURE__ */ new Set();
+	for (const provider of fatalRecoveryHintProviders) try {
+		const hint = provider();
+		if (!hint?.command || seenCommands.has(hint.command)) continue;
+		seenCommands.add(hint.command);
+		lines.push(`  ${escapeFatalHintText(hint.label)}: ${escapeFatalHintText(hint.command)}`);
+	} catch (err) {
+		warn("Fatal recovery hint provider failed", { err });
+	}
+	return lines.length > 0 ? `\n[Recovery]\n${lines.join("\n")}\n` : "";
+}
+function formatFatalError(label, err) {
+	const name = err.name || "Error";
+	const message = err.message || "(no message)";
+	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) {
+	const forcedExit = setTimeout(() => exitProcess(1), CLEANUP_DEADLINE_MS);
+	try {
+		restoreTerminalStderr();
+		try {
+			fs.writeSync(2, `${formatFatalError(label, err)}${formatFatalRecoveryHints()}`);
+		} catch {}
+		error(logMessage, { err });
+		await runCleanup(reason);
+	} finally {
+		clearTimeout(forcedExit);
+		exitProcess(1);
+	}
+}
+if (isMainThread) process.on("SIGINT", async () => {
+	await runCleanup("sigint");
+	exitProcess(130);
+}).on("SIGUSR1", () => {
+	if (inspectorOpened) return;
+	inspectorOpened = true;
+	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 });
+		return;
+	}
+	await exitAfterFatal("Uncaught Exception", "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 (isExpectedCleanupError(reason)) {
+		warn("Ignoring expected cleanup rejection", { err });
+		return;
+	}
+	for (const interceptor of rejectionInterceptors) try {
+		if (interceptor(reason)) return;
+	} catch (interceptorErr) {
+		warn("Unhandled-rejection interceptor threw; continuing with fatal path", { err: interceptorErr });
+	}
+	await exitAfterFatal("Unhandled Rejection", "Unhandled rejection", err, "unhandled_rejection");
+}).on("exit", async () => {
+	runCleanup("exit");
+}).on("SIGTERM", async () => {
+	await runCleanup("sigterm");
+	exitProcess(143);
+}).on("SIGHUP", async () => {
+	await runCleanup("sighup");
+	exitProcess(129);
+});
+else process.on("exit", () => {
+	runCleanup("exit");
+});
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/which.ts
+const XCODE_BINS = /* @__PURE__ */ new Set([
+	"clang",
+	"clang++",
+	"gcc",
+	"g++",
+	"cc",
+	"c++",
+	"cpp",
+	"c89",
+	"c99",
+	"swift",
+	"swiftc",
+	"swift-frontend",
+	"clangd",
+	"sourcekit-lsp",
+	"ld",
+	"ld-classic",
+	"ar",
+	"ranlib",
+	"libtool",
+	"as",
+	"lipo",
+	"install_name_tool",
+	"codesign_allocate",
+	"make",
+	"gnumake",
+	"m4",
+	"flex",
+	"bison",
+	"yacc",
+	"lex",
+	"git",
+	"git-receive-pack",
+	"git-upload-pack",
+	"git-upload-archive",
+	"git-shell",
+	"scalar",
+	"lldb",
+	"lldb-dap",
+	"nm",
+	"otool",
+	"objdump",
+	"strings",
+	"strip",
+	"size",
+	"dsymutil",
+	"dwarfdump",
+	"lipo",
+	"vtool",
+	"clang-format",
+	"swift-format"
+]);
+const XCODE_BIN_PREFIXES = [
+	"python",
+	"pip",
+	"pydoc",
+	"2to3"
+];
+function isXcodeBin(command) {
+	if (XCODE_BINS.has(command)) return true;
+	for (const prefix of XCODE_BIN_PREFIXES) if (command.startsWith(prefix)) return true;
+	return false;
+}
+function getDeveloperDirs() {
+	const envDir = process.env.DEVELOPER_DIR;
+	if (envDir && fs.existsSync(envDir)) return envDir;
+	try {
+		return fs.readlinkSync("/var/db/xcode_select_link");
+	} catch {}
+	for (const candidate of ["/Applications/Xcode.app/Contents/Developer", "/Library/Developer/CommandLineTools"]) if (fs.existsSync(candidate)) return candidate;
+	return null;
+}
+let macosToolPaths;
+function getMacosToolPaths() {
+	if (macosToolPaths) return macosToolPaths;
+	const paths = ["/Library/Developer/CommandLineTools/usr/bin"];
+	const devDir = getDeveloperDirs();
+	if (devDir) paths.push(path.join(devDir, "usr/bin"), path.join(devDir, "Toolchains/XcodeDefault.xctoolchain/usr/bin"));
+	macosToolPaths = /* @__PURE__ */ new Map();
+	for (const dir of Array.from(new Set(paths))) try {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) if (entry.isFile() || entry.isSymbolicLink()) {
+			if (macosToolPaths.has(entry.name)) continue;
+			macosToolPaths.set(entry.name, path.join(dir, entry.name));
+		}
+	} catch {}
+	return macosToolPaths;
+}
+const toolCache = /* @__PURE__ */ new Map();
+function darwinWhich(command, options) {
+	const regular = Bun.which(command, options);
+	if (regular) return regular;
+	if (isXcodeBin(command)) return getMacosToolPaths().get(command) ?? null;
+	return null;
+}
+const whichFresh = os.platform() === "darwin" ? darwinWhich : Bun.which;
+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;
+}
+/**
+* Locate binary on PATH (with flexible caching).
+*
+* @param command - Binary name to resolve
+* @param options - Bun.WhichOptions plus `cache` control
+* @returns Filesystem path if found, else null
+*/
+function $which(command, options) {
+	const cachePolicy = options?.cache ?? 0;
+	const lookupOptions = options?.PATH !== void 0 || process.env.PATH === void 0 ? options : {
+		...options,
+		PATH: process.env.PATH
+	};
+	let key;
+	if (cachePolicy !== 1) {
+		key = cacheKey$1(command, lookupOptions);
+		if (cachePolicy !== 2) {
+			const cached = toolCache.get(key);
+			if (cached !== void 0) return cached;
+		}
+	}
+	const result = whichFresh(command, lookupOptions);
+	if (key != null && cachePolicy !== 3) toolCache.set(key, result);
+	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
+/** A string that bypasses HTML escaping when interpolated. */
+var SafeString = class {
+	#value;
+	constructor(value) {
+		this.#value = String(value);
+	}
+	/** Return the unescaped string value. */
+	toString() {
+		return this.#value;
+	}
+	/** Return the unescaped primitive value. */
+	toHTML() {
+		return this.#value;
+	}
+};
+const helpers = /* @__PURE__ */ new Map();
+const partials = /* @__PURE__ */ new Map();
+const BLOCK_TAG = /^\s*\{\{(?:#|\/|\^|else\b|!)/;
+function stripStandalone(source) {
+	const lines = source.split(/(?<=\n)/);
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index];
+		const body = line.endsWith("\n") ? line.slice(0, -1).replace(/\r$/, "") : line;
+		if (/^\s*\{\{!--/.test(body) && !body.includes("--}}")) {
+			for (let end = index + 1; end < lines.length; end++) {
+				const endLine = lines[end].endsWith("\n") ? lines[end].slice(0, -1).replace(/\r$/, "") : lines[end];
+				const close = endLine.indexOf("--}}");
+				if (close < 0) continue;
+				if (/^\s*$/.test(endLine.slice(close + 4))) {
+					for (let commentLine = index; commentLine <= end; commentLine++) lines[commentLine] = "";
+					index = end;
+				}
+				break;
+			}
+			continue;
+		}
+		if (BLOCK_TAG.test(body) && /^\s*\{\{(?:#|\/|\^|else\b|!)[^{}]*\}\}\s*$/.test(body)) lines[index] = body.trim();
+	}
+	return lines.join("");
+}
+function tokenizeExpression(source) {
+	const tokens = [];
+	let start = -1;
+	let quote = "";
+	let depth = 0;
+	let bracketDepth = 0;
+	for (let index = 0; index < source.length; index++) {
+		const char = source[index];
+		if (quote) {
+			if (char === "\\" && index + 1 < source.length) index++;
+			else if (char === quote) quote = "";
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			if (start < 0) start = index;
+			quote = char;
+			continue;
+		}
+		if (char === "(") {
+			if (start < 0) start = index;
+			depth++;
+			continue;
+		}
+		if (char === ")") {
+			depth--;
+			continue;
+		}
+		if (char === "[") {
+			if (start < 0) start = index;
+			bracketDepth++;
+			continue;
+		}
+		if (char === "]") {
+			bracketDepth--;
+			continue;
+		}
+		if (/\s/.test(char) && depth === 0 && bracketDepth === 0) {
+			if (start >= 0) tokens.push(source.slice(start, index));
+			start = -1;
+		} else if (start < 0) start = index;
+	}
+	if (start >= 0) tokens.push(source.slice(start));
+	return tokens;
+}
+function parseString(token) {
+	const quote = token[0];
+	let result = "";
+	for (let index = 1; index < token.length - 1; index++) {
+		const char = token[index];
+		if (char === "\\" && index + 1 < token.length - 1) {
+			const next = token[++index];
+			result += next === quote || next === "\\" ? next : `\\${next}`;
+		} else result += char;
+	}
+	return result;
+}
+function parseAtom(token) {
+	if (token.startsWith("(") && token.endsWith(")")) return parseCall(token.slice(1, -1));
+	if (token.startsWith("\"") && token.endsWith("\"") || token.startsWith("'") && token.endsWith("'")) return {
+		kind: "literal",
+		value: parseString(token)
+	};
+	if (token === "true" || token === "false") return {
+		kind: "literal",
+		value: token === "true"
+	};
+	if (token === "null") return {
+		kind: "literal",
+		value: null
+	};
+	if (token === "undefined") return {
+		kind: "literal",
+		value: void 0
+	};
+	if (/^-?(?:\d+\.?\d*|\.\d+)$/.test(token)) return {
+		kind: "literal",
+		value: Number(token)
+	};
+	return {
+		kind: "path",
+		value: token
+	};
+}
+function hashSeparator(token) {
+	let quote = "";
+	let depth = 0;
+	for (let index = 0; index < token.length; index++) {
+		const char = token[index];
+		if (quote) {
+			if (char === "\\") index++;
+			else if (char === quote) quote = "";
+		} else if (char === "\"" || char === "'") quote = char;
+		else if (char === "(") depth++;
+		else if (char === ")") depth--;
+		else if (char === "=" && depth === 0) return index;
+	}
+	return -1;
+}
+function parseCall(source) {
+	const tokens = tokenizeExpression(source.trim());
+	const name = tokens.shift() ?? "";
+	const args = [];
+	const hash = {};
+	for (const token of tokens) {
+		const separator = hashSeparator(token);
+		if (separator > 0) hash[token.slice(0, separator)] = parseAtom(token.slice(separator + 1));
+		else args.push(parseAtom(token));
+	}
+	return {
+		kind: "call",
+		name,
+		args,
+		hash
+	};
+}
+function findTagEnd(source, start, triple) {
+	const close = triple ? "}}}" : "}}";
+	let quote = "";
+	let depth = 0;
+	for (let index = start; index <= source.length - close.length; index++) {
+		const char = source[index];
+		if (quote) {
+			if (char === "\\") index++;
+			else if (char === quote) quote = "";
+			continue;
+		}
+		if (char === "\"" || char === "'") quote = char;
+		else if (char === "(") depth++;
+		else if (char === ")") depth--;
+		else if (depth === 0 && source.startsWith(close, index)) return index;
+	}
+	throw new Error("Parse error: unclosed template expression");
+}
+function parseTemplate(source) {
+	const root = [];
+	const stack = [];
+	let target = root;
+	let cursor = 0;
+	while (cursor < source.length) {
+		const open = source.indexOf("{{", cursor);
+		if (open < 0) {
+			if (cursor < source.length) target.push({
+				kind: "text",
+				value: source.slice(cursor)
+			});
+			break;
+		}
+		if (open > cursor) target.push({
+			kind: "text",
+			value: source.slice(cursor, open)
+		});
+		if (source.startsWith("{{!--", open)) {
+			const end = source.indexOf("--}}", open + 6);
+			if (end < 0) throw new Error("Parse error: unclosed comment");
+			cursor = end + 4;
+			continue;
+		}
+		const triple = source.startsWith("{{{", open);
+		const contentStart = open + (triple ? 3 : 2);
+		const end = findTagEnd(source, contentStart, triple);
+		const raw = source.slice(contentStart, end).trim();
+		cursor = end + (triple ? 3 : 2);
+		if (!raw || raw.startsWith("!")) continue;
+		if (raw === "else" || raw.startsWith("else ")) {
+			const current = stack[stack.length - 1];
+			if (!current) throw new Error("Parse error: unexpected else");
+			target = current.node.inverse;
+			if (raw.length > 4) {
+				const parentTarget = target;
+				const nested = {
+					kind: "block",
+					expression: parseCall(raw.slice(5)),
+					body: [],
+					inverse: [],
+					inverted: false
+				};
+				target.push(nested);
+				target = nested.body;
+				stack.push({
+					node: nested,
+					target: parentTarget,
+					inverted: false
+				});
+			}
+			continue;
+		}
+		if (raw.startsWith("#") || raw.startsWith("^")) {
+			const inverted = raw.startsWith("^");
+			const node = {
+				kind: "block",
+				expression: parseCall(raw.slice(1)),
+				body: [],
+				inverse: [],
+				inverted
+			};
+			target.push(node);
+			stack.push({
+				node,
+				target,
+				inverted
+			});
+			target = node.body;
+			continue;
+		}
+		if (raw.startsWith("/")) {
+			const 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;
+			continue;
+		}
+		if (raw.startsWith(">")) target.push({
+			kind: "partial",
+			expression: parseCall(raw.slice(1))
+		});
+		else target.push({
+			kind: "output",
+			expression: parseCall(raw.startsWith("&") ? raw.slice(1) : raw),
+			escaped: !triple && !raw.startsWith("&")
+		});
+	}
+	if (stack.length) throw new Error(`Parse error: unclosed block ${stack[stack.length - 1].node.expression.name}`);
+	return root;
+}
+function pathParts(path) {
+	const parts = [];
+	let start = 0;
+	let bracketStart = -1;
+	for (let index = 0; index <= path.length; index++) {
+		const char = path[index];
+		if (char === "[" && bracketStart < 0) {
+			if (index > start) parts.push(path.slice(start, index).replace(/[./]+$/, ""));
+			bracketStart = index + 1;
+		} else if (char === "]" && bracketStart >= 0) {
+			parts.push(path.slice(bracketStart, index));
+			start = index + 1;
+			bracketStart = -1;
+		} else if ((char === "." || char === "/" || char === void 0) && bracketStart < 0) {
+			if (index > start) parts.push(path.slice(start, index));
+			start = index + 1;
+		}
+	}
+	return parts.filter(Boolean);
+}
+function property(parent, key) {
+	if (parent == null) return void 0;
+	if (key === "length" && (typeof parent === "string" || Array.isArray(parent))) return parent.length;
+	if (typeof parent !== "object" && typeof parent !== "function") return void 0;
+	if (key === "__proto__" || key === "prototype" || key === "constructor") return void 0;
+	const record = parent;
+	return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+function resolvePath(path, frame) {
+	if (path === "this" || path === ".") return frame.context;
+	let current = frame;
+	while (path.startsWith("../")) {
+		current = current.parents[0] ?? current;
+		path = path.slice(3);
+	}
+	if (path === "this" || path === ".") return current.context;
+	if (path.startsWith("this.")) path = path.slice(5);
+	if (path === "@root") return current.root;
+	if (path.startsWith("@root.")) {
+		let value = current.root;
+		for (const part of pathParts(path.slice(6))) value = property(value, part);
+		return value;
+	}
+	if (path.startsWith("@")) {
+		const parts = pathParts(path.slice(1));
+		let value = current.data[parts.shift() ?? ""];
+		for (const part of parts) value = property(value, part);
+		return value;
+	}
+	let value = current.context;
+	for (const part of pathParts(path)) value = property(value, part);
+	return typeof value === "function" ? value.call(current.context) : value;
+}
+function childFrame(frame, context, data = frame.data) {
+	return {
+		context,
+		parents: [frame, ...frame.parents],
+		root: frame.root,
+		data
+	};
+}
+function evaluateExpression(expression, frame, evaluation) {
+	if (expression.kind === "literal") return expression.value;
+	if (expression.kind === "path") return resolvePath(expression.value, frame);
+	return evaluateCall(expression, frame, evaluation, false);
+}
+function isConditionalTruthy(value, includeZero = false) {
+	return value === 0 ? includeZero : Boolean(value) && !(Array.isArray(value) && value.length === 0);
+}
+function renderNodes(nodes, frame, evaluation) {
+	let result = "";
+	for (const node of nodes) if (node.kind === "text") result += node.value;
+	else if (node.kind === "output") {
+		const value = evaluateCall(node.expression, frame, evaluation, false);
+		result += stringify$1(value, node.escaped && !evaluation.options.noEscape);
+	} else if (node.kind === "partial") result += renderPartial(node, frame, evaluation);
+	else result += evaluateBlock(node, frame, evaluation);
+	return result;
+}
+function helperOptions(name, hash, frame, evaluation, body = [], inverse = []) {
+	return {
+		name,
+		hash,
+		data: frame.data,
+		fn: (context = frame.context, options) => renderNodes(body, childFrame(frame, context, options?.data ?? frame.data), evaluation),
+		inverse: (context = frame.context, options) => renderNodes(inverse, childFrame(frame, context, options?.data ?? frame.data), evaluation),
+		lookupProperty: property
+	};
+}
+function evaluateHash(hash, frame, evaluation) {
+	const result = {};
+	for (const key in hash) result[key] = evaluateExpression(hash[key], frame, evaluation);
+	return result;
+}
+function findHelper(name, evaluation) {
+	return evaluation.runtime.helpers?.[name] ?? evaluation.helpers.get(name);
+}
+function evaluateCall(call, frame, evaluation, forceHelper, body = [], inverse = []) {
+	const helper = findHelper(call.name, evaluation);
+	const args = call.args.map((argument) => evaluateExpression(argument, frame, evaluation));
+	const hash = evaluateHash(call.hash, frame, evaluation);
+	if (helper) return helper.call(frame.context, ...args, helperOptions(call.name, hash, frame, evaluation, body, inverse));
+	if (call.name === "lookup" && args.length >= 2) return property(args[0], String(args[1]));
+	if (forceHelper || args.length) throw new Error(`Missing helper: "${call.name}"`);
+	for (const _key in hash) throw new Error(`Missing helper: "${call.name}"`);
+	return resolvePath(call.name, frame);
+}
+function evaluateBlock(node, frame, evaluation) {
+	const { name } = node.expression;
+	if (findHelper(name, evaluation)) return stringify$1(evaluateCall(node.expression, frame, evaluation, true, node.body, node.inverse), false);
+	const args = node.expression.args.map((argument) => evaluateExpression(argument, frame, evaluation));
+	const value = args.length ? args[0] : resolvePath(name, frame);
+	const hash = evaluateHash(node.expression.hash, frame, evaluation);
+	if (name === "if" || name === "unless") {
+		const truthy = isConditionalTruthy(value, hash.includeZero === true);
+		return renderNodes((name === "if" ? truthy : !truthy) ? node.body : node.inverse, frame, evaluation);
+	}
+	if (name === "each") {
+		if (Array.isArray(value)) {
+			if (!value.length) return renderNodes(node.inverse, frame, evaluation);
+			return value.map((item, index) => renderNodes(node.body, childFrame(frame, item, {
+				...frame.data,
+				index,
+				key: index,
+				first: index === 0,
+				last: index === value.length - 1
+			}), evaluation)).join("");
+		}
+		if (value && typeof value === "object") {
+			const entries = Object.entries(value);
+			if (!entries.length) return renderNodes(node.inverse, frame, evaluation);
+			return entries.map(([key, item], index) => renderNodes(node.body, childFrame(frame, item, {
+				...frame.data,
+				index,
+				key,
+				first: index === 0,
+				last: index === entries.length - 1
+			}), evaluation)).join("");
+		}
+		return renderNodes(node.inverse, frame, evaluation);
+	}
+	if (name === "with") return isConditionalTruthy(value) ? renderNodes(node.body, childFrame(frame, value), evaluation) : renderNodes(node.inverse, frame, evaluation);
+	const resolved = resolvePath(name, frame);
+	if (Array.isArray(resolved)) return resolved.map((item) => renderNodes(node.body, childFrame(frame, item), evaluation)).join("") || renderNodes(node.inverse, frame, evaluation);
+	return resolved === false || resolved == null ? renderNodes(node.inverse, frame, evaluation) : renderNodes(node.body, childFrame(frame, resolved), evaluation);
+}
+function renderPartial(node, frame, evaluation) {
+	const partial = evaluation.runtime.partials?.[node.expression.name] ?? evaluation.partials.get(node.expression.name);
+	if (partial === void 0) throw new Error(`The partial ${node.expression.name} could not be found`);
+	const context = node.expression.args.length ? evaluateExpression(node.expression.args[0], frame, evaluation) : frame.context;
+	const hash = evaluateHash(node.expression.hash, frame, evaluation);
+	const merged = hash && context && typeof context === "object" ? {
+		...context,
+		...hash
+	} : context;
+	return typeof partial === "function" ? partial(merged, evaluation.runtime) : compile$1(partial, evaluation.options)(merged, evaluation.runtime);
+}
+function stringify$1(value, shouldEscape) {
+	if (value == null) return "";
+	if (value instanceof SafeString) return value.toString();
+	const text = String(value);
+	return shouldEscape ? escapeExpression(text) : text;
+}
+/** Escape a value with Handlebars' HTML entity set. */
+function escapeExpression(value) {
+	return (value == null ? "" : String(value)).replace(/[&<>"'`=]/g, (char) => ({
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#x27;",
+		"`": "&#x60;",
+		"=": "&#x3D;"
+	})[char] ?? char);
+}
+/** Compile a template into a reusable rendering function. */
+function compile$1(source, options = {}) {
+	const nodes = parseTemplate(stripStandalone(source));
+	return (context, runtime = {}) => {
+		const root = context ?? {};
+		const frame = {
+			context: root,
+			parents: [],
+			root,
+			data: {
+				root,
+				...runtime.data ?? {}
+			}
+		};
+		return renderNodes(nodes, frame, {
+			helpers,
+			partials,
+			options,
+			runtime
+		});
+	};
+}
+/** Create an isolated template engine with its own helper and partial registries. */
+function create() {
+	return new TemplateEngine();
+}
+/** Isolated template compiler and registry. */
+var TemplateEngine = class {
+	#helpers = /* @__PURE__ */ new Map();
+	#partials = /* @__PURE__ */ new Map();
+	/** Register a helper in this engine. */
+	registerHelper(name, helper) {
+		this.#helpers.set(name, helper);
+	}
+	/** Register a partial in this engine. */
+	registerPartial(name, partial) {
+		this.#partials.set(name, partial);
+	}
+	/** Compile a template using this engine's registries. */
+	compile(source, options = {}) {
+		const nodes = parseTemplate(stripStandalone(source));
+		return (context, runtime = {}) => {
+			const root = context ?? {};
+			const frame = {
+				context: root,
+				parents: [],
+				root,
+				data: {
+					root,
+					...runtime.data ?? {}
+				}
+			};
+			return renderNodes(nodes, frame, {
+				helpers: this.#helpers,
+				partials: this.#partials,
+				options,
+				runtime
+			});
+		};
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/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
+* RegExp exec (and match array allocation) per `<`-prefixed line. Caller
+* guarantees `s` starts `</`.
+*/
+function closingTagName(s) {
+	const n = s.length;
+	if (n < 4 || s.charCodeAt(n - 1) !== 62) return null;
+	for (let j = 2; j < n - 1; j++) {
+		const c = s.charCodeAt(j);
+		if (!(c >= 97 && c <= 122 || c === 45 || c === 95)) return null;
+	}
+	return s.slice(2, n - 1);
+}
+/**
+* Manual equivalent of {@link OPENING_XML}. Caller guarantees `s` starts with
+* `<` but not `</`. Falls back to the regex when the char after the tag name
+* is non-ASCII (possible unicode whitespace).
+*/
+function openingTagName(s) {
+	const n = s.length;
+	if (n < 3 || s.charCodeAt(n - 1) !== 62) return null;
+	let j = 1;
+	while (j < n - 1) {
+		const c = s.charCodeAt(j);
+		if (c >= 97 && c <= 122 || c === 45 || c === 95) j++;
+		else break;
+	}
+	if (j === 1) return null;
+	if (j === n - 1) return s.slice(1, j);
+	const c = s.charCodeAt(j);
+	if (c !== 32 && c !== 9) {
+		if (c < 128) return null;
+		const match = OPENING_XML.exec(s);
+		return match ? match[1] : null;
+	}
+	return s.indexOf(">", j + 1) === n - 1 ? s.slice(1, j) : null;
+}
+const TABLE_ROW = /^\|.*\|$/;
+const TABLE_SEP = /^\|[-:\s|]+\|$/;
+const NON_BLANK = /\S/;
+/**
+* RFC 2119 keywords (plus project aliases NEVER/AVOID) wrapped in markdown bold
+* — `**MUST**`, `**MUST NOT**`, `**NEVER**`, etc.
+*/
+const RFC2119_BOLD = /\*\*(MUST NOT|SHOULD NOT|RECOMMENDED|REQUIRED|OPTIONAL|SHOULD|MUST|MAY|NEVER|AVOID)\*\*/g;
+/**
+* Fast pre-check for {@link normalizeRfc2119}: a line that lacks every one of
+* these substrings is untouched by all three replacements, so the
+* split/replace/join machinery can be skipped entirely.
+*/
+const RFC2119_GUARD = /\*\*(?:MUST|SHOULD|RECOMMENDED|REQUIRED|OPTIONAL|MAY|NEVER|AVOID)|MUST NOT|SHOULD NOT/;
+const MUST_NOT = /\bMUST NOT\b/g;
+const SHOULD_NOT = /\bSHOULD NOT\b/g;
+function applyRfc2119(text) {
+	return text.replace(RFC2119_BOLD, "$1").replace(MUST_NOT, "NEVER").replace(SHOULD_NOT, "AVOID");
+}
+/**
+* Normalize RFC 2119 markers per project convention:
+*   - Strip `**KEYWORD**` bold (visual noise, no semantics).
+*   - Alias `MUST NOT` → `NEVER` and `SHOULD NOT` → `AVOID` (single-token equivalents).
+* Skips spans inside inline code (`` `…` ``) so alias definitions can be quoted literally.
+*/
+function normalizeRfc2119(line) {
+	if (!RFC2119_GUARD.test(line)) return line;
+	if (!line.includes("`")) return applyRfc2119(line);
+	const segments = line.split("`");
+	for (let i = 0; i < segments.length; i += 2) segments[i] = applyRfc2119(segments[i]);
+	return segments.join("`");
+}
+/** Compact a table row by trimming cell padding */
+function compactTableRow(line) {
+	return line.split("|").map((c) => c.trim()).join("|");
+}
+/** Compact a table separator row */
+function compactTableSep(line) {
+	return `|${line.split("|").filter((c) => c.trim()).map((c) => {
+		const trimmed = c.trim();
+		const left = trimmed.startsWith(":");
+		const right = trimmed.endsWith(":");
+		if (left && right) return ":---:";
+		if (left) return ":---";
+		if (right) return "---:";
+		return "---";
+	}).join("|")}|`;
+}
+const HTML_COMMENT_OPEN = "<!--";
+const HTML_COMMENT_CLOSE = "-->";
+const ASCII_SYMBOLS = /\.{3}|<->|->|<-|!=|<=|>=/g;
+const ASCII_SYMBOL_REPLACEMENTS = {
+	"...": "…",
+	"<->": "↔",
+	"->": "→",
+	"<-": "←",
+	"!=": "≠",
+	"<=": "≤",
+	">=": "≥"
+};
+const replaceAsciiSymbol = (match) => ASCII_SYMBOL_REPLACEMENTS[match];
+function replaceCommonAsciiSymbols(line) {
+	return line.replace(ASCII_SYMBOLS, replaceAsciiSymbol);
+}
+function replaceCommonAsciiSymbolsOutsideHtmlComments(line, state) {
+	if (!state.inHtmlComment && !line.includes(HTML_COMMENT_OPEN)) return replaceCommonAsciiSymbols(line);
+	let result = "";
+	let cursor = 0;
+	while (cursor < line.length) {
+		if (state.inHtmlComment) {
+			const closeIndex = line.indexOf(HTML_COMMENT_CLOSE, cursor);
+			if (closeIndex === -1) return result + line.slice(cursor);
+			result += line.slice(cursor, closeIndex + 3);
+			cursor = closeIndex + 3;
+			state.inHtmlComment = false;
+			continue;
+		}
+		const openIndex = line.indexOf(HTML_COMMENT_OPEN, cursor);
+		if (openIndex === -1) {
+			result += replaceCommonAsciiSymbols(line.slice(cursor));
+			return result;
+		}
+		result += replaceCommonAsciiSymbols(line.slice(cursor, openIndex));
+		const closeIndex = line.indexOf(HTML_COMMENT_CLOSE, openIndex + 4);
+		if (closeIndex === -1) {
+			result += line.slice(openIndex);
+			state.inHtmlComment = true;
+			return result;
+		}
+		result += line.slice(openIndex, closeIndex + 3);
+		cursor = closeIndex + 3;
+	}
+	return result;
+}
+function format(content, options = {}) {
+	const { renderPhase = "post-render", replaceAsciiSymbols = false, normalizeRfc2119: shouldNormalizeRfc2119 = false } = options;
+	const isPreRender = renderPhase === "pre-render";
+	const lines = content.split("\n");
+	const result = new Array(lines.length);
+	let n = 0;
+	let inCodeBlock = false;
+	const htmlCommentState = { inHtmlComment: false };
+	const topLevelTags = [];
+	for (let i = 0; i < lines.length; i++) {
+		const raw = lines[i];
+		const last = raw.charCodeAt(raw.length - 1);
+		let line = last <= 32 || last >= 128 ? raw.trimEnd() : raw;
+		let s = 0;
+		let first = line.charCodeAt(0);
+		while (first === 32 || first === 9) first = line.charCodeAt(++s);
+		if (first >= 128) {
+			s = line.length - line.trimStart().length;
+			first = line.charCodeAt(s);
+		}
+		if ((first === 96 || first === 126) && (line.startsWith("```", s) || line.startsWith("~~~", s))) {
+			inCodeBlock = !inCodeBlock;
+			result[n++] = line;
+			continue;
+		}
+		if (inCodeBlock) {
+			result[n++] = line;
+			continue;
+		}
+		if (replaceAsciiSymbols) {
+			const replaced = replaceCommonAsciiSymbolsOutsideHtmlComments(line, htmlCommentState);
+			if (replaced !== line) {
+				line = replaced;
+				s = 0;
+				first = line.charCodeAt(0);
+				while (first === 32 || first === 9) first = line.charCodeAt(++s);
+				if (first >= 128) {
+					s = line.length - line.trimStart().length;
+					first = line.charCodeAt(s);
+				}
+			}
+		}
+		let isClosingLine = false;
+		if (first === 60) {
+			const trimmedStart = s === 0 ? line : line.slice(s);
+			if (trimmedStart.charCodeAt(1) === 47) {
+				const tagName = closingTagName(trimmedStart);
+				if (tagName !== null) {
+					isClosingLine = true;
+					if (topLevelTags.length > 0 && topLevelTags[topLevelTags.length - 1] === tagName) topLevelTags.pop();
+				}
+			} else if (s === 0 && !trimmedStart.endsWith("/>")) {
+				const tagName = openingTagName(trimmedStart);
+				if (tagName !== null) topLevelTags.push(tagName);
+			}
+		} else if (first === 124) {
+			const trimmedStart = s === 0 ? line : line.slice(s);
+			if (TABLE_SEP.test(trimmedStart)) line = `${line.slice(0, s)}${compactTableSep(trimmedStart)}`;
+			else if (TABLE_ROW.test(trimmedStart)) line = `${line.slice(0, s)}${compactTableRow(trimmedStart)}`;
+		}
+		if (shouldNormalizeRfc2119) line = normalizeRfc2119(line);
+		if (s >= line.length) {
+			const next = lines[i + 1];
+			if (next === void 0 || next.length === 0 || !NON_BLANK.test(next)) {
+				while (n > 0 && result[n - 1].length === 0) n--;
+				let j = i + 1;
+				while (j < lines.length && (lines[j].length === 0 || !NON_BLANK.test(lines[j]))) j++;
+				i = j - 1;
+				continue;
+			}
+			if (n === 0 || result[n - 1].length === 0) continue;
+		}
+		if (isClosingLine || isPreRender && first === 123 && line.startsWith("{{/", s)) while (n > 0 && result[n - 1].length === 0) n--;
+		result[n++] = line;
+	}
+	while (n > 0 && result[n - 1].length === 0) n--;
+	result.length = n;
+	return result.join("\n");
+}
+const handlebars = create();
+handlebars.registerHelper("arg", function(index) {
+	const args = this.args ?? [];
+	const parsedIndex = typeof index === "number" ? index : Number.parseInt(index, 10);
+	if (!Number.isFinite(parsedIndex)) return "";
+	const zeroBased = parsedIndex - 1;
+	if (zeroBased < 0) return "";
+	return args[zeroBased] ?? "";
+});
+/**
+* {{#list items prefix="- " suffix="" join="\n"}}{{this}}{{/list}}
+* Renders an array with customizable prefix, suffix, and join separator.
+* Note: Use \n in join for newlines (will be unescaped automatically).
+*/
+handlebars.registerHelper("list", function(context, options) {
+	if (!Array.isArray(context) || context.length === 0) return "";
+	const prefix = options.hash.prefix ?? "";
+	const suffix = options.hash.suffix ?? "";
+	const separator = (options.hash.join ?? "\n").replace(/\\n/g, "\n").replace(/\\t/g, "	");
+	return context.map((item) => `${prefix}${options.fn(item)}${suffix}`).join(separator);
+});
+/**
+* {{join array ", "}}
+* Joins an array with a separator (default: ", ").
+* Note: Use \n/\t in the separator for newlines/tabs (unescaped automatically,
+* same convention as {{#list}} — Handlebars string literals carry no escapes).
+*/
+handlebars.registerHelper("join", (context, separator) => {
+	if (!Array.isArray(context)) return "";
+	const sep = typeof separator === "string" ? separator.replace(/\\n/g, "\n").replace(/\\t/g, "	") : ", ";
+	return context.join(sep);
+});
+/**
+* {{default value "fallback"}}
+* Returns the value if truthy, otherwise returns the fallback.
+*/
+handlebars.registerHelper("default", (value, defaultValue) => value || defaultValue);
+/**
+* {{pluralize count "item" "items"}}
+* Returns "1 item" or "5 items" based on count.
+*/
+handlebars.registerHelper("pluralize", (count, singular, plural) => `${count} ${count === 1 ? singular : plural}`);
+/**
+* {{#when value "==" compare}}...{{else}}...{{/when}}
+* Conditional block with comparison operators: ==, ===, !=, !==, >, <, >=, <=
+*/
+handlebars.registerHelper("when", function(lhs, operator, rhs, options) {
+	const fn = {
+		"==": (a, b) => a === b,
+		"===": (a, b) => a === b,
+		"!=": (a, b) => a !== b,
+		"!==": (a, b) => a !== b,
+		">": (a, b) => a > b,
+		"<": (a, b) => a < b,
+		">=": (a, b) => a >= b,
+		"<=": (a, b) => a <= b
+	}[operator];
+	if (!fn) return options.inverse(this);
+	return fn(lhs, rhs) ? options.fn(this) : options.inverse(this);
+});
+/**
+* {{#ifAny a b c}}...{{else}}...{{/ifAny}}
+* True if any argument is truthy.
+*/
+handlebars.registerHelper("ifAny", function(...args) {
+	const options = args.pop();
+	return args.some(Boolean) ? options.fn(this) : options.inverse(this);
+});
+/**
+* {{#ifAll a b c}}...{{else}}...{{/ifAll}}
+* True if all arguments are truthy.
+*/
+handlebars.registerHelper("ifAll", function(...args) {
+	const options = args.pop();
+	return args.every(Boolean) ? options.fn(this) : options.inverse(this);
+});
+/**
+* {{#table rows headers="Col1|Col2"}}{{col1}}|{{col2}}{{/table}}
+* Generates a markdown table from an array of objects.
+*/
+handlebars.registerHelper("table", function(context, options) {
+	if (!Array.isArray(context) || context.length === 0) return "";
+	const headers = options.hash.headers?.split("|") ?? [];
+	const separator = headers.map(() => "---").join(" | ");
+	return (headers.length > 0 ? `| ${headers.join(" | ")} |\n| ${separator} |\n` : "") + context.map((item) => `| ${options.fn(item).trim()} |`).join("\n");
+});
+/**
+* {{#codeblock lang="diff"}}...{{/codeblock}}
+* Wraps content in a fenced code block.
+*/
+handlebars.registerHelper("codeblock", function(options) {
+	return `\`\`\`${options.hash.lang ?? ""}\n${options.fn(this).trim()}\n\`\`\``;
+});
+/**
+* {{#xml "tag"}}content{{/xml}}
+* Wraps content in XML-style tags. Returns empty string if content is empty.
+*/
+handlebars.registerHelper("xml", function(tag, options) {
+	const content = options.fn(this).trim();
+	if (!content) return "";
+	return `<${tag}>\n${content}\n</${tag}>`;
+});
+/**
+* {{escapeXml value}}
+* Escapes XML special characters: & < > "
+*/
+handlebars.registerHelper("escapeXml", (value) => {
+	if (value == null) return "";
+	return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+});
+/**
+* {{len array}}
+* Returns the length of an array or string.
+*/
+handlebars.registerHelper("len", (value) => {
+	if (Array.isArray(value)) return value.length;
+	if (typeof value === "string") return value.length;
+	return 0;
+});
+/**
+* {{add a b}}
+* Adds two numbers.
+*/
+handlebars.registerHelper("add", (a, b) => (a ?? 0) + (b ?? 0));
+/**
+* {{sub a b}}
+* Subtracts b from a.
+*/
+handlebars.registerHelper("sub", (a, b) => (a ?? 0) - (b ?? 0));
+/**
+* {{#has collection item}}...{{else}}...{{/has}}
+* Checks if an array includes an item or if a Set/Map has a key.
+*/
+handlebars.registerHelper("has", function(collection, item, options) {
+	let found = false;
+	if (Array.isArray(collection)) found = collection.includes(item);
+	else if (collection instanceof Set) found = collection.has(item);
+	else if (collection instanceof Map) found = collection.has(item);
+	else if (collection && typeof collection === "object") {
+		if (typeof item === "string" || typeof item === "number" || typeof item === "symbol") found = item in collection;
+	}
+	return found ? options.fn(this) : options.inverse(this);
+});
+/**
+* {{includes array item}}
+* Returns true if array includes item. For use in other helpers.
+*/
+handlebars.registerHelper("includes", (collection, item) => {
+	if (Array.isArray(collection)) return collection.includes(item);
+	if (collection instanceof Set) return collection.has(item);
+	if (collection instanceof Map) return collection.has(item);
+	return false;
+});
+/**
+* {{not value}}
+* Returns logical NOT of value. For use in subexpressions.
+*/
+handlebars.registerHelper("not", (value) => !value);
+handlebars.registerHelper("jsonStringify", (value) => JSON.stringify(value));
+const compiledTemplateCache = /* @__PURE__ */ new Map();
+function compile(template) {
+	const cached = compiledTemplateCache.get(template);
+	if (cached) return cached;
+	const compiled = handlebars.compile(template, {
+		noEscape: true,
+		strict: false
+	});
+	compiledTemplateCache.set(template, compiled);
+	return compiled;
+}
+function render(template, context = {}) {
+	return format(compile(template)(context ?? {}), { renderPhase: "post-render" });
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/ptree.ts
+/**
+* Process tree management utilities for Bun subprocesses.
+*
+* - Track managed child processes for cleanup on shutdown (postmortem).
+* - Drain stdout/stderr to avoid subprocess pipe deadlocks.
+* - Cross-platform tree kill for process groups (Windows taskkill, Unix -pid).
+* - Convenience helpers: captureText / execText, AbortSignal, timeouts.
+*/
+/**
+* Base for all exceptions representing child process nonzero exit, killed, or
+* cancellation.
+*/
+var Exception = class extends Error {
+	exitCode;
+	stderr;
+	constructor(message, exitCode, stderr) {
+		super(message);
+		this.exitCode = exitCode;
+		this.stderr = stderr;
+		this.name = this.constructor.name;
+	}
+};
+/** Exception for nonzero exit codes (not cancellation). */
+var NonZeroExitError = class extends Exception {
+	static MAX_TRACE = 32768;
+	constructor(exitCode, stderr) {
+		super(`Process exited with code ${exitCode}:\n${stderr}`, exitCode, stderr);
+	}
+	get aborted() {
+		return false;
+	}
+};
+/** Exception for explicit process abortion (via signal). */
+var AbortError = class extends Exception {
+	reason;
+	constructor(reason, stderr) {
+		const msg = reason instanceof Error ? reason.message : String(reason ?? "aborted");
+		super(`Operation cancelled: ${msg}`, -1, stderr);
+		this.reason = reason;
+	}
+	get aborted() {
+		return true;
+	}
+};
+/** Exception for process timeout. */
+var TimeoutError = class extends AbortError {
+	constructor(timeout, stderr) {
+		super(/* @__PURE__ */ new Error(`Timed out after ${Math.round(timeout / 1e3)}s`), stderr);
+	}
+};
+/**
+* ChildProcess wraps a managed subprocess, capturing stderr tail, providing
+* cross-platform kill/detach logic plus AbortSignal integration.
+*
+* Stdout is exposed directly from the underlying Bun subprocess; consumers
+* must read it (via text(), wait(), etc.) to prevent pipe deadlock.
+* Stderr is eagerly drained into an internal buffer.
+*/
+var ChildProcess = class {
+	proc;
+	exposeStderr;
+	#nothrow = false;
+	#stderrTail = "";
+	#stderrChunks;
+	#exitReason;
+	#exitReasonPending;
+	#stderrDone;
+	#exited;
+	#stderrStream;
+	constructor(proc, exposeStderr, retainFullStderr = exposeStderr) {
+		this.proc = proc;
+		this.exposeStderr = exposeStderr;
+		if (retainFullStderr) this.#stderrChunks = [];
+		const dec = new TextDecoder();
+		const trim = () => {
+			if (this.#stderrTail.length > NonZeroExitError.MAX_TRACE) this.#stderrTail = this.#stderrTail.slice(-NonZeroExitError.MAX_TRACE);
+		};
+		let stderrStream = proc.stderr;
+		if (exposeStderr) {
+			const [teeStream, drainStream] = stderrStream.tee();
+			this.#stderrStream = teeStream;
+			stderrStream = drainStream;
+		}
+		this.#stderrDone = (async () => {
+			try {
+				for await (const chunk of stderrStream) {
+					this.#stderrChunks?.push(chunk);
+					this.#stderrTail += dec.decode(chunk, { stream: true });
+					trim();
+				}
+			} catch {}
+			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;
+				reject(this.#exitReasonPending);
+				return;
+			}
+			if (exitCode === 0) {
+				resolve(0);
+				return;
+			}
+			await this.#stderrDone;
+			if (exitCode !== null) {
+				this.#exitReason = new NonZeroExitError(exitCode, this.#stderrTail);
+				resolve(exitCode);
+				return;
+			}
+			const ex = this.proc.killed ? new AbortError(/* @__PURE__ */ new Error("process killed"), this.#stderrTail) : new NonZeroExitError(-1, this.#stderrTail);
+			this.#exitReason = ex;
+			reject(ex);
+		});
+	}
+	get pid() {
+		return this.proc.pid;
+	}
+	get exited() {
+		return this.#exited;
+	}
+	get exitCode() {
+		return this.proc.exitCode;
+	}
+	get exitReason() {
+		return this.#exitReason;
+	}
+	get killed() {
+		return this.proc.killed;
+	}
+	get stdin() {
+		return this.proc.stdin;
+	}
+	/** Raw stdout stream. Must be consumed to prevent pipe deadlock. */
+	get stdout() {
+		return this.proc.stdout;
+	}
+	/** Optional stderr stream (only when requested in spawn options). */
+	get stderr() {
+		return this.#stderrStream;
+	}
+	get exitedCleanly() {
+		if (this.#nothrow) return this.#exited;
+		return this.#exited.then((code) => {
+			if (code !== 0) throw new NonZeroExitError(code, this.#stderrTail);
+			return code;
+		});
+	}
+	/** Returns the truncated stderr tail (last 32KB). */
+	peekStderr() {
+		return this.#stderrTail;
+	}
+	nothrow() {
+		this.#nothrow = true;
+		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);
+	}
+	async text() {
+		const p = new Response(this.stdout).text();
+		if (this.#nothrow) return p;
+		const [text] = await Promise.all([p, this.exitedCleanly]);
+		return text;
+	}
+	async blob() {
+		const p = new Response(this.stdout).blob();
+		if (this.#nothrow) return p;
+		const [blob] = await Promise.all([p, this.exitedCleanly]);
+		return blob;
+	}
+	async json() {
+		return new Response(this.stdout).json();
+	}
+	async arrayBuffer() {
+		return new Response(this.stdout).arrayBuffer();
+	}
+	async bytes() {
+		const body = await new Response(this.stdout).bytes();
+		return body instanceof Uint8Array ? body : new Uint8Array(body);
+	}
+	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 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;
+		try {
+			await this.#exited;
+		} catch (err) {
+			if (err instanceof Exception) exitError = err;
+			else throw err;
+		}
+		if (!exitError) exitError = this.exitReason;
+		if (!exitError && this.exitCode !== null && this.exitCode !== 0) exitError = new NonZeroExitError(this.exitCode, this.#stderrTail);
+		const exitCode = this.exitCode ?? (exitError && !exitError.aborted ? exitError.exitCode : null);
+		const ok = exitCode === 0;
+		if (exitError) {
+			if (exitError.aborted && !allowAbort || !exitError.aborted && !allowNonZero) throw exitError;
+		}
+		return {
+			stdout,
+			stderr,
+			exitCode,
+			ok,
+			exitError
+		};
+	}
+	attachSignal(signal) {
+		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));
+	}
+	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));
+		});
+	}
+	[Symbol.dispose]() {
+		if (this.proc.exitCode !== null) return;
+		this.kill(new AbortError("process disposed", this.#stderrTail));
+	}
+};
+function spawnInternal(cmd, opts, retainFullStderr) {
+	const { timeout = -1, signal, stderr, ...rest } = opts ?? {};
+	const cp = new ChildProcess(Bun.spawn(cmd, {
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+		windowsHide: true,
+		...rest
+	}), stderr === "full", retainFullStderr);
+	if (signal) cp.attachSignal(signal);
+	if (timeout > 0) cp.attachTimeout(timeout);
+	return cp;
+}
+/** Spawn, wait, and return captured output. */
+async function exec(cmd, opts) {
+	try {
+		var _usingCtx$1 = _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({
+			stderr,
+			allowAbort,
+			allowNonZero
+		});
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+/** Combine AbortSignals and timeout values into a single signal. */
+function combineSignals(...signals) {
+	let timeout;
+	let n = 0;
+	for (let i = 0; i < signals.length; i++) {
+		const s = signals[i];
+		if (s instanceof AbortSignal) {
+			if (s.aborted) return s;
+			if (i !== n) signals[n] = s;
+			n++;
+		} else if (typeof s === "number" && s > 0) timeout = timeout === void 0 ? s : Math.min(timeout, s);
+	}
+	if (timeout !== void 0) {
+		signals[n] = AbortSignal.timeout(timeout);
+		n++;
+	}
+	switch (n) {
+		case 0: return;
+		case 1: return signals[0];
+		default: return AbortSignal.any(signals.slice(0, n));
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/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;
+let Snowflake;
+(function(_Snowflake) {
+	const PATTERN = _Snowflake.PATTERN = /^[0-9a-f]{16}$/;
+	_Snowflake.EPOCH_TIMESTAMP = EPOCH;
+	_Snowflake.MAX_SEQUENCE = MAX_SEQ;
+	function formatParts(dt, seq) {
+		return (BigInt(dt) << 22n | BigInt(seq)).toString(16).padStart(16, "0");
+	}
+	_Snowflake.formatParts = formatParts;
+	class Source {
+		#seq = 0;
+		constructor(sequence = randu32() & MAX_SEQ) {
+			this.#seq = sequence & MAX_SEQ;
+		}
+		get sequence() {
+			return this.#seq & MAX_SEQ;
+		}
+		set sequence(v) {
+			this.#seq = v & MAX_SEQ;
+		}
+		reset() {
+			this.#seq = 0;
+		}
+		generate(timestamp) {
+			const seq = this.#seq + 1 & MAX_SEQ;
+			const dt = timestamp - EPOCH;
+			this.#seq = seq;
+			return formatParts(dt, seq);
+		}
+	}
+	_Snowflake.Source = Source;
+	let defaultSource;
+	function next(timestamp = Date.now()) {
+		defaultSource ??= new Source();
+		return defaultSource.generate(timestamp);
+	}
+	_Snowflake.next = next;
+	function valid(value) {
+		return value.length === 16 && PATTERN.test(value);
+	}
+	_Snowflake.valid = valid;
+	function lowerbound(timelike) {
+		switch (typeof timelike) {
+			case "object": return formatParts(timelike.getTime() - EPOCH, 0);
+			case "number": return formatParts(timelike - EPOCH, 0);
+			case "string": return timelike;
+		}
+	}
+	_Snowflake.lowerbound = lowerbound;
+	function upperbound(timelike) {
+		switch (typeof timelike) {
+			case "object": return formatParts(timelike.getTime() - EPOCH, MAX_SEQ);
+			case "number": return formatParts(timelike - EPOCH, MAX_SEQ);
+			case "string": return timelike;
+		}
+	}
+	_Snowflake.upperbound = upperbound;
+	function getSequence(value) {
+		return Number.parseInt(value.substring(8, 16), 16) & MAX_SEQ;
+	}
+	_Snowflake.getSequence = getSequence;
+	function getTimestamp(value) {
+		const hi = Number.parseInt(value.substring(0, 8), 16);
+		const lo = Number.parseInt(value.substring(8, 16), 16);
+		return hi * 1024 + (lo >>> 22) + EPOCH;
+	}
+	_Snowflake.getTimestamp = getTimestamp;
+	function getDate(value) {
+		return new Date(getTimestamp(value));
+	}
+	_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
+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);
+	try {
+		for await (const chunk of source) yield* buffer.pullJSONL(chunk, 0, chunk.length);
+		if (!buffer.isEmpty) {
+			const tail = buffer.flush();
+			if (tail) {
+				buffer.clear();
+				const { values, error, done } = parseJsonlChunkCompat(tail, 0, tail.length);
+				if (values.length > 0) yield* values;
+				if (error) throw error;
+				if (!done) throw new Error("JSONL stream ended unexpectedly");
+			}
+		}
+	} catch (err) {
+		if (signal?.aborted) return;
+		throw err;
+	}
+}
+var ConcatSink = class {
+	#space;
+	#length = 0;
+	#ensureCapacity(size) {
+		const space = this.#space;
+		if (space && space.length >= size) return space;
+		const nextSize = space ? Math.max(size, space.length * 2) : size;
+		const next = Buffer.allocUnsafe(nextSize);
+		if (space && this.#length > 0) space.copy(next, 0, 0, this.#length);
+		this.#space = next;
+		return next;
+	}
+	append(chunk) {
+		const n = chunk.length;
+		if (!n) return;
+		const offset = this.#length;
+		this.#ensureCapacity(offset + n).set(chunk, offset);
+		this.#length += n;
+	}
+	reset(chunk) {
+		const n = chunk.length;
+		if (!n) {
+			this.#length = 0;
+			return;
+		}
+		this.#ensureCapacity(n).set(chunk, 0);
+		this.#length = n;
+	}
+	get isEmpty() {
+		return this.#length === 0;
+	}
+	flush() {
+		if (!this.#length) return void 0;
+		return this.#space.subarray(0, this.#length);
+	}
+	clear() {
+		this.#length = 0;
+	}
+	*appendAndFlushLines(chunk) {
+		let pos = 0;
+		while (pos < chunk.length) {
+			const nl = chunk.indexOf(LF, pos);
+			if (nl === -1) {
+				this.append(chunk.subarray(pos));
+				return;
+			}
+			const suffix = chunk.subarray(pos, nl);
+			pos = nl + 1;
+			if (this.isEmpty) yield suffix;
+			else {
+				this.append(suffix);
+				const payload = this.flush();
+				if (payload) {
+					yield payload;
+					this.clear();
+				}
+			}
+		}
+	}
+	appendAndFlushText(chunk, decoder) {
+		const lastNewline = chunk.lastIndexOf(LF);
+		if (lastNewline === -1) {
+			this.append(chunk);
+			return;
+		}
+		const completeEnd = lastNewline + 1;
+		let text;
+		if (this.isEmpty) {
+			const complete = completeEnd === chunk.length ? chunk : chunk.subarray(0, completeEnd);
+			text = decoder.decode(complete);
+		} else {
+			this.append(completeEnd === chunk.length ? chunk : chunk.subarray(0, completeEnd));
+			text = decoder.decode(this.flush());
+			this.clear();
+		}
+		if (completeEnd < chunk.length) this.append(chunk.subarray(completeEnd));
+		return text;
+	}
+	*pullJSONL(chunk, beg, end) {
+		if (this.isEmpty) {
+			const { values, error, read, done } = parseJsonlChunkCompat(chunk, beg, end);
+			if (values.length > 0) yield* values;
+			if (error) throw error;
+			if (done) return;
+			this.reset(chunk.subarray(read, end));
+			return;
+		}
+		const offset = this.#length;
+		const total = offset + (end - beg);
+		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);
+		if (values.length > 0) yield* values;
+		if (error) throw error;
+		if (done) {
+			this.#length = 0;
+			return;
+		}
+		const rem = total - read;
+		if (rem < total) space.copyWithin(0, read, total);
+		this.#length = rem;
+	}
+};
+function notifySseEventObserver(observer, event) {
+	if (!observer) return;
+	try {
+		observer(event);
+	} catch {}
+}
+function isRecoverableTrailingJson(data) {
+	const first = data.trimStart()[0];
+	if (first !== "{" && first !== "[") return false;
+	const recovered = parseStreamingJson(data);
+	return typeof recovered === "object" && recovered !== null;
+}
+async function* readSseJson(stream, signal, onEvent) {
+	for await (const sse of readSseEvents(stream, signal)) {
+		const isTrailing = trailingEvents.has(sse);
+		notifySseEventObserver(onEvent, sse);
+		const data = sse.data;
+		if (data === "" || data === "[DONE]") {
+			if (data === "[DONE]") return;
+			continue;
+		}
+		try {
+			yield JSON.parse(data);
+		} catch (err) {
+			if (err instanceof SyntaxError && isTrailing && isRecoverableTrailingJson(data)) return;
+			throw err;
+		}
+	}
+}
+const SSE_DECODER = new TextDecoder("utf-8");
+function flushSseEvent(state) {
+	if (state.event === null && state.data === null && state.id === void 0 && state.retry === void 0) {
+		state.raw = [];
+		return null;
+	}
+	const event = {
+		event: state.event,
+		data: state.data ?? "",
+		raw: state.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 = [];
+	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);
+		return null;
+	}
+	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);
+	if (value.charCodeAt(0) === 32) value = value.slice(1);
+	if (fieldName === "event") state.event = value;
+	else if (fieldName === "data") {
+		if (state.data === null) state.data = value;
+		else {
+			state.data += "\n";
+			state.data += value;
+		}
+	} else if (fieldName === "id") {
+		if (!value.includes("\0")) state.id = value;
+	} else if (fieldName === "retry" && value.length > 0) {
+		let valid = true;
+		for (let index = 0; index < value.length; index++) {
+			const code = value.charCodeAt(index);
+			if (code < 48 || code > 57) {
+				valid = false;
+				break;
+			}
+		}
+		if (valid) {
+			const retry = Number(value);
+			if (Number.isSafeInteger(retry)) state.retry = retry;
+		}
+	}
+	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) {
+	const lineBuffer = new ConcatSink();
+	const state = {
+		event: null,
+		data: null,
+		raw: []
+	};
+	const source = abortableSource(stream, signal);
+	try {
+		for await (const chunk of source) {
+			const text = lineBuffer.appendAndFlushText(chunk, SSE_DECODER);
+			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);
+				if (event) yield event;
+				start = newline + 1;
+			}
+		}
+		if (!lineBuffer.isEmpty) {
+			const tail = lineBuffer.flush();
+			if (tail) {
+				lineBuffer.clear();
+				const event = pushSseLine(SSE_DECODER.decode(tail), state);
+				if (event) {
+					trailingEvents.add(event);
+					yield event;
+				}
+			}
+		}
+		const trailing = flushSseEvent(state);
+		if (trailing) {
+			trailingEvents.add(trailing);
+			yield trailing;
+		}
+	} catch (err) {
+		if (signal?.aborted) return;
+		throw err;
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/temp.ts
+var TempDir = class TempDir {
+	#path;
+	constructor(path) {
+		this.#path = path;
+	}
+	static createSync(prefix) {
+		return new TempDir(fs.mkdtempSync(normalizePrefix(prefix)));
+	}
+	static async create(prefix) {
+		return new TempDir(await fs_promises_shim_exports.mkdtemp(normalizePrefix(prefix)));
+	}
+	#removePromise = null;
+	path() {
+		return this.#path;
+	}
+	absolute() {
+		return path.resolve(this.#path);
+	}
+	remove() {
+		if (this.#removePromise) return this.#removePromise;
+		const removePromise = removeWithRetries(this.#path);
+		this.#removePromise = removePromise;
+		return removePromise;
+	}
+	removeSync() {
+		removeSyncWithRetries(this.#path);
+		this.#removePromise = Promise.resolve();
+	}
+	toString() {
+		return this.#path;
+	}
+	join(...paths) {
+		return path.join(this.#path, ...paths);
+	}
+	async [Symbol.asyncDispose]() {
+		try {
+			await this.remove();
+		} catch {}
+	}
+	[Symbol.dispose]() {
+		try {
+			this.removeSync();
+		} catch {}
+	}
+};
+const kTempDir = os.tmpdir();
+function normalizePrefix(prefix) {
+	if (!prefix) return `${kTempDir}${path.sep}pi-temp-`;
+	else if (prefix.startsWith("@")) return path.join(kTempDir, prefix.slice(1));
+	return prefix;
+}
+const kRemoveOptions = {
+	recursive: true,
+	force: true
+};
+const kRemoveRetries = 40;
+const kRemoveRetryDelayMs = 50;
+const kRetryableRemoveErrorCodes = /* @__PURE__ */ new Set([
+	"EBUSY",
+	"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 {
+		await fs_promises_shim_exports.rm(target, kRemoveOptions);
+		return;
+	} catch (err) {
+		if (!shouldRetryRemove(err, attempt)) throw err;
+		await Bun.sleep(kRemoveRetryDelayMs);
+	}
+}
+function removeSyncWithRetries(target) {
+	for (let attempt = 0;; attempt++) try {
+		fs.rmSync(target, kRemoveOptions);
+		return;
+	} catch (err) {
+		if (!shouldRetryRemove(err, attempt)) throw err;
+		sleepSync(kRemoveRetryDelayMs);
+	}
+}
+function shouldRetryRemove(err, attempt) {
+	return attempt < kRemoveRetries && process.platform === "win32" && isRetryableRemoveError(err);
+}
+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@17.3.5/node_modules/@oh-my-pi/pi-utils/src/tls-fetch.ts
+/**
+* `NODE_EXTRA_CA_CERTS` shim for Bun's `fetch`.
+*
+* Node's TLS layer honours `NODE_EXTRA_CA_CERTS` natively, but Bun's
+* `fetch` does not, and both the provider streams (`openai-responses`,
+* `openai-completions`, `openai-codex-responses`, `ollama-chat`, ...) and
+* catalog model discovery (`/models` probes) route every request through
+* Bun's runtime. Without this wrapper, corporate relays and private
+* gateways behind a custom CA bundle fail with
+* `unknown certificate verification error` even when the env var is set.
+*
+* The wrapper merges the resolved CA bundle into Bun's `RequestInit.tls.ca`.
+* Bun's `tls.ca` REPLACES the default trust store when set, so the wrapper
+* always seeds {@link tls.rootCertificates} when the caller has not already
+* curated their own CA list.
+*/
+/**
+* `NODE_EXTRA_CA_CERTS` was set but unusable (path does not exist). This is
+* a config/contract error, not a transient transport fault — it is never
+* retried.
+*/
+var ExtraCaError = class extends Error {
+	constructor(message, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "ExtraCaError";
+	}
+};
+const EXTRA_CA_FETCH_MARKER = Symbol("omp.extraCaFetch");
+/**
+* Cached resolution of `NODE_EXTRA_CA_CERTS`. Keyed on the env value plus
+* the file mtime for path values so on-disk cert rotation (short-lived
+* corporate bundles) invalidates the cache instead of pinning the first
+* read forever.
+*/
+let cacheKey;
+let cacheValue;
+/**
+* Returns the PEM bytes referenced by `NODE_EXTRA_CA_CERTS`, or `undefined`
+* when the env var is unset/empty.
+*
+* Accepts the same shapes Node accepts plus an inline-PEM escape hatch:
+* - Inline PEM (`-----BEGIN CERTIFICATE-----...`). Literal `\n` escapes in
+*   the env value are expanded so callers can ship single-line PEMs through
+*   shell exports.
+* - File path. Anything that does not contain a PEM header is treated as a
+*   path, matching Node's "extensionless filename is still a path" contract.
+*   `ENOENT` becomes {@link ExtraCaError}; other I/O errors bubble.
+*/
+function resolveExtraCa() {
+	const raw = $env.NODE_EXTRA_CA_CERTS?.trim();
+	if (!raw) return void 0;
+	let key;
+	if (raw.includes("-----BEGIN")) key = raw;
+	else try {
+		key = `${raw}@${fs.statSync(raw).mtimeMs}`;
+	} catch {
+		key = raw;
+	}
+	if (key === cacheKey) return cacheValue;
+	if (raw.includes("-----BEGIN")) cacheValue = raw.replace(/\\n/g, "\n");
+	else try {
+		cacheValue = fs.readFileSync(raw, "utf8");
+	} catch (error) {
+		if (isEnoent(error)) throw new ExtraCaError(`NODE_EXTRA_CA_CERTS path does not exist: ${raw}`);
+		throw error;
+	}
+	cacheKey = key;
+	return cacheValue;
+}
+/**
+* Merge `extraCa` into `init.tls.ca`. When the caller has not supplied a CA
+* list, the system root store is included alongside the extra bundle —
+* Bun's `tls.ca` replaces the default trust store, so omitting roots would
+* break every public host. When the caller already curated a list (e.g.
+* Anthropic Foundry's mTLS options, which already seed
+* `tls.rootCertificates`), only the extra CA is appended.
+*/
+function withExtraCaInit(init, extraCa) {
+	const existingTls = init?.tls;
+	const existingCa = existingTls?.ca;
+	let mergedCa;
+	if (existingCa === void 0) mergedCa = [...tls.rootCertificates, extraCa];
+	else if (Array.isArray(existingCa)) mergedCa = [...existingCa, extraCa];
+	else mergedCa = [existingCa, extraCa];
+	return {
+		...init,
+		tls: {
+			...existingTls,
+			ca: mergedCa
+		}
+	};
+}
+/**
+* Wrap `fetchImpl` so every call honours `NODE_EXTRA_CA_CERTS`. Idempotent:
+* a fetch already wrapped is returned unchanged so repeated composition
+* (Anthropic auth-retry replays, request-debug fan-out) never stacks
+* wrappers. When the env var is unset the original fetch is returned, so
+* default deployments pay nothing.
+*/
+function wrapFetchForExtraCa(fetchImpl) {
+	if (fetchImpl[EXTRA_CA_FETCH_MARKER]) return fetchImpl;
+	if (!$env.NODE_EXTRA_CA_CERTS?.trim()) return fetchImpl;
+	return Object.assign(async (input, init) => {
+		const extraCa = resolveExtraCa();
+		return extraCa ? fetchImpl(input, withExtraCaInit(init, extraCa)) : fetchImpl(input, init);
+	}, 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
+function isPlainObject(val) {
+	return Object.getPrototypeOf(val) === Object.prototype || Array.isArray(val);
+}
+function structuredCloneJSON(value) {
+	if (!value || typeof value !== "object") return value;
+	if (isPlainObject(value)) try {
+		return structuredClone(value);
+	} catch {}
+	return JSON.parse(JSON.stringify(value));
+}
+//#endregion
+export { once 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, peekFile as Q, isBunTestRuntime as R, debug as S, warn as T, getAutoQaDbPath as U, VERSION as V, getDebugLogPath as W, getToolsDir as X, getRemoteDir as Y, isProbablyBinary as Z, parseStreamingJsonThrottled as _, readSseEvents as a, isEnotdir as b, combineSignals as c, $which as d, untilAborted 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, render as u, hasFsCode as v, time as w, parseFrontmatter as x, isEnoent as y, isTerminalHeadless as z };