zidane 5.14.4 → 6.0.0

package/dist/tools-CCd8e-HT.js

@@ -1,1739 +0,0 @@
-import { c as resolveReadStateMap, r as hashContent, s as readStateKey } from "./read-state-BymF41Jb.js";
-import { i as styleReplacementForVia, n as resolveOldString, r as stripLineNumberPrefixes, t as describeVia } from "./edit-utils-EGosADZq.js";
-import { J as resolveAttachmentFromTurns, c as looksBinary, g as pathArgError, q as parseAttachmentHandle, t as createAgent } from "./agent-Cch2ayTt.js";
-import { a as formatTaskStatus, i as formatDuration, s as previewLine } from "./format-BNOXpl-1.js";
-import { i as parseGitLsFiles, r as GIT_LS_FILES_COMMAND } from "./glob-DluQFSw1.js";
-import { l as errorMessage, u as isAbortLikeError } from "./errors-DJUxZg9b.js";
-import { n as reconcileImageMediaType } from "./media-sniff-Bn76JxAu.js";
-import { n as flattenTurns, r as formatTokenUsage } from "./stats-DAKBEKjc.js";
-import { n as shellQuote, t as alwaysQuote } from "./shell-quote-BmnhZmdM.js";
-import { Buffer } from "node:buffer";
-//#region src/behaviors/read-file-defaults.ts
-function normalizeReadFileInteger(value, fallback) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-	if (value < 0) return fallback;
-	return Math.floor(value);
-}
-function resolveReadFileDefaults(behavior, fallbacks) {
-	return {
-		lineLimit: normalizeReadFileInteger(behavior?.readFileDefaults?.limit, fallbacks.lineLimit),
-		textMaxBytes: normalizeReadFileInteger(behavior?.readFileDefaults?.maxBytes, fallbacks.textMaxBytes),
-		attachmentMaxBytes: normalizeReadFileInteger(behavior?.readFileDefaults?.maxBytes, fallbacks.attachmentMaxBytes)
-	};
-}
-//#endregion
-//#region src/tools/path-suggest.ts
-function entryPath$2(entry) {
-	return typeof entry === "string" ? entry : entry.path;
-}
-/**
-* Find a sibling file in the same directory sharing `path`'s basename
-* (sans extension), excluding the missing path itself. Returns just the
-* filename (not the full path) when found, otherwise `null`.
-*
-* Silent on errors — a missing parent directory or a `listFiles` failure
-* means we have no suggestion, not that anything is wrong.
-*/
-async function findSimilarFile(execution, handle, path) {
-	const slash = path.lastIndexOf("/");
-	const dir = slash === -1 ? "." : path.slice(0, slash) || "/";
-	const target = slash === -1 ? path : path.slice(slash + 1);
-	const dot = target.lastIndexOf(".");
-	const targetBase = dot === -1 ? target : target.slice(0, dot);
-	if (targetBase.length === 0) return null;
-	let entries;
-	try {
-		entries = await execution.listFiles(handle, dir);
-	} catch {
-		return null;
-	}
-	for (const item of entries) {
-		const entry = entryPath$2(item);
-		if (entry === target) continue;
-		const entryDot = entry.lastIndexOf(".");
-		if ((entryDot === -1 ? entry : entry.slice(0, entryDot)) === targetBase) return entry;
-	}
-	return null;
-}
-/**
-* Format a `Did you mean X?` suffix for missing-file errors. Returns an empty
-* string when no suggestion is available so callers can string-concat
-* unconditionally.
-*/
-async function suggestionFor(execution, handle, path) {
-	const sibling = await findSimilarFile(execution, handle, path);
-	return sibling ? ` Did you mean ${sibling}?` : "";
-}
-//#endregion
-//#region src/tools/edit.ts
-/**
-* Surgical edit — replace `old_string` with `new_string` in a single file.
-*
-* Mirrors Claude Code's `Edit` semantics so models post-trained on Anthropic's
-* tool surface need no relearning. Fails clearly when `old_string` isn't unique
-* (unless `replace_all: true`) and when not found, with a nearest-match preview
-* so the model can recover without a separate `read_file` round-trip.
-*/
-const edit = {
-	spec: {
-		name: "edit",
-		description: "Replace exact `old_string` with `new_string` in a file. Fails if `old_string` is not unique unless `replace_all: true`. Prefer over `write_file` for surgical changes — preserves the rest of the file. Tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string` — they are stripped before matching/writing, so you can paste a numbered chunk verbatim.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				path: {
-					type: "string",
-					description: "File path (relative to the execution-context cwd, or absolute)."
-				},
-				old_string: {
-					type: "string",
-					description: "Exact substring to find."
-				},
-				new_string: {
-					type: "string",
-					description: "Replacement substring."
-				},
-				replace_all: {
-					type: "boolean",
-					description: "Replace every occurrence. Default: false."
-				}
-			},
-			required: [
-				"path",
-				"old_string",
-				"new_string"
-			]
-		}
-	},
-	async execute({ path, old_string, new_string, replace_all }, ctx) {
-		const target = path;
-		const find = old_string;
-		const replacement = new_string;
-		const replaceAll = replace_all === true;
-		const pathErr = pathArgError(target);
-		if (pathErr) {
-			ctx.reportOutcome?.("failed");
-			return `Edit error: ${pathErr}`;
-		}
-		if (find === replacement) return `Edit error: old_string and new_string are identical — nothing to change in ${target}.`;
-		if (find.length === 0) return `Edit error: old_string is empty. Use write_file to create or fully overwrite a file.`;
-		let original;
-		try {
-			original = await ctx.execution.readFile(ctx.handle, target);
-		} catch {
-			const hint = await suggestionFor(ctx.execution, ctx.handle, target);
-			ctx.reportOutcome?.("failed");
-			return `Edit error: file not found: ${target}.${hint}`;
-		}
-		if (ctx.behavior?.requireReadBeforeEdit) {
-			const readState = resolveReadStateMap(ctx);
-			if (readState) {
-				const absKey = readStateKey(ctx.handle.cwd, target);
-				const prior = readState.get(absKey);
-				if (!prior) return `Edit error: ${target} has not been read in this session. Call read_file first so the edit applies against the current contents.`;
-				if (prior.contentHash !== hashContent(original)) return `Edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
-			}
-		}
-		const match = resolveOldString(original, find);
-		if (!match) {
-			const preview = nearestMatchPreview(original, find);
-			ctx.reportOutcome?.("failed");
-			return preview ? `Edit error: old_string not found in ${target}. Closest match in the file: ${preview}` : `Edit error: old_string not found in ${target}.`;
-		}
-		const { actual, occurrences, via } = match;
-		if (occurrences > 1 && !replaceAll) return `Edit error: old_string appears ${occurrences} times in ${target}. Pass replace_all=true or expand old_string for uniqueness.`;
-		const styledReplacement = styleReplacementForVia(replacement, via, actual);
-		const updated = replaceAll ? original.split(actual).join(styledReplacement) : original.replace(actual, styledReplacement);
-		if (updated === original) {
-			ctx.reportOutcome?.("noop");
-			return `Edit error: replacement produced no change in ${target}.`;
-		}
-		await ctx.execution.writeFile(ctx.handle, target, updated);
-		const readState = resolveReadStateMap(ctx);
-		if (readState) {
-			const absKey = readStateKey(ctx.handle.cwd, target);
-			const prior = readState.get(absKey);
-			if (prior) readState.set(absKey, {
-				...prior,
-				contentHash: hashContent(updated),
-				mtimeMs: Date.now()
-			});
-		}
-		ctx.reportOutcome?.("edited");
-		const viaNote = via === "exact" ? "" : ` (old_string was not found verbatim; matched via ${describeVia(via)})`;
-		return `Edited ${target}: replaced ${occurrences} occurrence${occurrences === 1 ? "" : "s"}.${viaNote}`;
-	}
-};
-/**
-* Find the line that shares the longest common prefix with the needle's first
-* line. Cheap heuristic — better than nothing for the common "model has a typo"
-* case (off-by-one indent, trailing whitespace, escape mismatch).
-*
-* Returns a "line N: <preview>" snippet or null when no line shares a useful
-* prefix. Strips line-number prefixes from the needle first so a model that
-* pasted a numbered `read_file` chunk verbatim still gets a useful diagnostic.
-*/
-function nearestMatchPreview(haystack, needle) {
-	const needleFirstLine = stripLineNumberPrefixes(needle).split("\n")[0];
-	if (needleFirstLine.length < 3) return null;
-	const lines = haystack.split("\n");
-	let bestScore = 0;
-	let bestIdx = -1;
-	for (let i = 0; i < lines.length; i++) {
-		const score = sharedPrefixLength(lines[i], needleFirstLine);
-		if (score > bestScore) {
-			bestScore = score;
-			bestIdx = i;
-		}
-	}
-	if (bestIdx < 0 || bestScore < Math.min(8, Math.floor(needleFirstLine.length / 2))) return null;
-	const snippet = lines[bestIdx].slice(0, 80);
-	return `line ${bestIdx + 1}: ${JSON.stringify(snippet)}`;
-}
-function sharedPrefixLength(a, b) {
-	const max = Math.min(a.length, b.length);
-	let i = 0;
-	while (i < max && a.charCodeAt(i) === b.charCodeAt(i)) i++;
-	return i;
-}
-//#endregion
-//#region src/tools/glob.ts
-/**
-* Glob-pattern file matching.
-*
-* Delegates matching to {@link ExecutionContext.listFiles} with `{ glob:
-* true }`. This keeps filesystem semantics inside the execution context
-* (process / docker / sandbox) instead of reaching around it from the tool.
-*
-* Results are capped at 1000 entries to keep model input bounded. The
-* cap applies after the directory filter, so dirs don't consume the
-* file budget.
-*
-* Patterns are deliberately NOT confined to the workspace: like
-* `read_file`, `../`-prefixed patterns may match outside the cwd — the
-* execution context is the sandbox boundary, not this tool.
-*
-* By default, contexts that can cheaply provide metadata return
-* `<path>\t<size>\t<mtime>` rows. Contexts without cheap metadata support return
-* paths only. Pass `metadata: false` to request plain newline-separated paths.
-*/
-const DEFAULT_LIMIT = 1e3;
-/** Backstop so a pathological walk can never hang the agent's turn. */
-const GLOB_TIMEOUT_MS = 2e4;
-function entryPath$1(entry) {
-	return typeof entry === "string" ? entry : entry.path;
-}
-function entryMetadata(entry) {
-	return typeof entry === "string" ? void 0 : entry;
-}
-function renderEntry(entry, wantMetadata) {
-	const path = entryPath$1(entry);
-	const meta = entryMetadata(entry);
-	if (!wantMetadata || typeof meta?.size !== "number" || typeof meta.mtimeMs !== "number") return path;
-	return `${path}\t${meta.size}\t${new Date(meta.mtimeMs).toISOString()}`;
-}
-const glob = {
-	isConcurrencySafe: true,
-	spec: {
-		name: "glob",
-		description: "Match files by glob pattern (supports **, *, ?). Relative to the execution context cwd; patterns may reach outside the workspace (e.g. \"../shared/**/*.ts\"). By default each row is `<path>\\t<size-bytes>\\t<mtime-iso>`; set `metadata: false` for a plain newline-separated list of paths. Always sorted.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				pattern: {
-					type: "string",
-					description: "Glob pattern (e.g. \"src/**/*.ts\", \"*.md\", \"test/**/fixtures/*\")."
-				},
-				limit: {
-					type: "number",
-					description: `Maximum number of matches to return. Default: ${DEFAULT_LIMIT}.`
-				},
-				metadata: {
-					type: "boolean",
-					description: "Append size (bytes) and mtime (ISO) per row, tab-separated. Default: true. In-process only — non-process execution contexts always return paths."
-				},
-				gitignore: {
-					type: "boolean",
-					description: "Skip files git ignores (.gitignore, .git/info/exclude, global excludes). Default: true. Set false to include ignored files like node_modules. Honored where git is available; a no-op otherwise."
-				}
-			},
-			required: ["pattern"]
-		}
-	},
-	async execute({ pattern, limit, metadata, gitignore }, ctx) {
-		const pat = pattern;
-		const max = typeof limit === "number" && limit > 0 ? limit : DEFAULT_LIMIT;
-		const wantMetadata = metadata !== false;
-		try {
-			if (ctx.execution.capabilities.glob !== true) throw new Error(`The active execution context (${ctx.execution.type}) does not support glob matching.`);
-			const controller = new AbortController();
-			const onAbort = () => controller.abort();
-			ctx.signal.addEventListener("abort", onAbort, { once: true });
-			let timer;
-			const timeout = new Promise((resolve) => {
-				timer = setTimeout(() => {
-					controller.abort();
-					resolve("timeout");
-				}, GLOB_TIMEOUT_MS);
-			});
-			try {
-				const outcome = await Promise.race([ctx.execution.listFiles(ctx.handle, pat, {
-					glob: true,
-					limit: max,
-					metadata: wantMetadata,
-					gitignore,
-					signal: controller.signal
-				}), timeout]);
-				if (outcome === "timeout") return `Glob timed out after ${GLOB_TIMEOUT_MS}ms — narrow the pattern (anchor a literal prefix like \`src/**\`) or scope it to a subdirectory.`;
-				if (outcome.length === 0) return "(no matches)";
-				return outcome.map((entry) => renderEntry(entry, wantMetadata)).join("\n");
-			} finally {
-				clearTimeout(timer);
-				ctx.signal.removeEventListener("abort", onAbort);
-			}
-		} catch (err) {
-			return `Glob error: ${errorMessage(err)}`;
-		}
-	}
-};
-//#endregion
-//#region src/tools/grep.ts
-/**
-* Search file contents by regex.
-*
-* Wraps ripgrep (`rg`) when available; when it's not, falls back to a
-* regex search that enumerates files via the execution context's shell
-* (`find` over `exec`) and reads them via `ctx.execution.readFile`. Both
-* legs go through the {@link ToolContext.execution} seam, so the search
-* runs wherever the context's files actually live — in-process, a
-* container, or a remote sandbox — without the tool ever touching the host
-* filesystem directly.
-*
-* The tool surface mirrors Claude Code's `Grep` so models authored against the
-* Anthropic tool surface need no relearning. Output modes:
-*   - `files_with_matches` (default) — newline-separated paths.
-*   - `content` — `path:line:match` (line numbers on by default).
-*   - `count` — `path:N` per matching file.
-*
-* Results are capped via `head_limit` (default 250) to keep model input
-* bounded; `offset` lets the caller page through. Pagination operates on
-* OUTPUT LINES, not match groups — in content mode, context lines and `--`
-* separators consume the budget too (documented in the schema).
-*
-* A line cap is not enough on its own: ripgrep is line-oriented, so a minified
-* / single-line file collapses to ONE match line that is the entire file, and
-* `head_limit` would happily return megabytes — enough to blow the model's
-* context window. Output is therefore ALSO byte-bounded: each line is clipped
-* to `MAX_LINE_BYTES` and the total to `OUTPUT_BYTE_CAP`, mirroring the byte
-* discipline `read_file` already enforces.
-*
-* `path` is deliberately NOT confined to the workspace: like `read_file`,
-* absolute paths and `../` traversal are allowed — the execution context is
-* the sandbox boundary, not this tool.
-*/
-const DEFAULT_HEAD_LIMIT = 250;
-/**
-* Per-line byte cap. ripgrep reports a match as the whole matching LINE, so a
-* minified / single-line file (one line = the entire file) would otherwise be
-* returned in full. Clip each line so a single line can't dump unbounded bytes
-* into the model context.
-*/
-const MAX_LINE_BYTES = 2e3;
-/** Total output byte cap, mirroring read_file's `DEFAULT_BYTE_CAP`. */
-const OUTPUT_BYTE_CAP = 262144;
-const DEFAULT_OUTPUT_MODE = "files_with_matches";
-const grep = {
-	isConcurrencySafe: true,
-	spec: {
-		name: "grep",
-		description: "Search file contents by regex. Returns matching paths (default), match content, or per-file counts. Backed by ripgrep when available, with a portable shell-listing + regex fallback when `rg` is absent.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				"pattern": {
-					type: "string",
-					description: "Regex (PCRE-flavored via ripgrep, JS regex via fallback)."
-				},
-				"path": {
-					type: "string",
-					description: "File or directory to search. Default: \".\". May be absolute or outside the workspace (no confinement — consistent with read_file)."
-				},
-				"glob": {
-					type: "string",
-					description: "Restrict to files matching this glob, e.g. \"**/*.ts\"."
-				},
-				"type": {
-					type: "string",
-					description: "rg file type filter, e.g. \"ts\", \"py\", \"rust\". Ignored by the fallback."
-				},
-				"output_mode": {
-					type: "string",
-					enum: [
-						"content",
-						"files_with_matches",
-						"count"
-					],
-					description: "Default: \"files_with_matches\"."
-				},
-				"-i": {
-					type: "boolean",
-					description: "Case-insensitive match."
-				},
-				"-n": {
-					type: "boolean",
-					description: "Show line numbers (content mode). Default: true."
-				},
-				"-A": {
-					type: "integer",
-					description: "Lines of trailing context (content mode)."
-				},
-				"-B": {
-					type: "integer",
-					description: "Lines of leading context (content mode)."
-				},
-				"-C": {
-					type: "integer",
-					description: "Lines of surrounding context (content mode). Overridden by -A/-B if set."
-				},
-				"multiline": {
-					type: "boolean",
-					description: "Allow patterns to match across line boundaries."
-				},
-				"gitignore": {
-					type: "boolean",
-					description: "Skip files git ignores (.gitignore, .git/info/exclude, global excludes). Default: true. Set false to also search ignored files like node_modules."
-				},
-				"head_limit": {
-					type: "integer",
-					description: `Cap output lines. Default: 250. Set 0 for unlimited lines. In content mode, context lines (-A/-B/-C) and "--" separators count toward the cap, so the number of matches shown may be lower. Output is independently byte-bounded: each line is clipped to ${MAX_LINE_BYTES} bytes and the total to ${OUTPUT_BYTE_CAP} bytes, so long (e.g. minified) lines never overflow the context window.`
-				},
-				"offset": {
-					type: "integer",
-					description: "Skip first N output lines. Default: 0."
-				}
-			},
-			required: ["pattern"]
-		}
-	},
-	async execute(rawInput, ctx) {
-		const input = rawInput;
-		try {
-			if (await isRipgrepAvailable(ctx)) return await runViaRipgrep(input, ctx);
-			return await runFallback(input, ctx);
-		} catch (err) {
-			if (isAbortLikeError(err)) throw err;
-			return `grep error: ${errorMessage(err)}`;
-		}
-	}
-};
-/**
-* Probe ripgrep availability **per call**. The probe is intentionally not
-* cached: caching at module scope would leak across execution contexts (an
-* orchestrator running an in-process agent and a docker agent in the same
-* Node process must be able to differ on whether `rg` exists), and caching
-* per handle adds bookkeeping for negligible savings — `rg --version` is
-* ~5 ms, and grep is invoked at most a few times per turn.
-*/
-async function isRipgrepAvailable(ctx) {
-	return (await ctx.execution.exec(ctx.handle, "rg --version", { signal: ctx.signal })).exitCode === 0;
-}
-async function runViaRipgrep(input, ctx) {
-	const args = ["rg"];
-	const mode = input.output_mode ?? DEFAULT_OUTPUT_MODE;
-	if (mode === "files_with_matches") args.push("--files-with-matches");
-	else if (mode === "count") args.push("--count");
-	else args.push(input["-n"] ?? true ? "--line-number" : "--no-line-number");
-	if (input["-i"]) args.push("-i");
-	if (mode === "content") {
-		if (typeof input["-A"] === "number") args.push("-A", String(input["-A"]));
-		if (typeof input["-B"] === "number") args.push("-B", String(input["-B"]));
-		if (typeof input["-C"] === "number" && typeof input["-A"] !== "number" && typeof input["-B"] !== "number") args.push("-C", String(input["-C"]));
-	}
-	if (input.multiline) args.push("--multiline", "--multiline-dotall");
-	if (input.gitignore === false) args.push("--no-ignore");
-	if (input.glob) args.push("--glob", input.glob);
-	if (input.type) args.push("--type", input.type);
-	args.push("--", input.pattern);
-	args.push(input.path ?? ".");
-	const command = args.map(shellQuote).join(" ");
-	const result = await ctx.execution.exec(ctx.handle, command, { signal: ctx.signal });
-	if (result.exitCode !== 0 && result.exitCode !== 1) return `grep error: ${result.stderr.trim() || `rg exited with code ${result.exitCode}`}`;
-	return formatPaginated(result.stdout, input);
-}
-async function runFallback(input, ctx) {
-	const mode = input.output_mode ?? DEFAULT_OUTPUT_MODE;
-	const flags = `${input["-i"] ? "i" : ""}${input.multiline ? "s" : ""}${mode !== "content" ? "" : "g"}`;
-	let regex;
-	try {
-		regex = new RegExp(input.pattern, flags || void 0);
-	} catch (err) {
-		return `grep error: invalid regex: ${errorMessage(err)}`;
-	}
-	const files = await enumerateFiles(input, ctx);
-	const showLineNumbers = input["-n"] ?? true;
-	const before = input["-B"] ?? input["-C"] ?? 0;
-	const after = input["-A"] ?? input["-C"] ?? 0;
-	const lines = [];
-	for (const path of files) {
-		let content;
-		try {
-			content = await ctx.execution.readFile(ctx.handle, path);
-		} catch (err) {
-			if (isAbortLikeError(err)) throw err;
-			continue;
-		}
-		if (input.multiline) {
-			const allMatches = [...content.matchAll(new RegExp(regex.source, `${flags.replace(/g/, "")}g`))];
-			if (allMatches.length === 0) continue;
-			if (mode === "files_with_matches") {
-				lines.push(path);
-				continue;
-			}
-			if (mode === "count") {
-				lines.push(`${path}:${allMatches.length}`);
-				continue;
-			}
-			for (const m of allMatches) {
-				const lineStart = content.lastIndexOf("\n", m.index - 1) + 1;
-				const lineEnd = content.indexOf("\n", m.index);
-				const snippet = content.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd);
-				const lineNo = content.slice(0, m.index).split("\n").length;
-				lines.push(formatContentLine(path, lineNo, snippet, showLineNumbers));
-			}
-			continue;
-		}
-		const fileLines = content.split("\n");
-		const matched = [];
-		for (let i = 0; i < fileLines.length; i++) {
-			regex.lastIndex = 0;
-			if (regex.test(fileLines[i])) matched.push(i);
-		}
-		if (matched.length === 0) continue;
-		if (mode === "files_with_matches") {
-			lines.push(path);
-			continue;
-		}
-		if (mode === "count") {
-			lines.push(`${path}:${matched.length}`);
-			continue;
-		}
-		const includeLineNos = /* @__PURE__ */ new Set();
-		for (const m of matched) for (let i = Math.max(0, m - before); i <= Math.min(fileLines.length - 1, m + after); i++) includeLineNos.add(i);
-		const sorted = [...includeLineNos].sort((a, b) => a - b);
-		let prev = -2;
-		for (const lineNo of sorted) {
-			if (lineNo > prev + 1 && lines.length > 0) lines.push("--");
-			const snippet = fileLines[lineNo];
-			lines.push(formatContentLine(path, lineNo + 1, snippet, showLineNumbers));
-			prev = lineNo;
-		}
-	}
-	return formatPaginated(lines.join("\n"), input);
-}
-function formatContentLine(path, lineNo, snippet, showLineNumbers) {
-	return showLineNumbers ? `${path}:${lineNo}:${snippet}` : `${path}:${snippet}`;
-}
-async function enumerateFiles(input, ctx) {
-	const root = input.path ?? ".";
-	if (input.path && !input.path.includes("*") && !input.path.includes("?")) {
-		if ((await ctx.execution.exec(ctx.handle, `test -f ${shellQuote(input.path)} && echo file || echo dir`, { signal: ctx.signal })).stdout.trim() === "file") return [input.path];
-	}
-	const result = await ctx.execution.exec(ctx.handle, buildFindCommand(root, input.glob), { signal: ctx.signal });
-	if (result.exitCode !== 0 && !result.stdout.trim()) throw new Error(result.stderr.trim() || `find exited with code ${result.exitCode}`);
-	const files = result.stdout.split("\n").map((line) => line.replace(/^\.\//, "")).filter((line) => line.length > 0).sort();
-	if (input.gitignore === false) return files;
-	return filterByGitignore(files, root, ctx);
-}
-/**
-* Best-effort intersection of `files` with `git ls-files` (non-ignored set).
-* Returns `files` unchanged when git is unavailable, the dir isn't a repo, or
-* `root` escapes the repo (absolute / `..`) — the filter can only fail open.
-*/
-async function filterByGitignore(files, root, ctx) {
-	if (files.length === 0) return files;
-	if (root !== "." && (root.startsWith("/") || root.split("/").includes(".."))) return files;
-	try {
-		const res = await ctx.execution.exec(ctx.handle, GIT_LS_FILES_COMMAND, { signal: ctx.signal });
-		if (res.exitCode !== 0) return files;
-		const allowed = new Set(parseGitLsFiles(res.stdout));
-		if (allowed.size === 0) return files;
-		return files.filter((file) => allowed.has(file));
-	} catch {
-		return files;
-	}
-}
-/**
-* Build a `find` command listing files under `root`, optionally filtered by
-* `glob`. Mirrors `glob`'s shell fallback:
-*   - a bare basename, or one behind a leading recursive-wildcard segment,
-*     with no inner slash → `-name` (matches at any depth, including the top
-*     level — preserving the recursive-glob semantics).
-*   - anything with a slash → `-path` against the full relative path. `find`'s
-*     `*` spans `/`, so the single- and double-star forms collapse to the
-*     same matcher; close enough for the no-`rg` fallback.
-*/
-function buildFindCommand(root, glob) {
-	const findRoot = normalizeFindRoot(root);
-	const base = shellQuote(findRoot);
-	if (!glob) return `find ${base} -type f`;
-	const anyDepth = glob.match(/^(?:\*\*\/)?([^/]+)$/);
-	if (anyDepth) return `find ${base} -type f -name ${shellQuote(anyDepth[1])}`;
-	const normRoot = findRoot.replace(/\/$/, "");
-	return `find ${base} -type f -path ${shellQuote(root === "." ? `./${glob}` : `${normRoot}/${glob}`)}`;
-}
-function normalizeFindRoot(root) {
-	return root.startsWith("-") ? `./${root}` : root;
-}
-function formatPaginated(text, input) {
-	const headLimit = typeof input.head_limit === "number" && input.head_limit >= 0 ? input.head_limit : DEFAULT_HEAD_LIMIT;
-	const offset = typeof input.offset === "number" && input.offset > 0 ? Math.floor(input.offset) : 0;
-	if (!text.trim()) return "(no matches)";
-	const lines = text.split("\n").filter((l) => l.length > 0);
-	const total = lines.length;
-	const sliced = headLimit === 0 ? lines.slice(offset) : lines.slice(offset, offset + headLimit);
-	if (sliced.length === 0) return "(no matches in this slice)";
-	const capped = [];
-	let bytesUsed = 0;
-	let byteCut = false;
-	for (const line of sliced) {
-		const clipped = clipLine(line);
-		const lineBytes = Buffer.byteLength(clipped) + 1;
-		if (bytesUsed + lineBytes > OUTPUT_BYTE_CAP && capped.length > 0) {
-			byteCut = true;
-			break;
-		}
-		capped.push(clipped);
-		bytesUsed += lineBytes;
-	}
-	const shown = capped.length;
-	const truncatedHead = offset > 0;
-	const lineCutTail = headLimit > 0 && offset + headLimit < total;
-	let out = capped.join("\n");
-	if (truncatedHead) out = `…(${offset} earlier lines skipped)…\n${out}`;
-	if (byteCut) out = `${out}\n…(output truncated at ${OUTPUT_BYTE_CAP} bytes after ${shown} of ${total - offset} matching lines; narrow the pattern or page with offset=${offset + shown})`;
-	else if (lineCutTail) out = `${out}\n…(${total - offset - headLimit} more lines; re-run with offset=${offset + headLimit} or larger head_limit)`;
-	return out;
-}
-/**
-* Clip one output line to `MAX_LINE_BYTES` at a UTF-8-safe boundary, appending
-* a marker that reports how many bytes were withheld. Lines within budget pass
-* through untouched.
-*/
-function clipLine(line) {
-	if (Buffer.byteLength(line) <= MAX_LINE_BYTES) return line;
-	let cut = Math.min(line.length, MAX_LINE_BYTES);
-	while (cut > 0 && Buffer.byteLength(line.slice(0, cut)) > MAX_LINE_BYTES) cut--;
-	const omitted = Buffer.byteLength(line) - Buffer.byteLength(line.slice(0, cut));
-	return `${line.slice(0, cut)}… [line clipped, ${omitted} more bytes]`;
-}
-//#endregion
-//#region src/tools/interaction.ts
-function abortReason(signal) {
-	return typeof signal.reason === "string" && signal.reason.length > 0 ? signal.reason : "Interaction aborted";
-}
-/**
-* Create an interaction tool that lets the agent request structured input.
-*
-* The model calls this tool with a payload matching the schema.
-* `onRequest` is called with the payload and should return the response
-* (string or object) that gets sent back to the model as the tool result.
-*/
-function createInteractionTool(options) {
-	return {
-		spec: {
-			name: options.name ?? "interaction",
-			description: options.description ?? "Request structured input from the user or external system.",
-			inputSchema: options.schema
-		},
-		async execute(input, ctx) {
-			const { signal } = ctx;
-			if (signal?.aborted) throw new Error(abortReason(signal));
-			let onAbort;
-			const abortPromise = signal ? new Promise((_, reject) => {
-				onAbort = () => reject(new Error(abortReason(signal)));
-				signal.addEventListener("abort", onAbort, { once: true });
-			}) : void 0;
-			try {
-				const result = abortPromise ? await Promise.race([options.onRequest(input, ctx), abortPromise]) : await options.onRequest(input, ctx);
-				return typeof result === "string" ? result : JSON.stringify(result);
-			} finally {
-				if (signal && onAbort) signal.removeEventListener("abort", onAbort);
-			}
-		}
-	};
-}
-//#endregion
-//#region src/tools/list-files.ts
-function entryPath(entry) {
-	return typeof entry === "string" ? entry : entry.path;
-}
-const listFiles = {
-	isConcurrencySafe: true,
-	spec: {
-		name: "list_files",
-		description: "List the immediate entries (files and subdirectories) at literal directory `path`. Returns a newline-separated list, or `(empty directory)` when the directory exists but is empty. Returns `Directory not found: <path>` for a missing path. Non-recursive: use `glob` for pattern matching across nested directories.",
-		inputSchema: {
-			type: "object",
-			properties: { path: {
-				type: "string",
-				description: "Directory path (relative to the execution-context cwd, or absolute). Defaults to `.`."
-			} },
-			required: []
-		}
-	},
-	async execute({ path }, ctx) {
-		try {
-			return (await ctx.execution.listFiles(ctx.handle, path || ".")).map(entryPath).join("\n") || "(empty directory)";
-		} catch {
-			return `Directory not found: ${path}`;
-		}
-	}
-};
-//#endregion
-//#region src/tools/multi-edit.ts
-/**
-* Inline annotation builder — kept local to avoid importing from
-* `chat/edit-approval.ts` (that's a renderer-side module; tools live
-* one layer below). Line shape matches `parseEditOutcomesFromResult`'s
-* regex so the round-trip is lossless.
-*
-* Newlines in `reason` are folded to spaces because the parser is line-
-* scoped (`body.split('\n')`); a multi-line reason would split into a
-* "trailing prose" line and trip the malformed-block guard, losing every
-* outcome below it. Static reasons in this file are single-line; the
-* sanitize is a guard against a pathological `target` (file path
-* containing a newline) leaking into `old_string not found in <target>`.
-*/
-function annotationFor(outcomes) {
-	const lines = ["<edit-outcomes>"];
-	for (let i = 0; i < outcomes.length; i++) {
-		const o = outcomes[i];
-		const reason = o.reason ? `: ${o.reason.replace(/\r?\n/g, " ")}` : "";
-		lines.push(`#${i + 1} ${o.kind}${reason}`);
-	}
-	lines.push("</edit-outcomes>");
-	return lines.join("\n");
-}
-const multiEdit = {
-	spec: {
-		name: "multi_edit",
-		description: "Apply a sequential list of edits to a file. Each edit operates on the result of the previous APPLIED edit. Prefer this over multiple `edit` calls when several non-overlapping changes are needed in the same file. Edits run **best-effort**: a per-step failure (`old_string` not found, ambiguous match without `replace_all`, identical strings) is reported in the result but does NOT block the remaining steps. The file is written iff at least one step applied. The result lists per-hunk outcomes (`applied` / `failed`) so the model can re-issue just the failures without resending the whole batch. Each step tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string`.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				path: {
-					type: "string",
-					description: "File path (relative to the execution-context cwd, or absolute)."
-				},
-				edits: {
-					type: "array",
-					description: "List of edits applied in order; each operates on the previous applied edit's output.",
-					items: {
-						type: "object",
-						properties: {
-							old_string: { type: "string" },
-							new_string: { type: "string" },
-							replace_all: { type: "boolean" }
-						},
-						required: ["old_string", "new_string"]
-					}
-				}
-			},
-			required: ["path", "edits"]
-		}
-	},
-	async execute({ path, edits }, ctx) {
-		const target = path;
-		const steps = edits;
-		const pathErr = pathArgError(target);
-		if (pathErr) {
-			ctx.reportOutcome?.("failed");
-			return `multi_edit error: ${pathErr}`;
-		}
-		if (!Array.isArray(steps) || steps.length === 0) {
-			ctx.reportOutcome?.("failed");
-			return `multi_edit error: edits must be a non-empty array.`;
-		}
-		let current;
-		try {
-			current = await ctx.execution.readFile(ctx.handle, target);
-		} catch {
-			const hint = await suggestionFor(ctx.execution, ctx.handle, target);
-			ctx.reportOutcome?.("failed");
-			return `multi_edit error: file not found: ${target}.${hint}`;
-		}
-		if (ctx.behavior?.requireReadBeforeEdit) {
-			const readState = resolveReadStateMap(ctx);
-			if (readState) {
-				const absKey = readStateKey(ctx.handle.cwd, target);
-				const prior = readState.get(absKey);
-				if (!prior) {
-					ctx.reportOutcome?.("failed");
-					return `multi_edit error: ${target} has not been read in this session. Call read_file first so the edits apply against the current contents.`;
-				}
-				if (prior.contentHash !== hashContent(current)) {
-					ctx.reportOutcome?.("failed");
-					return `multi_edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
-				}
-			}
-		}
-		const outcomes = [];
-		const viaNotes = [];
-		let totalReplacements = 0;
-		for (let i = 0; i < steps.length; i++) {
-			const step = steps[i];
-			const find = step.old_string;
-			const replacement = step.new_string;
-			const replaceAll = step.replace_all === true;
-			if (typeof find !== "string" || typeof replacement !== "string") {
-				outcomes.push({
-					kind: "failed",
-					reason: "missing old_string or new_string"
-				});
-				continue;
-			}
-			if (find.length === 0) {
-				outcomes.push({
-					kind: "failed",
-					reason: "empty old_string (use write_file to fully replace a file)"
-				});
-				continue;
-			}
-			if (find === replacement) {
-				outcomes.push({
-					kind: "failed",
-					reason: "old_string and new_string are identical"
-				});
-				continue;
-			}
-			const match = resolveOldString(current, find);
-			if (!match) {
-				outcomes.push({
-					kind: "failed",
-					reason: `old_string not found in ${target}`
-				});
-				continue;
-			}
-			const { actual, occurrences, via } = match;
-			if (occurrences > 1 && !replaceAll) {
-				outcomes.push({
-					kind: "failed",
-					reason: `old_string appears ${occurrences} times — pass replace_all=true on this edit or expand old_string for uniqueness`
-				});
-				continue;
-			}
-			const styledReplacement = styleReplacementForVia(replacement, via, actual);
-			current = replaceAll ? current.split(actual).join(styledReplacement) : current.replace(actual, styledReplacement);
-			totalReplacements += occurrences;
-			if (via !== "exact") viaNotes.push(`edit #${i + 1}: old_string was not found verbatim; matched via ${describeVia(via)}`);
-			outcomes.push({ kind: "applied" });
-		}
-		const appliedCount = outcomes.reduce((n, o) => o.kind === "applied" ? n + 1 : n, 0);
-		const failedCount = outcomes.length - appliedCount;
-		if (appliedCount > 0) {
-			await ctx.execution.writeFile(ctx.handle, target, current);
-			ctx.reportOutcome?.("edited");
-			const readState = resolveReadStateMap(ctx);
-			if (readState) {
-				const absKey = readStateKey(ctx.handle.cwd, target);
-				const prior = readState.get(absKey);
-				if (prior) readState.set(absKey, {
-					...prior,
-					contentHash: hashContent(current),
-					mtimeMs: Date.now()
-				});
-			}
-		} else ctx.reportOutcome?.("failed");
-		const n = steps.length;
-		let header;
-		if (appliedCount === n) header = `Edited ${target}: applied ${n} edit${n === 1 ? "" : "s"} (${totalReplacements} replacement${totalReplacements === 1 ? "" : "s"}).`;
-		else if (appliedCount > 0) header = `Edited ${target}: applied ${appliedCount} of ${n} edits (${totalReplacements} replacement${totalReplacements === 1 ? "" : "s"}).`;
-		else header = `multi_edit error: no edits applied to ${target} (${n} attempted).`;
-		const failureLines = [];
-		for (let i = 0; i < outcomes.length; i++) {
-			const o = outcomes[i];
-			if (o.kind === "failed") failureLines.push(`edit #${i + 1} failed: ${o.reason}`);
-		}
-		const parts = [header];
-		if (viaNotes.length > 0) parts.push(viaNotes.join("\n"));
-		if (failureLines.length > 0) parts.push(failureLines.join("\n"));
-		if (failedCount > 0) parts.push(annotationFor(outcomes));
-		return parts.join("\n\n");
-	}
-};
-//#endregion
-//#region src/tools/binary-read.ts
-/**
-* Best-effort guess at IANA media type from a file extension. Covers the
-* extensions Zidane's `read_file` actually dispatches to image blocks
-* (png/jpg/jpeg/gif/webp). Other extensions return `undefined` and the
-* caller short-circuits the binary route.
-*/
-function imageMediaTypeFor(path) {
-	const dot = path.lastIndexOf(".");
-	if (dot === -1) return void 0;
-	switch (path.slice(dot + 1).toLowerCase()) {
-		case "png": return "image/png";
-		case "jpg":
-		case "jpeg": return "image/jpeg";
-		case "gif": return "image/gif";
-		case "webp": return "image/webp";
-		default: return;
-	}
-}
-/**
-* Read a file as base64. Prefers `ExecutionContext.readFileBinary` (zero
-* subprocess overhead in-process) and falls back to `base64 < path` via
-* the shell seam — works on docker / sandbox without an interface change.
-*
-* Returns `{ base64, byteLength }`. `byteLength` is the *decoded* byte count
-* so callers can size-budget against the original file, not the inflated
-* base64 representation (which is ~4/3× larger).
-*/
-async function readFileAsBase64(execution, handle, path) {
-	if (execution.readFileBinary) {
-		const bytes = await execution.readFileBinary(handle, path);
-		return {
-			base64: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64"),
-			byteLength: bytes.byteLength
-		};
-	}
-	const cmd = `base64 < ${alwaysQuote(path)}`;
-	const result = await execution.exec(handle, cmd);
-	if (result.exitCode !== 0) throw new Error(`base64 read failed: ${result.stderr || `exit ${result.exitCode}`}`);
-	const b64 = result.stdout.replace(/\s+/g, "");
-	return {
-		base64: b64,
-		byteLength: decodedBase64ByteLength(b64)
-	};
-}
-/**
-* Decoded byte length of a (whitespace-stripped) base64 string. Accounts for
-* `=` padding so the value matches the original file size to the byte —
-* `Math.floor(len * 3 / 4)` over-reports by 1–2 bytes on padded payloads.
-*/
-function decodedBase64ByteLength(b64) {
-	if (b64.length === 0) return 0;
-	let pad = 0;
-	if (b64.endsWith("==")) pad = 2;
-	else if (b64.endsWith("=")) pad = 1;
-	return Math.max(0, b64.length * 3 / 4 - pad);
-}
-//#endregion
-//#region src/tools/read-file.ts
-/**
-* Read a file with line-based offset/limit and a hard byte cap.
-*
-* Defaults are tuned for source code: 2000 lines / 256 KiB. A typical source
-* file, lockfile, or large config fits in one read; logs and very large
-* fixtures get truncated with a footer that documents how to fetch the
-* remainder.
-*
-* Binary files are detected on the leading bytes — if the buffer contains a
-* NUL or has an unreasonable proportion of non-printable bytes, we skip text
-* decoding and return a marker so the model doesn't drown in mojibake.
-*/
-const DEFAULT_LINE_LIMIT = 2e3;
-const DEFAULT_BYTE_CAP = 262144;
-/**
-* Hard upper bound on raw attachment bytes we'll inline as a base64 block.
-* Above this, we return a marker instead — the model won't get useful
-* information from a 10 MB+ screenshot rendered as one tool result, and
-* the wire bill gets ugly. Override via the `maxBytes` parameter on the
-* tool call.
-*/
-const DEFAULT_ATTACHMENT_BYTE_CAP = 5 * 1024 * 1024;
-function attachmentByteLength(data, encoding) {
-	if (encoding === "text") return Buffer.byteLength(data);
-	if (data.length === 0) return 0;
-	const pad = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
-	return Math.max(0, Math.floor(data.length * 3 / 4) - pad);
-}
-const readFile = {
-	isConcurrencySafe: true,
-	spec: {
-		name: "read_file",
-		description: "Read a file by path. Text files return lines [offset..offset+limit). Default offset=1, limit=2000. Each line is prefixed with its 1-indexed line number followed by a tab (e.g. `42\\tconst foo = bar`); the prefix is metadata, not part of the file. Mirrors Claude Code's `cat -n`-style compact output for token efficiency. A trailing footer explains how to read the rest when truncated. Images (png/jpg/gif/webp) and PDFs return structured attachments for capable models; other binary files return a short marker rather than mojibake.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				path: {
-					type: "string",
-					description: "File path (relative to the execution-context cwd, or absolute)."
-				},
-				offset: {
-					type: "integer",
-					description: "1-indexed line number to start from. Default: 1."
-				},
-				limit: {
-					type: "integer",
-					description: "Max lines to return. Default: 2000. Set 0 for unlimited."
-				},
-				maxBytes: {
-					type: "integer",
-					description: "Hard byte cap on file content read, regardless of line count. Default: 262144 for text, 5242880 for image/PDF attachments. Set 0 for unlimited. The rendered output may be slightly larger than this cap when `lineNumbers` is on (each line carries a `<N>\\t` prefix)."
-				},
-				lineNumbers: {
-					type: "boolean",
-					description: "Prefix each line with its 1-indexed line number. Default: true. Override the agent-wide `behavior.readLineNumbers` for this call."
-				}
-			},
-			required: ["path"]
-		}
-	},
-	async execute({ path, offset, limit, maxBytes, lineNumbers }, ctx) {
-		const defaults = resolveReadFileDefaults(ctx.behavior, {
-			lineLimit: DEFAULT_LINE_LIMIT,
-			textMaxBytes: DEFAULT_BYTE_CAP,
-			attachmentMaxBytes: DEFAULT_ATTACHMENT_BYTE_CAP
-		});
-		const handleHash = typeof path === "string" ? parseAttachmentHandle(path) : null;
-		if (handleHash) {
-			const turns = ctx.session?.turns;
-			if (!turns) return `Attachment ${path} cannot be resolved: no session is bound to this run.`;
-			const found = resolveAttachmentFromTurns(turns, handleHash);
-			if (!found) return `Attachment ${path} not found in this session's history (it may predate this session, or only ever lived as a host-offloaded reference).`;
-			const sizeCap = normalizeReadFileInteger(maxBytes, defaults.attachmentMaxBytes);
-			const byteLength = attachmentByteLength(found.data, found.encoding);
-			if (sizeCap > 0 && byteLength > sizeCap) return `[attachment too large to re-inline: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes if you need the original bytes.]`;
-			return [{
-				type: "text",
-				text: `${found.kind === "image" ? "Image" : "Document"} re-resolved from session history (${found.mediaType}${found.name ? `, "${found.name}"` : ""}).`
-			}, found.kind === "image" ? {
-				type: "image",
-				mediaType: found.mediaType,
-				data: found.data,
-				...found.name ? { name: found.name } : {}
-			} : {
-				type: "document",
-				mediaType: found.mediaType,
-				data: found.data,
-				encoding: found.encoding ?? "base64",
-				...found.name ? { name: found.name } : {}
-			}];
-		}
-		const pathErr = pathArgError(path);
-		if (pathErr) return `Read error: ${pathErr}`;
-		const extMedia = imageMediaTypeFor(path);
-		if (extMedia) {
-			const sizeCap = normalizeReadFileInteger(maxBytes, defaults.attachmentMaxBytes);
-			try {
-				const { base64, byteLength } = await readFileAsBase64(ctx.execution, ctx.handle, path);
-				if (sizeCap > 0 && byteLength > sizeCap) return `[image too large to inline: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes, or use shell to inspect.]`;
-				const imgMedia = reconcileImageMediaType(extMedia, base64);
-				return [{
-					type: "text",
-					text: `Image: ${path} (${byteLength} bytes, ${imgMedia})`
-				}, {
-					type: "image",
-					mediaType: imgMedia,
-					data: base64
-				}];
-			} catch (err) {
-				const hint = await suggestionFor(ctx.execution, ctx.handle, path);
-				return `Image read failed: ${path} — ${errorMessage(err)}.${hint}`;
-			}
-		}
-		const docMedia = documentMediaTypeFor(path);
-		if (docMedia) {
-			const sizeCap = normalizeReadFileInteger(maxBytes, defaults.attachmentMaxBytes);
-			try {
-				const { base64, byteLength } = await readFileAsBase64(ctx.execution, ctx.handle, path);
-				if (sizeCap > 0 && byteLength > sizeCap) return `[document too large to attach: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes, or use shell/read text extraction to inspect.]`;
-				if (docMedia === "application/pdf" && !isPdfBase64(base64)) return `[binary file: ${path}, ${byteLength} bytes; extension suggests PDF but file header does not start with %PDF-]`;
-				return [{
-					type: "text",
-					text: `Document: ${path} (${byteLength} bytes, ${docMedia})`
-				}, {
-					type: "document",
-					mediaType: docMedia,
-					data: base64,
-					encoding: "base64",
-					name: fileNameForPath(path)
-				}];
-			} catch (err) {
-				const hint = await suggestionFor(ctx.execution, ctx.handle, path);
-				return `Document read failed: ${path} — ${errorMessage(err)}.${hint}`;
-			}
-		}
-		let raw;
-		try {
-			raw = await ctx.execution.readFile(ctx.handle, path);
-		} catch {
-			return `File not found: ${path}.${await suggestionFor(ctx.execution, ctx.handle, path)}`;
-		}
-		const totalBytes = Buffer.byteLength(raw);
-		const dedupEnabled = ctx.behavior?.dedupReads !== false;
-		const gateEnabled = ctx.behavior?.requireReadBeforeEdit === true;
-		const readState = dedupEnabled || gateEnabled ? resolveReadStateMap(ctx) : void 0;
-		const absKey = readStateKey(ctx.handle.cwd, path);
-		const offsetForKey = normalizeReadFileInteger(offset, 1);
-		const limitForKey = normalizeReadFileInteger(limit, defaults.lineLimit);
-		const maxBytesForKey = normalizeReadFileInteger(maxBytes, defaults.textMaxBytes);
-		const showLineNumbers = typeof lineNumbers === "boolean" ? lineNumbers : ctx.behavior?.readLineNumbers ?? true;
-		const currentHash = readState ? hashContent(raw) : "";
-		const rememberRead = () => {
-			if (!readState) return;
-			readState.set(absKey, {
-				contentHash: currentHash,
-				offset: offsetForKey,
-				limit: limitForKey,
-				maxBytes: maxBytesForKey,
-				lineNumbers: showLineNumbers,
-				mtimeMs: Date.now()
-			});
-		};
-		if (dedupEnabled && readState) {
-			const prior = readState.get(absKey);
-			if (prior && prior.contentHash === currentHash && prior.offset === offsetForKey && prior.limit === limitForKey && prior.maxBytes === maxBytesForKey && prior.lineNumbers === showLineNumbers && prior.elided !== true) {
-				rememberRead();
-				return `File ${path} unchanged since the previous read in this session — the prior result above is still current, so this duplicate read was skipped to save tokens.`;
-			}
-		}
-		if (looksBinary(raw)) return `[binary file: ${path}, ${totalBytes} bytes; use shell with hexdump | xxd | od to inspect]`;
-		const offsetN = offsetForKey;
-		const limitN = limitForKey;
-		const maxBytesN = maxBytesForKey;
-		const lines = raw.split("\n");
-		const totalLines = lines.length;
-		const startIdx = Math.max(0, offsetN - 1);
-		const endIdx = limitN > 0 ? Math.min(totalLines, startIdx + limitN) : totalLines;
-		let slice = lines.slice(startIdx, endIdx);
-		let bytesCut = false;
-		if (maxBytesN > 0) {
-			const truncatedSlice = [];
-			let bytesUsed = 0;
-			for (const line of slice) {
-				const lineBytes = Buffer.byteLength(line) + 1;
-				if (bytesUsed + lineBytes > maxBytesN && truncatedSlice.length > 0) {
-					bytesCut = true;
-					break;
-				}
-				truncatedSlice.push(line);
-				bytesUsed += lineBytes;
-				if (bytesUsed >= maxBytesN) break;
-			}
-			if (truncatedSlice.length < slice.length) bytesCut = true;
-			slice = truncatedSlice;
-		}
-		let midLineCut = false;
-		if (maxBytesN > 0 && slice.length > 0) {
-			if (Buffer.byteLength(slice.join("\n")) > maxBytesN) {
-				const lastIdx = slice.length - 1;
-				const lastLine = slice[lastIdx];
-				const otherBytes = lastIdx > 0 ? Buffer.byteLength(slice.slice(0, lastIdx).join("\n")) + 1 : 0;
-				const budgetForLast = Math.max(0, maxBytesN - otherBytes);
-				let cut = Math.min(lastLine.length, budgetForLast);
-				while (cut > 0 && Buffer.byteLength(lastLine.slice(0, cut)) > budgetForLast) cut--;
-				slice[lastIdx] = lastLine.slice(0, cut);
-				midLineCut = true;
-				bytesCut = true;
-			}
-		}
-		const lastLineRead = startIdx + slice.length;
-		const body = showLineNumbers ? slice.map((line, i) => `${startIdx + i + 1}\t${line}`).join("\n") : slice.join("\n");
-		rememberRead();
-		const linesTruncated = endIdx < totalLines || bytesCut;
-		if (!linesTruncated && offsetN === 1) return body;
-		if (!linesTruncated) return `${body}\n\n…read lines ${offsetN}-${lastLineRead} of ${totalLines}.`;
-		if (midLineCut) return `${body}\n\n…truncated mid-line at line ${lastLineRead} (byte cap ${maxBytesN} reached). File has ${totalLines} lines, ${totalBytes} bytes total. Raise maxBytes to read the full line.`;
-		return `${body}\n\n…truncated at line ${lastLineRead} (${bytesCut ? `byte cap (${maxBytesN}) reached` : `line limit (${limitN}) reached`}). File has ${totalLines} lines, ${totalBytes} bytes total — re-read with offset=${lastLineRead + 1} to continue.`;
-	}
-};
-function documentMediaTypeFor(path) {
-	const dot = path.lastIndexOf(".");
-	if (dot === -1) return void 0;
-	return path.slice(dot + 1).toLowerCase() === "pdf" ? "application/pdf" : void 0;
-}
-function fileNameForPath(path) {
-	const normalized = path.replace(/\\/g, "/");
-	const slash = normalized.lastIndexOf("/");
-	return slash === -1 ? normalized : normalized.slice(slash + 1);
-}
-function isPdfBase64(base64) {
-	return Buffer.from(base64.slice(0, 16), "base64").toString("ascii").startsWith("%PDF-");
-}
-//#endregion
-//#region src/tools/shell-kill.ts
-const shellKill = {
-	isConcurrencySafe: true,
-	spec: {
-		name: "shell_kill",
-		description: [
-			"Terminate a running background task started by `shell({ run_in_background: true })`.",
-			"Sends SIGTERM to the whole process group so the shell wrapper AND its child commands die together.",
-			"Returns the final exit info (status, exit code, output path) or a \"no such task\" message when the id is unknown / already cleaned up.",
-			"Idempotent — calling on a task that has already terminated returns the cached exit info without re-killing."
-		].join("\n"),
-		inputSchema: {
-			type: "object",
-			properties: { task_id: {
-				type: "string",
-				description: "The task id returned by a prior `shell({ run_in_background: true })` call."
-			} },
-			required: ["task_id"],
-			additionalProperties: false
-		}
-	},
-	async execute(input, ctx) {
-		const taskId = input.task_id;
-		if (!ctx.execution.killBackground) return `shell_kill error: the active execution context (${ctx.execution.type}) does not support background tasks.`;
-		const info = await ctx.execution.killBackground(ctx.handle, taskId);
-		if (!info) return `shell_kill: no such task "${taskId}". It may have already exited and been cleaned up, or it was never started in this session.`;
-		return [
-			`Killed ${info.taskId} — ${formatTaskStatus(info)} after ${formatDuration(info.durationMs)}.`,
-			`  command: ${previewLine(info.command, 60)}`,
-			`  output:  ${info.outputPath}`
-		].join("\n");
-	}
-};
-//#endregion
-//#region src/tools/spawn.ts
-const BUBBLED_EVENTS = [
-	"stream:text",
-	"stream:thinking",
-	"stream:end",
-	"stream:error",
-	"stream:server_tool_use",
-	"stream:server_tool_result",
-	"tool:dispatched",
-	"tool:before",
-	"tool:after",
-	"tool:error",
-	"tool:cancelled",
-	"background:start",
-	"background:exit",
-	"background:reassign",
-	"turn:after"
-];
-const BUBBLED_MUTABLE_EVENTS = [
-	"content-ref:resolve",
-	"tool:gate",
-	"mcp:tool:gate",
-	"tool:transform"
-];
-const CHILD_EVENT_NAME = {
-	"stream:text": "child:stream:text",
-	"stream:thinking": "child:stream:thinking",
-	"stream:end": "child:stream:end",
-	"stream:error": "child:stream:error",
-	"stream:server_tool_use": "child:stream:server_tool_use",
-	"stream:server_tool_result": "child:stream:server_tool_result",
-	"tool:dispatched": "child:tool:dispatched",
-	"tool:before": "child:tool:before",
-	"tool:after": "child:tool:after",
-	"tool:error": "child:tool:error",
-	"tool:cancelled": "child:tool:cancelled",
-	"background:start": "child:background:start",
-	"background:exit": "child:background:exit",
-	"background:reassign": "child:background:reassign",
-	"turn:after": "child:turn:after"
-};
-const CHILD_MUTABLE_EVENT_NAME = {
-	"content-ref:resolve": "content-ref:resolve",
-	"tool:gate": "child:tool:gate",
-	"mcp:tool:gate": "child:mcp:tool:gate",
-	"tool:transform": "child:tool:transform"
-};
-const sessionChildCounters = /* @__PURE__ */ new WeakMap();
-function reserveChildLabel(session) {
-	let counter = sessionChildCounters.get(session);
-	if (counter === void 0) counter = session.runs.filter((r) => (r.depth ?? 0) > 0).length;
-	counter += 1;
-	sessionChildCounters.set(session, counter);
-	return `child-${counter}`;
-}
-function extractText(message) {
-	if (!message || typeof message !== "object") return "";
-	const msg = message;
-	if (typeof msg.content === "string") return msg.content;
-	if (Array.isArray(msg.content)) return msg.content.filter((block) => !!block && typeof block === "object" && block.type === "text").map((block) => block.text).join("\n");
-	return "";
-}
-/**
-* Read-only tool whitelist applied when a subagent preset has
-* `readonly: true` and no explicit `tools` list. Intentionally narrow —
-* only obviously non-mutating built-ins. Hosts wanting a different
-* read-only profile (e.g. include `glob` for a code-search agent) should
-* pass an explicit `tools` array on the subagent def.
-*/
-const READONLY_TOOL_DEFAULTS = [
-	"read_file",
-	"grep",
-	"glob",
-	"list_files"
-];
-/**
-* Apply a subagent preset's tool filter to the parent's tool registry.
-* Always a strict subset of the input — the child agent never gains
-* tools the parent doesn't have. Names that don't match a parent tool
-* are silently dropped (matches MCP's lenient `enabledTools` behavior).
-*
-* Precedence: `def.tools` (explicit list) > `def.readonly: true`
-* (built-in read-only set) > unfiltered.
-*/
-function filterToolsForSubagent(parentTools, def) {
-	if (!parentTools) return parentTools;
-	const explicit = def.tools;
-	if (explicit && explicit.length > 0) {
-		const wanted = new Set(explicit);
-		const filtered = {};
-		for (const [registryKey, t] of Object.entries(parentTools)) if (wanted.has(t.spec.name)) filtered[registryKey] = t;
-		return filtered;
-	}
-	if (def.readonly) {
-		const wanted = new Set(READONLY_TOOL_DEFAULTS);
-		const filtered = {};
-		for (const [registryKey, t] of Object.entries(parentTools)) if (wanted.has(t.spec.name)) filtered[registryKey] = t;
-		return filtered;
-	}
-	return parentTools;
-}
-/**
-* Render the per-type descriptions into a single schema-field
-* description string the model reads when choosing a `subagent_type`.
-* Falls back to a generic line when the host didn't supply any per-type
-* descriptions.
-*/
-function buildSubagentTypeDescription(registry) {
-	const lines = [];
-	let hasAny = false;
-	for (const [key, def] of Object.entries(registry)) if (def.description) {
-		lines.push(`- "${key}": ${def.description}`);
-		hasAny = true;
-	} else lines.push(`- "${key}"`);
-	lines.push("- \"general-purpose\": no specialization; uses the spawn tool's default config.");
-	if (!hasAny) return `Optional subagent preset. One of: ${lines.map((l) => l.replace(/^- /, "").replace(/:.*$/, "")).join(", ")}.`;
-	return `Optional subagent preset that overlays the spawn tool's defaults.\n${lines.join("\n")}`;
-}
-/**
-* Race `task` (an already-running child `agent.run()` promise) against a
-* timer. Does NOT race against the parent abort signal — the child agent
-* already observes the same signal internally and handles its own aborted
-* bookkeeping, so racing here would detach the spawn from the child's
-* session-persisting finally block.
-*
-* On timeout: rejects with `SpawnTimeoutError`; caller is expected to call
-* `agent.abort()` and subsequently `await` the original `task` so the
-* child's session state (runs, turns, status) gets flushed before the
-* parent moves on.
-*/
-async function raceWithTimeout(task, timeoutMs) {
-	if (!timeoutMs || timeoutMs <= 0) return task;
-	let timer;
-	try {
-		return await new Promise((resolve, reject) => {
-			timer = setTimeout(() => reject(new SpawnTimeoutError(timeoutMs)), timeoutMs);
-			task.then(resolve, reject);
-		});
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-var SpawnTimeoutError = class extends Error {
-	timeoutMs;
-	constructor(timeoutMs) {
-		super(`Child agent timed out after ${timeoutMs}ms`);
-		this.name = "SpawnTimeoutError";
-		this.timeoutMs = timeoutMs;
-	}
-};
-/**
-* Wire child's hooks to bubble into `parentHooks` as `child:*` events.
-*
-* Three kinds of forwarding:
-*
-* 1. **Originating observational events** (`stream:text`, `tool:before`, …)
-*    → rewrite to the matching `child:*` event, inject `{ childId, depth }`,
-*    fire on the parent's hook bus as a **spread copy** (so parent listeners
-*    can't accidentally mutate the child's ctx).
-* 2. **Originating gate events** (`tool:gate`, `mcp:tool:gate`) → forward
-*    the **same ctx reference**, augmented with `childId` / `depth`, so a
-*    parent listener writing `ctx.block = true` lands on the gate the
-*    child's loop is awaiting on. The bubble itself `await`s the parent's
-*    callHook so any async approval (e.g. a TUI picker) completes before
-*    the child's loop sees the decision.
-* 3. **Re-bubbled `child:*` events** from a grandchild already carry the
-*    originating `childId` + `depth`. Forward verbatim so a top-level
-*    listener sees true ancestry, not the immediate parent's.
-*
-* Returns a function that unregisters every listener registered here.
-* Called before `agent.run()` starts, torn down in a finally block — so
-* nothing leaks even if the child throws mid-run.
-*/
-/**
-* Surface a thrown observational-bubble listener without killing the
-* process. Observational events (`child:stream:text`, `child:tool:after`,
-* `child:turn:after`, …) are fire-and-forget — a rejected promise here
-* has no caller. Without this handler, a buggy parent listener bubbles
-* up to an unhandled-rejection, and Node/Bun under
-* `--unhandled-rejections=strict` terminates the host.
-*
-* Gated on `ZIDANE_DEBUG` so production logs stay quiet; debug builds
-* still get the tagged line.
-*/
-function swallowBubbleError(eventName, err) {
-	if (!process.env.ZIDANE_DEBUG) return;
-	const message = err instanceof Error ? err.stack ?? err.message : String(err);
-	process.stderr.write(`[zidane/spawn] parent listener for "${eventName}" rejected: ${message}\n`);
-}
-function bubbleHooks(childHooks, parentHooks, childId, depth) {
-	const unregisters = [];
-	const fire = parentHooks.callHook;
-	for (const evt of BUBBLED_EVENTS) {
-		const parentEvt = CHILD_EVENT_NAME[evt];
-		const unregister = childHooks.hook(evt, (ctx) => {
-			Promise.resolve(fire(parentEvt, {
-				...ctx,
-				childId,
-				depth
-			})).catch((err) => swallowBubbleError(parentEvt, err));
-		});
-		unregisters.push(unregister);
-	}
-	const tagOnCtx = (ctx) => {
-		ctx.childId ??= childId;
-		ctx.depth ??= depth;
-	};
-	for (const evt of BUBBLED_MUTABLE_EVENTS) {
-		const parentEvt = CHILD_MUTABLE_EVENT_NAME[evt];
-		const unregister = childHooks.hook(evt, async (ctx) => {
-			tagOnCtx(ctx);
-			await fire(parentEvt, ctx);
-		});
-		unregisters.push(unregister);
-	}
-	const chainHook = childHooks.hook;
-	for (const evt of BUBBLED_EVENTS) {
-		const parentEvt = CHILD_EVENT_NAME[evt];
-		unregisters.push(chainHook(parentEvt, (ctx) => {
-			Promise.resolve(fire(parentEvt, ctx)).catch((err) => swallowBubbleError(parentEvt, err));
-		}));
-	}
-	for (const evt of BUBBLED_MUTABLE_EVENTS) {
-		const parentEvt = CHILD_MUTABLE_EVENT_NAME[evt];
-		if (parentEvt === evt) continue;
-		unregisters.push(chainHook(parentEvt, async (ctx) => {
-			await fire(parentEvt, ctx);
-		}));
-	}
-	return () => {
-		for (const u of unregisters) u();
-	};
-}
-/**
-* Create a configured spawn tool.
-*
-* State (`children`, `totalChildStats`, counters, active count) is scoped to
-* the returned instance. Multiple parent agents using the same instance will
-* share counters + stats + concurrency slots — call `createSpawnTool()` per
-* agent (or use the stateless default `spawn`) to keep them isolated.
-*/
-function createSpawnTool(options = {}) {
-	const localChildren = /* @__PURE__ */ new Map();
-	let localCounter = 0;
-	let localActiveCount = 0;
-	const maxConcurrent = options.maxConcurrent ?? 3;
-	const maxDepth = options.maxDepth ?? 3;
-	const forwardHooks = options.forwardHooks ?? true;
-	const localStats = {
-		totalIn: 0,
-		totalOut: 0,
-		totalCacheRead: 0,
-		totalCacheCreation: 0,
-		turns: 0,
-		elapsed: 0
-	};
-	const subagentRegistry = options.subagents;
-	const subagentTypeKeys = !!subagentRegistry && Object.keys(subagentRegistry).length > 0 ? [...new Set([...Object.keys(subagentRegistry), "general-purpose"])] : [];
-	return {
-		get children() {
-			return localChildren;
-		},
-		get totalChildStats() {
-			return { ...localStats };
-		},
-		isConcurrencySafe: true,
-		spec: {
-			name: "spawn",
-			description: "Spawn a sub-agent for a self-contained task that benefits from isolation (separate context window, separate retries) — for example, a deep research dive or a long codegen pass on a specific file. The sub-agent runs independently with its own tool access and returns its final response. Do NOT spawn for sequential steps you could do yourself.",
-			inputSchema: {
-				type: "object",
-				properties: {
-					task: {
-						type: "string",
-						description: "The task prompt for the sub-agent. Be specific about what you want it to accomplish."
-					},
-					system: {
-						type: "string",
-						description: "Optional system prompt override for this specific sub-agent."
-					},
-					...subagentTypeKeys.length > 0 ? { subagent_type: {
-						type: "string",
-						enum: subagentTypeKeys,
-						description: buildSubagentTypeDescription(subagentRegistry)
-					} } : {}
-				},
-				required: ["task"]
-			}
-		},
-		async execute(input, ctx) {
-			const task = input.task;
-			const systemOverride = input.system;
-			const requestedSubagentType = typeof input.subagent_type === "string" ? input.subagent_type : void 0;
-			const subagentDef = requestedSubagentType && subagentRegistry ? subagentRegistry[requestedSubagentType] ?? void 0 : void 0;
-			const parentDepth = ctx.depth ?? 0;
-			const childDepth = parentDepth + 1;
-			if (childDepth > maxDepth) return `Cannot spawn: maxDepth=${maxDepth} reached (parent depth=${parentDepth}). Deepen the cap with createSpawnTool({ maxDepth }).`;
-			if (localActiveCount >= maxConcurrent) return `Cannot spawn: ${localActiveCount}/${maxConcurrent} sub-agents already running. Wait for one to complete.`;
-			if (ctx.signal.aborted) return `[sub-agent pre-aborted] Parent signal was already aborted — skipped "${task.slice(0, 80)}"`;
-			const id = ctx.session ? reserveChildLabel(ctx.session) : `child-${++localCounter}`;
-			localActiveCount++;
-			const child = {
-				id,
-				task,
-				startedAt: Date.now(),
-				depth: childDepth
-			};
-			localChildren.set(id, child);
-			let destroyError;
-			let childRunStatus = "completed";
-			let finalStats;
-			let result = "";
-			let unbubble;
-			try {
-				const filteredTools = subagentDef ? filterToolsForSubagent(ctx.tools, subagentDef) : ctx.tools;
-				const parentPreset = {
-					...ctx.name !== void 0 ? { name: ctx.name } : {},
-					...ctx.system !== void 0 ? { system: ctx.system } : {},
-					tools: filteredTools,
-					...ctx.toolAliases !== void 0 ? { toolAliases: ctx.toolAliases } : {},
-					...ctx.mcpServers !== void 0 ? { mcpServers: ctx.mcpServers } : {},
-					...ctx.skills !== void 0 ? { skills: ctx.skills } : {},
-					...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {}
-				};
-				const sharedReadState = options.shareReadState ? resolveReadStateMap(ctx) : void 0;
-				const agent = createAgent({
-					...parentPreset,
-					...options.preset,
-					provider: ctx.provider,
-					execution: ctx.execution,
-					...options.persist && ctx.session ? { session: ctx.session } : {},
-					...sharedReadState ? { readState: sharedReadState } : {}
-				});
-				if (forwardHooks) {
-					const unregisterEnricher = agent.hooks.hook("tool:before", async (toolCtx) => {
-						if (toolCtx.name !== "write_file" && toolCtx.name !== "edit" && toolCtx.name !== "multi_edit") return;
-						if (!agent.handle) return;
-						const inputPath = toolCtx.input?.path;
-						if (typeof inputPath !== "string") return;
-						try {
-							toolCtx.priorContent = await agent.execution.readFile(agent.handle, inputPath);
-						} catch {}
-					});
-					const unbubbleInner = bubbleHooks(agent.hooks, ctx.hooks, id, childDepth);
-					unbubble = () => {
-						unregisterEnricher();
-						unbubbleInner();
-					};
-				}
-				options.onSpawn?.(child);
-				const spawnHookCtx = {
-					id,
-					task,
-					depth: childDepth,
-					tracingContext: {}
-				};
-				await ctx.hooks.callHook("spawn:before", spawnHookCtx);
-				const propagatedTracing = Object.keys(spawnHookCtx.tracingContext).length > 0 ? Object.freeze({ ...spawnHookCtx.tracingContext }) : void 0;
-				const effectiveSystem = systemOverride ?? subagentDef?.system ?? options.system;
-				const runPromise = agent.run({
-					prompt: task,
-					model: options.model ?? ctx.model,
-					system: effectiveSystem,
-					thinking: options.thinking,
-					signal: ctx.signal,
-					depth: childDepth,
-					...options.persist && ctx.runId ? { parentRunId: ctx.runId } : {},
-					...propagatedTracing ? { tracingContext: propagatedTracing } : {}
-				});
-				try {
-					finalStats = await raceWithTimeout(runPromise, options.timeoutMs);
-					const treeTurns = flattenTurns(finalStats).length;
-					const usage = formatTokenUsage(finalStats);
-					if (ctx.signal.aborted) {
-						childRunStatus = "aborted";
-						result = [`[sub-agent ${id}] Aborted after ${treeTurns} turns (${finalStats.elapsed}ms)`, `Tokens: ${usage}`].join("\n");
-					} else {
-						const response = extractText(agent.turns.at(-1));
-						result = [
-							`[sub-agent ${id}] Completed in ${treeTurns} turns (${finalStats.elapsed}ms)`,
-							`Tokens: ${usage}`,
-							"",
-							response || "(no text response)"
-						].join("\n");
-					}
-				} catch (err) {
-					if (err instanceof SpawnTimeoutError) {
-						childRunStatus = "timeout";
-						agent.abort();
-						try {
-							finalStats = await runPromise;
-						} catch {
-							finalStats = {
-								totalIn: 0,
-								totalOut: 0,
-								totalCacheRead: 0,
-								totalCacheCreation: 0,
-								turns: 0,
-								elapsed: err.timeoutMs
-							};
-						}
-						result = `[sub-agent ${id}] Timed out after ${err.timeoutMs}ms`;
-					} else {
-						const error = err instanceof Error ? err : new Error(String(err));
-						childRunStatus = "error";
-						finalStats = {
-							totalIn: 0,
-							totalOut: 0,
-							totalCacheRead: 0,
-							totalCacheCreation: 0,
-							turns: 0,
-							elapsed: 0
-						};
-						result = `[sub-agent ${id}] Error: ${error.message}`;
-						await ctx.hooks.callHook("spawn:error", {
-							id,
-							task,
-							depth: childDepth,
-							error
-						});
-					}
-				} finally {
-					const childHandle = agent.handle;
-					if (childHandle && ctx.execution.reassignBackgroundTasks) try {
-						const reassigned = await ctx.execution.reassignBackgroundTasks(childHandle, ctx.handle, (info) => {
-							Promise.resolve(ctx.hooks.callHook("background:exit", info)).catch(() => {});
-						});
-						for (const entry of reassigned) await ctx.hooks.callHook("background:reassign", {
-							taskId: entry.taskId,
-							fromHandleId: childHandle.id,
-							toHandleId: ctx.handle.id,
-							childId: id,
-							pid: entry.pid,
-							command: entry.command,
-							outputPath: entry.outputPath,
-							startedAt: entry.startedAt
-						});
-					} catch (err) {
-						if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/spawn] reassignBackgroundTasks failed: ${err instanceof Error ? err.message : String(err)}\n`);
-					}
-					try {
-						await agent.destroy();
-					} catch (err) {
-						destroyError = err instanceof Error ? err : new Error(String(err));
-					}
-				}
-				if (finalStats) {
-					localStats.totalIn += finalStats.totalIn;
-					localStats.totalOut += finalStats.totalOut;
-					localStats.totalCacheRead += finalStats.totalCacheRead;
-					localStats.totalCacheCreation += finalStats.totalCacheCreation;
-					localStats.turns += finalStats.turns;
-					localStats.elapsed += finalStats.elapsed;
-				}
-				const childRunStats = {
-					id,
-					task,
-					stats: finalStats,
-					depth: childDepth,
-					status: childRunStatus,
-					...finalStats.output ? { output: finalStats.output } : {}
-				};
-				options.onComplete?.(child, finalStats, childRunStatus);
-				await ctx.hooks.callHook("spawn:complete", childRunStats);
-				if (destroyError) await ctx.hooks.callHook("spawn:error", {
-					id,
-					task,
-					depth: childDepth,
-					error: destroyError
-				});
-				return result;
-			} finally {
-				unbubble?.();
-				localActiveCount--;
-				localChildren.delete(id);
-			}
-		}
-	};
-}
-//#endregion
-//#region src/tools/write-file.ts
-/**
-* Write a file, with an idempotency signal when the content is unchanged.
-*
-* Three return shapes — chosen so the model can recognize a no-op without a
-* separate read:
-*   - `Created path (N bytes)` — file did not exist
-*   - `Updated path (N bytes)` — content differed from on-disk
-*   - `No change needed: path already at target state (N bytes)` — equal
-*
-* Race window: in non-process execution contexts (docker, sandbox) shared by
-* multiple agents, another writer can mutate the file between our read and
-* our write. Local process context is single-writer per agent so the race is
-* a non-issue there. Documented rather than locked because the cost of
-* cross-context locking outweighs the cost of a stale "No change" message.
-*/
-const writeFile = {
-	spec: {
-		name: "write_file",
-		description: "Write `content` to `path`, creating any missing parent directories. Overwrites existing files in full; prefer `edit` / `multi_edit` for surgical changes when you only want to alter part of a file. Returns one of: `Created <path> (N bytes)` (file did not exist), `Updated <path> (N bytes)` (content differed), or `No change needed: <path> already at target state (N bytes)` — so the model can detect no-ops without a separate `read_file`.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				path: {
-					type: "string",
-					description: "File path (relative to the execution-context cwd, or absolute)."
-				},
-				content: {
-					type: "string",
-					description: "Complete file content. Overwrites any existing file at `path`."
-				}
-			},
-			required: ["path", "content"]
-		}
-	},
-	async execute({ path, content }, ctx) {
-		const targetPath = path;
-		const targetContent = content;
-		const pathErr = pathArgError(targetPath);
-		if (pathErr) {
-			ctx.reportOutcome?.("failed");
-			return `Write error: ${pathErr}`;
-		}
-		let existing;
-		try {
-			existing = await ctx.execution.readFile(ctx.handle, targetPath);
-		} catch {}
-		const bytes = Buffer.byteLength(targetContent);
-		if (existing === targetContent) {
-			ctx.reportOutcome?.("noop");
-			return `No change needed: ${targetPath} already at target state (${bytes} bytes).`;
-		}
-		await ctx.execution.writeFile(ctx.handle, targetPath, targetContent);
-		const readState = resolveReadStateMap(ctx);
-		if (readState) readState.set(readStateKey(ctx.handle.cwd, targetPath), {
-			contentHash: hashContent(targetContent),
-			offset: 0,
-			limit: Number.POSITIVE_INFINITY,
-			maxBytes: Number.POSITIVE_INFINITY,
-			mtimeMs: Date.now()
-		});
-		ctx.reportOutcome?.(existing === void 0 ? "created" : "updated");
-		return existing === void 0 ? `Created ${targetPath} (${bytes} bytes).` : `Updated ${targetPath} (${bytes} bytes).`;
-	}
-};
-//#endregion
-export { multiEdit as a, grep as c, readFile as i, glob as l, createSpawnTool as n, listFiles as o, shellKill as r, createInteractionTool as s, writeFile as t, edit as u };
-
-//# sourceMappingURL=tools-CCd8e-HT.js.map