codsh-cli 0.2.0 → 0.3.0

package/lib/index.js

@@ -1,4911 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import { basename, dirname, join, parse } from "node:path";
-import z from "@deepseek-ai/schemastery";
-import { installModelSelection } from "@deepseek-ai/dsh-agent";
-import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { SessionId } from "@deepseek-ai/dsh-session";
-import { homedir } from "node:os";
-import stringWidth from "string-width";
-import { readdirSync } from "node:fs";
-import { createInterface } from "node:readline";
-import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
-import { fileURLToPath } from "node:url";
-import { structuredPatch } from "diff";
-
-//#region src/approval.ts
-/**
-* Approval state for one terminal session.
-*
-* The remembered set is per-process and never written to disk. An
-* {@link ApprovalRequest} carries the tool name, reason, and call id but NOT
-* the call arguments, so a grant cannot be narrowed to "this command" — it
-* covers every later call to that tool. Persisting a grant that broad across
-* runs would outlive the intent that produced it.
-*/
-var TerminalApproval = class {
-	allowed = /* @__PURE__ */ new Set();
-	constructor(prompt, theme, write) {
-		this.prompt = prompt;
-		this.theme = theme;
-		this.write = write;
-	}
-	/** Tool names granted for the rest of this process, in grant order. */
-	get remembered() {
-		return [...this.allowed];
-	}
-	/** Forget every remembered grant, so the next call of each tool asks again. */
-	clear() {
-		this.allowed.clear();
-	}
-	/**
-	* Decide one request, asking the keyboard unless the tool is already granted.
-	* @param req - the pending decision.
-	* @returns the outcome for this request.
-	*/
-	async decide(req) {
-		if (this.allowed.has(req.toolName)) return "allowed-once";
-		const answer = await this.prompt.ask(req.toolName, req.reason, req.signal);
-		if (answer === void 0) return "cancelled";
-		if (answer === "reject") {
-			this.write(this.theme.error(`  ✗ denied ${req.toolName}`));
-			return "rejected";
-		}
-		if (answer === "always") {
-			this.allowed.add(req.toolName);
-			this.write(this.theme.dim(`  ✓ allowing every ${req.toolName} call for the rest of this session`));
-		}
-		return "allowed-once";
-	}
-};
-/**
-* Map one keystroke to an approval answer.
-* @param key - the character typed at the prompt.
-* @returns the answer, or undefined when the key means nothing here.
-*/
-function answerForKey(key) {
-	const normalized = key.trim().toLowerCase();
-	if (normalized === "y" || normalized === "") return "once";
-	if (normalized === "a") return "always";
-	if (normalized === "n") return "reject";
-}
-
-//#endregion
-//#region src/theme.ts
-/** SGR codes applied by {@link Theme}, by role. */
-const SGR$1 = {
-	reset: "\x1B[0m",
-	dim: "\x1B[2m",
-	bold: "\x1B[1m",
-	red: "\x1B[31m",
-	green: "\x1B[32m",
-	yellow: "\x1B[33m",
-	blue: "\x1B[34m",
-	magenta: "\x1B[35m",
-	cyan: "\x1B[36m"
-};
-/** A theme that emits no sequences, used off a TTY and under `NO_COLOR`. */
-const PLAIN = {
-	colored: false,
-	dim: (text) => text,
-	bold: (text) => text,
-	error: (text) => text,
-	success: (text) => text,
-	pending: (text) => text,
-	tool: (text) => text,
-	path: (text) => text,
-	user: (text) => text,
-	syntax: {
-		keyword: (text) => text,
-		string: (text) => text,
-		number: (text) => text,
-		comment: (text) => text
-	}
-};
-/**
-* Build the theme for one surface.
-*
-* Color is suppressed off a TTY and whenever `NO_COLOR` is set to any value,
-* following the `no-color.org` convention: a redirected transcript stays
-* greppable, and a pipe never receives sequences a reader would have to strip.
-*
-* Secondary text uses a palette gray on a 256-color terminal rather than the
-* `dim` attribute: several terminals render `dim` at full brightness, and a
-* hierarchy nobody can see is no hierarchy — the placeholder, the menu details,
-* and the status row must sit visibly behind what the person typed.
-* @param isTty - whether the output stream is a terminal.
-* @param env - the environment to read `NO_COLOR` and the color depth from.
-* @returns the styling functions for this surface.
-*/
-function createTheme(isTty, env) {
-	if (!isTty || env.NO_COLOR !== void 0) return PLAIN;
-	const palette = env.TERM?.includes("256color") === true || env.COLORTERM !== void 0;
-	const wrap = (code) => (text) => `${code}${text}${SGR$1.reset}`;
-	return {
-		colored: true,
-		dim: wrap(palette ? "\x1B[38;5;245m" : SGR$1.dim),
-		bold: wrap(SGR$1.bold),
-		error: wrap(SGR$1.red),
-		success: wrap(SGR$1.green),
-		pending: wrap(SGR$1.yellow),
-		tool: wrap(SGR$1.cyan),
-		path: wrap(SGR$1.blue),
-		user: wrap(SGR$1.magenta),
-		syntax: {
-			keyword: wrap(SGR$1.magenta),
-			string: wrap(SGR$1.green),
-			number: wrap(SGR$1.cyan),
-			comment: wrap(SGR$1.dim)
-		}
-	};
-}
-/**
-* Display columns a string occupies once printed, ignoring styling sequences.
-*
-* Measured by `string-width` — the width authority cli-table3, ink, and every
-* maintained terminal renderer sit on — so East Asian Wide, emoji presentation
-* (`⚡` included), combining marks, and ZWJ sequences all match what a
-* terminal's cursor actually does. A hand-kept range table here mis-sized `⚡`
-* and sheared a real table's columns; widths are exactly the kind of data
-* nobody should maintain by hand.
-* @param text - the string to measure, possibly carrying SGR sequences.
-* @returns the number of display columns.
-*/
-function displayWidth(text) {
-	if (text === "") return 0;
-	let ascii = true;
-	for (let index = 0; index < text.length; index += 1) {
-		const code = text.charCodeAt(index);
-		if (code < 32 || code > 126) {
-			ascii = false;
-			break;
-		}
-	}
-	if (ascii) return text.length;
-	return stringWidth(text);
-}
-/** Matches one SGR sequence at the start of a string. */
-const SGR_AT_START = /^\u001B\[[0-9;]*m/u;
-/**
-* Shorten a string to at most `columns` display columns, marking the cut with
-* an ellipsis when anything was dropped.
-*
-* Styling survives: sequences cost no columns and travel with the text they
-* style, and a cut that kept any styling closes it with a reset before the
-* ellipsis so nothing leaks onto the next row. A string that already fits is
-* returned exactly as it came — a fit is not a licence to restyle it.
-* @param text - the string to shorten, possibly carrying SGR sequences.
-* @param columns - the display-column budget; a budget under 2 yields the empty string.
-* @returns the string, unchanged when it already fits.
-*/
-function truncate(text, columns) {
-	if (displayWidth(text) <= columns) return text;
-	if (columns < 2) return "";
-	let width = 0;
-	let out = "";
-	let styled = false;
-	let at = 0;
-	while (at < text.length) {
-		const sequence = SGR_AT_START.exec(text.slice(at));
-		if (sequence !== null) {
-			out += sequence[0];
-			styled = true;
-			at += sequence[0].length;
-			continue;
-		}
-		const code = text.codePointAt(at) ?? 0;
-		const cell = String.fromCodePoint(code);
-		const step = displayWidth(cell);
-		if (width + step > columns - 1) break;
-		width += step;
-		out += cell;
-		at += cell.length;
-	}
-	return `${out}${styled ? "\x1B[0m" : ""}…`;
-}
-
-//#endregion
-//#region src/status.ts
-/**
-* Abbreviate a token count the way a status line wants it: exact while small,
-* one decimal at thousands, whole at millions.
-* @param tokens - the count to render.
-* @returns the abbreviated figure.
-*/
-function formatTokens(tokens) {
-	if (tokens < 1e3) return String(tokens);
-	if (tokens < 1e6) {
-		const thousands = tokens / 1e3;
-		return `${thousands < 10 ? thousands.toFixed(1) : Math.round(thousands)}k`;
-	}
-	return `${(tokens / 1e6).toFixed(1)}M`;
-}
-/**
-* Total tokens a session has spent across every bucket.
-*
-* The four buckets are disjoint by contract — reasoning already sits inside
-* output — so a plain sum is the session total.
-* @param usage - cumulative usage, or undefined before any request.
-* @returns the total, or undefined when nothing is recorded.
-*/
-function totalTokens(usage) {
-	if (usage === void 0) return void 0;
-	return usage.uncachedInputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
-}
-/**
-* Percentage of the context window still free for the next request.
-*
-* `projectedTokens` is what the NEXT prompt would cost, which is the figure a
-* person deciding whether to keep going needs; it also moves the instant a
-* compaction shadows a span, where the raw sample cannot.
-* @param context - the occupancy projection.
-* @returns whole percent remaining, or undefined without both figures.
-*/
-function contextLeftPercent(context) {
-	const window = context?.contextWindow;
-	const used = context?.projectedTokens ?? context?.pressureTokens;
-	if (window === void 0 || used === void 0 || window <= 0) return void 0;
-	return Math.max(0, Math.min(100, Math.round((1 - used / window) * 100)));
-}
-/**
-* Shorten a path for display, collapsing the home directory to `~`.
-* @param path - the absolute path.
-* @param home - the home directory to collapse; defaults to the real one.
-* @returns the display path.
-*/
-function displayPath(path, home = homedir()) {
-	return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
-}
-/**
-* Read the checked-out branch by walking up to the repository's `HEAD`.
-*
-* Read rather than shelled out: `git` may be absent, slow, or blocked by the
-* sandbox, and a status line must never be the reason a prompt stalls. A
-* detached head reports no branch rather than a bare revision, which would read
-* as a branch named after a hash.
-* @param cwd - directory to start from.
-* @returns the branch name, or undefined outside a repository or when detached.
-*/
-async function gitBranch(cwd) {
-	const root = parse(cwd).root;
-	for (let dir = cwd;; dir = dirname(dir)) {
-		const marker = join(dir, ".git");
-		const pointer = await readFile(marker, "utf8").catch(() => void 0);
-		const gitDir = pointer === void 0 ? marker : pointer.startsWith("gitdir:") ? pointer.slice(7).trim() : void 0;
-		if (gitDir !== void 0) {
-			const head = await readFile(join(gitDir, "HEAD"), "utf8").catch(() => void 0);
-			const ref = head?.trim().match(/^ref: refs\/heads\/(.+)$/);
-			if (ref?.[1] !== void 0) return ref[1];
-			if (head !== void 0) return void 0;
-		}
-		if (dir === root) return void 0;
-	}
-}
-/**
-* Render the status line.
-*
-* Segments that have nothing to report are dropped rather than shown empty, so
-* a fresh session reads as short rather than as broken.
-* @param facts - what to report.
-* @param theme - styling for the segments.
-* @param columns - display columns available; a longer line is cut, never wrapped.
-* @returns the line, unstyled when the theme is plain.
-*/
-function statusLine(facts, theme, columns) {
-	const left = contextLeftPercent(facts.context);
-	const total = totalTokens(facts.usage);
-	const headroom = left === void 0 ? [] : [left <= 10 ? theme.error(`${left}% context left`) : left <= 25 ? theme.pending(`${left}% context left`) : theme.dim(`${left}% context left`)];
-	return truncate([
-		theme.tool(facts.model),
-		...facts.preset === void 0 ? [] : [theme.dim(facts.preset)],
-		...facts.permission === void 0 ? [] : [theme.dim(facts.permission)],
-		...facts.planMode ? [theme.pending("plan")] : [],
-		...total === void 0 ? [] : [theme.dim(`${formatTokens(total)} tokens`)],
-		...headroom,
-		theme.dim(facts.branch === void 0 ? displayPath(facts.cwd) : `${displayPath(facts.cwd)} (${facts.branch})`)
-	].join(theme.dim(" · ")), columns);
-}
-/**
-* Render the fuller readout `/status` answers with.
-*
-* The status line is a glance; this is the place a person looks when the glance
-* raised a question, so it names each usage bucket rather than one total.
-* @param facts - what to report.
-* @param session - the session identity, which `--resume` takes.
-* @returns the report, one `label: value` per line.
-*/
-function statusReport(facts, session) {
-	const left = contextLeftPercent(facts.context);
-	const window = facts.context?.contextWindow;
-	const next = facts.context?.projectedTokens ?? facts.context?.pressureTokens;
-	const usage = facts.usage;
-	const rows = [
-		["session", session],
-		["model", facts.model],
-		...facts.preset === void 0 ? [] : [["preset", facts.preset]],
-		...facts.permission === void 0 ? [] : [["permissions", facts.permission]],
-		["plan mode", facts.planMode ? "on" : "off"],
-		["workspace", facts.branch === void 0 ? displayPath(facts.cwd) : `${displayPath(facts.cwd)} (${facts.branch})`],
-		...usage === void 0 ? [] : [
-			["input", formatTokens(usage.uncachedInputTokens)],
-			["output", formatTokens(usage.outputTokens)],
-			["cache read", formatTokens(usage.cacheReadTokens)],
-			["cache write", formatTokens(usage.cacheWriteTokens)],
-			["total", formatTokens(totalTokens(usage) ?? 0)]
-		],
-		...next === void 0 || window === void 0 ? [] : [["next request", `${formatTokens(next)} of ${formatTokens(window)}${left === void 0 ? "" : ` (${left}% left)`}`]]
-	];
-	const label = Math.max(...rows.map(([name$1]) => name$1.length));
-	return rows.map(([name$1, value]) => `${name$1.padEnd(label)}  ${value}`).join("\n");
-}
-
-//#endregion
-//#region src/banner.ts
-/** The product name, shown as the framed headline. */
-const NAME$1 = "dsh code";
-/**
-* The lettermark, drawn in half-block glyphs.
-*
-* Forty columns wide: it fits an eighty-column terminal with room to spare,
-* and anything narrower falls back to the plain headline anyway.
-*/
-const LOGO = [
-	" ██████╗ ██████╗ ██████╗ ███████╗██╗  ██╗",
-	"██╔════╝██╔═══██╗██╔══██╗██╔════╝██║  ██║",
-	"██║     ██║   ██║██║  ██║███████╗███████║",
-	"██║     ██║   ██║██║  ██║╚════██║██╔══██║",
-	"╚██████╗╚██████╔╝██████╔╝███████║██║  ██║",
-	" ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝"
-];
-/** Display width of the widest logo row. */
-const LOGO_WIDTH = 41;
-/**
-* Frame one headline in a rounded box sized to its content.
-*
-* Drawn from the measured display width rather than the character count, so a
-* headline carrying wide characters still closes its own box.
-* @param headline - the text to frame, already styled.
-* @param width - display width of the headline's plain text.
-* @param theme - styling for the frame itself.
-* @returns the three box lines.
-*/
-function framed(headline, width, theme) {
-	const rule = "─".repeat(width + 2);
-	return [
-		theme.dim(`╭${rule}╮`),
-		`${theme.dim("│")} ${headline} ${theme.dim("│")}`,
-		theme.dim(`╰${rule}╯`)
-	];
-}
-/**
-* Render the opening banner.
-* @param facts - what to report.
-* @param theme - styling for the frame and the detail lines.
-* @param columns - display columns available; a narrow terminal loses the frame.
-* @returns the lines to print, ending with a blank separator.
-*/
-function bannerLines(facts, theme, columns) {
-	const composition = [facts.model, ...facts.preset === void 0 ? [] : [facts.preset]].join(" · ");
-	const where = facts.branch === void 0 ? displayPath(facts.cwd) : `${displayPath(facts.cwd)} (${facts.branch})`;
-	const interrupt = facts.readsKeys ? "ESC" : "Ctrl-C";
-	const plain = `${NAME$1} · ${composition}`;
-	const headline = `${theme.bold(NAME$1)}${theme.dim(` · ${composition}`)}`;
-	const details = [
-		theme.dim(`  ${truncate(where, columns - 2)}`),
-		theme.dim(`  session ${facts.session}${facts.resumed ? " (resumed)" : ""}`),
-		"",
-		theme.dim(truncate(`  /help for commands · Tab completes · ⇧Tab plan mode · ${interrupt} interrupts · /exit leaves`, columns)),
-		""
-	];
-	if (facts.readsKeys && !facts.resumed && columns >= LOGO_WIDTH + 2) return [
-		"",
-		...LOGO.map((row) => theme.user(` ${row}`)),
-		"",
-		` ${theme.bold("✻ Welcome to codsh")}${theme.dim(` · ${composition}`)}`,
-		"",
-		...details
-	];
-	return [...displayWidth(plain) + 4 <= columns ? framed(headline, displayWidth(plain), theme) : [truncate(plain, columns)], ...details];
-}
-
-//#endregion
-//#region src/completion.ts
-/** Directories never worth offering: build output and version-control internals. */
-const HIDDEN_DIRS = new Set([
-	"node_modules",
-	".git",
-	"lib",
-	"dist",
-	"build",
-	"out",
-	"coverage"
-]);
-/** Deepest directory level the file index walks. */
-const INDEX_DEPTH = 8;
-/** Most entries the file index keeps; a bigger workspace is sampled, not hung on. */
-const INDEX_CAP = 5e3;
-/** How long one file index answers Tabs before the workspace is re-walked. */
-const INDEX_TTL_MS = 5e3;
-/** Candidates offered per completion. */
-const LIMIT = 8;
-/**
-* Score `needle` against `hay` as a fuzzy subsequence.
-*
-* Consecutive hits and hits on a boundary (start, or after a separator) score
-* higher, which is what ranks `src/idx` matches the way a person expects. A
-* needle that is not a subsequence scores nothing at all.
-* @param needle - what was typed, matched case-insensitively.
-* @param hay - the candidate.
-* @returns the score, or undefined when it does not match.
-*/
-function fuzzyScore(needle, hay) {
-	const want = needle.toLowerCase();
-	const have = hay.toLowerCase();
-	let score = 0;
-	let at = -1;
-	let previous = -2;
-	for (const cell of want) {
-		at = have.indexOf(cell, at + 1);
-		if (at < 0) return void 0;
-		const boundary = at === 0 || "/._- ".includes(have[at - 1] ?? "");
-		score += at === previous + 1 ? 3 : boundary ? 2 : 1;
-		previous = at;
-	}
-	return score * 100 - have.length;
-}
-let cached;
-/**
-* Walk the workspace into a flat list of relative paths.
-*
-* Synchronous and bounded: Tab is a keystroke-latency path, so the walk is
-* capped in depth and count and its result reused for a few seconds. An
-* unreadable directory contributes nothing rather than failing the keystroke.
-* @param cwd - the workspace root.
-* @returns relative paths, directories marked with a trailing slash.
-*/
-function fileIndex(cwd) {
-	const now = Date.now();
-	if (cached !== void 0 && cached.cwd === cwd && now - cached.at < INDEX_TTL_MS) return cached.entries;
-	const entries = [];
-	const queue = [""];
-	while (queue.length > 0 && entries.length < INDEX_CAP) {
-		const dir = queue.shift() ?? "";
-		if (dir.split("/").length > INDEX_DEPTH) continue;
-		let found;
-		try {
-			found = readdirSync(join(cwd, dir), { withFileTypes: true });
-		} catch {
-			continue;
-		}
-		for (const entry of found) {
-			if (entries.length >= INDEX_CAP) break;
-			if (entry.name.startsWith(".") || HIDDEN_DIRS.has(entry.name)) continue;
-			const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
-			if (entry.isDirectory()) {
-				entries.push(`${path}/`);
-				queue.push(path);
-			} else entries.push(path);
-		}
-	}
-	cached = {
-		cwd,
-		at: now,
-		entries
-	};
-	return entries;
-}
-/**
-* Complete a workspace path from an `@` mention, fuzzily across the whole tree.
-* @param token - the mention as typed, including its leading `@`.
-* @param cwd - the workspace the mention resolves against.
-* @returns candidate mentions, best match first.
-*/
-function completePath(token, cwd) {
-	const typed = token.slice(1);
-	const entries = fileIndex(cwd);
-	if (typed === "") return entries.filter((entry) => !entry.slice(0, -1).includes("/")).sort().slice(0, LIMIT).map((entry) => `@${entry}`);
-	const prefixed = entries.filter((entry) => entry.startsWith(typed)).sort();
-	const scored = entries.map((entry) => ({
-		entry,
-		score: fuzzyScore(typed, entry)
-	})).filter((hit) => hit.score !== void 0).sort((a, b) => b.score - a.score).map((hit) => hit.entry);
-	const ranked = [];
-	for (const entry of [...prefixed, ...scored]) {
-		if (!ranked.includes(entry)) ranked.push(entry);
-		if (ranked.length >= LIMIT) break;
-	}
-	return ranked.map((entry) => `@${entry}`);
-}
-/**
-* Build the completer for one session.
-*
-* The command list is read on each use rather than captured, because a command
-* registry is scoped and changes with the session's mode — plan mode alone adds
-* and removes one.
-* @param commands - reads the currently registered commands.
-* @param cwd - the workspace `@` mentions resolve against.
-* @returns a completer over the word under the cursor.
-*/
-function createCompleter(commands, cwd) {
-	return (line) => {
-		const token = line.slice(line.lastIndexOf(" ") + 1);
-		if (token.startsWith("@")) return [completePath(token, cwd), token];
-		if (!line.startsWith("/") || line.includes(" ")) return [[], token];
-		const typed = line.slice(1);
-		const names = commands().map((command) => `/${command.name}`);
-		const prefixed = names.filter((name$1) => name$1.startsWith(`/${typed}`));
-		const fuzzy = names.map((name$1) => ({
-			name: name$1,
-			score: fuzzyScore(typed, name$1.slice(1))
-		})).filter((hit) => hit.score !== void 0).sort((a, b) => b.score - a.score).map((hit) => hit.name);
-		const ranked = [];
-		for (const name$1 of [...prefixed, ...fuzzy]) {
-			if (!ranked.includes(name$1)) ranked.push(name$1);
-			if (ranked.length >= LIMIT) break;
-		}
-		return [ranked, line];
-	};
-}
-
-//#endregion
-//#region src/custom-commands.ts
-/** The registry's command-name rule; a file that breaks it cannot register. */
-const NAME = /^[a-z][a-z0-9_-]*$/;
-/**
-* Parse one command file: optional `---` frontmatter with a `description`
-* line, then the prompt body.
-* @param source - the file content.
-* @returns the description (empty when absent) and the body.
-*/
-function parseCommandFile(source) {
-	if (source.startsWith("---\n")) {
-		const end = source.indexOf("\n---\n", 4);
-		if (end >= 0) {
-			const header = source.slice(4, end);
-			return {
-				description: /^description:\s*(.+)$/m.exec(header)?.[1]?.trim() ?? "",
-				body: source.slice(end + 5).trim()
-			};
-		}
-	}
-	return {
-		description: "",
-		body: source.trim()
-	};
-}
-/**
-* Fill a template with the typed arguments.
-* @param template - the prompt body.
-* @param typed - what followed the command name, possibly empty.
-* @returns the prompt to submit: placeholders replaced, or the arguments
-*   appended when the template never asked for them.
-*/
-function expandTemplate(template, typed) {
-	if (template.includes("$ARGUMENTS")) return template.replaceAll("$ARGUMENTS", typed);
-	return typed === "" ? template : `${template}\n\n${typed}`;
-}
-/**
-* Load every command under the given roots, later roots shadowing earlier.
-*
-* A missing root is normal (most setups define no custom commands); an
-* unreadable or misnamed file is a warning, never a failed startup — a broken
-* canned prompt should cost that prompt, not the session.
-* @param roots - directories to scan, lowest precedence first.
-* @param taken - names already registered, which a file cannot shadow.
-* @returns the loaded commands and the warnings to show once.
-*/
-async function loadCustomCommands(roots, taken) {
-	const commands = /* @__PURE__ */ new Map();
-	const warnings = [];
-	for (const root of roots) {
-		let entries;
-		try {
-			entries = await readdir(root);
-		} catch {
-			continue;
-		}
-		for (const entry of entries.filter((name$1) => name$1.endsWith(".md")).sort()) {
-			const name$1 = entry.slice(0, -3);
-			if (!NAME.test(name$1)) {
-				warnings.push(`${join(root, entry)}: "${name$1}" is not a command name (lowercase letters, digits, - and _)`);
-				continue;
-			}
-			if (taken.has(name$1)) {
-				warnings.push(`${join(root, entry)}: /${name$1} is already a built-in command`);
-				continue;
-			}
-			try {
-				const { description, body } = parseCommandFile(await readFile(join(root, entry), "utf8"));
-				if (body === "") {
-					warnings.push(`${join(root, entry)}: empty prompt body`);
-					continue;
-				}
-				commands.set(name$1, {
-					name: name$1,
-					description: description === "" ? `custom command (${entry})` : description,
-					template: body
-				});
-			} catch (error) {
-				warnings.push(`${join(root, entry)}: ${error instanceof Error ? error.message : String(error)}`);
-			}
-		}
-	}
-	return {
-		commands: [...commands.values()],
-		warnings
-	};
-}
-
-//#endregion
-//#region src/keys.ts
-/** Bracketed paste start, which a terminal wraps pasted text in. */
-const PASTE_START = "\x1B[200~";
-/** Bracketed paste end. */
-const PASTE_END = "\x1B[201~";
-/**
-* Rows one wheel event moves.
-*
-* One, not three: trackpads and hi-res wheels emit a stream of events per
-* gesture, so a multiplier here compounds into overshoot. The smoothness comes
-* from coalescing the stream into one repaint, not from bigger steps.
-*/
-const WHEEL_LINES = 1;
-/** An SGR mouse report: `ESC [ < button ; column ; row (M|m)`. */
-const MOUSE = /^\u001B\[<(\d+);(\d+);(\d+)([Mm])/;
-/** Wheel-up button code in the SGR encoding; wheel-down is one higher. */
-const WHEEL_UP = 64;
-/** Modifier bits in an SGR button code: Shift, Meta, and Control. */
-const MOUSE_MODIFIERS = 28;
-/** The motion bit, set on reports sent while a button is held. */
-const MOUSE_MOTION = 32;
-/** Sequences that resolve to one key, longest first so a prefix never wins. */
-const SEQUENCES = [
-	["\x1B[5~", {
-		kind: "page",
-		direction: -1
-	}],
-	["\x1B[6~", {
-		kind: "page",
-		direction: 1
-	}],
-	["\x1B[1;2A", {
-		kind: "scroll",
-		lines: -1
-	}],
-	["\x1B[1;2B", {
-		kind: "scroll",
-		lines: 1
-	}],
-	["\x1B[1;5F", { kind: "scroll-end" }],
-	["\x1B[1;5D", { kind: "word-left" }],
-	["\x1B[1;5C", { kind: "word-right" }],
-	["\x1B[1;3D", { kind: "word-left" }],
-	["\x1B[1;3C", { kind: "word-right" }],
-	["\x1B[3~", { kind: "delete" }],
-	["\x1B[1~", { kind: "home" }],
-	["\x1B[4~", { kind: "end" }],
-	["\x1B[7~", { kind: "home" }],
-	["\x1B[8~", { kind: "end" }],
-	["\x1B[A", { kind: "up" }],
-	["\x1B[B", { kind: "down" }],
-	["\x1B[C", { kind: "right" }],
-	["\x1B[D", { kind: "left" }],
-	["\x1B[H", { kind: "home" }],
-	["\x1B[F", { kind: "end" }],
-	["\x1BOA", { kind: "up" }],
-	["\x1BOB", { kind: "down" }],
-	["\x1BOC", { kind: "right" }],
-	["\x1BOD", { kind: "left" }],
-	["\x1BOH", { kind: "home" }],
-	["\x1BOF", { kind: "end" }],
-	["\x1B[Z", { kind: "shift-tab" }],
-	["\x1Bb", { kind: "word-left" }],
-	["\x1Bf", { kind: "word-right" }],
-	["\x1B", { kind: "kill-word" }],
-	["\x1B\r", { kind: "newline" }],
-	["\x1B\n", { kind: "newline" }]
-];
-/**
-* Control bytes that map straight to one key.
-*
-* Both carriage return and line feed submit. A terminal in raw mode sends `\r`
-* for Enter, but not every one does, and a key that inserted a line break
-* instead of submitting would be the worse failure — Alt-Enter is the binding
-* that adds a line.
-*/
-const CONTROLS = {
-	"\r": { kind: "enter" },
-	"\n": { kind: "enter" },
-	"	": { kind: "tab" },
-	"": { kind: "backspace" },
-	"\b": { kind: "backspace" },
-	"": { kind: "interrupt" },
-	"": { kind: "eof" },
-	"
": { kind: "home" },
-	"": { kind: "end" },
-	"\v": { kind: "kill-line" },
-	"\f": { kind: "clear-screen" },
-	"": { kind: "expand-output" },
-	"": { kind: "kill-input" },
-	"": { kind: "kill-word" }
-};
-/** Decodes terminal bytes into keys, holding partial sequences between reads. */
-var KeyDecoder = class {
-	held = "";
-	pasting = false;
-	pasted = "";
-	/**
-	* Feed one read's worth of input.
-	* @param chunk - the bytes as text.
-	* @returns the keys this read completed, in order.
-	*/
-	push(chunk) {
-		this.held += chunk;
-		const keys = [];
-		for (;;) {
-			const key = this.take();
-			if (key === void 0) break;
-			keys.push(...key);
-		}
-		return keys;
-	}
-	/** Whether bytes are held back awaiting the rest of a sequence. */
-	get pending() {
-		return this.held !== "";
-	}
-	/**
-	* Resolve a held Escape that no further byte arrived for.
-	*
-	* `ESC` alone and the first byte of `ESC [ A` are the same byte, so the two can
-	* only be told apart by what follows — or by nothing following. The caller arms
-	* a short timer after each read and calls this when it expires: an arrow key
-	* split across reads completes long before that, and a key pressed by itself
-	* never completes at all.
-	* @returns the Escape key, or nothing when the held bytes are a real prefix.
-	*/
-	flush() {
-		if (this.pasting || this.held !== "\x1B") return [];
-		this.held = "";
-		return [{ kind: "escape" }];
-	}
-	/**
-	* Resolve the held bytes into one key, if they are enough.
-	* @returns the keys produced, or undefined when more bytes are needed.
-	*/
-	take() {
-		if (this.held === "") return void 0;
-		if (this.pasting) return this.takePasted();
-		if (this.held.startsWith(PASTE_START)) {
-			this.held = this.held.slice(6);
-			this.pasting = true;
-			this.pasted = "";
-			return [];
-		}
-		if (PASTE_START.startsWith(this.held)) return void 0;
-		const mouse = MOUSE.exec(this.held);
-		if (mouse !== null) {
-			this.held = this.held.slice(mouse[0].length);
-			const button = Number(mouse[1]);
-			if (button === WHEEL_UP) return [{
-				kind: "scroll",
-				lines: -WHEEL_LINES
-			}];
-			if (button === WHEEL_UP + 1) return [{
-				kind: "scroll",
-				lines: WHEEL_LINES
-			}];
-			const column = Number(mouse[2]);
-			const row = Number(mouse[3]);
-			if ((button & ~MOUSE_MOTION) === 0 && (button & MOUSE_MODIFIERS) === 0) {
-				if (mouse[4] === "m") return [{
-					kind: "mouse-up",
-					row,
-					column
-				}];
-				if ((button & MOUSE_MOTION) !== 0) return [{
-					kind: "mouse-drag",
-					row,
-					column
-				}];
-				return [{
-					kind: "mouse-down",
-					row,
-					column
-				}];
-			}
-			return [];
-		}
-		if (/^\u001B(\[(<\d*(;\d*){0,2})?)?$/.test(this.held)) return void 0;
-		for (const [sequence, key] of SEQUENCES) {
-			if (this.held.startsWith(sequence)) {
-				this.held = this.held.slice(sequence.length);
-				return [key];
-			}
-			if (sequence.startsWith(this.held)) return void 0;
-		}
-		const first = this.held[0] ?? "";
-		if (first === "\x1B") {
-			this.held = this.held.slice(1);
-			return [];
-		}
-		const control = CONTROLS[first];
-		if (control !== void 0) {
-			this.held = this.held.slice(1);
-			return [control];
-		}
-		const printable = /^[^\u0000-\u001F\u007F]+/u.exec(this.held);
-		if (printable === null) {
-			this.held = this.held.slice(1);
-			return [];
-		}
-		this.held = this.held.slice(printable[0].length);
-		return [{
-			kind: "text",
-			text: printable[0]
-		}];
-	}
-	/**
-	* Collect bracketed-paste content up to its end marker.
-	* @returns the paste key once complete, otherwise undefined.
-	*/
-	takePasted() {
-		const end = this.held.indexOf(PASTE_END);
-		if (end < 0) {
-			const safe = Math.max(0, this.held.length - 6 + 1);
-			this.pasted += this.held.slice(0, safe);
-			this.held = this.held.slice(safe);
-			return;
-		}
-		this.pasted += this.held.slice(0, end);
-		this.held = this.held.slice(end + 6);
-		this.pasting = false;
-		const text = this.pasted;
-		this.pasted = "";
-		return [{
-			kind: "paste",
-			text
-		}];
-	}
-};
-/** Ask the terminal to wrap pasted text in markers. */
-const ENABLE_PASTE_MARKERS = "\x1B[?2004h";
-/** Stop the terminal wrapping pasted text, restoring what it did before. */
-const DISABLE_PASTE_MARKERS = "\x1B[?2004l";
-
-//#endregion
-//#region src/wrap.ts
-/** One SGR sequence, which occupies no display columns. */
-const SGR = /^\u001B\[[0-9;]*m/;
-/** Any other escape sequence, also zero-width. */
-const ESCAPE = /^(?:\u001B\[[0-9;?]*[A-Za-z]|\u001B\][^\u0007]*\u0007|\u001B.)/;
-/** Closes every style a row opened, so a row never bleeds into the next. */
-const RESET = "\x1B[0m";
-/**
-* Break one styled line into rows no wider than `columns` display columns.
-*
-* Styles carry across the break: each continuation row re-opens whatever was
-* active where the cut fell, and every row that opened a style closes it.
-* @param text - the styled line, without a terminator.
-* @param columns - display columns available per row.
-* @returns the rows, at least one (an empty line yields one empty row).
-*/
-function wrapStyled(text, columns) {
-	if (columns <= 0) return [text];
-	const rows = [];
-	/** SGR sequences active at the cursor, in the order they were applied. */
-	let active = [];
-	let row = "";
-	let width = 0;
-	let rest = text;
-	const flush = () => {
-		rows.push(active.length > 0 ? `${row}${RESET}` : row);
-		row = active.join("");
-		width = 0;
-	};
-	while (rest !== "") {
-		const sgr = SGR.exec(rest);
-		if (sgr !== null) {
-			const sequence = sgr[0];
-			if (sequence === "\x1B[0m" || sequence === "\x1B[m") active = [];
-			else active.push(sequence);
-			row += sequence;
-			rest = rest.slice(sequence.length);
-			continue;
-		}
-		const other = ESCAPE.exec(rest);
-		if (other !== null) {
-			row += other[0];
-			rest = rest.slice(other[0].length);
-			continue;
-		}
-		const character = [...rest][0] ?? "";
-		const cost = displayWidth(character);
-		if (width + cost > columns && width > 0) flush();
-		row += character;
-		width += cost;
-		rest = rest.slice(character.length);
-	}
-	rows.push(active.length > 0 ? `${row}${RESET}` : row);
-	return rows;
-}
-/**
-* Wrap many lines, keeping their order.
-* @param lines - styled lines.
-* @param columns - display columns per row.
-* @returns the physical rows they occupy.
-*/
-function wrapAll(lines, columns) {
-	return lines.flatMap((line) => wrapStyled(line, columns));
-}
-
-//#endregion
-//#region src/screen.ts
-/** Logical transcript lines kept before the oldest are dropped. */
-const MAX_SCROLLBACK = 5e3;
-/** Enter the alternate screen, saving the cursor and the current buffer. */
-const ENTER_ALT = "\x1B[?1049h";
-/** Leave it, restoring both. */
-const LEAVE_ALT = "\x1B[?1049l";
-/**
-* Report wheel and button events, in the SGR encoding.
-*
-* Button tracking (1002) rather than any-motion (1003): the wheel and clicks
-* are all this surface reads, and motion reporting floods the input for
-* nothing. Most terminals still hand a Shift-drag to their own selection, so
-* copying text keeps working.
-*/
-const ENABLE_MOUSE = "\x1B[?1002h\x1B[?1006h";
-/** Stop reporting them. */
-const DISABLE_MOUSE = "\x1B[?1006l\x1B[?1002l";
-/** Ask the terminal to paint a frame atomically, so no half-frame is shown. */
-const SYNC_BEGIN = "\x1B[?2026h";
-/** End the atomic frame. */
-const SYNC_END = "\x1B[?2026l";
-/** Erase the row from the cursor rightwards. */
-const CLEAR_LINE = "\x1B[K";
-/** Hide the cursor while a frame is painted. */
-const HIDE_CURSOR = "\x1B[?25l";
-/** Show it again. */
-const SHOW_CURSOR = "\x1B[?25h";
-/** Styling escapes, removed before a row is measured or copied. */
-const STYLES = /\u001B\[[0-9;]*m/gu;
-/** Start reverse video, which is how the selection shows itself. */
-const INVERSE = "\x1B[7m";
-/** End reverse video only, leaving any other attributes alone. */
-const INVERSE_OFF = "\x1B[27m";
-/**
-* The string index where a display column begins.
-*
-* Columns are what the mouse reports and characters are what strings hold;
-* this is the bridge. A column landing inside a wide character snaps past it.
-* @param text - plain text, no escapes.
-* @param column - display column, 0-based.
-* @returns the index of the first character at or beyond that column.
-*/
-function columnIndex(text, column) {
-	let width = 0;
-	let index = 0;
-	for (const character of text) {
-		if (width >= column) return index;
-		width += displayWidth(character);
-		index += character.length;
-	}
-	return text.length;
-}
-/** An alternate-screen viewport over a scrollback buffer this surface owns. */
-var Screen = class {
-	/** Logical transcript lines, unwrapped, oldest first. */
-	logical = [];
-	/** The same lines wrapped to the current width — what the viewport slices. */
-	physical = [];
-	/** The bottom rows: input box, menu, indicator, status. */
-	chrome = [];
-	chromeCursor = {
-		row: 0,
-		column: 0
-	};
-	/** Whether the chrome holds input focus, which is when the cursor shows. */
-	chromeFocus = true;
-	/** Physical rows hidden below the viewport; zero means following the tail. */
-	offset = 0;
-	/** What to show while scrolled back, drawn over the viewport's top row. */
-	notice = "";
-	/** A mouse selection over the transcript, in physical-row coordinates. */
-	selection;
-	/** Collapsed blocks in the transcript, in order, with both of their forms. */
-	folds = [];
-	/** Whether the folds currently show their full form. */
-	expanded = false;
-	/** The last painted frame, so a repaint only touches rows that changed. */
-	painted = [];
-	/** Width the current frame was painted at, to detect a resize. */
-	paintedColumns = 0;
-	active = false;
-	constructor(host) {
-		this.host = host;
-	}
-	/** Whether the alternate screen is currently held. */
-	get entered() {
-		return this.active;
-	}
-	/** Physical rows scrolled up out of view; zero means the tail is showing. */
-	get scrolledBy() {
-		return this.offset;
-	}
-	/** Take the alternate screen and start reporting the mouse. */
-	enter() {
-		if (this.active) return;
-		this.active = true;
-		this.host.write(`${ENTER_ALT}${ENABLE_MOUSE}${HIDE_CURSOR}`);
-		this.painted = [];
-		this.render();
-	}
-	/**
-	* Give the terminal back exactly as it was.
-	*
-	* Idempotent, because every exit path calls it — a normal quit, an
-	* interrupt, and a crash handler all have to leave the terminal usable.
-	*/
-	leave() {
-		if (!this.active) return;
-		this.active = false;
-		this.host.write(`${DISABLE_MOUSE}${SHOW_CURSOR}${LEAVE_ALT}`);
-		this.painted = [];
-	}
-	/**
-	* Append finished transcript lines.
-	*
-	* Following the tail is the default; a person who has scrolled up stays
-	* where they are, and the new rows accumulate below them.
-	* @param lines - the lines to keep, already styled.
-	*/
-	append(lines) {
-		if (lines.length === 0) return;
-		const columns = this.contentColumns();
-		for (const line of lines) {
-			this.logical.push(line);
-			this.physical.push(...wrapStyled(line, columns));
-		}
-		if (this.logical.length > MAX_SCROLLBACK) {
-			const dropped = this.logical.length - MAX_SCROLLBACK;
-			this.logical.splice(0, dropped);
-			this.folds = this.folds.flatMap((fold) => {
-				const at = fold.at - dropped;
-				return at >= 0 ? [{
-					...fold,
-					at
-				}] : [];
-			});
-			this.rewrap();
-		}
-		this.render();
-	}
-	/**
-	* Append one collapsible block: its summary now, its full form on demand.
-	*
-	* This is what makes every long block — not merely the latest — expandable:
-	* the buffer keeps both forms, and toggling rebuilds the transcript in
-	* place, exactly like a details/summary element.
-	* @param summary - the collapsed lines, already styled.
-	* @param full - the expanded lines, already styled.
-	*/
-	appendFold(summary, full) {
-		const shown = this.expanded ? full : summary;
-		this.folds.push({
-			at: this.logical.length,
-			shownLength: shown.length,
-			summary: [...summary],
-			full: [...full],
-			expanded: this.expanded
-		});
-		this.append(shown);
-	}
-	/**
-	* Turn the last `count` appended lines into a collapsible block after the
-	* fact.
-	*
-	* This is how a finished answer becomes foldable without ever having been
-	* withheld: it streamed in the open, and only once complete does it grow a
-	* summary form. The block starts expanded — the person is reading it — and
-	* collapses with the rest when the conversation moves on.
-	* @param count - how many trailing lines the block owns.
-	* @param summary - the collapsed lines, already styled.
-	*/
-	foldBack(count, summary) {
-		const at = this.logical.length - count;
-		if (count <= 0 || at < 0) return;
-		const last = this.folds.at(-1);
-		if (last !== void 0 && at < last.at + last.shownLength) return;
-		this.folds.push({
-			at,
-			shownLength: count,
-			summary: [...summary],
-			full: this.logical.slice(at),
-			expanded: true
-		});
-	}
-	/** Whether any collapsible block exists. */
-	get hasFolds() {
-		return this.folds.length > 0;
-	}
-	/** Whether the folds currently show their full form. */
-	get foldsExpanded() {
-		return this.expanded;
-	}
-	/**
-	* Swap every fold between its summary and its full form.
-	* @returns false when there is nothing to toggle.
-	*/
-	toggleFolds() {
-		if (this.folds.length === 0) return false;
-		this.setFolds(!this.expanded);
-		return true;
-	}
-	/** Return every fold to its summary, the way moving on reads as dismissal. */
-	collapseFolds() {
-		if (this.folds.some((fold) => fold.expanded)) this.setFolds(false);
-		else this.expanded = false;
-	}
-	/** Put every fold into one form, whatever mix of states they are in now. */
-	setFolds(expanded) {
-		this.expanded = expanded;
-		const deltas = /* @__PURE__ */ new Map();
-		for (const fold of [...this.folds].reverse()) {
-			if (fold.expanded === expanded) {
-				deltas.set(fold, 0);
-				continue;
-			}
-			const shown = expanded ? fold.full : fold.summary;
-			this.logical.splice(fold.at, fold.shownLength, ...shown);
-			deltas.set(fold, shown.length - fold.shownLength);
-			fold.shownLength = shown.length;
-			fold.expanded = expanded;
-		}
-		let shift = 0;
-		for (const fold of this.folds) {
-			fold.at += shift;
-			shift += deltas.get(fold) ?? 0;
-		}
-		this.rewrap();
-		this.offset = 0;
-		this.painted = [];
-		this.render();
-	}
-	/**
-	* Replace the bottom rows.
-	* @param rows - the chrome, top to bottom.
-	* @param cursor - where the cursor belongs among them.
-	* @param focus - whether to show the cursor there.
-	*/
-	setChrome(rows, cursor, focus) {
-		this.chrome = rows.map((row) => truncate(row, this.contentColumns()));
-		this.chromeCursor = { ...cursor };
-		this.chromeFocus = focus;
-		this.render();
-	}
-	/**
-	* Set the line shown while the reader is away from the tail.
-	*
-	* Drawn OVER the viewport's top row rather than added to the chrome: a notice
-	* that changed the chrome's height would move the input box as a side effect
-	* of scrolling, and would make a page up and a page down different sizes.
-	* @param text - the styled notice, already fitted.
-	*/
-	setScrollNotice(text) {
-		if (text === this.notice) return;
-		this.notice = text;
-		if (this.offset > 0) this.render();
-	}
-	/**
-	* Scroll the transcript.
-	* @param delta - rows to move; negative scrolls back into history.
-	*/
-	scrollBy(delta) {
-		const limit = Math.max(0, this.physical.length - this.viewportHeight());
-		const next = Math.min(limit, Math.max(0, this.offset - delta));
-		if (next === this.offset) return;
-		this.offset = next;
-		this.render();
-	}
-	/**
-	* Scroll by a whole viewport, which is what the page keys mean.
-	* @param direction - -1 for back into history, 1 towards the tail.
-	*/
-	scrollPage(direction) {
-		this.scrollBy(direction * Math.max(1, this.viewportHeight() - 1));
-	}
-	/** Jump back to the tail, which is also what a new submission does. */
-	scrollToBottom() {
-		if (this.offset === 0) return;
-		this.offset = 0;
-		this.render();
-	}
-	/**
-	* Drop the transcript, keeping the chrome.
-	*
-	* Ctrl-L on a shared terminal clears a viewport the person may want back; on
-	* our own screen the buffer IS the session's history, so this empties it.
-	*/
-	clearTranscript() {
-		this.logical = [];
-		this.physical = [];
-		this.folds = [];
-		this.expanded = false;
-		this.offset = 0;
-		this.painted = [];
-		this.render();
-	}
-	/** Re-wrap and repaint after the terminal changed size. */
-	resize() {
-		this.rewrap();
-		this.painted = [];
-		this.render();
-	}
-	/**
-	* Anchor a selection where the left button went down.
-	*
-	* The terminal cannot select for us while mouse reporting is on, so the
-	* viewport does it: press anchors, motion extends, release copies — the
-	* shape opencode and Claude give the same gesture.
-	* @param row - terminal row, 1-based.
-	* @param column - terminal column, 1-based.
-	*/
-	mouseDown(row, column) {
-		const had = this.selection !== void 0;
-		this.selection = void 0;
-		const at = this.locate(row, column, false);
-		if (at !== void 0) this.selection = {
-			anchor: at,
-			focus: at,
-			dragged: false
-		};
-		if (had) this.render();
-	}
-	/**
-	* Extend the selection to where the pointer moved.
-	* @param row - terminal row, 1-based.
-	* @param column - terminal column, 1-based.
-	*/
-	mouseDrag(row, column) {
-		if (this.selection === void 0) return;
-		const at = this.locate(row, column, true);
-		if (at === void 0) return;
-		this.selection.focus = at;
-		this.selection.dragged = true;
-		this.render();
-	}
-	/**
-	* Finish the gesture.
-	*
-	* The highlight stays up — the copy already happened, and the marks show
-	* what it took — until the next click or reflow dismisses it.
-	* @returns the selected text, or undefined for a bare click.
-	*/
-	mouseUp() {
-		const selection = this.selection;
-		if (selection === void 0) return void 0;
-		if (!selection.dragged) {
-			this.selection = void 0;
-			return;
-		}
-		const text = this.selectedText();
-		if (text === "") {
-			this.selection = void 0;
-			this.render();
-			return;
-		}
-		return text;
-	}
-	/** The selection's bounds in order, top-left first. */
-	orderedSelection() {
-		const selection = this.selection;
-		if (selection === void 0 || !selection.dragged) return void 0;
-		const { anchor, focus } = selection;
-		const [from, to] = focus.row < anchor.row || focus.row === anchor.row && focus.column < anchor.column ? [focus, anchor] : [anchor, focus];
-		return {
-			from,
-			to
-		};
-	}
-	/** The plain text under the selection, visual rows joined by newlines. */
-	selectedText() {
-		const bounds = this.orderedSelection();
-		if (bounds === void 0) return "";
-		const rows = [];
-		for (let index = bounds.from.row; index <= bounds.to.row; index += 1) {
-			const plain = (this.physical[index] ?? "").replaceAll(STYLES, "");
-			const start = index === bounds.from.row ? columnIndex(plain, bounds.from.column) : 0;
-			const end = index === bounds.to.row ? columnIndex(plain, bounds.to.column + 1) : plain.length;
-			rows.push(plain.slice(start, end));
-		}
-		return rows.join("\n").replace(/^\n+|\n+$/gu, "") === "" ? "" : rows.join("\n");
-	}
-	/**
-	* Map a terminal position to a physical buffer position.
-	* @param row - terminal row, 1-based.
-	* @param column - terminal column, 1-based.
-	* @param clamp - pull an outside position to the nearest content row, the
-	* way dragging past an edge keeps selecting, instead of refusing it.
-	* @returns the position, or undefined when it misses the content.
-	*/
-	locate(row, column, clamp) {
-		if (this.physical.length === 0) return void 0;
-		const height = this.viewportHeight();
-		const end = this.physical.length - this.offset;
-		const start = Math.max(0, end - height);
-		let index = start + row - 1;
-		if (!clamp && (row - 1 >= height || index >= end || index < start)) return void 0;
-		index = Math.min(Math.max(index, start), end - 1);
-		return {
-			row: index,
-			column: Math.max(0, column - 1)
-		};
-	}
-	/** Rows the transcript viewport occupies. */
-	viewportHeight() {
-		return Math.max(1, this.host.rows() - this.chrome.length);
-	}
-	/** Columns content is laid out for, one short of the width so no row wraps. */
-	contentColumns() {
-		return Math.max(1, this.host.columns() - 1);
-	}
-	/** Re-wrap every kept line at the current width. */
-	rewrap() {
-		this.selection = void 0;
-		this.physical = wrapAll(this.logical, this.contentColumns());
-		const limit = Math.max(0, this.physical.length - this.viewportHeight());
-		this.offset = Math.min(this.offset, limit);
-	}
-	/**
-	* Compose and paint the frame.
-	*
-	* The viewport is padded at the top when the transcript is shorter than the
-	* screen, which is what puts the chrome at the bottom from the first frame
-	* rather than wherever output happened to reach.
-	*/
-	render() {
-		if (!this.active) return;
-		const columns = this.host.columns();
-		if (columns !== this.paintedColumns) {
-			this.physical = wrapAll(this.logical, this.contentColumns());
-			this.painted = [];
-			this.paintedColumns = columns;
-		}
-		const height = this.viewportHeight();
-		const end = this.physical.length - this.offset;
-		const visible = this.physical.slice(Math.max(0, end - height), Math.max(0, end));
-		const padding = Array.from({ length: Math.max(0, height - visible.length) }, () => "");
-		const bounds = this.orderedSelection();
-		if (bounds !== void 0) {
-			const first = Math.max(0, end - height);
-			for (let index = 0; index < visible.length; index += 1) {
-				const at = first + index;
-				if (at < bounds.from.row || at > bounds.to.row) continue;
-				const plain = (visible[index] ?? "").replaceAll(STYLES, "");
-				const start = at === bounds.from.row ? columnIndex(plain, bounds.from.column) : 0;
-				const stop = at === bounds.to.row ? columnIndex(plain, bounds.to.column + 1) : plain.length;
-				let marked = plain.slice(start, stop);
-				if (marked === "" && at > bounds.from.row && at < bounds.to.row) marked = " ";
-				if (marked === "" && start >= stop) continue;
-				visible[index] = `${plain.slice(0, start)}${INVERSE}${marked}${INVERSE_OFF}${plain.slice(stop)}`;
-			}
-		}
-		const viewport = [...visible, ...padding];
-		if (this.offset > 0 && this.notice !== "" && viewport.length > 0) viewport[0] = truncate(this.notice, this.contentColumns());
-		const frame = [...viewport, ...this.chrome];
-		let out = SYNC_BEGIN + HIDE_CURSOR;
-		frame.forEach((row, index) => {
-			if (this.painted[index] === row) return;
-			out += `\u001B[${index + 1};1H${CLEAR_LINE}${row}`;
-		});
-		for (let index = frame.length; index < this.painted.length; index += 1) out += `\u001B[${index + 1};1H${CLEAR_LINE}`;
-		if (this.chromeFocus) {
-			const row = frame.length - this.chrome.length + this.chromeCursor.row + 1;
-			out += `\u001B[${row};${this.chromeCursor.column + 1}H${SHOW_CURSOR}`;
-		}
-		out += SYNC_END;
-		this.host.write(out);
-		this.painted = frame;
-	}
-};
-
-//#endregion
-//#region src/console.ts
-/** Columns assumed when the output stream reports none (a pipe). */
-const FALLBACK_COLUMNS = 80;
-/**
-* Narrowest width this surface will lay out for.
-*
-* A terminal can report a width of zero — a PTY opened without a window size
-* does — and honouring it would truncate every card line away to nothing. Below
-* this floor the lines overflow instead, which stays readable.
-*/
-const MIN_COLUMNS = 20;
-/** Rows assumed when the output stream reports none. */
-const FALLBACK_ROWS = 24;
-/**
-* How long a held Escape waits for a successor before it counts as the key.
-*
-* `ESC` alone and the first byte of `ESC [ A` are the same byte. A terminal
-* delivers the rest of a real sequence in the same read or the very next one, so
-* a wait this short never splits one while still answering the bare key
-* promptly.
-*/
-const ESCAPE_FLUSH_MS = 20;
-/** Line input and output over one pair of process streams. */
-var TerminalConsole = class {
-	rl;
-	decoder = new KeyDecoder();
-	pending = [];
-	waiters = [];
-	keyHandler;
-	/** Keys decoded before any handler registered — type-ahead is never dropped. */
-	earlyKeys = [];
-	escapeTimer;
-	ended = false;
-	/** The viewport this surface owns on a terminal; absent off one. */
-	screen;
-	constructor(input, output) {
-		this.input = input;
-		this.output = output;
-		if (this.readsKeys) {
-			input.setRawMode?.(true);
-			this.output.write(ENABLE_PASTE_MARKERS);
-			this.screen = new Screen({
-				write: (data) => void this.output.write(data),
-				columns: () => this.columns,
-				rows: () => Math.max(2, this.output.rows ?? FALLBACK_ROWS)
-			});
-			this.output.on("resize", () => {
-				this.screen?.resize();
-			});
-			input.on("data", (chunk) => {
-				this.onBytes(chunk);
-			});
-			input.on("end", () => {
-				this.end();
-			});
-			this.rl = void 0;
-			return;
-		}
-		this.rl = createInterface({
-			input,
-			output,
-			terminal: false
-		});
-		this.rl.on("line", (line) => {
-			this.offer(line);
-		});
-		this.rl.on("close", () => {
-			this.end();
-		});
-	}
-	/** Display columns available for one line, never below {@link MIN_COLUMNS}. */
-	get columns() {
-		return Math.max(this.output.columns ?? FALLBACK_COLUMNS, MIN_COLUMNS);
-	}
-	/**
-	* Columns content may be laid out for: one less than the width, because the
-	* viewport wraps at that boundary. Markdown layout MUST use this figure — a
-	* table laid out one column wider is refolded by the viewport, and its rows
-	* shear apart.
-	*/
-	get contentColumns() {
-		return Math.max(1, this.columns - 1);
-	}
-	/** Whether the output stream is a terminal. */
-	get isTty() {
-		return this.output.isTTY === true;
-	}
-	/**
-	* Whether this surface owns the keyboard.
-	*
-	* That needs both streams on a terminal: raw mode is what delivers a key
-	* before its line, and there is no point managing rows on a stream with no
-	* cursor.
-	*/
-	get readsKeys() {
-		return this.input.isTTY === true && this.isTty;
-	}
-	/** Whether input has finished. */
-	get finished() {
-		return this.ended;
-	}
-	/**
-	* Register a handler for terminal window changes.
-	* @param handler - called after each resize while registered.
-	* @returns a disposer that removes it.
-	*/
-	onResize(handler) {
-		if (!this.readsKeys) return () => {};
-		this.output.on("resize", handler);
-		return () => void this.output.off("resize", handler);
-	}
-	/**
-	* Take the viewport: the transcript and the prompt live on their own screen
-	* from here, and the terminal keeps the buffer the person had.
-	*/
-	enterScreen() {
-		this.screen?.enter();
-	}
-	/**
-	* Give the terminal back. Idempotent: every exit path calls it.
-	*/
-	leaveScreen() {
-		this.screen?.leave();
-	}
-	/** Whether this surface currently holds its own screen. */
-	get owningScreen() {
-		return this.screen?.entered === true;
-	}
-	/**
-	* Scroll the transcript inside the viewport.
-	* @param delta - rows to move; negative goes back into history.
-	*/
-	scrollBy(delta) {
-		this.screen?.scrollBy(delta);
-	}
-	/**
-	* Set the notice shown while the transcript is scrolled back.
-	* @param text - the styled line, or the empty string for none.
-	*/
-	setScrollNotice(text) {
-		this.screen?.setScrollNotice(text);
-	}
-	/**
-	* Scroll the transcript by a whole viewport.
-	* @param direction - -1 for back into history, 1 towards the tail.
-	*/
-	scrollPage(direction) {
-		this.screen?.scrollPage(direction);
-	}
-	/** Return to the tail of the transcript. */
-	scrollToBottom() {
-		this.screen?.scrollToBottom();
-	}
-	/** Physical rows currently scrolled out of view; zero means at the tail. */
-	get scrolledBy() {
-		return this.screen?.scrolledBy ?? 0;
-	}
-	/**
-	* Clear the transcript this session accumulated.
-	*
-	* On its own screen there is no shell scrollback to preserve, so this empties
-	* the buffer the viewport shows rather than wiping a shared terminal.
-	*/
-	clearScreen() {
-		this.screen?.clearTranscript();
-	}
-	/**
-	* Route decoded keys to a handler.
-	* @param handler - receives every key while registered.
-	* @returns a disposer that removes it.
-	*/
-	onKey(handler) {
-		this.keyHandler = handler;
-		for (const key of this.earlyKeys.splice(0)) handler(key);
-		return () => {
-			this.keyHandler = void 0;
-		};
-	}
-	/**
-	* Decode one read and dispatch its keys.
-	* @param chunk - the bytes the terminal delivered.
-	*/
-	onBytes(chunk) {
-		const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-		for (const key of this.decoder.push(text)) this.deliver(key);
-		this.armEscapeFlush();
-	}
-	/** Hand one key to the handler, or hold it until one registers. */
-	deliver(key) {
-		if (this.keyHandler === void 0) {
-			this.earlyKeys.push(key);
-			return;
-		}
-		this.keyHandler(key);
-	}
-	/** Wait briefly for the rest of a held sequence, then resolve it as Escape. */
-	armEscapeFlush() {
-		if (this.escapeTimer !== void 0) clearTimeout(this.escapeTimer);
-		this.escapeTimer = void 0;
-		if (!this.decoder.pending) return;
-		this.escapeTimer = setTimeout(() => {
-			this.escapeTimer = void 0;
-			for (const key of this.decoder.flush()) this.deliver(key);
-		}, ESCAPE_FLUSH_MS);
-		this.escapeTimer.unref();
-	}
-	/**
-	* Hand one input line to the longest-waiting read, or queue it.
-	* @param line - the line the reader produced.
-	*/
-	offer(line) {
-		const waiter = this.waiters.shift();
-		if (waiter === void 0) {
-			this.pending.push(line);
-			return;
-		}
-		waiter.dispose();
-		waiter.resolve(line);
-	}
-	/** Mark input finished and release every waiting read. */
-	end() {
-		if (this.ended) return;
-		this.ended = true;
-		for (const waiter of this.waiters.splice(0)) {
-			waiter.dispose();
-			waiter.resolve(void 0);
-		}
-	}
-	/**
-	* Keep one finished transcript line.
-	*
-	* On its own screen the line goes into the viewport's scrollback, which is
-	* what lets the transcript scroll under a prompt that does not move. Off one
-	* it is written straight out, because a pipe's reader wants exactly that.
-	* @param line - the line, without its terminator.
-	*/
-	write(line) {
-		if (this.screen !== void 0) {
-			this.screen.append([line]);
-			return;
-		}
-		this.output.write(`${line}\n`);
-	}
-	/**
-	* Replace the rows pinned below the transcript.
-	*
-	* This is the whole live area: an input box, a completion menu, a working
-	* indicator, the status row. Off a terminal the call is ignored — a
-	* redirected transcript must not collect frames of a box nobody can see.
-	* @param rows - the rows to display, top to bottom.
-	* @param cursor - where to leave the terminal cursor among them.
-	* @param focus - whether the rows hold input focus, which is when the cursor
-	*   shows. Parked anywhere else it reads as content colliding with it.
-	*/
-	setRegion(rows, cursor, focus = true) {
-		this.screen?.setChrome(rows, cursor, focus);
-	}
-	/**
-	* Keep one collapsible block: summary now, full form behind the toggle.
-	*
-	* Off a terminal only the summary is written — a pipe has no keys to toggle
-	* with, and scripts want the digest.
-	* @param summary - the collapsed lines.
-	* @param full - the expanded lines.
-	*/
-	appendFold(summary, full) {
-		if (this.screen !== void 0) {
-			this.screen.appendFold(summary, full);
-			return;
-		}
-		for (const line of summary) this.output.write(`${line}\n`);
-	}
-	/**
-	* Swap every collapsible block between summary and full form.
-	* @returns false when there is nothing to toggle.
-	*/
-	/**
-	* Anchor a mouse selection at a terminal position.
-	* @param row - terminal row, 1-based.
-	* @param column - terminal column, 1-based.
-	*/
-	mouseDown(row, column) {
-		this.screen?.mouseDown(row, column);
-	}
-	/**
-	* Extend the mouse selection to a terminal position.
-	* @param row - terminal row, 1-based.
-	* @param column - terminal column, 1-based.
-	*/
-	mouseDrag(row, column) {
-		this.screen?.mouseDrag(row, column);
-	}
-	/**
-	* Finish the mouse selection.
-	* @returns the selected text, or undefined for a bare click.
-	*/
-	mouseUp() {
-		return this.screen?.mouseUp();
-	}
-	/**
-	* Put text on the clipboard.
-	*
-	* Two channels, because neither is universal: OSC 52 reaches through SSH and
-	* works wherever the terminal permits it, and the platform helper covers the
-	* terminals that refuse the escape. `CODSH_CLIPBOARD` narrows it to `osc52`,
-	* `system`, or `off` — tests use `osc52` so a run never touches the real
-	* clipboard.
-	* @param text - the plain text to copy.
-	* @returns whether a copy was attempted at all.
-	*/
-	copyText(text) {
-		const mode = process.env["CODSH_CLIPBOARD"] ?? "both";
-		if (mode === "off" || text === "") return false;
-		if (mode !== "system") this.output.write(`\u001B]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`);
-		if (mode !== "osc52") {
-			const command = process.platform === "darwin" ? ["pbcopy"] : process.platform === "win32" ? ["clip"] : process.env["WAYLAND_DISPLAY"] === void 0 ? [
-				"xclip",
-				"-selection",
-				"clipboard"
-			] : ["wl-copy"];
-			try {
-				const child = spawn(command[0] ?? "", command.slice(1), { stdio: [
-					"pipe",
-					"ignore",
-					"ignore"
-				] });
-				child.on("error", () => {});
-				child.stdin.end(text);
-			} catch {}
-		}
-		return true;
-	}
-	/**
-	* Make the last `count` written lines a collapsible block after the fact.
-	*
-	* Screen-only on purpose: a pipe already carries the full text, and a
-	* summary would subtract from it.
-	* @param count - how many trailing lines the block owns.
-	* @param summary - the collapsed lines, already styled.
-	*/
-	foldRecent(count, summary) {
-		this.screen?.foldBack(count, summary);
-	}
-	toggleFolds() {
-		return this.screen?.toggleFolds() ?? false;
-	}
-	/** Return every block to its summary. */
-	collapseFolds() {
-		this.screen?.collapseFolds();
-	}
-	/** Take the pinned rows down, leaving the transcript alone. */
-	clearRegion() {
-		this.screen?.setChrome([], {
-			row: 0,
-			column: 0
-		}, false);
-	}
-	/** Ring the terminal bell; a pipe gets nothing to beep with. */
-	bell() {
-		if (!this.isTty) return;
-		this.output.write("\x07");
-	}
-	/**
-	* Set the terminal window title.
-	* @param title - the title text; control bytes are the terminal's to reject.
-	*/
-	setTitle(title) {
-		if (!this.isTty) return;
-		this.output.write(`\u001B]2;${title}\u0007`);
-	}
-	/**
-	* Read one line from a piped stream.
-	*
-	* Only the non-terminal shape reads this way; with the keyboard owned, input
-	* arrives as keys and the caller drives an editor instead.
-	* @param signal - aborts the pending read.
-	* @returns the line, or undefined when input ended or the read aborted.
-	*/
-	readLine(signal) {
-		const queued = this.pending.shift();
-		if (queued !== void 0) return Promise.resolve(queued);
-		if (this.ended) return Promise.resolve(void 0);
-		if (signal?.aborted === true) return Promise.resolve(void 0);
-		return new Promise((resolve) => {
-			const waiter = {
-				resolve,
-				dispose: () => {
-					signal?.removeEventListener("abort", onAbort);
-				}
-			};
-			const onAbort = () => {
-				const index = this.waiters.indexOf(waiter);
-				if (index >= 0) this.waiters.splice(index, 1);
-				waiter.dispose();
-				resolve(void 0);
-			};
-			signal?.addEventListener("abort", onAbort, { once: true });
-			this.waiters.push(waiter);
-		});
-	}
-	/** Restore the terminal and stop reading. */
-	close() {
-		if (this.escapeTimer !== void 0) clearTimeout(this.escapeTimer);
-		if (this.readsKeys) {
-			this.screen?.leave();
-			this.output.write(DISABLE_PASTE_MARKERS);
-			this.input.setRawMode?.(false);
-			this.input.pause();
-		}
-		this.rl?.close();
-		this.end();
-	}
-	/**
-	* Write one line to the terminal the person keeps, not to our viewport.
-	*
-	* The exit summary is what needs this: the session's own screen disappears
-	* with it, so the few facts worth keeping — the session id, what it cost —
-	* have to land in the buffer that survives.
-	* @param line - the line, without its terminator.
-	*/
-	writeAfterScreen(line) {
-		this.output.write(`${line}\n`);
-	}
-};
-
-//#endregion
-//#region src/editor.ts
-/** Longest run of history the editor keeps for one session. */
-const HISTORY_LIMIT = 200;
-/**
-* Split text into the units the cursor counts.
-*
-* Code points, not grapheme clusters: a column here is one cursor step, and the
-* terminal moves the cursor by code point too. A combining mark or a ZWJ emoji
-* therefore takes more than one step, which is the same limit the width
-* measurement carries.
-* @param text - the text to split.
-* @returns its code points.
-*/
-const points = (text) => Array.from(text);
-/** A multi-line prompt editor. */
-var Editor = class {
-	lines = [""];
-	row = 0;
-	column = 0;
-	candidates = [];
-	selected = 0;
-	history = [];
-	/** Where the caller is in history; equals `history.length` when not browsing. */
-	browsing = 0;
-	/** The buffer set aside while history is being browsed. */
-	stashed;
-	constructor(sources) {
-		this.sources = sources;
-	}
-	/** What to render. */
-	get view() {
-		return {
-			lines: this.lines,
-			row: this.row,
-			column: this.column,
-			candidates: this.candidates,
-			selected: this.selected,
-			token: this.token()
-		};
-	}
-	/** The buffer as one string. */
-	get text() {
-		return this.lines.join("\n");
-	}
-	/** Whether nothing has been typed. */
-	get empty() {
-		return this.text === "";
-	}
-	/**
-	* Replace the buffer with earlier text, cursor at its end.
-	*
-	* This is recall-for-editing: the second Escape puts the previous submission
-	* back so it can be corrected and resent.
-	* @param text - the text to edit, possibly multi-line.
-	*/
-	prefill(text) {
-		this.lines = text.split("\n");
-		this.row = this.lines.length - 1;
-		this.column = points(this.line()).length;
-		this.candidates = [];
-	}
-	/** Submissions this session recorded, oldest first, for persistence. */
-	get pastSubmissions() {
-		return this.history;
-	}
-	/**
-	* Preload history from an earlier session.
-	*
-	* Applied before any live submission, so recall starts where the last
-	* session ended rather than empty.
-	* @param entries - past submissions, oldest first.
-	*/
-	seedHistory(entries) {
-		this.history.splice(0, this.history.length, ...entries.slice(-HISTORY_LIMIT));
-		this.browsing = this.history.length;
-	}
-	/**
-	* Apply one key.
-	* @param key - the decoded keystroke.
-	* @returns what the caller must do about it.
-	*/
-	handle(key) {
-		switch (key.kind) {
-			case "text": return this.insert(key.text);
-			case "paste": return this.insert(key.text);
-			case "enter": return this.accept();
-			case "newline": return this.insert("\n");
-			case "tab": return this.complete();
-			case "backspace": return this.backspace();
-			case "delete": return this.forwardDelete();
-			case "up": return this.moveUp();
-			case "down": return this.moveDown();
-			case "left": return this.moveLeft();
-			case "right": return this.moveRight();
-			case "home": return this.jump(0);
-			case "end": return this.jump(points(this.line()).length);
-			case "kill-line": return this.killLine();
-			case "kill-input": return this.killInput();
-			case "kill-word": return this.killWord();
-			case "word-left": return this.wordLeft();
-			case "word-right": return this.wordRight();
-			case "escape": return this.cancel();
-			case "interrupt": return { kind: "interrupt" };
-			case "eof": return this.text === "" ? { kind: "eof" } : { kind: "none" };
-			default: return { kind: "none" };
-		}
-	}
-	/** The line the cursor is on. */
-	line() {
-		return this.lines[this.row] ?? "";
-	}
-	/** Replace the cursor's line. */
-	setLine(text) {
-		this.lines[this.row] = text;
-	}
-	/**
-	* Insert text at the cursor, splitting lines on newlines.
-	* @param text - the text to insert.
-	* @returns always `none`; insertion never completes a read.
-	*/
-	insert(text) {
-		const line = this.line();
-		const before = points(line).slice(0, this.column).join("");
-		const after = points(line).slice(this.column).join("");
-		const parts = (before + text + after).split("\n");
-		const inserted = (before + text).split("\n");
-		this.lines.splice(this.row, 1, ...parts);
-		this.row += inserted.length - 1;
-		this.column = points(inserted.at(-1) ?? "").length;
-		this.refresh();
-		return { kind: "none" };
-	}
-	/**
-	* Submit, or accept the highlighted candidate when the menu is open.
-	* @returns the submission, or `none` when a candidate was taken instead.
-	*/
-	accept() {
-		if (this.candidates.length > 0) return this.take();
-		const text = this.text;
-		if (text.trim() === "") return { kind: "none" };
-		this.remember(text);
-		this.lines = [""];
-		this.row = 0;
-		this.column = 0;
-		this.candidates = [];
-		return {
-			kind: "submit",
-			text
-		};
-	}
-	/** Record a submission for history, collapsing an immediate repeat. */
-	remember(text) {
-		if (this.history.at(-1) !== text) this.history.push(text);
-		if (this.history.length > HISTORY_LIMIT) this.history.shift();
-		this.browsing = this.history.length;
-		this.stashed = void 0;
-	}
-	/**
-	* Open the menu, or move through it when it is already open.
-	* @returns always `none`.
-	*/
-	complete() {
-		if (this.candidates.length === 0) this.refresh();
-		if (this.candidates.length === 1) return this.take();
-		if (this.candidates.length > 1) this.selected = (this.selected + 1) % this.candidates.length;
-		return { kind: "none" };
-	}
-	/**
-	* Replace the token under the cursor with the selected candidate.
-	* @returns always `none`.
-	*/
-	take() {
-		const candidate = this.candidates[this.selected];
-		this.candidates = [];
-		if (candidate === void 0) return { kind: "none" };
-		const cells = points(this.line());
-		const start = this.tokenStart();
-		const replaced = [
-			...cells.slice(0, start),
-			candidate.value,
-			...cells.slice(this.column)
-		];
-		this.setLine(replaced.join(""));
-		this.column = start + points(candidate.value).length;
-		return { kind: "none" };
-	}
-	/** Where the token under the cursor begins, in code points. */
-	tokenStart() {
-		return points(this.line()).slice(0, this.column).lastIndexOf(" ") + 1;
-	}
-	/** The token under the cursor. */
-	token() {
-		return points(this.line()).slice(this.tokenStart(), this.column).join("");
-	}
-	/**
-	* Recompute the candidate list for the token under the cursor.
-	*
-	* Recomputed on every edit rather than only on Tab, which is what makes the
-	* menu appear as a command is typed instead of after a key that asks for it.
-	*/
-	refresh() {
-		const token = this.token();
-		const wholeLine = this.row === 0 && this.tokenStart() === 0;
-		const line = this.lines[0] ?? "";
-		const command = /^\/([a-z][a-z0-9_-]*) /.exec(line)?.[1];
-		const inArgument = this.row === 0 && command !== void 0 && this.tokenStart() === command.length + 2;
-		if (token.startsWith("@")) {
-			const [values] = this.sources.paths(token);
-			this.candidates = values.map((value) => ({
-				value,
-				detail: ""
-			}));
-		} else if (wholeLine && token.startsWith("/")) this.candidates = this.sources.commands().filter((entry) => `/${entry.name}`.startsWith(token)).map((entry) => ({
-			value: `/${entry.name}`,
-			detail: entry.description
-		}));
-		else if (inArgument) this.candidates = [...this.sources.commandArguments?.(command, token) ?? []];
-		else this.candidates = [];
-		if (this.candidates.length === 1 && this.candidates[0]?.value === token) this.candidates = [];
-		this.selected = 0;
-	}
-	/** Remove the character before the cursor, joining lines at a boundary. */
-	backspace() {
-		if (this.column > 0) {
-			const cells = points(this.line());
-			cells.splice(this.column - 1, 1);
-			this.setLine(cells.join(""));
-			this.column -= 1;
-		} else if (this.row > 0) {
-			const previous = this.lines[this.row - 1] ?? "";
-			const current = this.line();
-			this.lines.splice(this.row - 1, 2, previous + current);
-			this.row -= 1;
-			this.column = points(previous).length;
-		}
-		this.refresh();
-		return { kind: "none" };
-	}
-	/** Remove the character after the cursor, joining lines at a boundary. */
-	forwardDelete() {
-		const cells = points(this.line());
-		if (this.column < cells.length) {
-			cells.splice(this.column, 1);
-			this.setLine(cells.join(""));
-		} else if (this.row < this.lines.length - 1) {
-			const next = this.lines[this.row + 1] ?? "";
-			this.lines.splice(this.row, 2, this.line() + next);
-		}
-		this.refresh();
-		return { kind: "none" };
-	}
-	/** Move up a line, or back through history from the first line. */
-	moveUp() {
-		if (this.candidates.length > 0) {
-			this.selected = (this.selected - 1 + this.candidates.length) % this.candidates.length;
-			return { kind: "none" };
-		}
-		if (this.row > 0) {
-			this.row -= 1;
-			this.column = Math.min(this.column, points(this.line()).length);
-			return { kind: "none" };
-		}
-		return this.recall(-1);
-	}
-	/** Move down a line, or forward through history from the last line. */
-	moveDown() {
-		if (this.candidates.length > 0) {
-			this.selected = (this.selected + 1) % this.candidates.length;
-			return { kind: "none" };
-		}
-		if (this.row < this.lines.length - 1) {
-			this.row += 1;
-			this.column = Math.min(this.column, points(this.line()).length);
-			return { kind: "none" };
-		}
-		return this.recall(1);
-	}
-	/**
-	* Step through history.
-	* @param delta - -1 for older, 1 for newer.
-	* @returns always `none`.
-	*/
-	recall(delta) {
-		const next = this.browsing + delta;
-		if (next < 0 || next > this.history.length) return { kind: "none" };
-		if (this.browsing === this.history.length) this.stashed = this.lines;
-		this.browsing = next;
-		this.lines = [...next === this.history.length ? this.stashed ?? [""] : (this.history[next] ?? "").split("\n")];
-		this.row = this.lines.length - 1;
-		this.column = points(this.line()).length;
-		this.candidates = [];
-		return { kind: "none" };
-	}
-	/** Move the cursor one position left, wrapping to the previous line. */
-	moveLeft() {
-		if (this.column > 0) this.column -= 1;
-		else if (this.row > 0) {
-			this.row -= 1;
-			this.column = points(this.line()).length;
-		}
-		return { kind: "none" };
-	}
-	/** Move the cursor one position right, wrapping to the next line. */
-	moveRight() {
-		if (this.column < points(this.line()).length) this.column += 1;
-		else if (this.row < this.lines.length - 1) {
-			this.row += 1;
-			this.column = 0;
-		}
-		return { kind: "none" };
-	}
-	/**
-	* Put the cursor at a column on the current line.
-	* @param column - the target column.
-	* @returns always `none`.
-	*/
-	jump(column) {
-		this.column = column;
-		return { kind: "none" };
-	}
-	/** Drop everything after the cursor on this line. */
-	killLine() {
-		this.setLine(points(this.line()).slice(0, this.column).join(""));
-		this.refresh();
-		return { kind: "none" };
-	}
-	/** Drop everything before the cursor on this line. */
-	killInput() {
-		this.setLine(points(this.line()).slice(this.column).join(""));
-		this.column = 0;
-		this.refresh();
-		return { kind: "none" };
-	}
-	/** Move the cursor to the start of the word before it. */
-	wordLeft() {
-		const cells = points(this.line());
-		let at = this.column;
-		while (at > 0 && cells[at - 1] === " ") at -= 1;
-		while (at > 0 && cells[at - 1] !== " ") at -= 1;
-		this.column = at;
-		return { kind: "none" };
-	}
-	/** Move the cursor past the end of the word after it. */
-	wordRight() {
-		const cells = points(this.line());
-		let at = this.column;
-		while (at < cells.length && cells[at] === " ") at += 1;
-		while (at < cells.length && cells[at] !== " ") at += 1;
-		this.column = at;
-		return { kind: "none" };
-	}
-	/** Drop the word before the cursor. */
-	killWord() {
-		const cells = points(this.line());
-		let at = this.column;
-		while (at > 0 && cells[at - 1] === " ") at -= 1;
-		while (at > 0 && cells[at - 1] !== " ") at -= 1;
-		this.setLine([...cells.slice(0, at), ...cells.slice(this.column)].join(""));
-		this.column = at;
-		this.refresh();
-		return { kind: "none" };
-	}
-	/**
-	* Close the menu, or report Escape when there is none to close.
-	* @returns `none` when a menu was dismissed, otherwise `escape`.
-	*/
-	cancel() {
-		if (this.candidates.length > 0) {
-			this.candidates = [];
-			return { kind: "none" };
-		}
-		return { kind: "escape" };
-	}
-};
-
-//#endregion
-//#region src/inputbox.ts
-/** How many candidates the menu shows before it says how many it hid. */
-const MENU_LIMIT = 8;
-/** Columns the frame itself occupies: two borders and two pads. */
-const FRAME_WIDTH = 4;
-/** Columns the gutter occupies inside the frame: the marker and its space. */
-const GUTTER_WIDTH = 2;
-/** Content rows shown before the box windows around the cursor. */
-const MAX_CONTENT_ROWS = 6;
-/**
-* Wrap one logical line into segments no wider than the budget.
-* @param line - the logical line.
-* @param logical - its index.
-* @param budget - display columns per segment.
-* @returns at least one segment, empty lines included.
-*/
-function wrapLine(line, logical, budget) {
-	const cells = Array.from(line);
-	const rows = [];
-	let start = 0;
-	let width = 0;
-	let length = 0;
-	for (const cell of cells) {
-		const cost = displayWidth(cell);
-		if (width + cost > budget && length > 0) {
-			rows.push({
-				text: cells.slice(start, start + length).join(""),
-				logical,
-				start,
-				length,
-				last: false
-			});
-			start += length;
-			width = 0;
-			length = 0;
-		}
-		width += cost;
-		length += 1;
-	}
-	rows.push({
-		text: cells.slice(start, start + length).join(""),
-		logical,
-		start,
-		length,
-		last: true
-	});
-	return rows;
-}
-/**
-* Lay out the input box.
-* @param view - what the editor is showing.
-* @param theme - styling for the frame, the marker, and the menu.
-* @param columns - display columns available.
-* @param options - placeholder, hint, and frame accent.
-* @returns the rows and cursor position.
-*/
-function inputBox(view, theme, columns, options = {}) {
-	const accent = options.accent ?? ((text) => theme.dim(text));
-	const inner = Math.max(8, columns - FRAME_WIDTH);
-	const budget = inner - GUTTER_WIDTH;
-	const rule = "─".repeat(inner + 2);
-	const visual = view.lines.flatMap((line, index) => wrapLine(line, index, budget));
-	const cursorVisual = visual.findIndex((row) => row.logical === view.row && view.column >= row.start && (view.column < row.start + row.length || row.last && view.column === row.start + row.length));
-	const cursorAt = Math.max(0, cursorVisual);
-	const start = Math.max(0, Math.min(visual.length - MAX_CONTENT_ROWS, cursorAt - (MAX_CONTENT_ROWS - 1)));
-	const end = Math.min(visual.length, start + MAX_CONTENT_ROWS);
-	const shown = visual.slice(start, end);
-	const empty = view.lines.length === 1 && view.lines[0] === "";
-	const rows = [accent(`╭${rule}╮`)];
-	if (empty && options.placeholder !== void 0) {
-		const text = truncate(options.placeholder, budget);
-		const pad = " ".repeat(Math.max(0, budget - displayWidth(text)));
-		rows.push(`${accent("│")} ${theme.user("›")} ${theme.dim(text)}${pad} ${accent("│")}`);
-	} else shown.forEach((row, index) => {
-		const first = start + index === 0;
-		const clippedAbove = index === 0 && start > 0;
-		const clippedBelow = index === shown.length - 1 && end < visual.length;
-		const gutter = clippedAbove || clippedBelow ? theme.dim("…") : first ? theme.user("›") : " ";
-		const pad = " ".repeat(Math.max(0, budget - displayWidth(row.text)));
-		rows.push(`${accent("│")} ${gutter} ${row.text}${pad} ${accent("│")}`);
-	});
-	rows.push(accent(`╰${rule}╯`));
-	if (view.candidates.length > 0) {
-		const first = Math.min(Math.max(0, view.selected - MENU_LIMIT + 1), Math.max(0, view.candidates.length - MENU_LIMIT));
-		const menu = view.candidates.slice(first, first + MENU_LIMIT);
-		const width = Math.max(...menu.map((candidate) => displayWidth(candidate.value)));
-		if (first > 0) rows.push(theme.dim(`  ↑ ${first} more`));
-		menu.forEach((candidate, index) => {
-			const chosen = first + index === view.selected;
-			const matched = view.token !== "" && candidate.value.startsWith(view.token) ? view.token.length : 0;
-			const head = candidate.value.slice(0, matched);
-			const tail = candidate.value.slice(matched);
-			const label = chosen ? theme.bold(theme.tool(candidate.value)) : `${theme.tool(head)}${tail}`;
-			const pad = " ".repeat(Math.max(0, width - displayWidth(candidate.value)));
-			const detail = candidate.detail === "" ? "" : `  ${candidate.detail}`;
-			rows.push(truncate(`${chosen ? theme.user("❯") : " "} ${label}${pad}${theme.dim(detail)}`, columns));
-		});
-		const below = view.candidates.length - first - menu.length;
-		if (below > 0) rows.push(theme.dim(`  ↓ ${below} more`));
-	} else if (options.hint !== void 0) rows.push(theme.dim(truncate(options.hint, columns)));
-	const inCursorRow = visual[cursorAt];
-	const before = inCursorRow === void 0 ? "" : Array.from(view.lines[view.row] ?? "").slice(inCursorRow.start, view.column).join("");
-	return {
-		rows,
-		cursorRow: 1 + (cursorAt - start),
-		cursorColumn: FRAME_WIDTH + Math.min(displayWidth(before), budget)
-	};
-}
-
-//#endregion
-//#region src/selector.ts
-/** An in-progress selection. */
-/** Option rows shown at once; the window follows the marked row. */
-const VISIBLE_ROWS = 10;
-var Selector = class {
-	selected = 0;
-	checked = /* @__PURE__ */ new Set();
-	constructor(spec) {
-		this.spec = spec;
-	}
-	/** How many rows the widget offers, the custom row included. */
-	get count() {
-		return this.spec.options.length + (this.spec.custom === void 0 ? 0 : 1);
-	}
-	/** Whether a row index is the custom "type your own" row. */
-	isCustom(index) {
-		return this.spec.custom !== void 0 && index === this.spec.options.length;
-	}
-	/**
-	* Apply one key.
-	* @param key - the decoded keystroke.
-	* @returns whether the selection settled, and how.
-	*/
-	handle(key) {
-		switch (key.kind) {
-			case "up":
-				this.selected = (this.selected - 1 + this.count) % this.count;
-				return { kind: "pending" };
-			case "down":
-			case "tab":
-				this.selected = (this.selected + 1) % this.count;
-				return { kind: "pending" };
-			case "enter": return this.accept(this.selected);
-			case "escape": return {
-				kind: "done",
-				outcome: { kind: "cancelled" }
-			};
-			case "text": return this.typed(key.text);
-			default: return { kind: "pending" };
-		}
-	}
-	/**
-	* Resolve a typed character: a digit jumps, a shortcut picks, Space toggles.
-	* @param text - what was typed.
-	* @returns whether the selection settled.
-	*/
-	typed(text) {
-		if (this.spec.multi === true && text === " ") {
-			if (!this.isCustom(this.selected)) if (this.checked.has(this.selected)) this.checked.delete(this.selected);
-			else this.checked.add(this.selected);
-			return { kind: "pending" };
-		}
-		const digit = Number(text);
-		if (Number.isInteger(digit) && digit >= 1 && digit <= this.count) {
-			if (this.spec.multi === true && !this.isCustom(digit - 1)) {
-				this.selected = digit - 1;
-				if (this.checked.has(digit - 1)) this.checked.delete(digit - 1);
-				else this.checked.add(digit - 1);
-				return { kind: "pending" };
-			}
-			return this.accept(digit - 1);
-		}
-		const shortcut = this.spec.options.findIndex((option) => option.shortcut === text.toLowerCase());
-		if (shortcut >= 0) return this.accept(shortcut);
-		return { kind: "pending" };
-	}
-	/**
-	* Settle on a row.
-	* @param index - the row accepted.
-	* @returns the settled step.
-	*/
-	accept(index) {
-		if (this.isCustom(index)) return {
-			kind: "done",
-			outcome: { kind: "custom" }
-		};
-		if (this.spec.multi === true) return {
-			kind: "done",
-			outcome: {
-				kind: "chosen",
-				indices: this.checked.size > 0 ? [...this.checked].sort((a, b) => a - b) : [index]
-			}
-		};
-		return {
-			kind: "done",
-			outcome: {
-				kind: "chosen",
-				indices: [index]
-			}
-		};
-	}
-	/**
-	* Render the widget.
-	* @param theme - styling for the marker, shortcuts, and details.
-	* @param columns - display columns available per row.
-	* @returns the rows, title first.
-	*/
-	view(theme, columns) {
-		const rows = [theme.bold(truncate(this.spec.title, columns))];
-		const total = this.count;
-		const first = Math.min(Math.max(0, this.selected - VISIBLE_ROWS + 1), Math.max(0, total - VISIBLE_ROWS));
-		if (first > 0) rows.push(theme.dim(`  ↑ ${first} more`));
-		for (let index = first; index < Math.min(total, first + VISIBLE_ROWS); index += 1) {
-			const option = this.spec.options[index];
-			if (option !== void 0) rows.push(this.row(index, this.label(option, theme), option.detail, theme, columns));
-			else if (this.spec.custom !== void 0) rows.push(this.row(index, theme.dim(this.spec.custom), void 0, theme, columns));
-		}
-		const below = total - first - VISIBLE_ROWS;
-		if (below > 0) rows.push(theme.dim(`  ↓ ${below} more`));
-		const how = this.spec.multi === true ? "Space toggles · Enter confirms · Esc cancels" : "↑↓ move · Enter accepts · Esc cancels";
-		rows.push(theme.dim(truncate(`  ${how}`, columns)));
-		return rows;
-	}
-	/**
-	* One option's label with its number and shortcut.
-	* @param option - the option to label.
-	* @param theme - styling for the shortcut.
-	* @returns the label text.
-	*/
-	label(option, theme) {
-		const shortcut = option.shortcut === void 0 ? "" : theme.dim(` (${option.shortcut})`);
-		return `${option.label}${shortcut}`;
-	}
-	/**
-	* One rendered row.
-	* @param index - the row's index.
-	* @param label - the row's label, already styled.
-	* @param detail - dim context beside it.
-	* @param theme - styling for the marker and detail.
-	* @param columns - display columns available.
-	* @returns the row text.
-	*/
-	row(index, label, detail, theme, columns) {
-		const marked = index === this.selected;
-		const marker = marked ? theme.user("❯") : " ";
-		const box = this.spec.multi === true && !this.isCustom(index) ? this.checked.has(index) ? theme.success("◉ ") : theme.dim("○ ") : "";
-		const number = theme.dim(`${index + 1}.`);
-		const trail = detail === void 0 || detail === "" ? "" : theme.dim(`  ${detail}`);
-		return truncate(`${marker} ${number} ${box}${marked ? theme.bold(theme.tool(label)) : label}${trail}`, columns);
-	}
-};
-
-//#endregion
-//#region src/prompt.ts
-/** How long a flash notice holds the hint row. */
-const FLASH_MS = 1500;
-/** Drives the input box and answers reads and selections. */
-var Prompt = class {
-	editor;
-	pending;
-	select_;
-	/**
-	* Submissions made before anything asked for them.
-	*
-	* Typing while the agent works — or in the instant before a read begins — must
-	* not be lost; the queue is what a line reader provides for free.
-	*/
-	queued = [];
-	/** The working indicator shown under the box. */
-	hint;
-	/** A short-lived notice that borrows the hint row, e.g. the copy toast. */
-	flash;
-	flashTimer;
-	/** The always-current session facts shown as the region's last row. */
-	status;
-	/** The assistant line still arriving, shown above the box. */
-	streaming;
-	/** Frame styling for the current mode, e.g. plan mode's accent. */
-	accent;
-	/** Whether a read is outstanding, which decides where a submission goes. */
-	reading = false;
-	/** Wheel rows accumulated this tick, painted once — scrolling per event janks. */
-	pendingScroll = 0;
-	scrollFlushQueued = false;
-	/**
-	* Whether the interactive session is running, which is when the box is worth
-	* drawing. The box stays up while the agent works — typing ahead must be
-	* visible, and a prompt that vanishes for every turn reads as losing focus —
-	* so this is session-scoped, not read-scoped.
-	*/
-	engaged = false;
-	constructor(console, theme, sources, handlers, placeholder) {
-		this.console = console;
-		this.theme = theme;
-		this.handlers = handlers;
-		this.placeholder = placeholder;
-		this.editor = new Editor(sources);
-		if (this.console.readsKeys) {
-			this.console.onKey((key) => {
-				this.onKey(key);
-			});
-			this.console.onResize(() => {
-				this.render();
-			});
-		}
-	}
-	/** The editor's submission history, for persistence. */
-	get history() {
-		return this.editor.pastSubmissions;
-	}
-	/**
-	* Preload history from an earlier session.
-	* @param entries - past submissions, oldest first.
-	*/
-	seedHistory(entries) {
-		this.editor.seedHistory(entries);
-	}
-	/** Whether the box holds no typed text. */
-	get empty() {
-		return this.editor.empty;
-	}
-	/**
-	* Show the input box from now on, independent of an outstanding read.
-	* @param engaged - whether the interactive session is running.
-	*/
-	setEngaged(engaged) {
-		this.engaged = engaged;
-		this.render();
-	}
-	/**
-	* Put earlier text back into the box for editing.
-	* @param text - the text to edit.
-	*/
-	prefill(text) {
-		this.editor.prefill(text);
-		this.render();
-	}
-	/**
-	* Set the working indicator under the box.
-	* @param text - the text, or undefined to drop the row.
-	*/
-	setHint(text) {
-		if (text === this.hint) return;
-		this.hint = text;
-		this.render();
-	}
-	/**
-	* Show a notice on the hint row briefly, then give the row back.
-	*
-	* The hint row belongs to the working indicator, which repaints itself
-	* continuously — a notice written through setHint would last one tick. The
-	* flash outranks the hint until its moment passes.
-	* @param text - the styled notice.
-	*/
-	setFlash(text) {
-		this.flash = text;
-		if (this.flashTimer !== void 0) clearTimeout(this.flashTimer);
-		this.flashTimer = setTimeout(() => {
-			this.flash = void 0;
-			this.flashTimer = void 0;
-			this.render();
-		}, FLASH_MS);
-		this.flashTimer.unref();
-		this.render();
-	}
-	/**
-	* Set the status row, the region's always-current last line.
-	* @param text - the styled row, or undefined to drop it.
-	*/
-	setStatus(text) {
-		if (text === this.status) return;
-		this.status = text;
-		this.render();
-	}
-	/**
-	* Set the frame accent, which is how a mode shows on the box itself.
-	* @param accent - the styling, or undefined for the default frame.
-	*/
-	setAccent(accent) {
-		this.accent = accent;
-		this.render();
-	}
-	/**
-	* Set the assistant line currently arriving, shown above the box.
-	* @param text - the partial line, or undefined when none is open.
-	*/
-	setStreaming(text) {
-		this.streaming = text;
-		this.render();
-	}
-	/**
-	* Write one finished transcript line above the region.
-	* @param line - the line to keep.
-	*/
-	write(line) {
-		this.console.write(line);
-	}
-	/**
-	* Wait for the next submitted text.
-	* @param signal - abandons the read, which an aborted tool call does.
-	* @returns the text, or undefined when input ended or the read was abandoned.
-	*/
-	read(signal) {
-		if (!this.console.readsKeys) return this.console.readLine(signal);
-		const typedAhead = this.queued.shift();
-		if (typedAhead !== void 0) return Promise.resolve(typedAhead);
-		if (this.console.finished) return Promise.resolve(void 0);
-		this.reading = true;
-		this.render();
-		return new Promise((resolve) => {
-			const settle = (text) => {
-				this.pending = void 0;
-				this.reading = false;
-				resolve(text);
-			};
-			const onAbort = () => {
-				settle(void 0);
-			};
-			this.pending = {
-				resolve: settle,
-				dispose: () => {
-					signal?.removeEventListener("abort", onAbort);
-				}
-			};
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
-	}
-	/**
-	* Put one decision to the keyboard as an arrow-key selection.
-	*
-	* Only the terminal shape can offer this; the caller keeps a line-based
-	* fallback for pipes, where the selection keys cannot arrive.
-	* @param spec - the question and its options.
-	* @param signal - cancels the selection, which an aborted tool call does.
-	* @returns how the person decided.
-	*/
-	select(spec, signal) {
-		if (this.console.finished || signal?.aborted === true) return Promise.resolve({ kind: "cancelled" });
-		return new Promise((resolve) => {
-			const settle = (outcome) => {
-				this.select_ = void 0;
-				resolve(outcome);
-				this.render();
-			};
-			const onAbort = () => {
-				settle({ kind: "cancelled" });
-			};
-			this.select_ = {
-				selector: new Selector(spec),
-				resolve: settle,
-				dispose: () => {
-					signal?.removeEventListener("abort", onAbort);
-				}
-			};
-			signal?.addEventListener("abort", onAbort, { once: true });
-			this.render();
-		});
-	}
-	/** Take the region down, so what follows lands at the bottom of the screen. */
-	clear() {
-		this.reading = false;
-		this.console.clearRegion();
-	}
-	/**
-	* Apply one key: control keys to the owner, a selection's keys to the
-	* selector, everything else to the editor.
-	* @param key - the decoded keystroke.
-	*/
-	onKey(key) {
-		if (key.kind === "interrupt") {
-			this.handlers.interrupt();
-			return;
-		}
-		if (key.kind === "clear-screen") {
-			this.console.clearScreen();
-			this.render();
-			return;
-		}
-		if (key.kind === "shift-tab") {
-			this.handlers.shiftTab?.();
-			return;
-		}
-		if (key.kind === "expand-output") {
-			this.handlers.expandOutput?.();
-			return;
-		}
-		if (key.kind === "page") {
-			this.console.scrollPage(key.direction);
-			this.render();
-			return;
-		}
-		if (key.kind === "scroll") {
-			this.pendingScroll += key.lines;
-			if (!this.scrollFlushQueued) {
-				this.scrollFlushQueued = true;
-				queueMicrotask(() => {
-					this.scrollFlushQueued = false;
-					const delta = this.pendingScroll;
-					this.pendingScroll = 0;
-					if (delta !== 0) {
-						this.console.scrollBy(delta);
-						this.render();
-					}
-				});
-			}
-			return;
-		}
-		if (key.kind === "scroll-end") {
-			this.console.scrollToBottom();
-			this.render();
-			return;
-		}
-		if (key.kind === "mouse-down") {
-			this.console.mouseDown(key.row, key.column);
-			return;
-		}
-		if (key.kind === "mouse-drag") {
-			this.console.mouseDrag(key.row, key.column);
-			return;
-		}
-		if (key.kind === "mouse-up") {
-			const text = this.console.mouseUp();
-			if (text !== void 0 && this.console.copyText(text)) {
-				const rows = text.split("\n").length;
-				this.setFlash(this.theme.dim(rows > 1 ? `  ✓ copied ${rows} lines` : "  ✓ copied"));
-			}
-			return;
-		}
-		const selecting = this.select_;
-		if (selecting !== void 0) {
-			const step = selecting.selector.handle(key);
-			if (step.kind === "done") {
-				selecting.dispose();
-				selecting.resolve(step.outcome);
-				return;
-			}
-			this.render();
-			return;
-		}
-		const action = this.editor.handle(key);
-		switch (action.kind) {
-			case "submit": {
-				const waiting = this.pending;
-				if (waiting === void 0) {
-					this.queued.push(action.text);
-					break;
-				}
-				waiting.dispose();
-				waiting.resolve(action.text);
-				this.console.scrollToBottom();
-				break;
-			}
-			case "escape":
-				this.handlers.escape();
-				break;
-			case "eof": {
-				const waiting = this.pending;
-				if (waiting !== void 0) {
-					waiting.dispose();
-					waiting.resolve(void 0);
-				}
-				this.handlers.eof();
-				break;
-			}
-			default: break;
-		}
-		this.render();
-	}
-	/** Recompose and redraw the bottom region. */
-	render() {
-		if (!this.console.readsKeys) return;
-		const columns = this.console.columns - 1;
-		const rows = [];
-		let cursor = {
-			row: 0,
-			column: 0
-		};
-		if (this.streaming !== void 0) rows.push(this.streaming);
-		if (this.select_ !== void 0) rows.push(...this.select_.selector.view(this.theme, columns));
-		else if (this.engaged || this.reading) {
-			const box = inputBox(this.editor.view, this.theme, columns, {
-				placeholder: this.placeholder,
-				accent: this.accent
-			});
-			cursor = {
-				row: rows.length + box.cursorRow,
-				column: box.cursorColumn
-			};
-			rows.push(...box.rows);
-		}
-		if (this.queued.length > 0) {
-			const preview = this.queued[0] ?? "";
-			const more = this.queued.length > 1 ? ` (+${this.queued.length - 1} more)` : "";
-			rows.push(this.theme.dim(truncate(`  ↳ queued: ${preview.split("\n")[0] ?? ""}${more}`, columns)));
-		}
-		this.console.setScrollNotice(this.console.scrolledBy > 0 ? this.theme.dim(truncate(`  ↑ ${this.console.scrolledBy} rows above · PgDn returns to the latest`, columns)) : "");
-		const notice = this.flash ?? this.hint;
-		if (notice !== void 0) rows.push(notice);
-		if (this.status !== void 0) rows.push(this.status);
-		if (rows.length === 0) {
-			this.console.clearRegion();
-			return;
-		}
-		const focus = this.select_ === void 0 && (this.engaged || this.reading);
-		if (!focus) cursor = {
-			row: rows.length - 1,
-			column: 0
-		};
-		this.console.setRegion(rows, cursor, focus);
-	}
-};
-
-//#endregion
-//#region src/preset-install.ts
-/** The preset this bundle's patch names as the roster default. */
-const PACKAGED_PRESET = "code-cli";
-/**
-* The writable roster root, relative to the Harness home.
-*
-* Repeated rather than imported: `dsh-agent-presets` keeps this as its own
-* internal `USER_PRESET_DIR` and does not export it, and this package installs
-* from npm against a PUBLISHED dependency — an import added to the workspace
-* source would resolve here and break for everyone else. `tests/` asserts the
-* two stay equal, so a rename upstream fails loudly instead of silently
-* installing into a directory nothing reads.
-*/
-const USER_PRESET_DIR = ".agent-presets";
-/**
-* The packaged preset directory.
-*
-* Resolved from this module rather than the process cwd so it is correct in the
-* built `lib/` layout and in the source tree alike; `agent-presets/` sits beside
-* both.
-*/
-const PACKAGED_ROOT = fileURLToPath(new URL("../agent-presets/", import.meta.url));
-/**
-* Copy the packaged preset into the user root unless it is already there.
-* @param home - the user preset root; defaults to the Harness home's.
-* @returns where the preset lives and whether this call wrote it.
-*/
-async function installPackagedPreset(home = dshHomePath(USER_PRESET_DIR)) {
-	const target = join(home, PACKAGED_PRESET);
-	if (await readdir(target).catch(() => void 0) !== void 0) return {
-		path: target,
-		installed: false
-	};
-	const source = join(PACKAGED_ROOT, PACKAGED_PRESET);
-	const entries = await readdir(source, { withFileTypes: true });
-	await mkdir(target, { recursive: true });
-	for (const entry of entries) {
-		if (!entry.isFile()) continue;
-		await copyFile(join(source, entry.name), join(target, entry.name));
-	}
-	return {
-		path: target,
-		installed: true
-	};
-}
-
-//#endregion
-//#region src/markdown.ts
-/** Opens or closes a fenced block, capturing its language. */
-const FENCE = /^\s*(?:```|~~~)\s*([\w+-]*)\s*$/;
-/** An ATX heading and its text. */
-const HEADING = /^(#{1,6})\s+(.*)$/;
-/** A bullet item: the indent, the marker, and the text. */
-const BULLET = /^(\s*)[-*+]\s+(.*)$/;
-/** A numbered item: the indent, the number, and the text. */
-const NUMBERED = /^(\s*)(\d+)[.)]\s+(.*)$/;
-/** A blockquote line. */
-const QUOTE = /^\s*>\s?(.*)$/;
-/** A thematic break. */
-const RULE = /^\s*(?:-{3,}|\*{3,}|_{3,})\s*$/;
-/** A table row: pipe-delimited cells with a leading and trailing pipe. */
-const TABLE_ROW = /^\s*\|.*\|\s*$/;
-/** A table's delimiter cell: dashes with optional alignment colons. */
-const TABLE_DELIMITER = /^:?-+:?$/;
-/**
-* Inline constructs, in one alternation so each is consumed once.
-*
-* Ordered so the longer delimiter wins: `**bold**` must not be read as two
-* empty emphases. Code spans come first because their content is literal.
-*
-* The underscore forms are guarded against intraword matches, which is what
-* Markdown itself requires: without the guard `some_helper_name` reads as an
-* emphasis and the identifier comes out mangled.
-*/
-const INLINE = /(`[^`]+`)|(\*\*[^*]+\*\*)|((?<!\w)__[^_]+__(?!\w))|(\[[^\]]*\]\([^)]*\))|(\*[^*\s][^*]*\*)|((?<!\w)_[^_\s][^_]*_(?!\w))/g;
-/**
-* Keywords shared across the languages this surface commonly shows.
-*
-* Deliberately conservative: a word that reads as a keyword in one language and
-* as an ordinary name in another is left out, because colouring `go(...)` or
-* `use(...)` as a keyword is a visible error while missing one is not.
-*/
-const KEYWORDS = new Set([
-	"as",
-	"async",
-	"await",
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"def",
-	"default",
-	"defer",
-	"elif",
-	"else",
-	"enum",
-	"export",
-	"extends",
-	"false",
-	"finally",
-	"fn",
-	"for",
-	"from",
-	"func",
-	"function",
-	"if",
-	"impl",
-	"import",
-	"in",
-	"instanceof",
-	"interface",
-	"lambda",
-	"let",
-	"match",
-	"new",
-	"nil",
-	"none",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"raise",
-	"return",
-	"self",
-	"static",
-	"struct",
-	"super",
-	"switch",
-	"this",
-	"throw",
-	"trait",
-	"true",
-	"try",
-	"type",
-	"typeof",
-	"undefined",
-	"var",
-	"void",
-	"while",
-	"with",
-	"yield"
-]);
-/** Code tokens, in one alternation: strings, comments, numbers, then words. */
-const CODE_TOKEN = /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)|(\/\/[^\n]*|#[^\n]*)|(\b\d[\d_.]*\b)|(\b[A-Za-z_]\w*\b)/g;
-/**
-* Colour one line of code by token class.
-*
-* A heuristic, not a parser: it has no state between lines, so a string or
-* comment spanning several lines is coloured only on the line where it opens.
-* Getting that wrong costs a colour, never the text — every branch reproduces
-* its input exactly.
-* @param line - the code line.
-* @param syntax - styling per token class.
-* @returns the coloured line.
-*/
-function highlightCode(line, syntax) {
-	return line.replace(CODE_TOKEN, (match, text, comment, number, word) => {
-		if (text !== void 0) return syntax.string(text);
-		if (comment !== void 0) return syntax.comment(comment);
-		if (number !== void 0) return syntax.number(number);
-		if (word !== void 0 && KEYWORDS.has(word)) return syntax.keyword(word);
-		return match;
-	});
-}
-/**
-* Style the inline constructs of one line of prose.
-* @param text - the line, with block syntax already stripped.
-* @param theme - styling for emphasis, code spans, and link targets.
-* @returns the styled line.
-*/
-function renderInline(text, theme) {
-	const emphasized = (inner) => inner.split(/(`[^`]+`)/u).map((segment) => segment.startsWith("`") && segment.endsWith("`") && segment.length > 1 ? theme.bold(theme.tool(segment.slice(1, -1))) : segment === "" ? "" : theme.bold(segment)).join("");
-	return text.replace(INLINE, (match, code, starBold, underBold, link, starEm, underEm) => {
-		if (code !== void 0) return theme.tool(code.slice(1, -1));
-		if (starBold !== void 0) return emphasized(starBold.slice(2, -2));
-		if (underBold !== void 0) return emphasized(underBold.slice(2, -2));
-		if (link !== void 0) {
-			const parts = /^\[([^\]]*)\]\(([^)]*)\)$/.exec(link);
-			if (parts === null) return match;
-			const [, label, target] = parts;
-			return `${theme.bold(label ?? "")} ${theme.dim(`(${target ?? ""})`)}`;
-		}
-		if (starEm !== void 0) return emphasized(starEm.slice(1, -1));
-		if (underEm !== void 0) return emphasized(underEm.slice(1, -1));
-		return match;
-	});
-}
-/**
-* Build a line-at-a-time Markdown renderer.
-* @param theme - styling for every construct.
-* @param columns - display columns available, read per table; absent means
-*   unconstrained. A table wider than this prints as its source lines.
-* @returns the renderer, carrying its own fence and table state.
-*/
-function createMarkdownStream(theme, columns) {
-	let fenceLanguage;
-	const table = [];
-	const fence = {
-		get: () => fenceLanguage,
-		set: (value) => {
-			fenceLanguage = value;
-		}
-	};
-	const drainTable = () => {
-		if (table.length === 0) return [];
-		return layoutTable(table.splice(0), theme, columns?.() ?? Number.POSITIVE_INFINITY);
-	};
-	return {
-		get inCode() {
-			return fenceLanguage !== void 0;
-		},
-		line: (line) => {
-			if (fenceLanguage === void 0 && TABLE_ROW.test(line)) {
-				table.push(line);
-				return [];
-			}
-			return [...drainTable(), ...renderLine(line, theme, fence)];
-		},
-		flush: drainTable
-	};
-}
-/**
-* Lay out one buffered table as a bordered grid.
-*
-* Outer borders, one space of padding inside every cell, and a rule between
-* every pair of rows: the padding keeps text off the rules, and the row rules
-* are unconditional because a wrapped cell's continuation must never blur into
-* the record below it. Cells render their inline constructs; every width is of
-* the VISIBLE text. A table wider than the terminal wraps inside its cells,
-* shrinking the widest columns toward an even share; only a terminal too
-* narrow to hold the columns at all falls back to the source lines.
-* @param rows - the raw `|`-delimited lines, in order.
-* @param theme - styling for the borders and the header.
-* @param budget - display columns available.
-* @returns the rendered table, or the source lines styled as prose.
-*/
-function layoutTable(rows, theme, budget) {
-	const asSource = () => rows.map((row) => renderInline(row, theme));
-	const raw = rows.map((row) => row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim()));
-	const delimiter = raw[1];
-	const marks = (delimiter ?? []).filter((cell) => cell !== "");
-	if (raw.length < 2 || delimiter === void 0 || marks.length === 0 || !marks.every((cell) => TABLE_DELIMITER.test(cell))) return asSource();
-	let count = Math.max(1, (raw[0] ?? []).length);
-	const content = [raw[0] ?? [], ...raw.slice(2)];
-	while (count > 1 && content.every((row) => (row[count - 1] ?? "") === "")) count -= 1;
-	const styled = content.map((row) => row.slice(0, count).map((cell) => renderInline(cell, theme)));
-	const visible = (cell) => displayWidth(cell.replaceAll(/\u001B\[[0-9;]*m/gu, ""));
-	const natural = Array.from({ length: count }, (_, column) => Math.max(1, ...styled.map((row) => visible(row[column] ?? ""))));
-	const framing = 3 * count + 1;
-	let widths = [...natural];
-	if (natural.reduce((sum, width) => sum + width, 0) + framing > budget) {
-		const available = budget - framing;
-		if (available < count * 2) return asSource();
-		const fair = Math.floor(available / count);
-		const kept = natural.map((width) => Math.min(width, fair));
-		let spare = available - kept.reduce((sum, width) => sum + width, 0);
-		widths = natural.map((width, column) => {
-			const base = kept[column] ?? 0;
-			if (width <= base) return width;
-			const extra = Math.min(width - base, spare);
-			spare -= extra;
-			return base + extra;
-		});
-	}
-	const edge = (left, junction, right) => theme.dim(`${left}${widths.map((width) => "─".repeat(width + 2)).join(junction)}${right}`);
-	const bar = theme.dim("│");
-	const line = (row, style) => {
-		const wrapped = Array.from({ length: count }, (_, column) => wrapStyled(row[column] ?? "", widths[column] ?? 1));
-		const height = Math.max(...wrapped.map((cell) => cell.length));
-		return Array.from({ length: height }, (_, index) => {
-			return `${bar}${wrapped.map((cell, column) => {
-				const piece = cell[index] ?? "";
-				const alignRight = /^:?-+:$/.test(delimiter[column] ?? "") && !/^:-+:$/.test(delimiter[column] ?? "");
-				const pad = " ".repeat(Math.max(0, (widths[column] ?? 0) - visible(piece)));
-				return alignRight ? ` ${pad}${style(piece)} ` : ` ${style(piece)}${pad} `;
-			}).join(bar)}${bar}`;
-		});
-	};
-	const separator = edge("├", "┼", "┤");
-	const body = styled.slice(1).flatMap((row, index) => index > 0 ? [separator, ...line(row, (text) => text)] : line(row, (text) => text));
-	return [
-		edge("╭", "┬", "╮"),
-		...line(styled[0] ?? [], (text) => theme.bold(text)),
-		separator,
-		...body,
-		edge("╰", "┴", "╯")
-	];
-}
-/**
-* Render one Markdown line against the carried fence state.
-* @param line - the input line.
-* @param theme - styling for every construct.
-* @param fence - the fence state, read and updated in place.
-* @returns the output lines for this input line.
-*/
-function renderLine(line, theme, fence) {
-	const out = [];
-	{
-		const opened = FENCE.exec(line);
-		let fenceLanguage = fence.get();
-		if (opened !== null) {
-			if (fenceLanguage === void 0) {
-				fenceLanguage = opened[1] ?? "";
-				if (fenceLanguage !== "") out.push(theme.dim(`  ${fenceLanguage}`));
-			} else fenceLanguage = void 0;
-			fence.set(fenceLanguage);
-			return out;
-		}
-		if (fenceLanguage !== void 0) {
-			out.push(`  ${highlightCode(line, theme.syntax)}`);
-			return out;
-		}
-		const heading = HEADING.exec(line);
-		if (heading !== null) {
-			out.push(theme.bold(renderInline(heading[2] ?? "", theme)));
-			return out;
-		}
-		if (RULE.test(line)) {
-			out.push(theme.dim("───"));
-			return out;
-		}
-		const quote = QUOTE.exec(line);
-		if (quote !== null) {
-			out.push(`${theme.dim("│")} ${theme.dim(renderInline(quote[1] ?? "", theme))}`);
-			return out;
-		}
-		const bullet = BULLET.exec(line);
-		if (bullet !== null) {
-			out.push(`${bullet[1] ?? ""}${theme.dim("•")} ${renderInline(bullet[2] ?? "", theme)}`);
-			return out;
-		}
-		const numbered = NUMBERED.exec(line);
-		if (numbered !== null) {
-			out.push(`${numbered[1] ?? ""}${theme.dim(`${numbered[2] ?? ""}.`)} ${renderInline(numbered[3] ?? "", theme)}`);
-			return out;
-		}
-		out.push(renderInline(line, theme));
-	}
-	return out;
-}
-/**
-* Render a whole Markdown answer as terminal lines.
-* @param text - the answer, as the model produced it.
-* @param theme - styling for every construct.
-* @returns the output lines, blocks included.
-*/
-function renderMarkdown(text, theme) {
-	const stream = createMarkdownStream(theme);
-	return [...text.split("\n").flatMap((line) => stream.line(line)), ...stream.flush()];
-}
-
-//#endregion
-//#region src/questions.ts
-/**
-* Parse a selection line against one question's options.
-*
-* A comma-separated list of numbers selects those options; a multi-select
-* question accepts several, a single-select takes the first. Anything that is
-* not a valid index becomes the free-text answer.
-* @param line - the line the person typed.
-* @param question - the question being answered.
-* @returns the encoded answer for this question.
-*/
-function encodeAnswer(line, question) {
-	const options = question.options ?? [];
-	const trimmed = line.trim();
-	if (trimmed === "") return {
-		id: question.id,
-		selected: []
-	};
-	const indices = trimmed.split(",").map((part) => Number(part.trim()));
-	if (!indices.every((index) => Number.isInteger(index) && index >= 1 && index <= options.length) || options.length === 0) return {
-		id: question.id,
-		selected: [],
-		custom: trimmed
-	};
-	const chosen = question.multiSelect === true ? indices : indices.slice(0, 1);
-	return {
-		id: question.id,
-		selected: chosen.map((index) => options[index - 1]?.label ?? "")
-	};
-}
-/**
-* Render one question as the lines shown above its prompt.
-* @param question - the question to render.
-* @param theme - styling for the heading and option list.
-* @returns the lines to print.
-*/
-function questionLines(question, theme) {
-	const lines = [""];
-	const plan = question.intent?.kind === "plan-review" ? question.intent : void 0;
-	if (plan !== void 0) {
-		lines.push(theme.pending("▲ plan for review"), "");
-		if (question.detail !== void 0) lines.push(...question.detail.split("\n"));
-		lines.push("", theme.bold(question.question));
-		(question.options ?? []).forEach((option, index) => {
-			const mark = option.label === plan.approve ? theme.success(String(index + 1)) : theme.error(String(index + 1));
-			const description = option.description === void 0 ? "" : theme.dim(` — ${option.description}`);
-			lines.push(`  ${mark}. ${option.label}${description}`);
-		});
-		lines.push(theme.dim("  (a number, or type your own answer)"));
-		return lines;
-	}
-	if (question.header !== void 0) lines.push(theme.dim(`[${question.header}]`));
-	lines.push(theme.bold(question.question));
-	if (question.detail !== void 0) lines.push(...question.detail.split("\n").map((line) => theme.dim(line)));
-	const options = question.options ?? [];
-	options.forEach((option, index) => {
-		const description = option.description === void 0 ? "" : theme.dim(` — ${option.description}`);
-		lines.push(`  ${theme.pending(String(index + 1))}. ${option.label}${description}`);
-	});
-	if (options.length > 0) {
-		const how = question.multiSelect === true ? "numbers separated by commas, or type your own answer" : "a number, or type your own answer";
-		lines.push(theme.dim(`  (${how})`));
-	}
-	return lines;
-}
-/** Answers `ask_user_question` from the terminal. */
-var TerminalQuestions = class {
-	constructor(reader, theme, write, select) {
-		this.reader = reader;
-		this.theme = theme;
-		this.write = write;
-		this.select = select;
-	}
-	/**
-	* Put every question in one request to the person, in order.
-	* @param request - the questions, owner agent, and abort signal.
-	* @returns one answer per question, in request order.
-	*/
-	async ask(request) {
-		const answers = [];
-		for (const question of request.questions) answers.push(await this.one(question, request.signal));
-		return { answers };
-	}
-	/**
-	* Put one question to the person.
-	* @param question - the question.
-	* @param signal - aborts with the owning tool call.
-	* @returns the encoded answer.
-	*/
-	async one(question, signal) {
-		const options = question.options ?? [];
-		if (this.select === void 0 || options.length === 0) {
-			for (const line of questionLines(question, this.theme)) this.write(line);
-			return encodeAnswer(await this.reader.read(signal) ?? "", question);
-		}
-		this.write("");
-		if (question.header !== void 0) this.write(this.theme.dim(`[${question.header}]`));
-		if (question.intent?.kind === "plan-review") {
-			this.write(this.theme.pending("▲ plan for review"));
-			this.write("");
-			if (question.detail !== void 0) for (const line of renderMarkdown(question.detail, this.theme)) this.write(line);
-			this.write("");
-		} else if (question.detail !== void 0) for (const line of question.detail.split("\n")) this.write(this.theme.dim(line));
-		const outcome = await this.select({
-			title: question.question,
-			options: options.map((option) => ({
-				label: option.label,
-				...option.description === void 0 ? {} : { detail: option.description }
-			})),
-			...question.multiSelect === true ? { multi: true } : {},
-			custom: "✎ Type your own answer"
-		}, signal);
-		if (outcome.kind === "chosen") {
-			const selected = outcome.indices.map((index) => options[index]?.label).filter((label) => label !== void 0);
-			this.write(this.theme.dim(`  ✓ ${selected.join(", ")}`));
-			return {
-				id: question.id,
-				selected
-			};
-		}
-		if (outcome.kind === "custom") {
-			const custom = (await this.reader.read(signal) ?? "").trim();
-			return custom === "" ? {
-				id: question.id,
-				selected: []
-			} : {
-				id: question.id,
-				selected: [],
-				custom
-			};
-		}
-		return {
-			id: question.id,
-			selected: []
-		};
-	}
-};
-
-//#endregion
-//#region src/spinner.ts
-/** Braille frames, one cell wide each, so the line never changes width. */
-const FRAMES = [
-	"⠋",
-	"⠙",
-	"⠹",
-	"⠸",
-	"⠼",
-	"⠴",
-	"⠦",
-	"⠧",
-	"⠇",
-	"⠏"
-];
-/** How often the frame advances. */
-const TICK_MS = 90;
-/**
-* Render one tick of the indicator.
-* @param frame - the frame index, taken modulo the frame count.
-* @param elapsedMs - milliseconds since the work started.
-* @param label - the verb and interrupt key to name.
-* @param theme - styling for the frame and the hint.
-* @returns the line to display.
-*/
-function spinnerText(frame, elapsedMs, label, theme) {
-	const seconds = (elapsedMs / 1e3).toFixed(elapsedMs < 1e4 ? 1 : 0);
-	const mark = FRAMES[frame % FRAMES.length] ?? FRAMES[0];
-	const extra = label.detail?.();
-	const detail = extra === void 0 || extra === "" ? "" : `${extra} · `;
-	return `${theme.pending(mark)} ${label.verb} ${theme.dim(`${seconds}s · ${detail}${label.interrupt} to interrupt`)}`;
-}
-/** Drives the working indicator for as long as the agent is busy. */
-var Spinner = class {
-	timer;
-	frame = 0;
-	startedAt = 0;
-	constructor(surface, theme, label, now = () => performance.now()) {
-		this.surface = surface;
-		this.theme = theme;
-		this.label = label;
-		this.now = now;
-	}
-	/** Whether the indicator is running. */
-	get running() {
-		return this.timer !== void 0;
-	}
-	/**
-	* Start the indicator, or do nothing when it is already running or the
-	* surface has no cursor to rewrite.
-	*
-	* The clock keeps running across a pause: the elapsed figure is the whole
-	* turn's, and an indicator that restarted from zero at every tool call would
-	* report each step instead.
-	*/
-	start() {
-		if (this.timer !== void 0 || !this.surface.isTty) return;
-		if (this.startedAt === 0) this.startedAt = this.now();
-		this.draw();
-		this.timer = setInterval(() => {
-			this.frame += 1;
-			this.draw();
-		}, TICK_MS);
-		this.timer.unref();
-	}
-	/** Hide the indicator without forgetting when the turn began. */
-	pause() {
-		if (this.timer === void 0) return;
-		clearInterval(this.timer);
-		this.timer = void 0;
-		this.surface.setLive(void 0);
-	}
-	/** Stop the indicator: the turn is over, and the next one starts at zero. */
-	stop() {
-		this.pause();
-		this.startedAt = 0;
-		this.frame = 0;
-	}
-	/** Paint the current frame. */
-	draw() {
-		this.surface.setLive(spinnerText(this.frame, this.now() - this.startedAt, this.label, this.theme));
-	}
-};
-
-//#endregion
-//#region src/streaming.ts
-/** Accumulates assistant text deltas into rendered lines. */
-var TextStream = class {
-	markdown;
-	partial = "";
-	seen = false;
-	constructor(theme, columns, plain = false) {
-		this.theme = theme;
-		this.columns = columns;
-		this.plain = plain;
-		this.markdown = createMarkdownStream(theme, columns);
-	}
-	/** Whether this message has produced any text yet. */
-	get streamed() {
-		return this.seen;
-	}
-	/**
-	* Take one text delta.
-	* @param delta - the text fragment, which may contain any number of newlines.
-	* @returns the lines to append and the line still open.
-	*/
-	push(delta) {
-		if (delta === "") return {
-			lines: [],
-			live: this.liveText()
-		};
-		this.seen = true;
-		const lines = [];
-		const parts = (this.partial + delta).split("\n");
-		this.partial = parts.pop() ?? "";
-		for (const complete of parts) lines.push(...this.renderLine(complete));
-		return {
-			lines,
-			live: this.liveText()
-		};
-	}
-	/**
-	* Close the message, rendering whatever line was still open.
-	*
-	* Called when the model finishes and when a turn is cancelled mid-line: the
-	* text already shown has to land in the transcript either way, or the live
-	* region would take it away again.
-	* @returns the remaining lines to append.
-	*/
-	flush() {
-		const lines = this.partial === "" ? [] : this.renderLine(this.partial);
-		lines.push(...this.plain ? [] : this.markdown.flush());
-		this.partial = "";
-		this.seen = false;
-		this.markdown = createMarkdownStream(this.theme, this.columns);
-		return lines;
-	}
-	/** Render one complete line in this stream's mode. */
-	renderLine(line) {
-		return this.plain ? [this.theme.dim(`  ${line}`)] : this.markdown.line(line);
-	}
-	/**
-	* The in-progress line as the live region should show it.
-	*
-	* Raw rather than rendered: it is not a line yet, and inside a fenced block it
-	* is code that Markdown must not touch. Truncated because the live region is
-	* one row — a wrapped live line cannot be erased by a single carriage return.
-	* @returns the text, or undefined when no line is open.
-	*/
-	liveText() {
-		if (this.partial === "") return void 0;
-		const prefix = this.markdown.inCode ? "  " : "";
-		return this.theme.dim(truncate(`${prefix}${this.partial}`, this.columns() - 1));
-	}
-};
-
-//#endregion
-//#region src/transcript.ts
-/** Context lines kept on each side of a rendered hunk. */
-const DIFF_CONTEXT = 3;
-/** Diff body lines printed for one file before the card collapses the rest. */
-const MAX_DIFF_LINES = 24;
-/**
-* Result body lines printed for one completed call before the card collapses.
-*
-* Small on purpose: a long output in the transcript is skimmed, not read, and
-* the collapsed remainder is one Ctrl+O away in full.
-*/
-const MAX_RESULT_LINES = 5;
-/**
-* Concatenate a message's text blocks, dropping reasoning and non-text content.
-* @param content - the message content blocks.
-* @returns the joined visible text.
-*/
-function visibleText(content) {
-	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
-}
-/**
-* Render one file's change as unified-diff body lines.
-*
-* A {@link FileDiff} carries one hunk's old and new blocks including their
-* context lines, so re-diffing the two blocks recovers which lines actually
-* changed. A `null` `oldText` is a create: every line is an addition.
-* @param diff - the file change to render.
-* @param theme - styling for added and removed lines.
-* @returns the body lines, marker-prefixed.
-*/
-function diffBody(diff, theme) {
-	if (diff.oldText === null) {
-		const lines$1 = diff.newText.split("\n");
-		if (lines$1.at(-1) === "") lines$1.pop();
-		return lines$1.map((line) => theme.success(`+ ${line}`));
-	}
-	const patch = structuredPatch("", "", diff.oldText, diff.newText, void 0, void 0, { context: DIFF_CONTEXT });
-	const lines = [];
-	for (const hunk of patch.hunks) for (const line of hunk.lines) {
-		if (line.startsWith("\\")) continue;
-		const text = line.slice(1);
-		if (line.startsWith("+")) lines.push(theme.success(`+ ${text}`));
-		else if (line.startsWith("-")) lines.push(theme.error(`- ${text}`));
-		else lines.push(theme.dim(`  ${text}`));
-	}
-	return lines;
-}
-/**
-* Cap a body at `limit` lines, replacing the remainder with a count.
-* @param lines - the rendered body.
-* @param limit - how many lines to keep.
-* @param theme - styling for the summary line.
-* @returns the capped body.
-*/
-function cap(lines, limit, theme) {
-	if (lines.length <= limit) return lines;
-	return [...lines.slice(0, limit), theme.dim(`  … +${lines.length - limit} lines (Ctrl+O expands)`)];
-}
-/** Renders one session's appended events as terminal lines. */
-var Transcript = class {
-	calls = /* @__PURE__ */ new Map();
-	/** The full form of the event just rendered, when its body was collapsed. */
-	fold;
-	constructor(options, presenters) {
-		this.options = options;
-		this.presenters = presenters;
-	}
-	/**
-	* Shorten an absolute path inside the workspace to a workspace-relative one.
-	* @param path - the model-facing path a card carries.
-	* @returns the display path.
-	*/
-	relative(path) {
-		const root = this.options.cwd.endsWith("/") ? this.options.cwd : `${this.options.cwd}/`;
-		return path.startsWith(root) ? path.slice(root.length) : path;
-	}
-	/**
-	* Shorten every workspace path a presenter embedded in free text.
-	*
-	* A title is prose the tool composed (`Write /abs/path`), so the path inside
-	* it needs the same shortening as a structured `locations` entry.
-	* @param text - the presenter-supplied line.
-	* @returns the line with workspace-rooted paths made relative.
-	*/
-	relativizeIn(text) {
-		const root = this.options.cwd.endsWith("/") ? this.options.cwd : `${this.options.cwd}/`;
-		return text.split(root).join("");
-	}
-	/**
-	* Paths worth appending to a title that may already name them.
-	* @param title - the presenter's title, already relativized.
-	* @param paths - the relativized paths the card covers.
-	* @returns the paths the title does not mention, joined for display.
-	*/
-	extraPaths(title, paths) {
-		const missing = paths.filter((path) => !title.includes(path));
-		return missing.length === 0 ? "" : ` ${missing.join(", ")}`;
-	}
-	/**
-	* Render one appended event.
-	* @param event - the event exactly as recorded.
-	* @returns the lines to append to the transcript, empty when the event shows nothing.
-	*/
-	render(event) {
-		const { theme } = this.options;
-		switch (event.type) {
-			case "user/message": {
-				if (event.data.source.kind !== "user") return [];
-				const [first = "", ...rest] = visibleText(event.data.content).split("\n");
-				return [
-					`${theme.user("›")} ${first}`,
-					...rest.map((line) => `  ${line}`),
-					""
-				];
-			}
-			case "assistant/message": {
-				const text = visibleText(event.data.message.content);
-				return text === "" ? [] : [...renderMarkdown(text, theme), ""];
-			}
-			case "tool/call": return this.renderCall(event.data.callId, event.data.name, event.data.arguments);
-			case "tool/result": return this.renderResult(event.data);
-			case "todo/write": {
-				const { todos } = event.data;
-				if (todos.length === 0) return [];
-				const done = todos.filter((todo) => todo.status === "completed").length;
-				return [
-					`${theme.tool("todos")} ${theme.dim(`${done}/${todos.length}`)}`,
-					...todos.map((todo) => {
-						if (todo.status === "completed") return theme.dim(`  ✔ ${todo.content}`);
-						if (todo.status === "in_progress") return `  ${theme.pending("▶")} ${todo.content}`;
-						return theme.dim(`  ○ ${todo.content}`);
-					}),
-					""
-				];
-			}
-			case "plan/mode": return event.data.active ? [theme.pending("▲ plan mode — exploring only; no files will change until you approve a plan"), ""] : [theme.dim("▼ plan mode off"), ""];
-			case "turn/end": return event.data.reason.kind === "error" ? [theme.error(`✗ ${event.data.reason.error.code}: ${event.data.reason.error.message}`), ""] : [];
-			default: return [];
-		}
-	}
-	/**
-	* Render a pending call as its declared card.
-	* @param callId - correlation id, remembered until the result pairs with it.
-	* @param name - the tool the model called.
-	* @param rawArguments - the unparsed arguments JSON the model produced.
-	* @returns the pending card's lines.
-	*/
-	renderCall(callId, name$1, rawArguments) {
-		const { theme, columns } = this.options;
-		let args;
-		try {
-			args = JSON.parse(rawArguments);
-		} catch {
-			args = void 0;
-		}
-		const view = this.safeCall(name$1, args);
-		const record = (title$1, lines) => {
-			this.calls.set(callId, {
-				name: name$1,
-				args,
-				title: title$1
-			});
-			return lines;
-		};
-		if (view === void 0) return record(name$1, [`${theme.pending("●")} ${theme.tool(name$1)}`]);
-		if (view.card === "terminal") {
-			const header = view.cwd === void 0 ? "" : theme.dim(` (${this.relative(view.cwd)})`);
-			const description = view.description === void 0 ? [] : [theme.dim(`  ${view.description}`)];
-			const command = this.relativizeIn(view.title);
-			return record(command, [
-				`${theme.pending("●")} ${theme.tool(name$1)}${header}`,
-				`  $ ${truncate(command, columns - 4)}`,
-				...description
-			]);
-		}
-		if (view.card === "diff") {
-			const title$1 = this.relativizeIn(view.title);
-			const paths = view.diffs.map((diff) => this.relative(diff.path));
-			return record(`${title$1}${this.extraPaths(title$1, paths)}`, [`${theme.pending("●")} ${theme.tool(title$1)}${theme.path(this.extraPaths(title$1, paths))}`]);
-		}
-		const title = this.relativizeIn(view.title);
-		const locations = (view.locations ?? []).map((location) => this.relative(location.path));
-		const extra = this.extraPaths(title, locations);
-		return record(`${title}${extra}`, [`${theme.pending("●")} ${truncate(title, columns - 4)}${theme.path(extra)}`]);
-	}
-	/**
-	* Render a completed call, pairing it with the call this transcript recorded.
-	* @param data - the `tool/result` payload.
-	* @returns the completed card's lines.
-	*/
-	renderResult(data) {
-		const { theme } = this.options;
-		const { message, meta, error } = data;
-		const [block] = message.content;
-		const callId = message.source.callId;
-		const pending = this.calls.get(callId);
-		this.calls.delete(callId);
-		const failed = error !== void 0 || block.isError === true;
-		const marker = failed ? theme.error("✗") : theme.success("●");
-		if (pending === void 0) {
-			const raw = this.resultText(block.content).split("\n");
-			const head$1 = `${marker} ${theme.dim("(result)")}`;
-			if (raw.length > MAX_RESULT_LINES) this.fold = [
-				head$1,
-				...raw,
-				""
-			];
-			return [
-				head$1,
-				...cap(raw, MAX_RESULT_LINES, theme),
-				""
-			];
-		}
-		const view = this.safeResult(pending, block.content, failed, meta);
-		const title = view?.title === void 0 ? pending.title : this.relativizeIn(view.title);
-		const { suffix, body, full } = this.outcome(view, block);
-		const head = failed || title !== pending.title ? [`${marker} ${theme.tool(title)}${suffix === "" ? "" : ` ${suffix}`}`] : suffix !== "" ? [`  ${suffix}`] : body.length === 0 ? [`  ${theme.success("✓")}`] : [];
-		if (full !== void 0) this.fold = [
-			...head,
-			...full,
-			""
-		];
-		return [
-			...head,
-			...body,
-			""
-		];
-	}
-	/**
-	* The expanded form of the lines {@link render} just returned, when that
-	* event's body was collapsed — the whole event re-rendered without its cap,
-	* because a fold swaps entire blocks, not just the clipped tail. The full
-	* body is kept from the render itself: what a tool truncated before
-	* returning is upstream of the log and unrecoverable everywhere.
-	* @returns the full lines, or undefined when nothing was collapsed.
-	*/
-	takeFold() {
-		const fold = this.fold;
-		this.fold = void 0;
-		return fold;
-	}
-	/**
-	* Render one completed call's status suffix and body from its declared view.
-	* @param view - the result view, absent when no presenter answered.
-	* @param block - the model-facing result block, used by the generic fallback.
-	* @returns the suffix, the (possibly capped) body, and — when the cap dropped
-	*   lines, or a bodiless card withheld content — the full body for Ctrl-O.
-	*/
-	outcome(view, block) {
-		const { theme } = this.options;
-		const capped = (lines, limit) => {
-			const body = cap(lines, limit, theme);
-			return lines.length > limit ? {
-				body,
-				full: lines
-			} : { body };
-		};
-		if (view?.card === "diff") return {
-			suffix: "",
-			...capped(view.diffs.flatMap((diff) => diffBody(diff, theme)), MAX_DIFF_LINES)
-		};
-		if (view?.card === "terminal") {
-			const suffix = view.signal !== void 0 ? theme.error(`(killed by ${view.signal})`) : view.exitCode !== void 0 && view.exitCode !== 0 ? theme.error(`(exit ${view.exitCode})`) : "";
-			const output = (view.output ?? "").trimEnd();
-			return {
-				suffix,
-				...capped(output === "" ? [] : output.split("\n").map((line) => theme.dim(`  ${line}`)), MAX_RESULT_LINES)
-			};
-		}
-		if (view?.card === "search") {
-			const total = view.truncated ? `${view.total}+ (capped)` : String(view.total);
-			const body = view.shape === "paths" ? view.paths.map((path) => theme.dim(`  ${this.relative(path)}`)) : view.files.flatMap((file) => [theme.path(`  ${this.relative(file.path)}`), ...file.matches.map((match) => theme.dim(`    ${match.lineNumber}: ${match.line}`))]);
-			return {
-				suffix: theme.dim(`${total} results`),
-				...capped(body, MAX_RESULT_LINES)
-			};
-		}
-		if (view?.card === "read") {
-			const body = view.lines.map((line) => theme.dim(`  ${line.number}: ${line.text}`));
-			return {
-				suffix: theme.dim(`${view.lines.length} of ${view.totalLines} lines`),
-				body: [],
-				...body.length === 0 ? {} : { full: body }
-			};
-		}
-		const text = this.resultText(view?.card === "generic" && view.content !== void 0 ? view.content : block.content);
-		if (text === "") return {
-			suffix: "",
-			body: []
-		};
-		return {
-			suffix: "",
-			...capped(text.split("\n").map((line) => theme.dim(`  ${line}`)), MAX_RESULT_LINES)
-		};
-	}
-	/**
-	* Flatten a result's content blocks to displayable text.
-	* @param content - the result content blocks.
-	* @returns the joined text.
-	*/
-	resultText(content) {
-		return visibleText(content).trimEnd();
-	}
-	/**
-	* Ask a call presenter for its view, absorbing a throwing presenter.
-	* @param name - the tool the model called.
-	* @param args - the parsed call arguments.
-	* @returns the view, or undefined to fall back to the generic line.
-	*/
-	safeCall(name$1, args) {
-		try {
-			return this.presenters.call(name$1, args);
-		} catch {
-			return;
-		}
-	}
-	/**
-	* Ask a result presenter for its view, absorbing a throwing presenter.
-	* @param pending - the recorded call this result pairs with.
-	* @param content - the model-facing result content.
-	* @param isError - whether the executor reported a failure.
-	* @param meta - the tool's private presentation payload, when it attached one.
-	* @returns the view, or undefined to fall back to the generic card.
-	*/
-	safeResult(pending, content, isError, meta) {
-		try {
-			return this.presenters.result(pending.name, pending.args, {
-				content: [...content],
-				isError,
-				...meta === void 0 ? {} : { meta }
-			});
-		} catch {
-			return;
-		}
-	}
-};
-
-//#endregion
-//#region src/index.ts
-/** Stable Cordis plugin name. */
-const name = "coding-cli-runner";
-/** Core services required before the surface can compose an agent. */
-const inject = [
-	"agentDefaultModel",
-	"agents",
-	"sessions",
-	"tools"
-];
-const Config = z.object({
-	task: z.string().default(""),
-	resume: z.string().default(""),
-	preset: z.string().default(""),
-	print: z.boolean().default(false),
-	bell: z.boolean().default(true),
-	bangTimeoutMs: z.number().default(12e4),
-	bangOutputLines: z.number().default(200)
-});
-/** The process streams the surface binds to; tests substitute captures. */
-const internals = {
-	input: process.stdin,
-	output: process.stdout
-};
-/** How long a second interrupt keeps ending the process rather than the turn. */
-const INTERRUPT_EXIT_WINDOW_MS = 2e3;
-/**
-* Resolve the session `--continue` reopens: the newest one recorded in this
-* working directory.
-* @param ctx - plugin context carrying the optional session query engine.
-* @param cwd - the workspace to match.
-* @returns the session id, or undefined when nothing was recorded here.
-*/
-async function latestSessionIn(ctx, cwd) {
-	const query = ctx.get("sessionQuery");
-	if (query === void 0) return void 0;
-	return (await query.listSessions()).find((record) => record.header.cwd === cwd)?.header.id;
-}
-/**
-* Build the presenter lookups for one live agent.
-*
-* Presenters live with the tool definitions, and definitions live in the scope
-* chain a preset registers into. The live agent IS that scope key.
-* @param ctx - plugin context carrying the tool registry.
-* @param agent - the live agent whose catalog to resolve against.
-* @returns the call and result presenter lookups.
-*/
-function presentersFor(ctx, agent) {
-	return {
-		call: (toolName, args) => ctx.tools.get(toolName, agent)?.presentCall?.(args),
-		result: (toolName, args, result) => ctx.tools.get(toolName, agent)?.presentResult?.(args, result)
-	};
-}
-/**
-* Whether plan mode is holding, from the log's last `plan/mode` record.
-*
-* Folded here rather than through the plugin's own helper because importing a
-* runtime value from a bundled dependency inlines that package into this one;
-* the flag is one last-wins boolean, and the surface already reads the log.
-* @param events - the session log, oldest first.
-* @returns whether plan mode is on.
-*/
-function planModeFrom(events) {
-	let active = false;
-	for (const event of events) if (event.type === "plan/mode") active = event.data.active;
-	return active;
-}
-/**
-* Gather what the status line reports for the session as it stands now.
-*
-* Read fresh on every call: usage, occupancy, permission, and plan state are
-* all folds over the log, so a stale copy would report the turn before last.
-* @param ctx - plugin context carrying the projection and permission services.
-* @param agent - the live agent.
-* @param cwd - the session workspace.
-* @param model - the model route answering this session.
-* @param presetId - the composed preset, when a roster resolved one.
-* @param branch - the checked-out branch, read once per prompt.
-* @returns the facts to render.
-*/
-function statusFacts(ctx, agent, cwd, selection, presetId, branch) {
-	const projections = ctx.get("sessionProjections")?.snapshot(agent.session).values;
-	return {
-		model: selection.current?.model ?? "",
-		preset: presetId,
-		permission: ctx.get("permissionPresets")?.current(agent.session.events),
-		planMode: planModeFrom(agent.session.events),
-		cwd,
-		branch,
-		usage: projections?.tokenUsage,
-		context: projections?.contextPressure
-	};
-}
-/**
-* Render every event a resumed session already holds, so the person sees the
-* conversation they are continuing.
-* @param session - the reconstructed session.
-* @param transcript - the renderer, which also learns the pending call table.
-* @param io - the terminal to write to.
-*/
-function replay(session, transcript, io) {
-	for (const event of session.events) for (const line of transcript.render(event)) io.console.write(line);
-}
-/**
-* Run one conversation turn and wait for the agent to go idle.
-* @param agent - the live agent.
-* @param text - the person's message.
-* @param working - the indicator to run while the turn does.
-* @param source - the message source; a canned prompt is plugin-sourced so the
-*   transcript echoes the command that ran it, not its whole body.
-*/
-async function turn(agent, text, working, source = { kind: "user" }) {
-	agent.followup(createUserMessage({
-		content: [{
-			type: "text",
-			text
-		}],
-		source
-	}));
-	working?.start();
-	try {
-		await agent.whenIdle();
-	} finally {
-		working?.stop();
-	}
-}
-/**
-* Execute one slash command through the command registry.
-* @param ctx - plugin context carrying the optional command registry.
-* @param agent - the live agent the command applies to.
-* @param line - the typed line, including its leading slash.
-* @param io - the terminal to write to.
-* @param theme - styling for the command's report.
-* @param signal - cancels the command when the person interrupts.
-*/
-async function runCommand(ctx, agent, line, io, theme, signal) {
-	const commands = ctx.get("commands");
-	if (commands === void 0) {
-		io.console.write(theme.error("  commands are unavailable in this composition"));
-		return;
-	}
-	if (line === "/help" || line === "/") {
-		const width = Math.max(...commands.list(agent).map((command) => command.name.length), 4);
-		for (const command of commands.list(agent)) io.console.write(`  ${theme.tool(`/${command.name}`.padEnd(width + 1))}  ${theme.dim(command.description)}`);
-		io.console.write(`  ${theme.tool("/exit".padEnd(width + 1))}  ${theme.dim("leave the session")}`);
-		io.console.write("");
-		return;
-	}
-	const execution = await commands.execute(agent, line, signal);
-	if (execution === void 0) {
-		io.console.write(theme.error(`  unknown command: ${line}`));
-		return;
-	}
-	const { result } = execution;
-	const report = result.kind === "error" ? theme.error(result.text) : result.text;
-	if (report !== void 0 && report !== "") for (const reported of report.split("\n")) io.console.write(`  ${reported}`);
-	io.console.write("");
-}
-/** How long the second Escape has to arrive to recall the previous message. */
-const RECALL_WINDOW_MS = 1500;
-/** Turns longer than this ring the bell on completion, when the bell is on. */
-const BELL_TURN_MS = 1e4;
-/** A finished answer longer than this many rendered lines becomes a fold. */
-const ANSWER_FOLD_LINES = 24;
-/** How many of its head lines a collapsed answer keeps visible. */
-const ANSWER_HEAD_LINES = 8;
-/**
-* Run one subprocess and capture everything it printed.
-* @param file - the executable, or a shell when `shell` is given.
-* @param args - its arguments.
-* @param options - working directory, abort wiring, and an optional kill timer.
-* @returns the merged output and exit status; spawn failures come back as a
-*   nonzero code with the error message as output.
-*/
-function capture(file, args, options) {
-	return new Promise((resolve) => {
-		const child = spawn(file, args, {
-			cwd: options.cwd,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		});
-		let output = "";
-		const take = (chunk) => {
-			output += chunk.toString();
-		};
-		child.stdout.on("data", take);
-		child.stderr.on("data", take);
-		const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
-			child.kill("SIGTERM");
-		}, options.timeoutMs);
-		const onAbort = () => {
-			child.kill("SIGTERM");
-		};
-		options.signal?.addEventListener("abort", onAbort, { once: true });
-		child.on("error", (error) => {
-			resolve({
-				output: error.message,
-				code: 127,
-				signal: null
-			});
-		});
-		child.on("close", (code, signal) => {
-			if (timer !== void 0) clearTimeout(timer);
-			options.signal?.removeEventListener("abort", onAbort);
-			resolve({
-				output,
-				code,
-				signal
-			});
-		});
-	});
-}
-/**
-* Style one unified-diff line for the transcript.
-* @param line - the raw diff line.
-* @param theme - styling for additions, removals, and headers.
-* @returns the styled line.
-*/
-function diffLine(line, theme) {
-	if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("diff ") || line.startsWith("index ")) return theme.dim(line);
-	if (line.startsWith("@@")) return theme.tool(line);
-	if (line.startsWith("+")) return theme.success(line);
-	if (line.startsWith("-")) return theme.error(line);
-	return theme.dim(line);
-}
-/**
-* A moment's age as a person reads it.
-* @param epochMs - when it happened.
-* @returns e.g. `just now`, `5m ago`, `3h ago`, `2d ago`.
-*/
-function age(epochMs) {
-	const minutes = Math.floor((Date.now() - epochMs) / 6e4);
-	if (minutes < 1) return "just now";
-	if (minutes < 60) return `${minutes}m ago`;
-	const hours = Math.floor(minutes / 60);
-	if (hours < 24) return `${hours}h ago`;
-	return `${Math.floor(hours / 24)}d ago`;
-}
-/** The `/init` prompt: a canned task submitted through the ordinary turn path. */
-const INIT_PROMPT = `Analyze this repository and write an AGENTS.md file at its root for future coding agents.
-Cover: what the project is, the repository layout, how to build/test/lint (exact commands), code conventions worth enforcing, and any non-obvious constraints you find in configs or docs.
-If AGENTS.md (or CLAUDE.md) already exists, read it first and improve it rather than starting over. Keep it concise and factual.`;
-/**
-* Compose the agent this invocation asked for: a fresh session, or the
-* persisted one `--resume`/`--continue` names.
-* @param ctx - plugin context carrying the agent, preset, and query services.
-* @param config - the resolved invocation.
-* @param cwd - the session workspace.
-* @returns the live agent and the preset it composed, or undefined when the
-*   requested session could not be resolved.
-*/
-async function compose(ctx, config, cwd) {
-	const agents = ctx.get("agents");
-	const defaultModel = ctx.get("agentDefaultModel");
-	if (agents === void 0 || defaultModel === void 0) return void 0;
-	const selection = defaultModel.currentSelection();
-	const selected = {
-		current: selection,
-		assembled: void 0
-	};
-	const presets = ctx.get("agentPresets");
-	const preset = presets === void 0 ? void 0 : await presets.resolve(config.preset === "" ? void 0 : config.preset);
-	const setup = async (agentCtx) => {
-		installModelSelection(agentCtx, selected);
-		if (presets !== void 0 && preset !== void 0) await presets.mount(agentCtx, preset.id);
-	};
-	const agentOptions = {
-		provider: selection.provider,
-		model: selection.model
-	};
-	const createAnother = () => agents.create({
-		sessionId: SessionId(`session-${randomUUID()}`),
-		meta: {
-			cwd,
-			...preset === void 0 ? {} : { agentPreset: preset.id }
-		},
-		agentOptions,
-		setup
-	});
-	const resumeAnother = (id) => agents.resume({
-		resumeSessionId: id,
-		agentOptions,
-		setup
-	});
-	const composed = {
-		model: selection.model,
-		selection: selected,
-		createAnother,
-		resumeAnother,
-		...preset === void 0 ? {} : { presetId: preset.id }
-	};
-	if (config.resume === "") return {
-		handle: await createAnother(),
-		...composed
-	};
-	const resumeSessionId = config.resume === "latest" ? await latestSessionIn(ctx, cwd) : SessionId(config.resume);
-	if (resumeSessionId === void 0) return void 0;
-	return {
-		handle: await resumeAnother(resumeSessionId),
-		...composed
-	};
-}
-/**
-* Drive one terminal session from composition to exit.
-* @param ctx - plugin context carrying the core services and launcher IO.
-* @param config - the resolved invocation.
-* @param io - process-facing effects.
-*/
-async function run(ctx, config, io) {
-	await ctx.get("loader")?.await();
-	const sessions = ctx.get("sessions");
-	if (sessions === void 0) return;
-	const cwd = process.cwd();
-	const theme = createTheme(io.console.isTty, process.env);
-	const preset = await installPackagedPreset();
-	if (preset.installed) io.console.write(theme.dim(`installed preset into ${preset.path}`));
-	const composed = await compose(ctx, config, cwd);
-	if (composed === void 0) {
-		io.console.write(theme.error(`dsh: no session to resume${config.resume === "latest" ? ` in ${cwd}` : ""}`));
-		io.exit(1);
-		return;
-	}
-	const { model, presetId, selection } = composed;
-	const live = {
-		handle: composed.handle,
-		agent: composed.handle.agent,
-		transcript: new Transcript({
-			theme,
-			columns: io.console.columns,
-			cwd
-		}, presentersFor(ctx, composed.handle.agent))
-	};
-	const facts = (branch$1) => statusFacts(ctx, live.agent, cwd, selection, presetId, branch$1);
-	io.console.setTitle(`dsh code — ${basename(cwd)}`);
-	let branch = await gitBranch(cwd);
-	if (config.resume !== "") replay(live.agent.session, live.transcript, io);
-	for (const line of bannerLines({
-		model,
-		preset: presetId,
-		cwd,
-		branch,
-		session: live.agent.session.id,
-		readsKeys: io.console.readsKeys,
-		resumed: config.resume !== ""
-	}, theme, io.console.columns)) io.console.write(line);
-	const disposers = [];
-	const commands = ctx.get("commands");
-	/** The advertised model catalog, fetched once and refreshed per /model call. */
-	let modelCatalog = [];
-	const refreshModelCatalog = async () => {
-		const llm = ctx.get("llm");
-		if (llm === void 0) return;
-		const providers = llm.listProviders();
-		modelCatalog = (await Promise.all(providers.map(async (provider) => {
-			try {
-				return await llm.listModels(provider.id);
-			} catch {
-				return [];
-			}
-		}))).flat().map((entry) => ({
-			provider: entry.provider,
-			id: entry.id,
-			name: entry.name
-		}));
-	};
-	refreshModelCatalog();
-	/**
-	* Resolve a /model argument to a selection.
-	* @param typed - a bare model id, or an explicit `provider/model`.
-	* @returns the selection, or an error message naming what is available.
-	*/
-	const resolveModelArgument = (typed) => {
-		const slash = typed.indexOf("/");
-		if (slash > 0) return {
-			provider: typed.slice(0, slash),
-			model: typed.slice(slash + 1)
-		};
-		const hits = modelCatalog.filter((entry) => entry.id === typed);
-		if (hits.length === 1 && hits[0] !== void 0) return {
-			provider: hits[0].provider,
-			model: hits[0].id
-		};
-		if (hits.length > 1) return `"${typed}" is served by several providers; pick one: ${hits.map((hit) => `${hit.provider}/${hit.id}`).join(", ")}`;
-		const known = modelCatalog.map((entry) => entry.id).join(", ");
-		return known === "" ? `no catalog to match "${typed}" against; use the explicit provider/model form` : `unknown model "${typed}" (available: ${known}); provider/model also works`;
-	};
-	const custom = await loadCustomCommands([dshHomePath("commands"), join(cwd, ".dsh", "commands")], new Set([
-		...(commands?.list(live.agent) ?? []).map((entry) => entry.name),
-		"exit",
-		"quit",
-		"help",
-		"init",
-		"status",
-		"model",
-		"clear",
-		"resume",
-		"diff"
-	]));
-	for (const warning of custom.warnings) io.console.write(theme.dim(`  skipped ${warning}`));
-	const customByName = new Map(custom.commands.map((command) => [command.name, command]));
-	const completable = () => [
-		...commands?.list(live.agent) ?? [],
-		{
-			name: "init",
-			description: "analyze the repo and draft AGENTS.md"
-		},
-		...custom.commands.map((command) => ({
-			name: command.name,
-			description: command.description
-		})),
-		{
-			name: "exit",
-			description: "leave the session"
-		}
-	];
-	const completePath$1 = createCompleter(completable, cwd);
-	/**
-	* The first-argument candidates per command, read live: plan's argument
-	* depends on its state, permission's on the preset table, model's on the
-	* advisory catalog.
-	*/
-	const argumentsFor = (command, typed) => {
-		const offer = (values) => values.filter((entry) => entry.value.startsWith(typed));
-		if (command === "plan") return planModeFrom(live.agent.session.events) ? offer([{
-			value: "off",
-			detail: "leave plan mode"
-		}]) : [];
-		if (command === "permission") {
-			const presets = ctx.get("permissionPresets");
-			if (presets === void 0) return [];
-			const current = presets.current(live.agent.session.events);
-			return offer(presets.names.map((name$1) => ({
-				value: name$1,
-				detail: name$1 === current ? "current" : ""
-			})));
-		}
-		if (command === "model") {
-			const current = selection.current;
-			const exact = offer(modelCatalog.map((entry) => ({
-				value: entry.id,
-				detail: entry.provider === current?.provider && entry.id === current.model ? "current" : entry.name
-			})));
-			if (exact.length > 0 || typed === "") return exact;
-			return modelCatalog.map((entry) => ({
-				entry,
-				score: fuzzyScore(typed, entry.id)
-			})).filter((hit) => hit.score !== void 0).sort((a, b) => b.score - a.score).map((hit) => ({
-				value: hit.entry.id,
-				detail: hit.entry.name
-			}));
-		}
-		return [];
-	};
-	let onEscapeKey = () => {};
-	let onInterruptKey = () => {};
-	const prompt = new Prompt(io.console, theme, {
-		commands: completable,
-		paths: completePath$1,
-		commandArguments: argumentsFor
-	}, {
-		interrupt: () => {
-			onInterruptKey();
-		},
-		escape: () => {
-			onEscapeKey();
-		},
-		eof: () => {
-			io.console.close();
-		},
-		shiftTab: () => {
-			const line = planModeFrom(live.agent.session.events) ? "/plan off" : "/plan";
-			commands?.execute(live.agent, line, new AbortController().signal);
-		},
-		expandOutput: () => {
-			if (!io.console.toggleFolds()) prompt.write(theme.dim("  nothing to expand"));
-		}
-	}, "Ask anything · / for commands · @ for files · ⇧Tab plan mode");
-	let turnBaseTokens = 0;
-	const spinner = new Spinner({
-		setLive: (text) => {
-			prompt.setHint(text);
-		},
-		isTty: io.console.readsKeys
-	}, theme, {
-		verb: "working",
-		interrupt: io.console.readsKeys ? "ESC" : "Ctrl-C",
-		detail: () => {
-			const spent = (totalTokens(facts(branch).usage) ?? 0) - turnBaseTokens;
-			return spent > 0 ? `${formatTokens(spent)} tokens` : void 0;
-		}
-	});
-	const historyPath = dshHomePath("code-cli-history.json");
-	try {
-		const seeded = JSON.parse(await readFile(historyPath, "utf8"));
-		if (Array.isArray(seeded)) prompt.seedHistory(seeded.filter((entry) => typeof entry === "string"));
-	} catch {}
-	let adopt = () => {};
-	/**
-	* Swap the surface onto another session: new handle in, old one disposed.
-	* @param next - the replacement, already composed.
-	* @param replayLog - whether to render the session's existing events.
-	*/
-	const switchTo = async (next, replayLog) => {
-		await sessions.flush(live.agent.session);
-		const old = live.handle;
-		adopt(next, replayLog);
-		await old.dispose();
-	};
-	if (commands !== void 0) {
-		disposers.push(commands.register({
-			name: "status",
-			description: "show the model, composition, permissions, and token usage",
-			handler: () => ({
-				kind: "success",
-				text: statusReport(facts(branch), live.agent.session.id)
-			})
-		}));
-		disposers.push(commands.register({
-			name: "clear",
-			description: "start a fresh session in place",
-			handler: async () => {
-				await switchTo(await composed.createAnother(), false);
-				for (const line of bannerLines({
-					model,
-					preset: presetId,
-					cwd,
-					branch,
-					session: live.agent.session.id,
-					readsKeys: io.console.readsKeys,
-					resumed: false
-				}, theme, io.console.columns)) prompt.write(line);
-				return {
-					kind: "success",
-					text: `new session ${live.agent.session.id}`
-				};
-			}
-		}));
-		disposers.push(commands.register({
-			name: "resume",
-			description: "switch to an earlier session",
-			input: { hint: "[session-id]" },
-			handler: async ({ rawInput, signal }) => {
-				const typed = rawInput.trim();
-				const resume = async (id) => {
-					if (id === live.agent.session.id) return {
-						kind: "success",
-						text: "already on that session"
-					};
-					await switchTo(await composed.resumeAnother(id), true);
-					return {
-						kind: "success",
-						text: `resumed ${id}`
-					};
-				};
-				if (typed !== "") return resume(SessionId(typed));
-				const query = ctx.get("sessionQuery");
-				if (query === void 0) return {
-					kind: "error",
-					text: "session listing is unavailable in this composition"
-				};
-				const records = (await query.listSessions()).filter((record) => record.header.id !== live.agent.session.id);
-				const here = records.filter((record) => record.header.cwd === cwd);
-				const elsewhere = records.filter((record) => record.header.cwd !== cwd);
-				const listed = [...here, ...elsewhere].slice(0, 20);
-				if (listed.length === 0) return {
-					kind: "success",
-					text: "no other sessions recorded"
-				};
-				const titles = await Promise.all(listed.map(async (record) => {
-					try {
-						return (await query.readTitle(record.header.id, signal))?.title;
-					} catch {
-						return;
-					}
-				}));
-				const rows = listed.map((record, index) => ({
-					id: record.header.id,
-					label: titles[index] ?? String(record.header.id),
-					detail: `${age(record.header.createdAt)}${record.header.cwd === cwd ? "" : ` · ${record.header.cwd ?? ""}`}`
-				}));
-				if (!io.console.readsKeys) return {
-					kind: "success",
-					text: rows.map((row) => `${row.id}  ${row.label}  ${row.detail}`).join("\n")
-				};
-				const outcome = await prompt.select({
-					title: "Resume session",
-					options: rows.map((row) => ({
-						label: row.label,
-						detail: row.detail
-					}))
-				}, signal);
-				if (outcome.kind !== "chosen") return {
-					kind: "success",
-					text: "nothing resumed"
-				};
-				const picked = rows[outcome.indices[0] ?? -1];
-				if (picked === void 0) return {
-					kind: "success",
-					text: "nothing resumed"
-				};
-				return resume(picked.id);
-			}
-		}));
-		disposers.push(commands.register({
-			name: "diff",
-			description: "show uncommitted workspace changes",
-			handler: async ({ signal }) => {
-				const against = await capture("git", ["diff", "HEAD"], {
-					cwd,
-					signal
-				});
-				const diff = against.code === 0 ? against : await capture("git", ["diff"], {
-					cwd,
-					signal
-				});
-				if (diff.code !== 0) return {
-					kind: "error",
-					text: diff.output.trim() === "" ? "not a git repository" : diff.output.trim()
-				};
-				if (diff.output.trim() === "") return {
-					kind: "success",
-					text: "no uncommitted changes"
-				};
-				for (const line of diff.output.trimEnd().split("\n")) prompt.write(diffLine(line, theme));
-				return { kind: "success" };
-			}
-		}));
-		/**
-		* Make one route the session's model.
-		*
-		* Assigning the live ref is the switch; the next request reads it. The
-		* default is saved too, like the web surface — a failure there costs the
-		* default, never the session.
-		*/
-		const applyModel = async (provider, model$1) => {
-			selection.current = {
-				provider,
-				model: model$1
-			};
-			try {
-				await ctx.get("agentDefaultModel")?.saveSelection(selection.current);
-			} catch {}
-			refreshStatus();
-		};
-		disposers.push(commands.register({
-			name: "model",
-			description: "switch the model answering this session",
-			input: { hint: "[model|provider/model]" },
-			handler: async ({ rawInput }) => {
-				const typed = rawInput.trim();
-				if (typed === "") {
-					await refreshModelCatalog();
-					const current = selection.current;
-					const header = `current ${current?.provider ?? "?"}/${current?.model ?? "?"}`;
-					if (modelCatalog.length === 0) return {
-						kind: "success",
-						text: header
-					};
-					if (!io.console.readsKeys) return {
-						kind: "success",
-						text: `${header}\n${modelCatalog.map((entry) => {
-							return `${entry.provider === current?.provider && entry.id === current.model ? "❯" : " "} ${entry.provider}/${entry.id}  ${entry.name}`;
-						}).join("\n")}`
-					};
-					const outcome = await prompt.select({
-						title: "Switch model",
-						options: modelCatalog.map((entry) => {
-							const active = entry.provider === current?.provider && entry.id === current.model;
-							return {
-								label: `${entry.provider}/${entry.id}`,
-								detail: active ? `${entry.name} · current` : entry.name
-							};
-						})
-					});
-					if (outcome.kind !== "chosen") return {
-						kind: "success",
-						text: "model unchanged"
-					};
-					const picked = modelCatalog[outcome.indices[0] ?? -1];
-					if (picked === void 0) return {
-						kind: "success",
-						text: "model unchanged"
-					};
-					await applyModel(picked.provider, picked.id);
-					return {
-						kind: "success",
-						text: `model ${picked.provider}/${picked.id}`
-					};
-				}
-				if (modelCatalog.length === 0) await refreshModelCatalog();
-				const resolved = resolveModelArgument(typed);
-				if (typeof resolved === "string") return {
-					kind: "error",
-					text: resolved
-				};
-				await applyModel(resolved.provider, resolved.model);
-				return {
-					kind: "success",
-					text: `model ${resolved.provider}/${resolved.model}`
-				};
-			}
-		}));
-	}
-	const stream = new TextStream(theme, () => io.console.contentColumns);
-	let answerLines = [];
-	const finishAnswer = () => {
-		if (!stream.streamed) return;
-		const tail = stream.flush();
-		emit([...tail, ""]);
-		answerLines.push(...tail);
-		if (answerLines.length > ANSWER_FOLD_LINES) io.console.foldRecent(answerLines.length + 1, [
-			...answerLines.slice(0, ANSWER_HEAD_LINES),
-			theme.dim(`  … +${answerLines.length - ANSWER_HEAD_LINES} lines (Ctrl+O expands)`),
-			""
-		]);
-		answerLines = [];
-	};
-	const thinking = new TextStream(theme, () => io.console.contentColumns, true);
-	let thinkingLines = [];
-	let thinkingStartedAt = 0;
-	const flushThinking = () => {
-		thinkingLines.push(...thinking.flush());
-		if (thinkingLines.length === 0) return;
-		const seconds = ((performance.now() - thinkingStartedAt) / 1e3).toFixed(1);
-		prompt.setStreaming(void 0);
-		io.console.appendFold([theme.dim(`✻ thought for ${seconds}s · +${thinkingLines.length} lines (Ctrl+O expands)`), ""], [
-			theme.dim(`✻ thought for ${seconds}s`),
-			...thinkingLines,
-			""
-		]);
-		thinkingLines = [];
-		thinkingStartedAt = 0;
-	};
-	/**
-	* Append the lines an event produced, and show the line still being typed.
-	* @param lines - finished lines for the transcript.
-	* @param live - the in-progress line, or undefined to release the region.
-	*/
-	const emit = (lines, live$1) => {
-		if (lines.length > 0) prompt.setStreaming(void 0);
-		for (const line of lines) prompt.write(line);
-		prompt.setStreaming(live$1);
-	};
-	/** Push the always-current status row; the pipe shape prints it instead. */
-	const refreshStatus = () => {
-		if (!io.console.readsKeys) return;
-		prompt.setStatus(statusLine(facts(branch), theme, io.console.columns - 1));
-	};
-	if (planModeFrom(live.agent.session.events)) prompt.setAccent((text) => theme.pending(text));
-	refreshStatus();
-	ctx.on("session/event", (session, event) => {
-		if (session !== live.agent.session) return;
-		if (event.type === "plan/mode") prompt.setAccent(event.data.active ? (text) => theme.pending(text) : void 0);
-		refreshStatus();
-		if (config.print && event.type === "user/message") return;
-		if (event.type === "assistant/chunk") {
-			const { chunk } = event.data;
-			if (chunk.type === "reasoning-delta") {
-				if (chunk.text === "") return;
-				if (thinkingStartedAt === 0) thinkingStartedAt = performance.now();
-				const step$1 = thinking.push(chunk.text);
-				thinkingLines.push(...step$1.lines);
-				prompt.setStreaming(step$1.live ?? thinkingLines.at(-1) ?? theme.dim("✻ thinking"));
-				return;
-			}
-			if (chunk.type !== "text-delta") return;
-			flushThinking();
-			const step = stream.push(chunk.text);
-			emit(step.lines, step.live);
-			answerLines.push(...step.lines);
-			return;
-		}
-		if (event.type === "assistant/message") {
-			flushThinking();
-			if (stream.streamed) {
-				finishAnswer();
-				return;
-			}
-		}
-		const lines = live.transcript.render(event);
-		const full = live.transcript.takeFold();
-		if (full === void 0) {
-			emit(lines);
-			return;
-		}
-		prompt.setStreaming(void 0);
-		io.console.appendFold(lines, full);
-	});
-	/** Pause the indicator around a decision, and resume it if work continues. */
-	const whileDeciding = async (decide) => {
-		spinner.pause();
-		if (config.bell) io.console.bell();
-		try {
-			return await decide();
-		} finally {
-			if (live.agent.status === "running") spinner.start();
-		}
-	};
-	const approval = new TerminalApproval({ ask: (toolName, reason, signal) => whileDeciding(async () => {
-		if (!io.console.readsKeys) {
-			const detail = reason === void 0 ? "" : ` ${theme.dim(reason)}`;
-			prompt.write(`${theme.pending("?")} allow ${theme.tool(toolName)}${detail}`);
-			const line = await prompt.read(signal);
-			return line === void 0 ? void 0 : answerForKey(line) ?? "reject";
-		}
-		if (reason !== void 0) prompt.write(theme.dim(`  ${reason}`));
-		const outcome = await prompt.select({
-			title: `Allow ${toolName}?`,
-			options: [
-				{
-					label: "Yes, this time",
-					shortcut: "y"
-				},
-				{
-					label: `Yes, every ${toolName} call this session`,
-					shortcut: "a"
-				},
-				{
-					label: "No",
-					shortcut: "n"
-				}
-			]
-		}, signal);
-		if (outcome.kind !== "chosen") return void 0;
-		const [chosen] = outcome.indices;
-		return chosen === 0 ? "once" : chosen === 1 ? "always" : "reject";
-	}) }, theme, (line) => {
-		prompt.write(line);
-	});
-	ctx.on("approval/request", (req, next) => req.agent === live.agent ? approval.decide(req) : next());
-	adopt = (next, replayLog) => {
-		live.handle = next;
-		live.agent = next.agent;
-		live.transcript = new Transcript({
-			theme,
-			columns: io.console.columns,
-			cwd
-		}, presentersFor(ctx, next.agent));
-		io.console.clearScreen();
-		approval.clear();
-		turnBaseTokens = 0;
-		prompt.setAccent(planModeFrom(next.agent.session.events) ? (text) => theme.pending(text) : void 0);
-		if (replayLog) replay(next.agent.session, live.transcript, io);
-		refreshStatus();
-	};
-	const questions = ctx.get("userQuestions");
-	if (questions !== void 0) {
-		const terminalQuestions = new TerminalQuestions(prompt, theme, (line) => {
-			prompt.write(line);
-		}, io.console.readsKeys ? async (spec, signal) => prompt.select(spec, signal) : void 0);
-		questions.registerProvider({ ask: async (request) => whileDeciding(() => terminalQuestions.ask(request)) });
-	}
-	let running;
-	/**
-	* Stop whatever the agent is doing. Cancelling an idle agent is a no-op, so
-	* the report is withheld unless there was work to stop — an Escape pressed at
-	* an empty prompt should look like nothing happened.
-	* @returns whether anything was running.
-	*/
-	const interrupt = () => {
-		const busy = live.agent.status === "running" || running !== void 0;
-		spinner.stop();
-		running?.abort();
-		live.agent.cancel({ kind: "user" });
-		flushThinking();
-		finishAnswer();
-		if (busy) prompt.write(theme.dim("  interrupted"));
-		return busy;
-	};
-	/**
-	* Hand the terminal back and leave.
-	*
-	* The session's own screen disappears with it, so the few facts a person
-	* still needs — which session this was, what it cost, how to reopen it — are
-	* written to the buffer that survives instead.
-	* @param code - the exit status to request.
-	*/
-	const leave = (code) => {
-		prompt.clear();
-		io.console.close();
-		const usage = totalTokens(facts(branch).usage);
-		const spent = usage === void 0 || usage === 0 ? "" : ` · ${formatTokens(usage)} tokens`;
-		io.console.writeAfterScreen(theme.dim(`codsh session ${live.agent.session.id}${spent}`));
-		io.console.writeAfterScreen(theme.dim(`  reopen with: codsh --resume ${live.agent.session.id}`));
-		io.exit(code);
-	};
-	let lastInterrupt = 0;
-	let recallArmed;
-	onEscapeKey = () => {
-		if (interrupt()) return;
-		if (!prompt.empty) return;
-		const last = prompt.history.findLast((entry) => !entry.startsWith("/") && !entry.startsWith("!"));
-		if (last === void 0) return;
-		if (recallArmed !== void 0) {
-			clearTimeout(recallArmed);
-			recallArmed = void 0;
-			prompt.setHint(void 0);
-			prompt.prefill(last);
-			return;
-		}
-		prompt.setHint(theme.dim("  ESC again to edit your previous message"));
-		recallArmed = setTimeout(() => {
-			recallArmed = void 0;
-			prompt.setHint(void 0);
-		}, RECALL_WINDOW_MS);
-		recallArmed.unref();
-	};
-	onInterruptKey = () => {
-		const now = performance.now();
-		const repeated = now - lastInterrupt < INTERRUPT_EXIT_WINDOW_MS;
-		lastInterrupt = now;
-		if (!repeated && interrupt()) {
-			prompt.write(theme.dim("  Ctrl-C again to exit"));
-			return;
-		}
-		leave(130);
-	};
-	/**
-	* Run one turn and report what it cost.
-	*
-	* The summary is the answer to "was that expensive?" at the moment a person
-	* decides whether to keep going, which is why it lands with the turn rather
-	* than only in the status line.
-	* @param text - the person's message.
-	*/
-	const answer = async (text, source) => {
-		const before = totalTokens(facts(branch).usage) ?? 0;
-		turnBaseTokens = before;
-		const started = performance.now();
-		io.console.setTitle(`⚡ dsh code — ${basename(cwd)}`);
-		try {
-			await turn(live.agent, text, spinner, source);
-		} finally {
-			io.console.setTitle(`dsh code — ${basename(cwd)}`);
-		}
-		const spent = (totalTokens(facts(branch).usage) ?? 0) - before;
-		const elapsed = (performance.now() - started) / 1e3;
-		if (config.bell && elapsed * 1e3 > BELL_TURN_MS) io.console.bell();
-		const cost = spent > 0 ? ` · ${formatTokens(spent)} tokens` : "";
-		prompt.write(theme.dim(`  ${elapsed.toFixed(1)}s${cost}`));
-		prompt.write("");
-	};
-	if (config.print) {
-		await turn(live.agent, config.task, spinner);
-		flushThinking();
-		finishAnswer();
-		await sessions.flush(live.agent.session);
-		prompt.clear();
-		io.console.close();
-		io.exit(0);
-		return;
-	}
-	/**
-	* Run a `!` line locally and hand the outcome to the model as context.
-	*
-	* The command runs in the person's shell in the workspace; its output prints
-	* like a terminal card and is injected as a plugin-sourced message, so the
-	* next request sees what just happened without a turn being spent on it.
-	* @param command - the line after the `!`.
-	*/
-	const passthrough = async (command) => {
-		prompt.write(`${theme.user("›")} ${theme.tool(`!${command}`)}`);
-		running = new AbortController();
-		try {
-			const result = await capture(process.env["SHELL"] ?? "/bin/sh", ["-c", command], {
-				cwd,
-				signal: running.signal,
-				timeoutMs: config.bangTimeoutMs
-			});
-			const lines = result.output.trimEnd() === "" ? [] : result.output.trimEnd().split("\n");
-			const kept = lines.slice(0, config.bangOutputLines);
-			const dropped = lines.length - kept.length;
-			for (const line of kept) prompt.write(theme.dim(`  ${line}`));
-			if (dropped > 0) prompt.write(theme.dim(`  … ${dropped} more lines`));
-			const status = result.signal !== null ? theme.error(`  ✗ killed by ${result.signal}`) : result.code !== 0 ? theme.error(`  ✗ exit ${result.code ?? "?"}`) : void 0;
-			if (status !== void 0) prompt.write(status);
-			prompt.write("");
-			const report = [...kept, ...dropped > 0 ? [`… ${dropped} more lines`] : []].join("\n");
-			const exit = result.signal !== null ? `killed by ${result.signal}` : String(result.code ?? 0);
-			live.agent.inject(createUserMessage({
-				content: [{
-					type: "text",
-					text: `<bash-input>${command}</bash-input>\n<bash-output>\n${report}\n</bash-output>\n<bash-exit>${exit}</bash-exit>`
-				}],
-				source: {
-					kind: "plugin",
-					plugin: "coding-cli"
-				}
-			}));
-		} finally {
-			running = void 0;
-		}
-	};
-	io.console.enterScreen();
-	prompt.setEngaged(true);
-	if (config.task !== "") await answer(config.task);
-	let shownStatus;
-	for (;;) {
-		branch = await gitBranch(cwd);
-		if (io.console.readsKeys) refreshStatus();
-		else {
-			const status = statusLine(facts(branch), theme, io.console.columns);
-			if (status !== shownStatus) {
-				prompt.write(status);
-				shownStatus = status;
-			}
-		}
-		const line = await prompt.read();
-		if (line === void 0) break;
-		io.console.collapseFolds();
-		const trimmed = line.trim();
-		if (trimmed === "") continue;
-		if (trimmed === "/exit" || trimmed === "/quit") break;
-		if (trimmed.startsWith("!")) {
-			const command = trimmed.slice(1).trim();
-			if (command !== "") await passthrough(command);
-			continue;
-		}
-		if (trimmed.startsWith("/")) {
-			prompt.write(`${theme.user("›")} ${trimmed}`);
-			const [, name$1 = "", rest = ""] = /^\/(\S+)\s*([\s\S]*)$/.exec(trimmed) ?? [];
-			if (name$1 === "init") {
-				await answer(INIT_PROMPT, {
-					kind: "plugin",
-					plugin: "coding-cli"
-				});
-				continue;
-			}
-			const canned = customByName.get(name$1);
-			if (canned !== void 0) {
-				await answer(expandTemplate(canned.template, rest.trim()), {
-					kind: "plugin",
-					plugin: "coding-cli"
-				});
-				continue;
-			}
-			running = new AbortController();
-			try {
-				await runCommand(ctx, live.agent, trimmed, io, theme, running.signal);
-			} finally {
-				running = void 0;
-			}
-			continue;
-		}
-		await answer(trimmed);
-	}
-	await sessions.flush(live.agent.session);
-	try {
-		const worthRecalling = prompt.history.filter((entry) => entry !== "/exit" && entry !== "/quit");
-		await writeFile(historyPath, `${JSON.stringify(worthRecalling)}\n`);
-	} catch {}
-	for (const dispose of disposers.splice(0)) dispose();
-	prompt.setEngaged(false);
-	leave(0);
-}
-/**
-* Report an unexpected surface failure and request a failing exit.
-* @param io - process-facing effects.
-* @param error - the failure.
-*/
-function fail(io, error) {
-	io.console.close();
-	io.console.writeAfterScreen(`codsh: ${error instanceof Error ? error.message : String(error)}`);
-	io.exit(1);
-}
-/**
-* Mount the interactive terminal surface.
-* @param ctx - plugin context carrying core services and the launcher-provided exit request.
-* @param config - validated invocation config.
-*/
-function apply(ctx, config) {
-	const exit = ctx.get("appExit");
-	if (exit === void 0) throw new Error("coding-cli-runner: the launcher must provide ctx.appExit before the tree mounts");
-	const io = {
-		console: new TerminalConsole(internals.input, internals.output),
-		exit
-	};
-	const restore = () => {
-		io.console.leaveScreen();
-	};
-	process.once("exit", restore);
-	for (const signal of ["SIGTERM", "SIGHUP"]) process.once(signal, () => {
-		restore();
-		process.exit(signal === "SIGTERM" ? 143 : 129);
-	});
-	run(ctx, config, io).catch((error) => {
-		fail(io, error);
-	});
-}
-
-//#endregion
-export { Config, apply, inject, internals, name };