blun-king-cli 9.1.600 → 9.1.601

package/blun.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:c0b3db57102f82b976cc669375212221a4788318dbd6d1bfc28e943f7bf649db
+// BLUN_BUILD_INPUT_SHA256:b5b19f76ccc092b4eba456b9da34bbda10f5c0717713caa03a28337eab2cac02
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
@@ -181000,7 +181000,10 @@ function applyCompletionBudgetWithDetails(args) {
 	});
 	if (args.retry !== void 0) cap = Math.max(args.retry.minimumCompletionTokens, Math.ceil(cap * args.retry.multiplier));
 	const maxContextTokens = args.capability?.max_context_tokens;
-	if (args.usedContextTokens !== void 0 && maxContextTokens !== void 0 && maxContextTokens > 0) cap = Math.max(MIN_FLOOR, Math.min(cap, maxContextTokens - args.usedContextTokens));
+	if (args.usedContextTokens !== void 0 && maxContextTokens !== void 0 && maxContextTokens > 0) {
+		const headroom = Math.min(2048, Math.ceil(maxContextTokens * .01));
+		cap = Math.max(MIN_FLOOR, Math.min(cap, maxContextTokens - args.usedContextTokens - headroom));
+	}
 	return {
 		provider: args.provider.withMaxCompletionTokens(cap, {
 			usedContextTokens: args.usedContextTokens,
@@ -235215,6 +235218,9 @@ var init_engine = __esmMin((() => {
 			for (const [event, hooks] of this.byEvent.entries()) result[event] = hooks.length;
 			return result;
 		}
+		hasMatchingHook(event, matcherValue) {
+			return this.matchingHooks(event, matcherValue).length > 0;
+		}
 		closeAdmission() {
 			this.admissionClosed = true;
 		}
@@ -264967,6 +264973,1381 @@ var init_tool_result_budget = __esmMin((() => {
 	TOOL_RESULT_PREVIEW_CHARS = 2e3;
 }));
 //#endregion
+//#region ../../packages/kaos/src/errors.ts
+var KaosError, KaosFileExistsError, KaosShellNotFoundError;
+var init_errors$1 = __esmMin((() => {
+	KaosError = class extends Error {
+		constructor(message) {
+			super(message);
+			this.name = "KaosError";
+		}
+	};
+	KaosFileExistsError = class extends KaosError {
+		constructor(message) {
+			super(message);
+			this.name = "KaosFileExistsError";
+		}
+	};
+	KaosShellNotFoundError = class extends KaosError {
+		constructor(message) {
+			super(message);
+			this.name = "KaosShellNotFoundError";
+		}
+	};
+}));
+//#endregion
+//#region ../../packages/kaos/src/environment.ts
+/**
+* Environment — cross-platform probe of OS / shell.
+*
+* Detection is a pure function of injected probes (`platform` / `arch` /
+* `release` / `env` / `isFile` / `execFileText`) so the same suite runs
+* identically on any host OS. `detectEnvironmentFromNode()` bundles the Node
+* defaults for production callers.
+*
+* On Windows the probe expects Git Bash (the canonical POSIX shell that
+* ships with Git for Windows). If it cannot be located the function
+* throws `KaosShellNotFoundError`; the SDK layer can wrap that into a
+* user-facing install hint. Set `BLUN_SHELL_PATH` to override.
+*/
+function resolveOsKind(platform) {
+	switch (platform) {
+		case "darwin": return "macOS";
+		case "linux": return "Linux";
+		case "win32": return "Windows";
+		default: return platform;
+	}
+}
+async function detectEnvironment(deps) {
+	const osKind = resolveOsKind(deps.platform);
+	const osArch = deps.arch;
+	const osVersion = deps.release;
+	if (deps.platform === "win32") return {
+		osKind,
+		osArch,
+		osVersion,
+		shellName: "bash",
+		shellPath: await locateWindowsGitBash(deps)
+	};
+	const candidates = [
+		"/bin/bash",
+		"/usr/bin/bash",
+		"/usr/local/bin/bash"
+	];
+	let found;
+	for (const p of candidates) if (await deps.isFile(p)) {
+		found = p;
+		break;
+	}
+	if (found !== void 0) return {
+		osKind,
+		osArch,
+		osVersion,
+		shellName: "bash",
+		shellPath: found
+	};
+	return {
+		osKind,
+		osArch,
+		osVersion,
+		shellName: "sh",
+		shellPath: "/bin/sh"
+	};
+}
+async function locateWindowsGitBash(deps) {
+	const checked = [];
+	const override = deps.env["BLUN_SHELL_PATH"]?.trim();
+	if (override !== void 0 && override.length > 0) {
+		checked.push(override);
+		if (await deps.isFile(override)) return override;
+	}
+	const gitExecutables = await findExecutablesOnPath("git.exe", deps.env["PATH"], deps.platform, deps.isFile);
+	for (const gitExe of gitExecutables) {
+		const inferred = gitBashCandidatesFromGitExe(gitExe);
+		if (inferred !== void 0) for (const candidate of inferred) {
+			checked.push(candidate);
+			if (await deps.isFile(candidate)) return candidate;
+		}
+		const gitExecPath = await readGitExecPath(deps, gitExe);
+		if (gitExecPath === void 0) continue;
+		for (const candidate of gitBashCandidatesFromGitExecPath(gitExecPath)) {
+			checked.push(candidate);
+			if (await deps.isFile(candidate)) return candidate;
+		}
+	}
+	const candidates = [
+		"C:\\Program Files\\Git\\bin\\bash.exe",
+		"C:\\Program Files\\Git\\usr\\bin\\bash.exe",
+		"C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+		"C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe"
+	];
+	const localAppData = deps.env["LOCALAPPDATA"]?.trim();
+	if (localAppData !== void 0 && localAppData.length > 0) {
+		candidates.push(`${localAppData}\\Programs\\Git\\bin\\bash.exe`);
+		candidates.push(`${localAppData}\\Programs\\Git\\usr\\bin\\bash.exe`);
+	}
+	for (const candidate of candidates) {
+		checked.push(candidate);
+		if (await deps.isFile(candidate)) return candidate;
+	}
+	throw new KaosShellNotFoundError(`Git Bash was not found on this Windows host. Install Git for Windows from https://gitforwindows.org/ or set BLUN_SHELL_PATH to a bash.exe. Checked: ${checked.join(", ")}.`);
+}
+async function readGitExecPath(deps, gitExe) {
+	if (deps.platform === "win32" && !isAbsoluteWindowsPath(gitExe)) return void 0;
+	const stdout = await deps.execFileText(gitExe, ["--exec-path"], GIT_EXEC_PATH_TIMEOUT_MS);
+	if (stdout === void 0) return void 0;
+	for (const line of stdout.split(/\r?\n/)) {
+		const execPath = line.trim();
+		if (execPath.length > 0) return execPath;
+	}
+}
+function gitBashCandidatesFromGitExe(gitExe) {
+	const normalizedGitExe = path$18.win32.normalize(normalizeWindowsPath(gitExe));
+	const gitDir = path$18.win32.dirname(normalizedGitExe);
+	const gitDirName = path$18.win32.basename(gitDir).toLowerCase();
+	if (gitDirName !== "cmd" && gitDirName !== "bin") return;
+	return gitBashCandidatesFromGitRoot(path$18.win32.dirname(gitDir));
+}
+function gitBashCandidatesFromGitExecPath(execPath) {
+	const normalized = path$18.win32.normalize(normalizeWindowsPath(execPath));
+	const parts = normalized.split("\\");
+	for (let i = parts.length - 1; i >= 0; i -= 1) {
+		const segment = parts[i]?.toLowerCase();
+		if (segment === "mingw32" || segment === "mingw64") {
+			const root = parts.slice(0, i).join("\\");
+			if (root.length > 0) return gitBashCandidatesFromGitRoot(root);
+		}
+	}
+	return gitBashCandidatesFromGitRoot(path$18.win32.join(normalized, "..", ".."));
+}
+function gitBashCandidatesFromGitRoot(root) {
+	return [path$18.win32.normalize(path$18.win32.join(root, "bin", "bash.exe")), path$18.win32.normalize(path$18.win32.join(root, "usr", "bin", "bash.exe"))];
+}
+function normalizeWindowsPath(path) {
+	return path.replaceAll("/", "\\");
+}
+function isAbsoluteWindowsPath(path) {
+	return path$18.win32.isAbsolute(normalizeWindowsPath(path));
+}
+function dedupeWindowsPaths(paths) {
+	const deduped = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const path of paths) {
+		const key = normalizeWindowsPath(path).toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(path);
+	}
+	return deduped;
+}
+function detectEnvironmentFromNode() {
+	if (detectedEnvironment !== void 0) return detectedEnvironment;
+	const platform = process.platform;
+	const env = process.env;
+	const isFile = async (path) => {
+		try {
+			await access(path, constants.F_OK);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	detectedEnvironment = detectEnvironment({
+		platform,
+		arch: process.arch,
+		release: nodeOs.release(),
+		env,
+		isFile,
+		execFileText: execFileText$1
+	});
+	return detectedEnvironment;
+}
+async function findExecutablesOnPath(name, pathEnv, platform, isFile) {
+	if (pathEnv === void 0 || pathEnv.length === 0) return [];
+	const listSep = platform === "win32" ? ";" : ":";
+	const dirSep = platform === "win32" ? "\\" : "/";
+	const paths = [];
+	for (const rawDir of pathEnv.split(listSep)) {
+		const dir = rawDir.trim();
+		if (dir.length === 0) continue;
+		if (platform === "win32" && !isAbsoluteWindowsPath(dir)) continue;
+		const candidate = dir.endsWith(dirSep) ? `${dir}${name}` : `${dir}${dirSep}${name}`;
+		if (await isFile(candidate)) paths.push(candidate);
+	}
+	return platform === "win32" ? dedupeWindowsPaths(paths) : paths;
+}
+async function execFileText$1(file, args, timeoutMs) {
+	return new Promise((resolve) => {
+		execFile(file, [...args], {
+			encoding: "utf8",
+			timeout: timeoutMs,
+			windowsHide: true
+		}, (error, stdout) => {
+			if (error !== null) {
+				resolve(void 0);
+				return;
+			}
+			resolve(stdout);
+		});
+	});
+}
+var GIT_EXEC_PATH_TIMEOUT_MS, detectedEnvironment;
+var init_environment$1 = __esmMin((() => {
+	init_errors$1();
+	GIT_EXEC_PATH_TIMEOUT_MS = 5e3;
+}));
+//#endregion
+//#region ../../packages/kaos/src/internal.ts
+function isUtf8Continuation(byte) {
+	return byte >= 128 && byte <= 191;
+}
+function decodeUtf8Ignore(data) {
+	let output = "";
+	let i = 0;
+	while (i < data.length) {
+		const b0 = data[i];
+		if (b0 === void 0) break;
+		if (b0 <= 127) {
+			output += String.fromCodePoint(b0);
+			i += 1;
+			continue;
+		}
+		if (b0 >= 194 && b0 <= 223) {
+			const b1 = data[i + 1];
+			if (b1 !== void 0 && isUtf8Continuation(b1)) {
+				output += String.fromCodePoint((b0 & 31) << 6 | b1 & 63);
+				i += 2;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		if (b0 >= 224 && b0 <= 239) {
+			const b1 = data[i + 1];
+			const b2 = data[i + 2];
+			if (b1 !== void 0 && (b0 === 224 && b1 >= 160 && b1 <= 191 || b0 >= 225 && b0 <= 236 && isUtf8Continuation(b1) || b0 === 237 && b1 >= 128 && b1 <= 159 || b0 >= 238 && b0 <= 239 && isUtf8Continuation(b1)) && b2 !== void 0 && isUtf8Continuation(b2)) {
+				output += String.fromCodePoint((b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63);
+				i += 3;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		if (b0 >= 240 && b0 <= 244) {
+			const b1 = data[i + 1];
+			const b2 = data[i + 2];
+			const b3 = data[i + 3];
+			if (b1 !== void 0 && (b0 === 240 && b1 >= 144 && b1 <= 191 || b0 >= 241 && b0 <= 243 && isUtf8Continuation(b1) || b0 === 244 && b1 >= 128 && b1 <= 143) && b2 !== void 0 && b3 !== void 0 && isUtf8Continuation(b2) && isUtf8Continuation(b3)) {
+				output += String.fromCodePoint((b0 & 7) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63);
+				i += 4;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		i += 1;
+	}
+	return output;
+}
+function decodeUtf16LeIgnore(data) {
+	let output = "";
+	let i = 0;
+	while (i + 1 < data.length) {
+		const first = data[i];
+		const second = data[i + 1];
+		if (first === void 0 || second === void 0) break;
+		const codeUnit = first | second << 8;
+		if (codeUnit >= 55296 && codeUnit <= 56319) {
+			const lowFirst = data[i + 2];
+			const lowSecond = data[i + 3];
+			if (lowFirst !== void 0 && lowSecond !== void 0) {
+				const low = lowFirst | lowSecond << 8;
+				if (low >= 56320 && low <= 57343) {
+					const codePoint = 65536 + (codeUnit - 55296 << 10) + (low - 56320);
+					output += String.fromCodePoint(codePoint);
+					i += 4;
+					continue;
+				}
+			}
+			i += 2;
+			continue;
+		}
+		if (codeUnit >= 56320 && codeUnit <= 57343) {
+			i += 2;
+			continue;
+		}
+		output += String.fromCodePoint(codeUnit);
+		i += 2;
+	}
+	return output;
+}
+/**
+* Decode a Buffer into a string with Python-compatible `errors` handling.
+*
+* - `'strict'` (default): throw on invalid sequences (via TextDecoder `fatal: true`)
+* - `'replace'`: substitute each invalid sequence with U+FFFD (TextDecoder default)
+* - `'ignore'`: drop invalid input sequences while preserving valid U+FFFD characters
+*
+* Falls back to `Buffer.toString(encoding)` for encodings TextDecoder does not
+* support (e.g. `hex`, `base64`, `binary`, `latin1`) — those are lossless
+* byte-to-character mappings so `errors` has no effect.
+* @internal
+*/
+function decodeTextWithErrors(data, encoding, errors = "strict", ignoreBOM = false) {
+	let webLabel;
+	switch (encoding) {
+		case "utf-8":
+		case "utf8":
+			webLabel = "utf-8";
+			break;
+		case "utf16le":
+		case "ucs2":
+		case "ucs-2":
+			webLabel = "utf-16le";
+			break;
+		default: webLabel = void 0;
+	}
+	if (webLabel === void 0) return data.toString(encoding);
+	if (errors === "strict") return new TextDecoder(webLabel, {
+		fatal: true,
+		ignoreBOM
+	}).decode(data);
+	if (errors === "ignore") return webLabel === "utf-8" ? decodeUtf8Ignore(data) : decodeUtf16LeIgnore(data);
+	return new TextDecoder(webLabel, {
+		fatal: false,
+		ignoreBOM
+	}).decode(data);
+}
+/**
+* Convert a glob pattern segment (e.g. "*.txt", "file?.log") into a RegExp.
+* Mirrors Python pathlib behavior: includes dotfiles, case-sensitive by default.
+* @internal
+*/
+function globPatternToRegex(pattern, caseSensitive) {
+	let regex = "^";
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === void 0) break;
+		switch (ch) {
+			case "*":
+				regex += "[^/]*";
+				break;
+			case "?":
+				regex += "[^/]";
+				break;
+			case "[": {
+				const end = pattern.indexOf("]", i + 1);
+				if (end === -1) regex += "\\[";
+				else {
+					let charClass = pattern.slice(i + 1, end);
+					charClass = charClass.replace(/\\/g, "\\\\");
+					if (charClass.startsWith("!")) charClass = "^" + charClass.slice(1);
+					else if (charClass.startsWith("^")) charClass = "\\" + charClass;
+					regex += "[" + charClass + "]";
+					i = end;
+				}
+				break;
+			}
+			case "\\":
+				if (i + 1 < pattern.length) {
+					const next = pattern.charAt(i + 1);
+					regex += next.replaceAll(/[{}()+.\\[\]^$|]/g, "\\$&");
+					i++;
+				} else regex += "\\\\";
+				break;
+			default: regex += ch.replaceAll(/[{}()+.\\[\]^$|]/g, "\\$&");
+		}
+	}
+	regex += "$";
+	return new RegExp(regex, caseSensitive ? "" : "i");
+}
+var BufferedReadable;
+var init_internal = __esmMin((() => {
+	BufferedReadable = class extends Readable$1 {
+		_source;
+		_ended = false;
+		constructor(source) {
+			super({ highWaterMark: 128 * 1024 });
+			this._source = source;
+			this._source.on("data", this._onData);
+			this._source.on("end", this._onEnd);
+			this._source.on("close", this._onClose);
+			this._source.on("error", this._onError);
+		}
+		_read() {
+			if (!this._ended && !this.destroyed) this._source.resume();
+		}
+		_destroy(error, callback) {
+			this._source.off("data", this._onData);
+			this._source.off("end", this._onEnd);
+			this._source.off("close", this._onClose);
+			this._source.off("error", this._onError);
+			this._source.destroy();
+			callback(error);
+		}
+		_onData = (chunk) => {
+			if (!this.push(chunk)) this._source.pause();
+		};
+		_onEnd = () => {
+			this._ended = true;
+			this.push(null);
+		};
+		_onClose = () => {
+			if (!this._ended) {
+				this._ended = true;
+				this.push(null);
+			}
+		};
+		_onError = (error) => {
+			this.destroy(error);
+		};
+	};
+}));
+//#endregion
+//#region ../../packages/kaos/src/login-shell-path.ts
+/**
+* Login-shell PATH probe — enrich `process.env.PATH` with entries from the
+* user's login shell.
+*
+* When blun is launched from a context that skipped the user's shell
+* profile (GUI launchers, non-login parent shells), `process.env.PATH`
+* misses entries like `/opt/homebrew/bin`, so commands spawned by the Bash
+* tool can't find tools the user has in their interactive shell (e.g.
+* `gh`). We run the user's login shell once (`$SHELL -l -c /usr/bin/env`),
+* extract its PATH, and append the entries the current PATH lacks. Existing
+* entries keep their order and priority; failures (no resolvable shell,
+* hung or broken profile) silently leave PATH untouched.
+*
+* launchd/daemon launches can leave `$SHELL` unset or blank (see
+* `defaultShell()` in agent-core's terminalService for the same case), so
+* the probe falls back to the OS account's login shell from the user
+* database before giving up.
+*
+* Like `detectEnvironment`, the probe is a pure function of injected deps
+* so the suite runs identically on any host. Windows is skipped: the
+* problem is specific to POSIX login-shell profiles.
+*/
+/**
+* Run the user's login shell and return its PATH, or `undefined` when the
+* probe does not apply (Windows, no resolvable shell) or fails (spawn
+* error, timeout, no PATH in the output).
+*/
+async function probeLoginShellPath(deps) {
+	if (deps.platform === "win32") return void 0;
+	const envShell = deps.env["SHELL"]?.trim();
+	const shell = envShell === void 0 || envShell.length === 0 ? deps.userShell() : envShell;
+	if (shell === void 0 || shell.length === 0) return void 0;
+	const stdout = await deps.execFileText(shell, [
+		"-l",
+		"-c",
+		"/usr/bin/env"
+	], LOGIN_SHELL_ENV_TIMEOUT_MS);
+	if (stdout === void 0) return void 0;
+	let path;
+	for (const line of stdout.split("\n")) if (line.startsWith("PATH=")) path = line.slice(5).trim();
+	if (path === void 0 || path.length === 0) return void 0;
+	return path;
+}
+/**
+* Union of the current PATH and the login-shell PATH: the current PATH
+* string is kept verbatim — including empty components, which POSIX
+* command lookup treats as the current directory — and login-shell
+* entries the current PATH lacks are appended in their own order. When
+* nothing is missing the current string is returned unchanged. Only
+* absolute login-shell entries are imported: empty, `.`, and relative
+* components are all cwd-dependent lookup, and appending one the user
+* did not already have would widen their search path — LocalKaos runs
+* commands from arbitrary workspace directories.
+*/
+function mergeLoginShellPath(currentPath, loginShellPath) {
+	const current = currentPath ?? "";
+	const seen = new Set(current.split(":").filter((entry) => entry.length > 0));
+	const additions = [];
+	for (const entry of loginShellPath.split(":")) {
+		if (!entry.startsWith("/") || seen.has(entry)) continue;
+		seen.add(entry);
+		additions.push(entry);
+	}
+	if (additions.length === 0) return current;
+	if (currentPath === void 0) return additions.join(":");
+	return `${current}:${additions.join(":")}`;
+}
+/** Probe the login shell and merge its PATH into `deps.env['PATH']`. */
+async function applyLoginShellPath(deps) {
+	const loginShellPath = await probeLoginShellPath(deps);
+	if (loginShellPath === void 0) return;
+	const currentPath = deps.env["PATH"];
+	const merged = mergeLoginShellPath(currentPath, loginShellPath);
+	if (merged === (currentPath ?? "")) return;
+	deps.env["PATH"] = merged;
+}
+/**
+* Production convenience — apply the probe to `process.env` once per
+* process. Memoised like `detectEnvironmentFromNode`: the login-shell PATH
+* does not change for the lifetime of the process, and repeated
+* `LocalKaos.create()` calls must not re-spawn the shell.
+*/
+/**
+* Login shell from the OS user database (`/etc/passwd` via getpwuid on
+* Linux, Directory Services on macOS). `userInfo()` throws when the uid
+* has no database entry (e.g. containers running an arbitrary uid), and
+* service accounts may carry `/usr/sbin/nologin` — the latter needs no
+* special casing here because probing it simply fails and degrades
+* silently.
+*/
+function userShellFromNode() {
+	try {
+		const shell = userInfo().shell;
+		return shell === null || shell.length === 0 ? void 0 : shell;
+	} catch {
+		return;
+	}
+}
+function applyLoginShellPathFromNode() {
+	if (appliedLoginShellPath !== void 0) return appliedLoginShellPath;
+	appliedLoginShellPath = applyLoginShellPath({
+		platform: process.platform,
+		env: process.env,
+		userShell: userShellFromNode,
+		execFileText: execFileText$1
+	});
+	return appliedLoginShellPath;
+}
+var LOGIN_SHELL_ENV_TIMEOUT_MS, appliedLoginShellPath;
+var init_login_shell_path = __esmMin((() => {
+	init_environment$1();
+	LOGIN_SHELL_ENV_TIMEOUT_MS = 5e3;
+}));
+//#endregion
+//#region ../../packages/kaos/src/local.ts
+/**
+* Build the `(dev, ino)` cycle-detection key used by `_globWalk`'s
+* visited set. Returns `null` when `ino` is 0, which Node returns on
+* filesystems that don't carry inodes (Windows FAT/exFAT, some SMB/NFS
+* mounts). A null key signals "no reliable identity for this dir" so
+* the caller skips visited tracking for that descent — cycle safety
+* is weakened on those filesystems, but normal walking works instead
+* of every directory colliding on the shared key `"<dev>:0"`.
+*/
+function cycleKey(s) {
+	if (s.ino === 0) return null;
+	return `${String(s.dev)}:${String(s.ino)}`;
+}
+function buildLocalSpawnOptions(_isWindows, cwd, env) {
+	return {
+		cwd,
+		env,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		detached: true,
+		windowsHide: true
+	};
+}
+function isUtf8Encoding(encoding) {
+	return encoding === "utf-8" || encoding === "utf8";
+}
+function* splitLinesKeepingTerminator(text) {
+	if (text.length === 0) return;
+	let start = 0;
+	for (let i = 0; i < text.length; i += 1) if (text.codePointAt(i) === 10) {
+		yield text.slice(start, i + 1);
+		start = i + 1;
+	}
+	if (start < text.length) yield text.slice(start);
+}
+function updateLineEndingFlagsFromBytes(flags, chunk, prevWasCr) {
+	for (let i = 0; i < chunk.length; i += 1) {
+		const byte = chunk[i];
+		if (byte === void 0) continue;
+		if (byte === 13) {
+			if (prevWasCr) flags.hasLoneCr = true;
+			prevWasCr = true;
+		} else if (byte === 10) {
+			if (prevWasCr) flags.hasCrLf = true;
+			else flags.hasLf = true;
+			prevWasCr = false;
+		} else {
+			if (prevWasCr) flags.hasLoneCr = true;
+			prevWasCr = false;
+		}
+	}
+	return prevWasCr;
+}
+function createUtf8Validator() {
+	let needed = 0;
+	let lower = 128;
+	let upper = 191;
+	const fail = () => {
+		throw new TypeError("Invalid UTF-8 data");
+	};
+	return {
+		write(chunk) {
+			for (let i = 0; i < chunk.length; i += 1) {
+				const byte = chunk[i];
+				if (byte === void 0) continue;
+				if (needed === 0) {
+					if (byte <= 127) continue;
+					if (byte >= 194 && byte <= 223) needed = 1;
+					else if (byte === 224) {
+						needed = 2;
+						lower = 160;
+					} else if (byte >= 225 && byte <= 236) needed = 2;
+					else if (byte === 237) {
+						needed = 2;
+						upper = 159;
+					} else if (byte >= 238 && byte <= 239) needed = 2;
+					else if (byte === 240) {
+						needed = 3;
+						lower = 144;
+					} else if (byte >= 241 && byte <= 243) needed = 3;
+					else if (byte === 244) {
+						needed = 3;
+						upper = 143;
+					} else fail();
+				} else {
+					if (byte < lower || byte > upper) fail();
+					lower = 128;
+					upper = 191;
+					needed -= 1;
+				}
+			}
+		},
+		end() {
+			if (needed !== 0) fail();
+		}
+	};
+}
+async function readRange(fh, start, length) {
+	const data = Buffer.alloc(length);
+	let offset = 0;
+	while (offset < length) {
+		const { bytesRead } = await fh.read(data, offset, length - offset, start + offset);
+		if (bytesRead === 0) break;
+		offset += bytesRead;
+	}
+	return offset === length ? data : data.subarray(0, offset);
+}
+function waitForSpawn(child) {
+	return new Promise((resolve, reject) => {
+		const onSpawn = () => {
+			child.off("error", onError);
+			resolve();
+		};
+		const onError = (err) => {
+			child.off("spawn", onSpawn);
+			reject(err);
+		};
+		child.once("spawn", onSpawn);
+		child.once("error", onError);
+	});
+}
+var isWindows$1, READ_CHUNK_SIZE, LocalProcess, LocalKaos;
+var init_local = __esmMin((() => {
+	init_dist$6();
+	init_environment$1();
+	init_errors$1();
+	init_internal();
+	init_login_shell_path();
+	isWindows$1 = process.platform === "win32";
+	READ_CHUNK_SIZE = 64 * 1024;
+	LocalProcess = class {
+		stdin;
+		stdout;
+		stderr;
+		pid;
+		_child;
+		_exitCode = null;
+		_exitPromise;
+		_disposed = false;
+		constructor(child) {
+			if (child.stdin === null || child.stdout === null || child.stderr === null) throw new Error("Process must be created with stdin/stdout/stderr pipes.");
+			this._child = child;
+			this.stdin = child.stdin;
+			this.stdout = new BufferedReadable(child.stdout);
+			this.stderr = new BufferedReadable(child.stderr);
+			this.pid = child.pid ?? -1;
+			this._exitPromise = new Promise((resolve, reject) => {
+				child.on("exit", (code) => {
+					this._exitCode = code ?? -1;
+					resolve(this._exitCode);
+				});
+				child.on("error", (error) => {
+					reject(error);
+				});
+			});
+		}
+		get exitCode() {
+			return this._exitCode;
+		}
+		async wait() {
+			return this._exitPromise;
+		}
+		kill(signal) {
+			if (this.pid <= 0) return Promise.resolve();
+			if (isWindows$1) {
+				const taskkillArgs = [
+					"/T",
+					"/F",
+					"/PID",
+					String(this.pid)
+				];
+				return new Promise((resolve) => {
+					const killer = spawn("taskkill", taskkillArgs, {
+						stdio: "ignore",
+						windowsHide: true
+					});
+					const done = () => {
+						resolve();
+					};
+					killer.once("error", done);
+					killer.once("close", done);
+				});
+			}
+			try {
+				process.kill(-this.pid, signal ?? "SIGTERM");
+			} catch (error) {
+				const err = error;
+				if (err.code === "ESRCH") return Promise.resolve();
+				if (err.code === "EPERM") {
+					try {
+						this._child.kill(signal ?? "SIGTERM");
+					} catch {}
+					return Promise.resolve();
+				}
+				throw error;
+			}
+			return Promise.resolve();
+		}
+		dispose() {
+			if (this._disposed) return;
+			this._disposed = true;
+			this.stdin.destroy();
+			this.stdout.destroy();
+			this.stderr.destroy();
+		}
+	};
+	LocalKaos = class LocalKaos {
+		name = "local";
+		osEnv;
+		_cwd;
+		_envLayers;
+		constructor(osEnv, cwd, envLayers = []) {
+			this._cwd = normalize$4(cwd ?? process.cwd());
+			this.osEnv = osEnv;
+			this._envLayers = envLayers;
+		}
+		/**
+		* Construct a fresh `LocalKaos` after probing the host environment.
+		*
+		* Each call returns a new instance with its own `_cwd`; concurrent
+		* callers can therefore operate on independent working directories
+		* without polluting one another.
+		*/
+		static async create() {
+			const [osEnv] = await Promise.all([detectEnvironmentFromNode(), applyLoginShellPathFromNode()]);
+			return new LocalKaos(osEnv);
+		}
+		withCwd(cwd) {
+			return new LocalKaos(this.osEnv, cwd, this._envLayers);
+		}
+		withEnv(env) {
+			return new LocalKaos(this.osEnv, this._cwd, [...this._envLayers, env]);
+		}
+		_resolvePath(path) {
+			if (isAbsolute$2(path)) return normalize$4(path);
+			return join$4(this._cwd, path);
+		}
+		pathClass() {
+			return isWindows$1 ? "win32" : "posix";
+		}
+		normpath(path) {
+			return normalize$4(path);
+		}
+		gethome() {
+			return normalize$4(homedir());
+		}
+		getcwd() {
+			return this._cwd;
+		}
+		/**
+		* Change the working directory of this LocalKaos instance.
+		*
+		* Unlike Python's `os.chdir`, this is instance-scoped and never touches
+		* `process.cwd()`. Child processes spawned via {@link exec} inherit this
+		* instance's `_cwd`; concurrent LocalKaos instances each carry their own
+		* independent cwd. If you need Python-compatible process-global cwd,
+		* call `process.chdir(x)` directly.
+		*/
+		async chdir(path) {
+			const resolved = this._resolvePath(path);
+			if (!(await stat(resolved)).isDirectory()) throw new Error(`Not a directory: ${resolved}`);
+			this._cwd = resolved;
+		}
+		async stat(path, options) {
+			const resolved = this._resolvePath(path);
+			const s = options?.followSymlinks ?? true ? await stat(resolved) : await lstat(resolved);
+			return {
+				stMode: s.mode,
+				stIno: s.ino,
+				stDev: s.dev,
+				stNlink: s.nlink,
+				stUid: s.uid,
+				stGid: s.gid,
+				stSize: s.size,
+				stAtime: s.atimeMs / 1e3,
+				stMtime: s.mtimeMs / 1e3,
+				stCtime: isWindows$1 ? s.birthtimeMs / 1e3 : s.ctimeMs / 1e3
+			};
+		}
+		async *iterdir(path) {
+			const resolved = this._resolvePath(path);
+			const entries = await readdir(resolved);
+			for (const entry of entries) yield join$4(resolved, entry);
+		}
+		async *glob(path, pattern, options) {
+			const resolved = this._resolvePath(path);
+			const caseSensitive = options?.caseSensitive ?? true;
+			const patternParts = pattern.split("/");
+			const initVisited = /* @__PURE__ */ new Set();
+			try {
+				const rootKey = cycleKey(await stat(resolved));
+				if (rootKey !== null) initVisited.add(rootKey);
+			} catch {}
+			yield* this._globWalk(resolved, patternParts, caseSensitive, initVisited);
+		}
+		async *_globWalk(basePath, patternParts, caseSensitive, visited) {
+			if (patternParts.length === 0) return;
+			const [currentPattern, ...remainingParts] = patternParts;
+			if (currentPattern === "**") {
+				if (remainingParts.length > 0) yield* this._globWalk(basePath, remainingParts, caseSensitive, visited);
+				else yield basePath;
+				let entries;
+				try {
+					entries = await readdir(basePath);
+				} catch {
+					return;
+				}
+				for (const entry of entries) {
+					const fullPath = join$4(basePath, entry);
+					let entryStat;
+					try {
+						entryStat = await stat(fullPath);
+					} catch {
+						continue;
+					}
+					if (entryStat.isDirectory()) {
+						const key = cycleKey(entryStat);
+						if (key !== null && visited.has(key)) continue;
+						yield* this._globWalk(fullPath, patternParts, caseSensitive, key !== null ? new Set([...visited, key]) : visited);
+					} else if (remainingParts.length === 0) yield fullPath;
+				}
+			} else {
+				const regex = globPatternToRegex(currentPattern ?? "", caseSensitive);
+				let entries;
+				try {
+					entries = await readdir(basePath);
+				} catch {
+					return;
+				}
+				for (const entry of entries) {
+					if (!regex.test(entry)) continue;
+					const fullPath = join$4(basePath, entry);
+					if (remainingParts.length === 0) yield fullPath;
+					else {
+						let entryStat;
+						try {
+							entryStat = await stat(fullPath);
+						} catch {
+							continue;
+						}
+						if (entryStat.isDirectory()) {
+							const key = cycleKey(entryStat);
+							if (key !== null && visited.has(key)) continue;
+							yield* this._globWalk(fullPath, remainingParts, caseSensitive, key !== null ? new Set([...visited, key]) : visited);
+						}
+					}
+				}
+			}
+		}
+		async readBytes(path, n) {
+			const resolved = this._resolvePath(path);
+			if (n === void 0) return Buffer.from(await readFile(resolved));
+			const fh = await open(resolved, "r");
+			try {
+				const buf = Buffer.alloc(n);
+				const { bytesRead } = await fh.read(buf, 0, n, 0);
+				return buf.subarray(0, bytesRead);
+			} finally {
+				await fh.close();
+			}
+		}
+		async readText(path, options) {
+			const resolved = this._resolvePath(path);
+			const encoding = options?.encoding ?? "utf-8";
+			const errors = options?.errors ?? "strict";
+			return decodeTextWithErrors(await readFile(resolved), encoding, errors);
+		}
+		async *readLines(path, options) {
+			const resolved = this._resolvePath(path);
+			const encoding = options?.encoding ?? "utf-8";
+			const errors = options?.errors ?? "strict";
+			if (!isUtf8Encoding(encoding)) {
+				yield* splitLinesKeepingTerminator(decodeTextWithErrors(await readFile(resolved), encoding, errors));
+				return;
+			}
+			yield* this._readUtf8Lines(resolved, errors);
+		}
+		async scanTextFile(path) {
+			const fh = await open(this._resolvePath(path), "r");
+			try {
+				const buf = Buffer.alloc(READ_CHUNK_SIZE);
+				const flags = {
+					hasCrLf: false,
+					hasLf: false,
+					hasLoneCr: false
+				};
+				const validator = createUtf8Validator();
+				let totalLines = 0;
+				let totalBytes = 0;
+				let endsWithNewline = false;
+				let hasNul = false;
+				let prevWasCr = false;
+				while (true) {
+					const { bytesRead } = await fh.read(buf, 0, buf.length, null);
+					if (bytesRead === 0) break;
+					const chunk = buf.subarray(0, bytesRead);
+					validator.write(chunk);
+					for (let i = 0; i < chunk.length; i += 1) {
+						const byte = chunk[i];
+						if (byte === void 0) continue;
+						if (byte === 0) hasNul = true;
+						if (byte === 10) totalLines += 1;
+					}
+					prevWasCr = updateLineEndingFlagsFromBytes(flags, chunk, prevWasCr);
+					totalBytes += bytesRead;
+					endsWithNewline = chunk[bytesRead - 1] === 10;
+				}
+				if (prevWasCr) flags.hasLoneCr = true;
+				validator.end();
+				if (totalBytes > 0 && !endsWithNewline) totalLines += 1;
+				return {
+					totalLines,
+					endsWithNewline,
+					hasNul,
+					lineEndingFlags: flags
+				};
+			} finally {
+				await fh.close();
+			}
+		}
+		async *readLineRange(path, options) {
+			const resolved = this._resolvePath(path);
+			const errors = options.errors ?? "strict";
+			yield* this._readUtf8Lines(resolved, errors, {
+				startLine: options.startLine,
+				maxLines: options.maxLines
+			});
+		}
+		async *readTailLines(path, options) {
+			if (options.tailCount <= 0) return;
+			const resolved = this._resolvePath(path);
+			const errors = options.errors ?? "strict";
+			const fh = await open(resolved, "r");
+			try {
+				const s = await fh.stat();
+				if (s.size === 0) return;
+				let pos = s.size;
+				let foundLf = 0;
+				let startOffset = 0;
+				let needLf = options.tailCount;
+				let sawTailBlock = false;
+				while (pos > 0 && foundLf < needLf) {
+					const readSize = Math.min(READ_CHUNK_SIZE, pos);
+					pos -= readSize;
+					const buf = Buffer.alloc(readSize);
+					await fh.read(buf, 0, readSize, pos);
+					if (!sawTailBlock) {
+						sawTailBlock = true;
+						needLf = buf[readSize - 1] === 10 ? options.tailCount + 1 : options.tailCount;
+					}
+					for (let i = readSize - 1; i >= 0; i -= 1) {
+						if (buf[i] !== 10) continue;
+						foundLf += 1;
+						if (foundLf === needLf) {
+							startOffset = pos + i + 1;
+							break;
+						}
+					}
+				}
+				if (foundLf < needLf) startOffset = 0;
+				yield* splitLinesKeepingTerminator(decodeTextWithErrors(await readRange(fh, startOffset, s.size - startOffset), "utf-8", errors, startOffset !== 0));
+			} finally {
+				await fh.close();
+			}
+		}
+		async *_readUtf8Lines(resolved, errors, range) {
+			const startLine = range?.startLine ?? 1;
+			const maxLines = range?.maxLines ?? Number.POSITIVE_INFINITY;
+			const fh = await open(resolved, "r");
+			try {
+				const buf = Buffer.alloc(READ_CHUNK_SIZE);
+				let pending = [];
+				let pendingOffset = 0;
+				let fileOffset = 0;
+				let lineNo = 1;
+				let yielded = 0;
+				while (true) {
+					const { bytesRead } = await fh.read(buf, 0, buf.length, null);
+					if (bytesRead === 0) break;
+					const chunk = buf.subarray(0, bytesRead);
+					let lineStart = 0;
+					for (let i = 0; i < chunk.length; i += 1) {
+						if (chunk[i] !== 10) continue;
+						const piece = chunk.subarray(lineStart, i + 1);
+						const lineOffset = pending.length === 0 ? fileOffset + lineStart : pendingOffset;
+						const line = pending.length === 0 ? piece : Buffer.concat([...pending, piece]);
+						if (lineNo >= startLine) {
+							yield decodeTextWithErrors(line, "utf-8", errors, lineOffset !== 0);
+							yielded += 1;
+							if (yielded >= maxLines) return;
+						}
+						pending = [];
+						lineStart = i + 1;
+						lineNo += 1;
+					}
+					if (lineStart < chunk.length) {
+						const tail = Buffer.from(chunk.subarray(lineStart));
+						if (pending.length === 0) pendingOffset = fileOffset + lineStart;
+						pending.push(tail);
+					}
+					fileOffset += bytesRead;
+				}
+				if (pending.length > 0) {
+					const line = Buffer.concat(pending);
+					if (lineNo >= startLine) yield decodeTextWithErrors(line, "utf-8", errors, pendingOffset !== 0);
+				}
+			} finally {
+				await fh.close();
+			}
+		}
+		async writeBytes(path, data) {
+			await writeFile(this._resolvePath(path), data);
+			return data.length;
+		}
+		async writeText(path, data, options) {
+			const resolved = this._resolvePath(path);
+			const encoding = options?.encoding ?? "utf-8";
+			if ((options?.mode ?? "w") === "a") await appendFile(resolved, data, encoding);
+			else await writeFile(resolved, data, encoding);
+			return data.length;
+		}
+		async mkdir(path, options) {
+			const resolved = this._resolvePath(path);
+			const parents = options?.parents ?? false;
+			const existOk = options?.existOk ?? false;
+			if (parents) {
+				if (!existOk) try {
+					if ((await stat(resolved)).isDirectory()) throw new KaosFileExistsError(`${resolved} already exists`);
+				} catch (error) {
+					if (error instanceof KaosFileExistsError) throw error;
+					if (error.code !== "ENOENT") throw error;
+				}
+				await mkdir(resolved, { recursive: true });
+				return;
+			}
+			try {
+				await mkdir(resolved);
+			} catch (error) {
+				if (existOk && error instanceof Error && "code" in error && error.code === "EEXIST") {
+					if (!(await stat(resolved)).isDirectory()) throw new KaosFileExistsError(`${resolved} already exists but is not a directory`);
+					return;
+				}
+				throw error;
+			}
+		}
+		async exec(...args) {
+			const command = args[0];
+			if (command === void 0) throw new Error("LocalKaos.exec(): at least one argument (the command to run) is required.");
+			const child = spawn(command, args.slice(1), buildLocalSpawnOptions(isWindows$1, this._cwd, this._buildExecEnv()));
+			await waitForSpawn(child);
+			return new LocalProcess(child);
+		}
+		async execWithEnv(args, env) {
+			const command = args[0];
+			if (command === void 0) throw new Error("LocalKaos.execWithEnv(): at least one argument (the command to run) is required.");
+			const child = spawn(command, args.slice(1), buildLocalSpawnOptions(isWindows$1, this._cwd, this._buildExecEnv(env)));
+			await waitForSpawn(child);
+			return new LocalProcess(child);
+		}
+		_buildExecEnv(invocationEnv) {
+			if (this._envLayers.length === 0) return invocationEnv;
+			const merged = {
+				...process.env,
+				...invocationEnv
+			};
+			for (const layer of this._envLayers) Object.assign(merged, layer);
+			return merged;
+		}
+	};
+}));
+var init_current = __esmMin((() => {
+	new AsyncLocalStorage();
+}));
+//#endregion
+//#region ../../packages/kaos/src/index.ts
+var init_src$1 = __esmMin((() => {
+	init_environment$1();
+	init_errors$1();
+	init_local();
+	init_current();
+}));
+//#endregion
+//#region ../../packages/agent-core/src/agent/turn/historical-tool-projection.ts
+function identity(stat) {
+	return `${stat.dev}:${stat.ino}:${stat.birthtimeNs}`;
+}
+function revision(stat) {
+	return `${identity(stat)}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}:${stat.mode}`;
+}
+function canonical(path) {
+	const normalized = resolve(path);
+	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+async function checkedDirectory(path) {
+	const stat = await lstat(path, { bigint: true });
+	if (!stat.isDirectory() || stat.isSymbolicLink() || canonical(await realpath(path)) !== canonical(path)) throw new Error("Unsafe recovery directory");
+	return stat;
+}
+async function checkedAncestors(path) {
+	for (let current = resolve(path); current !== parse(current).root; current = dirname(current)) await checkedDirectory(current);
+}
+function persistableText(message) {
+	if (message.isError === true || message.content.length !== 1) return void 0;
+	const part = message.content[0];
+	if (part?.type !== "text") return void 0;
+	const text = part.text;
+	if (text.length < MIN_CHARS || text.includes("\0") || RECOVERY_REFERENCE.test(text) || Buffer.from(text, "utf8").toString("utf8") !== text || text.split("\n").some((line) => line.length > 2e3)) return void 0;
+	return text;
+}
+var MIN_CHARS, MAX_REFERENCE_CHARS, RECOVERY_REFERENCE, HistoricalToolProjection;
+var init_historical_tool_projection = __esmMin((() => {
+	init_src$1();
+	init_src$3();
+	init_read();
+	init_file_type$1();
+	init_fs$3();
+	MIN_CHARS = 3e3;
+	MAX_REFERENCE_CHARS = 2500;
+	RECOVERY_REFERENCE = /\[Tool result offloaded\]|\[Repeated tool result omitted\]|^output_path\s*:|Tool output exceeded \d+ characters/m;
+	HistoricalToolProjection = class {
+		agent;
+		files = /* @__PURE__ */ new Map();
+		directories = /* @__PURE__ */ new Map();
+		dirtyDirectories = /* @__PURE__ */ new Set();
+		pending = Promise.resolve();
+		constructor(agent) {
+			this.agent = agent;
+		}
+		async project(history, turnAnchor, tools, context) {
+			const unchanged = {
+				history,
+				changed: false
+			};
+			const boundary = turnAnchor === void 0 ? -1 : history.indexOf(turnAnchor);
+			const read = tools.find((tool) => tool.name === "Read");
+			if (boundary < 0 || !(read instanceof ReadTool) || !(this.agent.kaos instanceof LocalKaos) || this.agent.homedir === void 0 || this.agent.hooks?.hasMatchingHook("PreToolUse", "Read")) return unchanged;
+			const calls = /* @__PURE__ */ new Map();
+			const results = /* @__PURE__ */ new Map();
+			const knownTools = new Set(this.agent.tools.loopTools.map((tool) => tool.name));
+			history.forEach((message, index) => {
+				for (const call of message.toolCalls) {
+					const previous = calls.get(call.id);
+					calls.set(call.id, {
+						index,
+						name: call.name,
+						count: (previous?.count ?? 0) + 1
+					});
+				}
+				if (message.role === "tool" && message.toolCallId !== void 0) {
+					const previous = results.get(message.toolCallId);
+					results.set(message.toolCallId, {
+						index,
+						count: (previous?.count ?? 0) + 1
+					});
+				}
+			});
+			const closedBatches = /* @__PURE__ */ new Set();
+			for (let index = 0; index < boundary; index++) {
+				const message = history[index];
+				if (message.role === "assistant" && message.toolCalls.length > 0 && message.toolCalls.every((call) => {
+					const result = results.get(call.id);
+					return calls.get(call.id)?.count === 1 && result?.count === 1 && result.index > index && result.index < boundary;
+				})) closedBatches.add(index);
+			}
+			const projected = [...history];
+			let changed = false;
+			for (let index = 0; index < boundary; index++) {
+				context.signal.throwIfAborted();
+				const message = history[index];
+				if (message.role !== "tool" || !message.toolCallId) continue;
+				const call = calls.get(message.toolCallId);
+				if (call === void 0 || call.count !== 1 || !closedBatches.has(call.index) || !knownTools.has(call.name)) continue;
+				const text = persistableText(message);
+				if (text === void 0) continue;
+				const digest = createHash("sha256").update(JSON.stringify([
+					canonical(this.agent.homedir),
+					call.name,
+					message.toolCallId,
+					text
+				])).digest("hex");
+				const outputPath = join(resolve(this.agent.homedir), "tool-results", "historical", `${digest}.txt`);
+				const header = `[Tool result offloaded]\noutput_path: ${outputPath}\noutput_size_chars: ${text.length}\nsha256: ${createHash("sha256").update(text).digest("hex")}\nnext_step: Use Read with this path and line_offset/n_lines to recover the complete output.
+
+[preview]
+`;
+				if (header.length >= MAX_REFERENCE_CHARS) continue;
+				try {
+					if (!await this.canRead(read, outputPath, context)) continue;
+					const save = this.pending.then(() => this.persist(outputPath, text));
+					this.pending = save.catch(() => void 0);
+					await save;
+					const stat = await this.agent.kaos.stat(outputPath);
+					if ((stat.stMode & 61440) !== 32768 || stat.stSize !== Buffer.byteLength(text)) continue;
+					const bytes = await this.agent.kaos.readBytes(outputPath, Buffer.byteLength(text) + 1);
+					if (!Buffer.from(bytes).equals(Buffer.from(text)) || detectFileType(outputPath, Buffer.from(bytes).subarray(0, 512)).kind !== "text") continue;
+					await this.verifyFile(outputPath, text);
+					context.signal.throwIfAborted();
+					if (!await this.canRead(read, outputPath, context)) continue;
+					let preview = text.slice(0, MAX_REFERENCE_CHARS - header.length);
+					if (/[\uD800-\uDBFF]$/.test(preview)) preview = preview.slice(0, -1);
+					projected[index] = {
+						...message,
+						content: [{
+							type: "text",
+							text: header + preview
+						}]
+					};
+					changed = true;
+				} catch {
+					context.signal.throwIfAborted();
+				}
+			}
+			try {
+				for (const path of this.dirtyDirectories) await this.verifyDirectory(path);
+				this.dirtyDirectories.clear();
+			} catch {
+				return unchanged;
+			}
+			return {
+				history: changed ? projected : history,
+				changed
+			};
+		}
+		async canRead(read, path, context) {
+			if (this.agent.tools.loopTools.find((tool) => tool.name === "Read") !== read || this.agent.hooks?.hasMatchingHook("PreToolUse", "Read")) return false;
+			const args = {
+				path,
+				line_offset: 1,
+				n_lines: 1e3
+			};
+			const execution = read.resolveExecution(args);
+			if ("isError" in execution) return false;
+			const toolCall = {
+				type: "function",
+				id: "historical-recovery-check",
+				name: "Read",
+				arguments: JSON.stringify(args)
+			};
+			for (const policy of this.agent.permission.policies) {
+				const result = await policy.evaluate({
+					...context,
+					tool: read,
+					toolCall,
+					toolCalls: [toolCall],
+					args,
+					execution
+				});
+				if (result !== void 0) return result.kind === "approve" && result.executionMetadata === void 0;
+			}
+			return false;
+		}
+		async ensureDirectory(path) {
+			let created = false;
+			try {
+				await mkdir(path, { mode: 448 });
+				created = true;
+			} catch (error) {
+				if (error.code !== "EEXIST") throw error;
+			}
+			if (created && this.directories.has(dirname(path))) this.dirtyDirectories.add(dirname(path));
+			const stat = await checkedDirectory(path);
+			const previous = this.directories.get(path);
+			if (previous !== void 0 && previous.identity !== identity(stat)) throw new Error("Recovery directory replaced");
+			if (previous === void 0) {
+				if (created) await hardenPrivatePath(path, "directory");
+				await this.verifyDirectory(path);
+			} else if (previous.revision !== revision(stat) && !this.dirtyDirectories.has(path)) await this.verifyDirectory(path);
+		}
+		async verifyDirectory(path) {
+			const before = await checkedDirectory(path);
+			const previous = this.directories.get(path);
+			if (previous !== void 0 && previous.identity !== identity(before)) throw new Error("Recovery directory replaced");
+			if (process.platform === "win32") new WindowsPrivateAcl().verify(path, "directory");
+			else if ((before.mode & 63n) !== 0n) throw new Error("Recovery directory is not private");
+			const after = await checkedDirectory(path);
+			if (revision(before) !== revision(after)) throw new Error("Recovery directory changed during verification");
+			this.directories.set(path, {
+				identity: identity(after),
+				revision: revision(after)
+			});
+		}
+		async persist(path, text) {
+			await checkedAncestors(dirname(dirname(dirname(path))));
+			await this.ensureDirectory(dirname(dirname(path)));
+			await this.ensureDirectory(dirname(path));
+			if (this.files.has(path)) {
+				await this.verifyFile(path, text);
+				return;
+			}
+			try {
+				await lstat(path);
+				await this.verifyFile(path, text);
+				if (process.platform === "win32") new WindowsPrivateAcl().verify(path, "file");
+				this.files.set(path, revision(await lstat(path, { bigint: true })));
+				return;
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			const staging = join(dirname(path), `${randomUUID()}.staging`);
+			this.dirtyDirectories.add(dirname(path));
+			try {
+				await atomicWritePrivate$1(staging, text);
+				await checkedAncestors(dirname(path));
+				await link(staging, path);
+			} finally {
+				await unlink(staging).catch(() => void 0);
+			}
+			await this.verifyFile(path, text);
+			this.files.set(path, revision(await lstat(path, { bigint: true })));
+		}
+		async verifyFile(path, text) {
+			const before = await lstat(path, { bigint: true });
+			if (!before.isFile() || before.isSymbolicLink() || before.nlink !== 1n || before.size !== BigInt(Buffer.byteLength(text)) || process.platform !== "win32" && (before.mode & 63n) !== 0n || canonical(await realpath(path)) !== canonical(path)) throw new Error("Unsafe recovery artifact");
+			const previous = this.files.get(path);
+			if (previous !== void 0 && previous !== revision(before)) throw new Error("Recovery artifact changed");
+			const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+			try {
+				if (revision(await handle.stat({ bigint: true })) !== revision(before) || !(await handle.readFile()).equals(Buffer.from(text)) || revision(await handle.stat({ bigint: true })) !== revision(before) || revision(await lstat(path, { bigint: true })) !== revision(before) || canonical(await realpath(path)) !== canonical(path)) throw new Error("Recovery artifact changed");
+			} finally {
+				await handle.close();
+			}
+		}
+	};
+}));
+//#endregion
 //#region ../../packages/agent-core/src/agent/response-review-decision.ts
 /** Never carry provider/guard prose, signed receipts or arbitrary codes into logs. */
 function rejectionFindings(report) {
@@ -265611,6 +266992,7 @@ var init_turn = __esmMin((() => {
 	init_canonical_args();
 	init_tool_dedup();
 	init_tool_result_budget();
+	init_historical_tool_projection();
 	init_response_review();
 	import_turn_tool_performance_policy = require_turn_tool_performance_policy();
 	BLUN_LEAN_TOOL_NAMES = new Set([
@@ -265693,8 +267075,10 @@ var init_turn = __esmMin((() => {
 		stepFailureByTurn = /* @__PURE__ */ new Map();
 		providerRequestFailureByTurn = /* @__PURE__ */ new Map();
 		currentStep = 0;
+		historicalToolProjection;
 		constructor(agent) {
 			this.agent = agent;
+			this.historicalToolProjection = new HistoricalToolProjection(agent);
 		}
 		/** Explicit host shutdown only; ordinary cancellation remains resumable. */
 		closeAdmission() {
@@ -266100,7 +267484,10 @@ var init_turn = __esmMin((() => {
 				turnId,
 				origin
 			});
+			const previousLastMessage = this.agent.context.history.at(-1);
 			this.agent.context.appendUserMessage(input, origin);
+			const appendedMessage = this.agent.context.history.at(-1);
+			const turnAnchor = appendedMessage !== previousLastMessage && appendedMessage?.role === "user" && appendedMessage.origin === origin ? appendedMessage : void 0;
 			const startedAt = Date.now();
 			let ended;
 			let blockedByUserPromptHook = false;
@@ -266127,7 +267514,7 @@ var init_turn = __esmMin((() => {
 						this.agent.log.warn("Turn-start observation failed");
 					}
 					signal.throwIfAborted();
-					const stopReason = await this.runStepLoop(turnId, signal, input, origin, (response) => {
+					const stopReason = await this.runStepLoop(turnId, signal, input, origin, turnAnchor, (response) => {
 						completedResponse = response;
 					});
 					completedStopReason = stopReason;
@@ -266292,7 +267679,7 @@ var init_turn = __esmMin((() => {
 				content: hookResult.message
 			});
 		}
-		async runStepLoop(turnId, signal, input, origin, onFinalResponse) {
+		async runStepLoop(turnId, signal, input, origin, turnAnchor, onFinalResponse) {
 			let stopHookContinuationUsed = false;
 			let goalOutcomeMessageContinuationUsed = false;
 			const deduper = new ToolCallDeduplicator({ telemetry: this.agent.telemetry });
@@ -266305,11 +267692,25 @@ var init_turn = __esmMin((() => {
 			let taskToolsNeeded = turnNeedsThinking || blunTurnHasAttachment(input);
 			const greetingAnchor = this.agent.context.history.findLast((message) => message.role === "user" && message.origin?.kind === "user");
 			let partialContext = false;
-			const turnHistory = () => {
-				const history = personalMemoryRecall === void 0 ? this.agent.context.history : [...this.agent.context.history, personalMemoryRecall];
+			const turnHistory = async (tools) => {
+				const raw = [...this.agent.context.history];
+				const history = personalMemoryRecall === void 0 ? raw : [...raw, personalMemoryRecall];
 				const selected = taskToolsNeeded ? history : greetingHistory(history, greetingAnchor);
-				partialContext = selected.length < history.length;
-				return selected;
+				const projected = await this.historicalToolProjection.project(selected, turnAnchor, tools, {
+					turnId: String(turnId),
+					stepNumber: this.currentStep,
+					signal,
+					llm: turnLLM
+				});
+				const current = this.agent.context.history;
+				if (current.length !== raw.length || current.some((message, index) => message !== raw[index])) {
+					const latest = personalMemoryRecall === void 0 ? current : [...current, personalMemoryRecall];
+					const retained = taskToolsNeeded ? latest : greetingHistory(latest, greetingAnchor);
+					partialContext = retained.length < latest.length;
+					return retained;
+				}
+				partialContext = selected.length < history.length || projected.changed;
+				return projected.history;
 			};
 			const turnLLM = this.agent.llmForTurn(turnNeedsThinking ? void 0 : "off");
 			const turnTools = this.agent.tools.captureTurnTools();
@@ -266345,8 +267746,8 @@ var init_turn = __esmMin((() => {
 							}, completion);
 						},
 						llm: turnLLM,
-						buildMessages: () => this.agent.context.project(turnHistory(), { dropOrphanResults: true }),
-						buildMessagesStrict: () => this.agent.context.project(turnHistory(), {
+						buildMessages: async () => this.agent.context.project(await turnHistory(selectedTools), { dropOrphanResults: true }),
+						buildMessagesStrict: async () => this.agent.context.project(await turnHistory(selectedTools), {
 							synthesizeMissing: true,
 							dropOrphanResults: true,
 							dedupeDuplicateToolCalls: true,
@@ -269581,6 +270982,7 @@ async function reviewNativeResponse(agent, language, input) {
 		});
 	};
 	const valueType = (value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+	let formatRetry = false;
 	for (let attempt = 1; attempt <= 2; attempt += 1) {
 		let receivedBytes = 0;
 		let outputLimitExceeded = false;
@@ -269597,7 +270999,7 @@ async function reviewNativeResponse(agent, language, input) {
 				attempt: `${attempt}/2`
 			}
 		};
-		const prompt = attempt === 1 ? NATIVE_REVIEW_PROMPT : `${NATIVE_REVIEW_PROMPT}\nThe previous review did not satisfy the required JSON format. Return exactly one object with the two required boolean keys nativeness and orthography, no wrapper or additional keys. Use true or false, not strings or null. Set a check to false if it fails or you are uncertain.`;
+		const prompt = !formatRetry ? NATIVE_REVIEW_PROMPT : `${NATIVE_REVIEW_PROMPT}\nThe previous review did not satisfy the required JSON format. Return exactly one object with the two required boolean keys nativeness and orthography, no wrapper or additional keys. Use true or false, not strings or null. Set a check to false if it fails or you are uncertain.`;
 		try {
 			signal.throwIfAborted();
 			const requested = agent.generate(provider, prompt, [], [createUserMessage(candidateMessage)], { onMessagePart: (part) => {
@@ -269622,7 +271024,10 @@ async function reviewNativeResponse(agent, language, input) {
 				parsed = JSON.parse(text);
 			} catch {
 				record("invalid_json", attempt);
-				if (attempt === 1) continue;
+				if (attempt === 1) {
+					formatRetry = true;
+					continue;
+				}
 				return;
 			}
 			if (!isPlainRecord(parsed) || Object.keys(parsed).length !== 2 || typeof parsed["nativeness"] !== "boolean" || typeof parsed["orthography"] !== "boolean") {
@@ -269633,7 +271038,10 @@ async function reviewNativeResponse(agent, language, input) {
 					nativenessType: fields ? valueType(fields["nativeness"]) : "missing",
 					orthographyType: fields ? valueType(fields["orthography"]) : "missing"
 				});
-				if (attempt === 1 && !(fields && (fields["nativeness"] === false || fields["orthography"] === false))) continue;
+				if (attempt === 1 && !(fields && (fields["nativeness"] === false || fields["orthography"] === false))) {
+					formatRetry = true;
+					continue;
+				}
 				return;
 			}
 			record(parsed["nativeness"] && parsed["orthography"] ? "approved" : "native_rejected", attempt, {
@@ -269644,7 +271052,12 @@ async function reviewNativeResponse(agent, language, input) {
 				nativeness: parsed["nativeness"],
 				orthography: parsed["orthography"]
 			};
-		} catch {
+		} catch (error) {
+			if (!signal.aborted && !outputLimitExceeded && attempt === 1 && error instanceof APIProviderRateLimitError) {
+				record("rate_limited", attempt);
+				if (error.retryAfterMs === null) await agent.providerRetryWait.defer(providerRetryScope(modelAlias, provider), 1e3);
+				continue;
+			}
 			return invalid(signal.aborted ? "cancelled" : outputLimitExceeded ? "output_limit" : "generation_failed");
 		}
 	}
@@ -269699,6 +271112,7 @@ var init_response_review_host = __esmMin((() => {
 	init_src$4();
 	init_abort();
 	init_response_review_mcp();
+	init_provider_retry_wait();
 	init_canonical_args();
 	NATIVE_REVIEW_PROMPT = [
 		"You are an independent language reviewer, not the author of the candidate.",
@@ -334226,1138 +335640,6 @@ var init_blun_media = __esmMin((() => {
 	};
 }));
 //#endregion
-//#region ../../packages/kaos/src/errors.ts
-var KaosError, KaosFileExistsError, KaosShellNotFoundError;
-var init_errors$1 = __esmMin((() => {
-	KaosError = class extends Error {
-		constructor(message) {
-			super(message);
-			this.name = "KaosError";
-		}
-	};
-	KaosFileExistsError = class extends KaosError {
-		constructor(message) {
-			super(message);
-			this.name = "KaosFileExistsError";
-		}
-	};
-	KaosShellNotFoundError = class extends KaosError {
-		constructor(message) {
-			super(message);
-			this.name = "KaosShellNotFoundError";
-		}
-	};
-}));
-//#endregion
-//#region ../../packages/kaos/src/environment.ts
-/**
-* Environment — cross-platform probe of OS / shell.
-*
-* Detection is a pure function of injected probes (`platform` / `arch` /
-* `release` / `env` / `isFile` / `execFileText`) so the same suite runs
-* identically on any host OS. `detectEnvironmentFromNode()` bundles the Node
-* defaults for production callers.
-*
-* On Windows the probe expects Git Bash (the canonical POSIX shell that
-* ships with Git for Windows). If it cannot be located the function
-* throws `KaosShellNotFoundError`; the SDK layer can wrap that into a
-* user-facing install hint. Set `BLUN_SHELL_PATH` to override.
-*/
-function resolveOsKind(platform) {
-	switch (platform) {
-		case "darwin": return "macOS";
-		case "linux": return "Linux";
-		case "win32": return "Windows";
-		default: return platform;
-	}
-}
-async function detectEnvironment(deps) {
-	const osKind = resolveOsKind(deps.platform);
-	const osArch = deps.arch;
-	const osVersion = deps.release;
-	if (deps.platform === "win32") return {
-		osKind,
-		osArch,
-		osVersion,
-		shellName: "bash",
-		shellPath: await locateWindowsGitBash(deps)
-	};
-	const candidates = [
-		"/bin/bash",
-		"/usr/bin/bash",
-		"/usr/local/bin/bash"
-	];
-	let found;
-	for (const p of candidates) if (await deps.isFile(p)) {
-		found = p;
-		break;
-	}
-	if (found !== void 0) return {
-		osKind,
-		osArch,
-		osVersion,
-		shellName: "bash",
-		shellPath: found
-	};
-	return {
-		osKind,
-		osArch,
-		osVersion,
-		shellName: "sh",
-		shellPath: "/bin/sh"
-	};
-}
-async function locateWindowsGitBash(deps) {
-	const checked = [];
-	const override = deps.env["BLUN_SHELL_PATH"]?.trim();
-	if (override !== void 0 && override.length > 0) {
-		checked.push(override);
-		if (await deps.isFile(override)) return override;
-	}
-	const gitExecutables = await findExecutablesOnPath("git.exe", deps.env["PATH"], deps.platform, deps.isFile);
-	for (const gitExe of gitExecutables) {
-		const inferred = gitBashCandidatesFromGitExe(gitExe);
-		if (inferred !== void 0) for (const candidate of inferred) {
-			checked.push(candidate);
-			if (await deps.isFile(candidate)) return candidate;
-		}
-		const gitExecPath = await readGitExecPath(deps, gitExe);
-		if (gitExecPath === void 0) continue;
-		for (const candidate of gitBashCandidatesFromGitExecPath(gitExecPath)) {
-			checked.push(candidate);
-			if (await deps.isFile(candidate)) return candidate;
-		}
-	}
-	const candidates = [
-		"C:\\Program Files\\Git\\bin\\bash.exe",
-		"C:\\Program Files\\Git\\usr\\bin\\bash.exe",
-		"C:\\Program Files (x86)\\Git\\bin\\bash.exe",
-		"C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe"
-	];
-	const localAppData = deps.env["LOCALAPPDATA"]?.trim();
-	if (localAppData !== void 0 && localAppData.length > 0) {
-		candidates.push(`${localAppData}\\Programs\\Git\\bin\\bash.exe`);
-		candidates.push(`${localAppData}\\Programs\\Git\\usr\\bin\\bash.exe`);
-	}
-	for (const candidate of candidates) {
-		checked.push(candidate);
-		if (await deps.isFile(candidate)) return candidate;
-	}
-	throw new KaosShellNotFoundError(`Git Bash was not found on this Windows host. Install Git for Windows from https://gitforwindows.org/ or set BLUN_SHELL_PATH to a bash.exe. Checked: ${checked.join(", ")}.`);
-}
-async function readGitExecPath(deps, gitExe) {
-	if (deps.platform === "win32" && !isAbsoluteWindowsPath(gitExe)) return void 0;
-	const stdout = await deps.execFileText(gitExe, ["--exec-path"], GIT_EXEC_PATH_TIMEOUT_MS);
-	if (stdout === void 0) return void 0;
-	for (const line of stdout.split(/\r?\n/)) {
-		const execPath = line.trim();
-		if (execPath.length > 0) return execPath;
-	}
-}
-function gitBashCandidatesFromGitExe(gitExe) {
-	const normalizedGitExe = path$18.win32.normalize(normalizeWindowsPath(gitExe));
-	const gitDir = path$18.win32.dirname(normalizedGitExe);
-	const gitDirName = path$18.win32.basename(gitDir).toLowerCase();
-	if (gitDirName !== "cmd" && gitDirName !== "bin") return;
-	return gitBashCandidatesFromGitRoot(path$18.win32.dirname(gitDir));
-}
-function gitBashCandidatesFromGitExecPath(execPath) {
-	const normalized = path$18.win32.normalize(normalizeWindowsPath(execPath));
-	const parts = normalized.split("\\");
-	for (let i = parts.length - 1; i >= 0; i -= 1) {
-		const segment = parts[i]?.toLowerCase();
-		if (segment === "mingw32" || segment === "mingw64") {
-			const root = parts.slice(0, i).join("\\");
-			if (root.length > 0) return gitBashCandidatesFromGitRoot(root);
-		}
-	}
-	return gitBashCandidatesFromGitRoot(path$18.win32.join(normalized, "..", ".."));
-}
-function gitBashCandidatesFromGitRoot(root) {
-	return [path$18.win32.normalize(path$18.win32.join(root, "bin", "bash.exe")), path$18.win32.normalize(path$18.win32.join(root, "usr", "bin", "bash.exe"))];
-}
-function normalizeWindowsPath(path) {
-	return path.replaceAll("/", "\\");
-}
-function isAbsoluteWindowsPath(path) {
-	return path$18.win32.isAbsolute(normalizeWindowsPath(path));
-}
-function dedupeWindowsPaths(paths) {
-	const deduped = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const path of paths) {
-		const key = normalizeWindowsPath(path).toLowerCase();
-		if (seen.has(key)) continue;
-		seen.add(key);
-		deduped.push(path);
-	}
-	return deduped;
-}
-function detectEnvironmentFromNode() {
-	if (detectedEnvironment !== void 0) return detectedEnvironment;
-	const platform = process.platform;
-	const env = process.env;
-	const isFile = async (path) => {
-		try {
-			await access(path, constants.F_OK);
-			return true;
-		} catch {
-			return false;
-		}
-	};
-	detectedEnvironment = detectEnvironment({
-		platform,
-		arch: process.arch,
-		release: nodeOs.release(),
-		env,
-		isFile,
-		execFileText: execFileText$1
-	});
-	return detectedEnvironment;
-}
-async function findExecutablesOnPath(name, pathEnv, platform, isFile) {
-	if (pathEnv === void 0 || pathEnv.length === 0) return [];
-	const listSep = platform === "win32" ? ";" : ":";
-	const dirSep = platform === "win32" ? "\\" : "/";
-	const paths = [];
-	for (const rawDir of pathEnv.split(listSep)) {
-		const dir = rawDir.trim();
-		if (dir.length === 0) continue;
-		if (platform === "win32" && !isAbsoluteWindowsPath(dir)) continue;
-		const candidate = dir.endsWith(dirSep) ? `${dir}${name}` : `${dir}${dirSep}${name}`;
-		if (await isFile(candidate)) paths.push(candidate);
-	}
-	return platform === "win32" ? dedupeWindowsPaths(paths) : paths;
-}
-async function execFileText$1(file, args, timeoutMs) {
-	return new Promise((resolve) => {
-		execFile(file, [...args], {
-			encoding: "utf8",
-			timeout: timeoutMs,
-			windowsHide: true
-		}, (error, stdout) => {
-			if (error !== null) {
-				resolve(void 0);
-				return;
-			}
-			resolve(stdout);
-		});
-	});
-}
-var GIT_EXEC_PATH_TIMEOUT_MS, detectedEnvironment;
-var init_environment$1 = __esmMin((() => {
-	init_errors$1();
-	GIT_EXEC_PATH_TIMEOUT_MS = 5e3;
-}));
-//#endregion
-//#region ../../packages/kaos/src/internal.ts
-function isUtf8Continuation(byte) {
-	return byte >= 128 && byte <= 191;
-}
-function decodeUtf8Ignore(data) {
-	let output = "";
-	let i = 0;
-	while (i < data.length) {
-		const b0 = data[i];
-		if (b0 === void 0) break;
-		if (b0 <= 127) {
-			output += String.fromCodePoint(b0);
-			i += 1;
-			continue;
-		}
-		if (b0 >= 194 && b0 <= 223) {
-			const b1 = data[i + 1];
-			if (b1 !== void 0 && isUtf8Continuation(b1)) {
-				output += String.fromCodePoint((b0 & 31) << 6 | b1 & 63);
-				i += 2;
-				continue;
-			}
-			i += 1;
-			continue;
-		}
-		if (b0 >= 224 && b0 <= 239) {
-			const b1 = data[i + 1];
-			const b2 = data[i + 2];
-			if (b1 !== void 0 && (b0 === 224 && b1 >= 160 && b1 <= 191 || b0 >= 225 && b0 <= 236 && isUtf8Continuation(b1) || b0 === 237 && b1 >= 128 && b1 <= 159 || b0 >= 238 && b0 <= 239 && isUtf8Continuation(b1)) && b2 !== void 0 && isUtf8Continuation(b2)) {
-				output += String.fromCodePoint((b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63);
-				i += 3;
-				continue;
-			}
-			i += 1;
-			continue;
-		}
-		if (b0 >= 240 && b0 <= 244) {
-			const b1 = data[i + 1];
-			const b2 = data[i + 2];
-			const b3 = data[i + 3];
-			if (b1 !== void 0 && (b0 === 240 && b1 >= 144 && b1 <= 191 || b0 >= 241 && b0 <= 243 && isUtf8Continuation(b1) || b0 === 244 && b1 >= 128 && b1 <= 143) && b2 !== void 0 && b3 !== void 0 && isUtf8Continuation(b2) && isUtf8Continuation(b3)) {
-				output += String.fromCodePoint((b0 & 7) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63);
-				i += 4;
-				continue;
-			}
-			i += 1;
-			continue;
-		}
-		i += 1;
-	}
-	return output;
-}
-function decodeUtf16LeIgnore(data) {
-	let output = "";
-	let i = 0;
-	while (i + 1 < data.length) {
-		const first = data[i];
-		const second = data[i + 1];
-		if (first === void 0 || second === void 0) break;
-		const codeUnit = first | second << 8;
-		if (codeUnit >= 55296 && codeUnit <= 56319) {
-			const lowFirst = data[i + 2];
-			const lowSecond = data[i + 3];
-			if (lowFirst !== void 0 && lowSecond !== void 0) {
-				const low = lowFirst | lowSecond << 8;
-				if (low >= 56320 && low <= 57343) {
-					const codePoint = 65536 + (codeUnit - 55296 << 10) + (low - 56320);
-					output += String.fromCodePoint(codePoint);
-					i += 4;
-					continue;
-				}
-			}
-			i += 2;
-			continue;
-		}
-		if (codeUnit >= 56320 && codeUnit <= 57343) {
-			i += 2;
-			continue;
-		}
-		output += String.fromCodePoint(codeUnit);
-		i += 2;
-	}
-	return output;
-}
-/**
-* Decode a Buffer into a string with Python-compatible `errors` handling.
-*
-* - `'strict'` (default): throw on invalid sequences (via TextDecoder `fatal: true`)
-* - `'replace'`: substitute each invalid sequence with U+FFFD (TextDecoder default)
-* - `'ignore'`: drop invalid input sequences while preserving valid U+FFFD characters
-*
-* Falls back to `Buffer.toString(encoding)` for encodings TextDecoder does not
-* support (e.g. `hex`, `base64`, `binary`, `latin1`) — those are lossless
-* byte-to-character mappings so `errors` has no effect.
-* @internal
-*/
-function decodeTextWithErrors(data, encoding, errors = "strict", ignoreBOM = false) {
-	let webLabel;
-	switch (encoding) {
-		case "utf-8":
-		case "utf8":
-			webLabel = "utf-8";
-			break;
-		case "utf16le":
-		case "ucs2":
-		case "ucs-2":
-			webLabel = "utf-16le";
-			break;
-		default: webLabel = void 0;
-	}
-	if (webLabel === void 0) return data.toString(encoding);
-	if (errors === "strict") return new TextDecoder(webLabel, {
-		fatal: true,
-		ignoreBOM
-	}).decode(data);
-	if (errors === "ignore") return webLabel === "utf-8" ? decodeUtf8Ignore(data) : decodeUtf16LeIgnore(data);
-	return new TextDecoder(webLabel, {
-		fatal: false,
-		ignoreBOM
-	}).decode(data);
-}
-/**
-* Convert a glob pattern segment (e.g. "*.txt", "file?.log") into a RegExp.
-* Mirrors Python pathlib behavior: includes dotfiles, case-sensitive by default.
-* @internal
-*/
-function globPatternToRegex(pattern, caseSensitive) {
-	let regex = "^";
-	for (let i = 0; i < pattern.length; i++) {
-		const ch = pattern[i];
-		if (ch === void 0) break;
-		switch (ch) {
-			case "*":
-				regex += "[^/]*";
-				break;
-			case "?":
-				regex += "[^/]";
-				break;
-			case "[": {
-				const end = pattern.indexOf("]", i + 1);
-				if (end === -1) regex += "\\[";
-				else {
-					let charClass = pattern.slice(i + 1, end);
-					charClass = charClass.replace(/\\/g, "\\\\");
-					if (charClass.startsWith("!")) charClass = "^" + charClass.slice(1);
-					else if (charClass.startsWith("^")) charClass = "\\" + charClass;
-					regex += "[" + charClass + "]";
-					i = end;
-				}
-				break;
-			}
-			case "\\":
-				if (i + 1 < pattern.length) {
-					const next = pattern.charAt(i + 1);
-					regex += next.replaceAll(/[{}()+.\\[\]^$|]/g, "\\$&");
-					i++;
-				} else regex += "\\\\";
-				break;
-			default: regex += ch.replaceAll(/[{}()+.\\[\]^$|]/g, "\\$&");
-		}
-	}
-	regex += "$";
-	return new RegExp(regex, caseSensitive ? "" : "i");
-}
-var BufferedReadable;
-var init_internal = __esmMin((() => {
-	BufferedReadable = class extends Readable$1 {
-		_source;
-		_ended = false;
-		constructor(source) {
-			super({ highWaterMark: 128 * 1024 });
-			this._source = source;
-			this._source.on("data", this._onData);
-			this._source.on("end", this._onEnd);
-			this._source.on("close", this._onClose);
-			this._source.on("error", this._onError);
-		}
-		_read() {
-			if (!this._ended && !this.destroyed) this._source.resume();
-		}
-		_destroy(error, callback) {
-			this._source.off("data", this._onData);
-			this._source.off("end", this._onEnd);
-			this._source.off("close", this._onClose);
-			this._source.off("error", this._onError);
-			this._source.destroy();
-			callback(error);
-		}
-		_onData = (chunk) => {
-			if (!this.push(chunk)) this._source.pause();
-		};
-		_onEnd = () => {
-			this._ended = true;
-			this.push(null);
-		};
-		_onClose = () => {
-			if (!this._ended) {
-				this._ended = true;
-				this.push(null);
-			}
-		};
-		_onError = (error) => {
-			this.destroy(error);
-		};
-	};
-}));
-//#endregion
-//#region ../../packages/kaos/src/login-shell-path.ts
-/**
-* Login-shell PATH probe — enrich `process.env.PATH` with entries from the
-* user's login shell.
-*
-* When blun is launched from a context that skipped the user's shell
-* profile (GUI launchers, non-login parent shells), `process.env.PATH`
-* misses entries like `/opt/homebrew/bin`, so commands spawned by the Bash
-* tool can't find tools the user has in their interactive shell (e.g.
-* `gh`). We run the user's login shell once (`$SHELL -l -c /usr/bin/env`),
-* extract its PATH, and append the entries the current PATH lacks. Existing
-* entries keep their order and priority; failures (no resolvable shell,
-* hung or broken profile) silently leave PATH untouched.
-*
-* launchd/daemon launches can leave `$SHELL` unset or blank (see
-* `defaultShell()` in agent-core's terminalService for the same case), so
-* the probe falls back to the OS account's login shell from the user
-* database before giving up.
-*
-* Like `detectEnvironment`, the probe is a pure function of injected deps
-* so the suite runs identically on any host. Windows is skipped: the
-* problem is specific to POSIX login-shell profiles.
-*/
-/**
-* Run the user's login shell and return its PATH, or `undefined` when the
-* probe does not apply (Windows, no resolvable shell) or fails (spawn
-* error, timeout, no PATH in the output).
-*/
-async function probeLoginShellPath(deps) {
-	if (deps.platform === "win32") return void 0;
-	const envShell = deps.env["SHELL"]?.trim();
-	const shell = envShell === void 0 || envShell.length === 0 ? deps.userShell() : envShell;
-	if (shell === void 0 || shell.length === 0) return void 0;
-	const stdout = await deps.execFileText(shell, [
-		"-l",
-		"-c",
-		"/usr/bin/env"
-	], LOGIN_SHELL_ENV_TIMEOUT_MS);
-	if (stdout === void 0) return void 0;
-	let path;
-	for (const line of stdout.split("\n")) if (line.startsWith("PATH=")) path = line.slice(5).trim();
-	if (path === void 0 || path.length === 0) return void 0;
-	return path;
-}
-/**
-* Union of the current PATH and the login-shell PATH: the current PATH
-* string is kept verbatim — including empty components, which POSIX
-* command lookup treats as the current directory — and login-shell
-* entries the current PATH lacks are appended in their own order. When
-* nothing is missing the current string is returned unchanged. Only
-* absolute login-shell entries are imported: empty, `.`, and relative
-* components are all cwd-dependent lookup, and appending one the user
-* did not already have would widen their search path — LocalKaos runs
-* commands from arbitrary workspace directories.
-*/
-function mergeLoginShellPath(currentPath, loginShellPath) {
-	const current = currentPath ?? "";
-	const seen = new Set(current.split(":").filter((entry) => entry.length > 0));
-	const additions = [];
-	for (const entry of loginShellPath.split(":")) {
-		if (!entry.startsWith("/") || seen.has(entry)) continue;
-		seen.add(entry);
-		additions.push(entry);
-	}
-	if (additions.length === 0) return current;
-	if (currentPath === void 0) return additions.join(":");
-	return `${current}:${additions.join(":")}`;
-}
-/** Probe the login shell and merge its PATH into `deps.env['PATH']`. */
-async function applyLoginShellPath(deps) {
-	const loginShellPath = await probeLoginShellPath(deps);
-	if (loginShellPath === void 0) return;
-	const currentPath = deps.env["PATH"];
-	const merged = mergeLoginShellPath(currentPath, loginShellPath);
-	if (merged === (currentPath ?? "")) return;
-	deps.env["PATH"] = merged;
-}
-/**
-* Production convenience — apply the probe to `process.env` once per
-* process. Memoised like `detectEnvironmentFromNode`: the login-shell PATH
-* does not change for the lifetime of the process, and repeated
-* `LocalKaos.create()` calls must not re-spawn the shell.
-*/
-/**
-* Login shell from the OS user database (`/etc/passwd` via getpwuid on
-* Linux, Directory Services on macOS). `userInfo()` throws when the uid
-* has no database entry (e.g. containers running an arbitrary uid), and
-* service accounts may carry `/usr/sbin/nologin` — the latter needs no
-* special casing here because probing it simply fails and degrades
-* silently.
-*/
-function userShellFromNode() {
-	try {
-		const shell = userInfo().shell;
-		return shell === null || shell.length === 0 ? void 0 : shell;
-	} catch {
-		return;
-	}
-}
-function applyLoginShellPathFromNode() {
-	if (appliedLoginShellPath !== void 0) return appliedLoginShellPath;
-	appliedLoginShellPath = applyLoginShellPath({
-		platform: process.platform,
-		env: process.env,
-		userShell: userShellFromNode,
-		execFileText: execFileText$1
-	});
-	return appliedLoginShellPath;
-}
-var LOGIN_SHELL_ENV_TIMEOUT_MS, appliedLoginShellPath;
-var init_login_shell_path = __esmMin((() => {
-	init_environment$1();
-	LOGIN_SHELL_ENV_TIMEOUT_MS = 5e3;
-}));
-//#endregion
-//#region ../../packages/kaos/src/local.ts
-/**
-* Build the `(dev, ino)` cycle-detection key used by `_globWalk`'s
-* visited set. Returns `null` when `ino` is 0, which Node returns on
-* filesystems that don't carry inodes (Windows FAT/exFAT, some SMB/NFS
-* mounts). A null key signals "no reliable identity for this dir" so
-* the caller skips visited tracking for that descent — cycle safety
-* is weakened on those filesystems, but normal walking works instead
-* of every directory colliding on the shared key `"<dev>:0"`.
-*/
-function cycleKey(s) {
-	if (s.ino === 0) return null;
-	return `${String(s.dev)}:${String(s.ino)}`;
-}
-function buildLocalSpawnOptions(_isWindows, cwd, env) {
-	return {
-		cwd,
-		env,
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		],
-		detached: true,
-		windowsHide: true
-	};
-}
-function isUtf8Encoding(encoding) {
-	return encoding === "utf-8" || encoding === "utf8";
-}
-function* splitLinesKeepingTerminator(text) {
-	if (text.length === 0) return;
-	let start = 0;
-	for (let i = 0; i < text.length; i += 1) if (text.codePointAt(i) === 10) {
-		yield text.slice(start, i + 1);
-		start = i + 1;
-	}
-	if (start < text.length) yield text.slice(start);
-}
-function updateLineEndingFlagsFromBytes(flags, chunk, prevWasCr) {
-	for (let i = 0; i < chunk.length; i += 1) {
-		const byte = chunk[i];
-		if (byte === void 0) continue;
-		if (byte === 13) {
-			if (prevWasCr) flags.hasLoneCr = true;
-			prevWasCr = true;
-		} else if (byte === 10) {
-			if (prevWasCr) flags.hasCrLf = true;
-			else flags.hasLf = true;
-			prevWasCr = false;
-		} else {
-			if (prevWasCr) flags.hasLoneCr = true;
-			prevWasCr = false;
-		}
-	}
-	return prevWasCr;
-}
-function createUtf8Validator() {
-	let needed = 0;
-	let lower = 128;
-	let upper = 191;
-	const fail = () => {
-		throw new TypeError("Invalid UTF-8 data");
-	};
-	return {
-		write(chunk) {
-			for (let i = 0; i < chunk.length; i += 1) {
-				const byte = chunk[i];
-				if (byte === void 0) continue;
-				if (needed === 0) {
-					if (byte <= 127) continue;
-					if (byte >= 194 && byte <= 223) needed = 1;
-					else if (byte === 224) {
-						needed = 2;
-						lower = 160;
-					} else if (byte >= 225 && byte <= 236) needed = 2;
-					else if (byte === 237) {
-						needed = 2;
-						upper = 159;
-					} else if (byte >= 238 && byte <= 239) needed = 2;
-					else if (byte === 240) {
-						needed = 3;
-						lower = 144;
-					} else if (byte >= 241 && byte <= 243) needed = 3;
-					else if (byte === 244) {
-						needed = 3;
-						upper = 143;
-					} else fail();
-				} else {
-					if (byte < lower || byte > upper) fail();
-					lower = 128;
-					upper = 191;
-					needed -= 1;
-				}
-			}
-		},
-		end() {
-			if (needed !== 0) fail();
-		}
-	};
-}
-async function readRange(fh, start, length) {
-	const data = Buffer.alloc(length);
-	let offset = 0;
-	while (offset < length) {
-		const { bytesRead } = await fh.read(data, offset, length - offset, start + offset);
-		if (bytesRead === 0) break;
-		offset += bytesRead;
-	}
-	return offset === length ? data : data.subarray(0, offset);
-}
-function waitForSpawn(child) {
-	return new Promise((resolve, reject) => {
-		const onSpawn = () => {
-			child.off("error", onError);
-			resolve();
-		};
-		const onError = (err) => {
-			child.off("spawn", onSpawn);
-			reject(err);
-		};
-		child.once("spawn", onSpawn);
-		child.once("error", onError);
-	});
-}
-var isWindows$1, READ_CHUNK_SIZE, LocalProcess, LocalKaos;
-var init_local = __esmMin((() => {
-	init_dist$6();
-	init_environment$1();
-	init_errors$1();
-	init_internal();
-	init_login_shell_path();
-	isWindows$1 = process.platform === "win32";
-	READ_CHUNK_SIZE = 64 * 1024;
-	LocalProcess = class {
-		stdin;
-		stdout;
-		stderr;
-		pid;
-		_child;
-		_exitCode = null;
-		_exitPromise;
-		_disposed = false;
-		constructor(child) {
-			if (child.stdin === null || child.stdout === null || child.stderr === null) throw new Error("Process must be created with stdin/stdout/stderr pipes.");
-			this._child = child;
-			this.stdin = child.stdin;
-			this.stdout = new BufferedReadable(child.stdout);
-			this.stderr = new BufferedReadable(child.stderr);
-			this.pid = child.pid ?? -1;
-			this._exitPromise = new Promise((resolve, reject) => {
-				child.on("exit", (code) => {
-					this._exitCode = code ?? -1;
-					resolve(this._exitCode);
-				});
-				child.on("error", (error) => {
-					reject(error);
-				});
-			});
-		}
-		get exitCode() {
-			return this._exitCode;
-		}
-		async wait() {
-			return this._exitPromise;
-		}
-		kill(signal) {
-			if (this.pid <= 0) return Promise.resolve();
-			if (isWindows$1) {
-				const taskkillArgs = [
-					"/T",
-					"/F",
-					"/PID",
-					String(this.pid)
-				];
-				return new Promise((resolve) => {
-					const killer = spawn("taskkill", taskkillArgs, {
-						stdio: "ignore",
-						windowsHide: true
-					});
-					const done = () => {
-						resolve();
-					};
-					killer.once("error", done);
-					killer.once("close", done);
-				});
-			}
-			try {
-				process.kill(-this.pid, signal ?? "SIGTERM");
-			} catch (error) {
-				const err = error;
-				if (err.code === "ESRCH") return Promise.resolve();
-				if (err.code === "EPERM") {
-					try {
-						this._child.kill(signal ?? "SIGTERM");
-					} catch {}
-					return Promise.resolve();
-				}
-				throw error;
-			}
-			return Promise.resolve();
-		}
-		dispose() {
-			if (this._disposed) return;
-			this._disposed = true;
-			this.stdin.destroy();
-			this.stdout.destroy();
-			this.stderr.destroy();
-		}
-	};
-	LocalKaos = class LocalKaos {
-		name = "local";
-		osEnv;
-		_cwd;
-		_envLayers;
-		constructor(osEnv, cwd, envLayers = []) {
-			this._cwd = normalize$4(cwd ?? process.cwd());
-			this.osEnv = osEnv;
-			this._envLayers = envLayers;
-		}
-		/**
-		* Construct a fresh `LocalKaos` after probing the host environment.
-		*
-		* Each call returns a new instance with its own `_cwd`; concurrent
-		* callers can therefore operate on independent working directories
-		* without polluting one another.
-		*/
-		static async create() {
-			const [osEnv] = await Promise.all([detectEnvironmentFromNode(), applyLoginShellPathFromNode()]);
-			return new LocalKaos(osEnv);
-		}
-		withCwd(cwd) {
-			return new LocalKaos(this.osEnv, cwd, this._envLayers);
-		}
-		withEnv(env) {
-			return new LocalKaos(this.osEnv, this._cwd, [...this._envLayers, env]);
-		}
-		_resolvePath(path) {
-			if (isAbsolute$2(path)) return normalize$4(path);
-			return join$4(this._cwd, path);
-		}
-		pathClass() {
-			return isWindows$1 ? "win32" : "posix";
-		}
-		normpath(path) {
-			return normalize$4(path);
-		}
-		gethome() {
-			return normalize$4(homedir());
-		}
-		getcwd() {
-			return this._cwd;
-		}
-		/**
-		* Change the working directory of this LocalKaos instance.
-		*
-		* Unlike Python's `os.chdir`, this is instance-scoped and never touches
-		* `process.cwd()`. Child processes spawned via {@link exec} inherit this
-		* instance's `_cwd`; concurrent LocalKaos instances each carry their own
-		* independent cwd. If you need Python-compatible process-global cwd,
-		* call `process.chdir(x)` directly.
-		*/
-		async chdir(path) {
-			const resolved = this._resolvePath(path);
-			if (!(await stat(resolved)).isDirectory()) throw new Error(`Not a directory: ${resolved}`);
-			this._cwd = resolved;
-		}
-		async stat(path, options) {
-			const resolved = this._resolvePath(path);
-			const s = options?.followSymlinks ?? true ? await stat(resolved) : await lstat(resolved);
-			return {
-				stMode: s.mode,
-				stIno: s.ino,
-				stDev: s.dev,
-				stNlink: s.nlink,
-				stUid: s.uid,
-				stGid: s.gid,
-				stSize: s.size,
-				stAtime: s.atimeMs / 1e3,
-				stMtime: s.mtimeMs / 1e3,
-				stCtime: isWindows$1 ? s.birthtimeMs / 1e3 : s.ctimeMs / 1e3
-			};
-		}
-		async *iterdir(path) {
-			const resolved = this._resolvePath(path);
-			const entries = await readdir(resolved);
-			for (const entry of entries) yield join$4(resolved, entry);
-		}
-		async *glob(path, pattern, options) {
-			const resolved = this._resolvePath(path);
-			const caseSensitive = options?.caseSensitive ?? true;
-			const patternParts = pattern.split("/");
-			const initVisited = /* @__PURE__ */ new Set();
-			try {
-				const rootKey = cycleKey(await stat(resolved));
-				if (rootKey !== null) initVisited.add(rootKey);
-			} catch {}
-			yield* this._globWalk(resolved, patternParts, caseSensitive, initVisited);
-		}
-		async *_globWalk(basePath, patternParts, caseSensitive, visited) {
-			if (patternParts.length === 0) return;
-			const [currentPattern, ...remainingParts] = patternParts;
-			if (currentPattern === "**") {
-				if (remainingParts.length > 0) yield* this._globWalk(basePath, remainingParts, caseSensitive, visited);
-				else yield basePath;
-				let entries;
-				try {
-					entries = await readdir(basePath);
-				} catch {
-					return;
-				}
-				for (const entry of entries) {
-					const fullPath = join$4(basePath, entry);
-					let entryStat;
-					try {
-						entryStat = await stat(fullPath);
-					} catch {
-						continue;
-					}
-					if (entryStat.isDirectory()) {
-						const key = cycleKey(entryStat);
-						if (key !== null && visited.has(key)) continue;
-						yield* this._globWalk(fullPath, patternParts, caseSensitive, key !== null ? new Set([...visited, key]) : visited);
-					} else if (remainingParts.length === 0) yield fullPath;
-				}
-			} else {
-				const regex = globPatternToRegex(currentPattern ?? "", caseSensitive);
-				let entries;
-				try {
-					entries = await readdir(basePath);
-				} catch {
-					return;
-				}
-				for (const entry of entries) {
-					if (!regex.test(entry)) continue;
-					const fullPath = join$4(basePath, entry);
-					if (remainingParts.length === 0) yield fullPath;
-					else {
-						let entryStat;
-						try {
-							entryStat = await stat(fullPath);
-						} catch {
-							continue;
-						}
-						if (entryStat.isDirectory()) {
-							const key = cycleKey(entryStat);
-							if (key !== null && visited.has(key)) continue;
-							yield* this._globWalk(fullPath, remainingParts, caseSensitive, key !== null ? new Set([...visited, key]) : visited);
-						}
-					}
-				}
-			}
-		}
-		async readBytes(path, n) {
-			const resolved = this._resolvePath(path);
-			if (n === void 0) return Buffer.from(await readFile(resolved));
-			const fh = await open(resolved, "r");
-			try {
-				const buf = Buffer.alloc(n);
-				const { bytesRead } = await fh.read(buf, 0, n, 0);
-				return buf.subarray(0, bytesRead);
-			} finally {
-				await fh.close();
-			}
-		}
-		async readText(path, options) {
-			const resolved = this._resolvePath(path);
-			const encoding = options?.encoding ?? "utf-8";
-			const errors = options?.errors ?? "strict";
-			return decodeTextWithErrors(await readFile(resolved), encoding, errors);
-		}
-		async *readLines(path, options) {
-			const resolved = this._resolvePath(path);
-			const encoding = options?.encoding ?? "utf-8";
-			const errors = options?.errors ?? "strict";
-			if (!isUtf8Encoding(encoding)) {
-				yield* splitLinesKeepingTerminator(decodeTextWithErrors(await readFile(resolved), encoding, errors));
-				return;
-			}
-			yield* this._readUtf8Lines(resolved, errors);
-		}
-		async scanTextFile(path) {
-			const fh = await open(this._resolvePath(path), "r");
-			try {
-				const buf = Buffer.alloc(READ_CHUNK_SIZE);
-				const flags = {
-					hasCrLf: false,
-					hasLf: false,
-					hasLoneCr: false
-				};
-				const validator = createUtf8Validator();
-				let totalLines = 0;
-				let totalBytes = 0;
-				let endsWithNewline = false;
-				let hasNul = false;
-				let prevWasCr = false;
-				while (true) {
-					const { bytesRead } = await fh.read(buf, 0, buf.length, null);
-					if (bytesRead === 0) break;
-					const chunk = buf.subarray(0, bytesRead);
-					validator.write(chunk);
-					for (let i = 0; i < chunk.length; i += 1) {
-						const byte = chunk[i];
-						if (byte === void 0) continue;
-						if (byte === 0) hasNul = true;
-						if (byte === 10) totalLines += 1;
-					}
-					prevWasCr = updateLineEndingFlagsFromBytes(flags, chunk, prevWasCr);
-					totalBytes += bytesRead;
-					endsWithNewline = chunk[bytesRead - 1] === 10;
-				}
-				if (prevWasCr) flags.hasLoneCr = true;
-				validator.end();
-				if (totalBytes > 0 && !endsWithNewline) totalLines += 1;
-				return {
-					totalLines,
-					endsWithNewline,
-					hasNul,
-					lineEndingFlags: flags
-				};
-			} finally {
-				await fh.close();
-			}
-		}
-		async *readLineRange(path, options) {
-			const resolved = this._resolvePath(path);
-			const errors = options.errors ?? "strict";
-			yield* this._readUtf8Lines(resolved, errors, {
-				startLine: options.startLine,
-				maxLines: options.maxLines
-			});
-		}
-		async *readTailLines(path, options) {
-			if (options.tailCount <= 0) return;
-			const resolved = this._resolvePath(path);
-			const errors = options.errors ?? "strict";
-			const fh = await open(resolved, "r");
-			try {
-				const s = await fh.stat();
-				if (s.size === 0) return;
-				let pos = s.size;
-				let foundLf = 0;
-				let startOffset = 0;
-				let needLf = options.tailCount;
-				let sawTailBlock = false;
-				while (pos > 0 && foundLf < needLf) {
-					const readSize = Math.min(READ_CHUNK_SIZE, pos);
-					pos -= readSize;
-					const buf = Buffer.alloc(readSize);
-					await fh.read(buf, 0, readSize, pos);
-					if (!sawTailBlock) {
-						sawTailBlock = true;
-						needLf = buf[readSize - 1] === 10 ? options.tailCount + 1 : options.tailCount;
-					}
-					for (let i = readSize - 1; i >= 0; i -= 1) {
-						if (buf[i] !== 10) continue;
-						foundLf += 1;
-						if (foundLf === needLf) {
-							startOffset = pos + i + 1;
-							break;
-						}
-					}
-				}
-				if (foundLf < needLf) startOffset = 0;
-				yield* splitLinesKeepingTerminator(decodeTextWithErrors(await readRange(fh, startOffset, s.size - startOffset), "utf-8", errors, startOffset !== 0));
-			} finally {
-				await fh.close();
-			}
-		}
-		async *_readUtf8Lines(resolved, errors, range) {
-			const startLine = range?.startLine ?? 1;
-			const maxLines = range?.maxLines ?? Number.POSITIVE_INFINITY;
-			const fh = await open(resolved, "r");
-			try {
-				const buf = Buffer.alloc(READ_CHUNK_SIZE);
-				let pending = [];
-				let pendingOffset = 0;
-				let fileOffset = 0;
-				let lineNo = 1;
-				let yielded = 0;
-				while (true) {
-					const { bytesRead } = await fh.read(buf, 0, buf.length, null);
-					if (bytesRead === 0) break;
-					const chunk = buf.subarray(0, bytesRead);
-					let lineStart = 0;
-					for (let i = 0; i < chunk.length; i += 1) {
-						if (chunk[i] !== 10) continue;
-						const piece = chunk.subarray(lineStart, i + 1);
-						const lineOffset = pending.length === 0 ? fileOffset + lineStart : pendingOffset;
-						const line = pending.length === 0 ? piece : Buffer.concat([...pending, piece]);
-						if (lineNo >= startLine) {
-							yield decodeTextWithErrors(line, "utf-8", errors, lineOffset !== 0);
-							yielded += 1;
-							if (yielded >= maxLines) return;
-						}
-						pending = [];
-						lineStart = i + 1;
-						lineNo += 1;
-					}
-					if (lineStart < chunk.length) {
-						const tail = Buffer.from(chunk.subarray(lineStart));
-						if (pending.length === 0) pendingOffset = fileOffset + lineStart;
-						pending.push(tail);
-					}
-					fileOffset += bytesRead;
-				}
-				if (pending.length > 0) {
-					const line = Buffer.concat(pending);
-					if (lineNo >= startLine) yield decodeTextWithErrors(line, "utf-8", errors, pendingOffset !== 0);
-				}
-			} finally {
-				await fh.close();
-			}
-		}
-		async writeBytes(path, data) {
-			await writeFile(this._resolvePath(path), data);
-			return data.length;
-		}
-		async writeText(path, data, options) {
-			const resolved = this._resolvePath(path);
-			const encoding = options?.encoding ?? "utf-8";
-			if ((options?.mode ?? "w") === "a") await appendFile(resolved, data, encoding);
-			else await writeFile(resolved, data, encoding);
-			return data.length;
-		}
-		async mkdir(path, options) {
-			const resolved = this._resolvePath(path);
-			const parents = options?.parents ?? false;
-			const existOk = options?.existOk ?? false;
-			if (parents) {
-				if (!existOk) try {
-					if ((await stat(resolved)).isDirectory()) throw new KaosFileExistsError(`${resolved} already exists`);
-				} catch (error) {
-					if (error instanceof KaosFileExistsError) throw error;
-					if (error.code !== "ENOENT") throw error;
-				}
-				await mkdir(resolved, { recursive: true });
-				return;
-			}
-			try {
-				await mkdir(resolved);
-			} catch (error) {
-				if (existOk && error instanceof Error && "code" in error && error.code === "EEXIST") {
-					if (!(await stat(resolved)).isDirectory()) throw new KaosFileExistsError(`${resolved} already exists but is not a directory`);
-					return;
-				}
-				throw error;
-			}
-		}
-		async exec(...args) {
-			const command = args[0];
-			if (command === void 0) throw new Error("LocalKaos.exec(): at least one argument (the command to run) is required.");
-			const child = spawn(command, args.slice(1), buildLocalSpawnOptions(isWindows$1, this._cwd, this._buildExecEnv()));
-			await waitForSpawn(child);
-			return new LocalProcess(child);
-		}
-		async execWithEnv(args, env) {
-			const command = args[0];
-			if (command === void 0) throw new Error("LocalKaos.execWithEnv(): at least one argument (the command to run) is required.");
-			const child = spawn(command, args.slice(1), buildLocalSpawnOptions(isWindows$1, this._cwd, this._buildExecEnv(env)));
-			await waitForSpawn(child);
-			return new LocalProcess(child);
-		}
-		_buildExecEnv(invocationEnv) {
-			if (this._envLayers.length === 0) return invocationEnv;
-			const merged = {
-				...process.env,
-				...invocationEnv
-			};
-			for (const layer of this._envLayers) Object.assign(merged, layer);
-			return merged;
-		}
-	};
-}));
-var init_current = __esmMin((() => {
-	new AsyncLocalStorage();
-}));
-//#endregion
-//#region ../../packages/kaos/src/index.ts
-var init_src$1 = __esmMin((() => {
-	init_environment$1();
-	init_errors$1();
-	init_local();
-	init_current();
-}));
-//#endregion
 //#region ../../packages/agent-core/src/agent/replay/build.ts
 async function buildReplay(persistence, range) {
 	const agent = new Agent$1({
@@ -531879,6 +532161,7 @@ var SessionEventHandler = class {
 		}
 	}
 	handleSessionError(event) {
+		if (event.code === "turn.agent_busy" && this.host.isManualPromptAdmissionPending?.(event.sessionId, event.agentId)) return;
 		this.host.streamingUI.flushNow();
 		this.host.streamingUI.resetToolUi();
 		this.host.streamingUI.finalizeLiveTextBuffers("idle");
@@ -539188,17 +539471,22 @@ var BlunTUI = class {
 	editorReplacement;
 	editorReplacementGeneration = 0;
 	preserveQueueAcrossSessionReset = false;
+	manualPromptInFlight;
+	isManualPromptAdmissionPending(sessionId, agentId) {
+		const pending = this.manualPromptInFlight;
+		return pending !== void 0 && this.session === pending.session && pending.session.id === sessionId && pending.agentId === agentId;
+	}
 	hasWaitingChannelMessage() {
 		return this.state.queuedMessages.some((item) => item.mode === "channel");
 	}
 	canInterruptForQueuedChannel() {
 		const item = this.state.queuedMessages[0];
 		if (/^[1-9]\d*$/u.test(this.pendingChannelReplyGuard?.chatId ?? "") && item?.channelChatId?.startsWith("-") === true) return false;
-		return item?.mode === "channel" && item.channelContextOnly !== true && this.session !== void 0 && this.queueSteerInFlight === void 0 && !this.deferUserMessages && !this.state.appState.isCompacting && this.state.appState.streamingPhase !== "idle" && this.state.appState.streamingPhase !== "shell" && this.shellOutputStreams.size === 0 && !this.streamingUI.hasActiveToolCalls();
+		return item?.mode === "channel" && item.channelContextOnly !== true && this.session !== void 0 && this.queueSteerInFlight === void 0 && this.manualPromptInFlight === void 0 && !this.deferUserMessages && !this.state.appState.isCompacting && this.state.appState.streamingPhase !== "idle" && this.state.appState.streamingPhase !== "shell" && this.shellOutputStreams.size === 0 && !this.streamingUI.hasActiveToolCalls();
 	}
 	canDeliverQueuedChannelHead() {
 		const item = this.state.queuedMessages[0];
-		if (this.isShuttingDown || this.queueCommandRunning || this.queueSteerInFlight !== void 0 || this.editorReplacementActive || this.deferUserMessages || this.session === void 0 || this.state.appState.model.trim().length === 0 || item?.mode !== "channel") return false;
+		if (this.isShuttingDown || this.queueCommandRunning || this.queueSteerInFlight !== void 0 || this.manualPromptInFlight !== void 0 || this.editorReplacementActive || this.deferUserMessages || this.session === void 0 || this.state.appState.model.trim().length === 0 || item?.mode !== "channel") return false;
 		const guard = this.pendingChannelReplyGuard;
 		return guard === void 0 || item.channelChatId !== void 0 && guard.chatId === item.channelChatId;
 	}
@@ -539322,7 +539610,7 @@ var BlunTUI = class {
 	canDrainQueue() {
 		const head = this.state.queuedMessages[0];
 		const remoteControl = head?.mode === "command" && head.channelCommandEnvelope !== void 0 && channelCommandCanInterrupt(head.text);
-		return !this.isShuttingDown && !this.queueCommandRunning && this.queueSteerInFlight === void 0 && !this.editorReplacementActive && !this.deferUserMessages && (remoteControl || this.state.appState.streamingPhase === "idle" && !this.state.appState.isCompacting);
+		return !this.isShuttingDown && !this.queueCommandRunning && this.queueSteerInFlight === void 0 && this.manualPromptInFlight === void 0 && !this.editorReplacementActive && !this.deferUserMessages && (remoteControl || this.state.appState.streamingPhase === "idle" && !this.state.appState.isCompacting);
 	}
 	scheduleQueueDrain() {
 		if (this.queueDrainTimer !== void 0 || !this.canDrainQueue()) return;
@@ -539350,11 +539638,12 @@ var BlunTUI = class {
 		}
 		const inFlightCount = this.queueSteerInFlight?.items.length ?? 0;
 		this.queueFlushBatchRemaining = inFlightCount + this.state.queuedMessages.length;
+		if (this.manualPromptInFlight !== void 0) this.manualPromptInFlight.flushRequested = this.queueFlushBatchRemaining > 0;
 		this.steerQueueFlushPrefix();
 		this.scheduleQueueDrain();
 	}
 	steerQueueFlushPrefix() {
-		if (this.queueSteerInFlight !== void 0 || this.queueFlushBatchRemaining === 0 || this.deferUserMessages || this.state.appState.isCompacting || this.state.appState.streamingPhase === "idle" || this.state.appState.streamingPhase === "shell") return;
+		if (this.queueSteerInFlight !== void 0 || this.manualPromptInFlight !== void 0 || this.queueFlushBatchRemaining === 0 || this.deferUserMessages || this.state.appState.isCompacting || this.state.appState.streamingPhase === "idle" || this.state.appState.streamingPhase === "shell") return;
 		const session = this.session;
 		if (session === void 0 || this.state.appState.model.trim().length === 0) {
 			this.showError(llmNotSetMessage());
@@ -539378,13 +539667,16 @@ var BlunTUI = class {
 			turnEnded: false,
 			onCommit: () => {
 				this.queueFlushBatchRemaining = Math.max(0, this.queueFlushBatchRemaining - items.length);
-				for (const item of items) this.appendTranscriptEntry({
-					id: nextTranscriptId(),
-					kind: "user",
-					turnId,
-					renderMode: "plain",
-					content: item.text.trim()
-				});
+				for (const item of items) {
+					if (item.transcriptRendered) continue;
+					this.appendTranscriptEntry({
+						id: nextTranscriptId(),
+						kind: "user",
+						turnId,
+						renderMode: "plain",
+						content: item.text.trim()
+					});
+				}
 			}
 		};
 		this.queueSteerInFlight = inFlight;
@@ -539456,7 +539748,7 @@ var BlunTUI = class {
 				channelCommandEnvelope: envelope,
 				channelAcknowledge: acknowledge
 			};
-			const busy = this.state.queuedMessages.length > 0 || this.queueSteerInFlight !== void 0 || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting;
+			const busy = this.state.queuedMessages.length > 0 || this.queueSteerInFlight !== void 0 || this.manualPromptInFlight !== void 0 || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting;
 			if (this.session === void 0 || this.deferUserMessages || this.queueCommandRunning || this.editorReplacementActive || busy && !channelCommandCanInterrupt(command)) {
 				this.state.queuedMessages.push(item);
 				this.scheduleQueueDrain();
@@ -539467,7 +539759,7 @@ var BlunTUI = class {
 		}
 		injectChannelEnvelope({
 			canDeliver: () => this.session !== void 0 && this.state.appState.model.trim().length > 0,
-			isBusy: () => this.queueCommandRunning || this.state.queuedMessages.length > 0 || this.queueSteerInFlight !== void 0 || this.deferUserMessages || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting,
+			isBusy: () => this.queueCommandRunning || this.state.queuedMessages.length > 0 || this.queueSteerInFlight !== void 0 || this.manualPromptInFlight !== void 0 || this.deferUserMessages || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting,
 			deliverNow: (modelInput, displayText, origin, contextOnly) => {
 				this.sendChannelMessageInternal(this.requireSession(), modelInput, displayText, origin, envelope.meta.chat_id, envelope.meta["image_path"], contextOnly, false, acknowledge);
 			},
@@ -539771,7 +540063,8 @@ var BlunTUI = class {
 			agentId: this.harness.interactiveAgentId,
 			parts: options?.parts,
 			imageAttachmentIds: options?.imageAttachmentIds !== void 0 && options.imageAttachmentIds.length > 0 ? options.imageAttachmentIds : void 0,
-			mode
+			mode,
+			transcriptRendered: options?.transcriptRendered
 		});
 		this.track("input_queue");
 	}
@@ -539830,7 +540123,8 @@ var BlunTUI = class {
 		this.harness.withInteractiveAgent(item.agentId ?? "main", () => {
 			this.sendMessageInternal(activeSession, item.text, {
 				parts: item.parts,
-				imageAttachmentIds: item.imageAttachmentIds
+				imageAttachmentIds: item.imageAttachmentIds,
+				transcriptRendered: item.transcriptRendered
 			});
 		});
 	}
@@ -539849,9 +540143,13 @@ var BlunTUI = class {
 		this.sessionEventHandler.requestQueuedGoalPromotion();
 	}
 	sendMessageInternal(session, input, options) {
+		if (this.manualPromptInFlight !== void 0) {
+			this.enqueueMessage(input, options);
+			return;
+		}
 		armPersonalMemoryRememberIntent(session.id, input);
 		const imageAttachmentIds = options?.imageAttachmentIds !== void 0 && options.imageAttachmentIds.length > 0 ? options.imageAttachmentIds : void 0;
-		this.appendTranscriptEntry({
+		if (!options?.transcriptRendered) this.appendTranscriptEntry({
 			id: nextTranscriptId(),
 			kind: "user",
 			turnId: void 0,
@@ -539859,13 +540157,48 @@ var BlunTUI = class {
 			content: input,
 			imageAttachmentIds
 		});
+		const agentId = this.harness.interactiveAgentId;
+		const inFlight = {
+			session,
+			agentId
+		};
+		this.manualPromptInFlight = inFlight;
+		let admissionResolved = false;
 		this.beginSessionRequest();
 		const sdkInput = options?.parts ?? input;
 		this.setAppState({
 			model: BLUN_KING_MODEL_ALIAS,
 			modelFallbackAllowed: false
 		});
-		session.promptAccepted(sdkInput).catch((error) => {
+		session.promptAccepted(sdkInput).then((result) => {
+			if (this.session !== session || this.manualPromptInFlight !== inFlight) return;
+			admissionResolved = true;
+			this.manualPromptInFlight = void 0;
+			if (!result.accepted) {
+				finishPersonalMemoryRememberIntentTurn(session.id);
+				if (inFlight.flushRequested && this.queueFlushBatchRemaining > 0) this.queueFlushBatchRemaining += 1;
+				this.state.queuedMessages = [{
+					text: input,
+					agentId,
+					parts: options?.parts,
+					imageAttachmentIds,
+					transcriptRendered: true
+				}, ...this.state.queuedMessages];
+				this.track("input_queue");
+				this.updateQueueDisplay();
+				this.state.ui.requestRender();
+			}
+			this.syncChannelQueueDeadline();
+			if (inFlight.flushRequested) this.steerQueueFlushPrefix();
+			this.scheduleQueueDrain();
+		}).catch((error) => {
+			if (this.session !== session) return;
+			if (admissionResolved) {
+				this.showError(formatErrorMessage$2(error));
+				return;
+			}
+			if (this.manualPromptInFlight !== inFlight) return;
+			this.manualPromptInFlight = void 0;
 			finishPersonalMemoryRememberIntentTurn(session.id);
 			const message = formatErrorMessage$2(error);
 			this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: message }));
@@ -539892,19 +540225,20 @@ var BlunTUI = class {
 		});
 	}
 	sendMessage(session, input, options) {
-		if (this.deferUserMessages || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting) {
+		if (this.deferUserMessages || this.manualPromptInFlight !== void 0 || this.state.queuedMessages.length > 0 || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting) {
 			this.enqueueMessage(input, options);
+			this.scheduleQueueDrain();
 			return;
 		}
 		this.sendMessageInternal(session, input, options);
 	}
 	steerMessage(session, input) {
-		if (this.deferUserMessages || this.state.appState.isCompacting) {
+		if (this.deferUserMessages || this.state.appState.isCompacting || this.manualPromptInFlight !== void 0) {
 			for (const part of input) this.enqueueMessage(part);
 			return;
 		}
 		if (this.state.appState.streamingPhase === "idle") {
-			for (const part of input) this.sendMessageInternal(session, part);
+			for (const part of input) this.sendMessage(session, part);
 			return;
 		}
 		for (const part of input) this.appendTranscriptEntry({
@@ -539924,6 +540258,7 @@ var BlunTUI = class {
 		this.state.startupState = "ready";
 	}
 	clearQueuedMessages() {
+		this.manualPromptInFlight = void 0;
 		const discarded = [...this.state.queuedMessages, ...this.queueSteerInFlight?.items ?? []];
 		this.queueSteerInFlight?.onRestore?.();
 		this.state.queuedMessages = [];
@@ -540239,6 +540574,7 @@ var BlunTUI = class {
 		this.state.terminal.setTitle(label);
 	}
 	resetSessionRuntime() {
+		this.manualPromptInFlight = void 0;
 		this.streamingUI.setSessionTotalTokens(void 0);
 		this.loopCountdown.dispose();
 		this.aborted = false;