codsh-cli 0.1.0

package/lib/index.js

@@ -0,0 +1,4008 @@
+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 { 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
+/**
+* Terminal styling and display metrics: SGR sequences that degrade to plain
+* text off a TTY, and the display-column width a rendered string occupies.
+* @module codsh-cli/src/theme
+*/
+/** SGR codes applied by {@link Theme}, by role. */
+const SGR = {
+	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.reset}`;
+	return {
+		colored: true,
+		dim: wrap(palette ? "\x1B[38;5;245m" : SGR.dim),
+		bold: wrap(SGR.bold),
+		error: wrap(SGR.red),
+		success: wrap(SGR.green),
+		pending: wrap(SGR.yellow),
+		tool: wrap(SGR.cyan),
+		path: wrap(SGR.blue),
+		user: wrap(SGR.magenta),
+		syntax: {
+			keyword: wrap(SGR.magenta),
+			string: wrap(SGR.green),
+			number: wrap(SGR.cyan),
+			comment: wrap(SGR.dim)
+		}
+	};
+}
+/**
+* Inclusive code-point ranges rendered two columns wide by a terminal: the
+* East Asian Wide and Fullwidth classes of Unicode TR11, which cover the CJK
+* blocks, Hangul, the fullwidth forms, and the emoji planes this surface
+* prints.
+*/
+const WIDE_RANGES = [
+	[4352, 4447],
+	[11904, 12350],
+	[12353, 13311],
+	[13312, 19903],
+	[19968, 40959],
+	[40960, 42191],
+	[43360, 43391],
+	[44032, 55203],
+	[63744, 64255],
+	[65040, 65049],
+	[65072, 65135],
+	[65280, 65376],
+	[65504, 65510],
+	[127744, 128591],
+	[129280, 129535],
+	[131072, 196605],
+	[196608, 262141]
+];
+/** Matches one SGR sequence, which occupies no display column. */
+const SGR_PATTERN = /\u001B\[[0-9;]*m/gu;
+/**
+* Whether one code point occupies two display columns.
+* @param code - the code point to classify.
+* @returns true when the terminal renders it double-width.
+*/
+function isWide(code) {
+	return WIDE_RANGES.some(([low, high]) => code >= low && code <= high);
+}
+/**
+* Display columns a string occupies once printed, ignoring styling sequences.
+*
+* Combining marks are counted as zero and East Asian Wide/Fullwidth code
+* points as two, which is what a terminal's own cursor arithmetic does. This
+* covers the alignment and wrapping this surface needs; it is not a complete
+* grapheme segmenter, so a ZWJ emoji sequence still counts each joined code
+* point ({@link ../README.md | Known Limitations}).
+* @param text - the string to measure, possibly carrying SGR sequences.
+* @returns the number of display columns.
+*/
+function displayWidth(text) {
+	let width = 0;
+	for (const character of text.replace(SGR_PATTERN, "")) {
+		const code = character.codePointAt(0);
+		if (code === void 0) continue;
+		if (code >= 768 && code <= 879) continue;
+		width += isWide(code) ? 2 : 1;
+	}
+	return width;
+}
+/** 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 = code >= 768 && code <= 879 ? 0 : isWide(code) ? 2 : 1;
+		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";
+/**
+* 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}`)}`;
+	return [
+		...displayWidth(plain) + 4 <= columns ? framed(headline, displayWidth(plain), theme) : [truncate(plain, columns)],
+		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)),
+		""
+	];
+}
+
+//#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~";
+/** Sequences that resolve to one key, longest first so a prefix never wins. */
+const SEQUENCES = [
+	["\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;
+		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/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;
+/** Erase the current line from the cursor rightwards. */
+const CLEAR_LINE = "\x1B[K";
+/** Erase from the cursor to the end of the screen. */
+const CLEAR_BELOW = "\x1B[0J";
+/** Hide the cursor while a region is redrawn, so it does not visibly jump. */
+const HIDE_CURSOR = "\x1B[?25l";
+/** Show the cursor again. */
+const SHOW_CURSOR = "\x1B[?25h";
+/**
+* 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;
+	/** Rows currently drawn in the bottom region. */
+	regionRows = [];
+	/** Where among those rows the cursor was left. */
+	regionCursor = {
+		row: 0,
+		column: 0
+	};
+	/** Whether the region currently holds input focus, which shows the cursor. */
+	regionFocus = true;
+	constructor(input, output) {
+		this.input = input;
+		this.output = output;
+		if (this.readsKeys) {
+			input.setRawMode?.(true);
+			this.output.write(ENABLE_PASTE_MARKERS);
+			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);
+	}
+	/** 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);
+	}
+	/**
+	* Clear the visible screen.
+	*
+	* The scrollback survives — this wipes the viewport the way a shell's clear
+	* does. The managed region is forgotten with it, so the caller redraws.
+	*/
+	clearScreen() {
+		if (!this.readsKeys) return;
+		this.output.write("\x1B[2J\x1B[H");
+		this.regionRows = [];
+		this.regionCursor = {
+			row: 0,
+			column: 0
+		};
+	}
+	/**
+	* 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);
+		}
+	}
+	/**
+	* Write one finished line above the managed region.
+	*
+	* The region is erased first and redrawn after, so the transcript stays
+	* append-only while the input box keeps its place at the bottom.
+	* @param line - the line, without its terminator.
+	*/
+	write(line) {
+		if (this.regionRows.length === 0) {
+			this.output.write(`${line}\n`);
+			return;
+		}
+		const rows = this.regionRows;
+		const cursor = this.regionCursor;
+		this.eraseRegion();
+		this.output.write(`${line}\n`);
+		this.drawRegion(rows, cursor, this.regionFocus);
+	}
+	/**
+	* Replace the managed region at the bottom of the screen.
+	*
+	* This is the whole live area: an input box, a completion menu, a working
+	* indicator. Everything the transcript keeps goes through {@link write}
+	* instead, because a terminal cannot revise a row that has scrolled. 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 region holds input focus. Without it the cursor
+	*   stays hidden: a block cursor parked on a display row (the status line,
+	*   a streaming line) reads as content colliding with it.
+	*/
+	setRegion(rows, cursor, focus = true) {
+		if (!this.readsKeys) return;
+		this.eraseRegion();
+		this.drawRegion(rows, cursor, focus);
+		this.regionRows = [...rows];
+		this.regionCursor = { ...cursor };
+		this.regionFocus = focus;
+	}
+	/** Remove the region, leaving the cursor where the next write will land. */
+	clearRegion() {
+		if (this.regionRows.length === 0) return;
+		this.eraseRegion();
+		if (!this.regionFocus) this.output.write(SHOW_CURSOR);
+		this.regionRows = [];
+		this.regionCursor = {
+			row: 0,
+			column: 0
+		};
+		this.regionFocus = true;
+	}
+	/** Move to the region's first row and erase everything from there down. */
+	eraseRegion() {
+		if (this.regionRows.length === 0) return;
+		const up = this.regionCursor.row > 0 ? `\u001B[${this.regionCursor.row}A` : "";
+		this.output.write(`${HIDE_CURSOR}${up}\r${CLEAR_BELOW}`);
+	}
+	/**
+	* Draw rows from the cursor down and place the cursor among them.
+	* @param rows - the rows to draw.
+	* @param cursor - the target position.
+	* @param focus - whether to show the cursor at that position afterwards.
+	*/
+	drawRegion(rows, cursor, focus = true) {
+		if (rows.length === 0) return;
+		const fitted = rows.map((row) => truncate(row, this.columns - 1));
+		const body = fitted.map((row) => `${CLEAR_LINE}${row}`).join("\n");
+		const back = fitted.length - 1 - cursor.row;
+		const up = back > 0 ? `\u001B[${back}A` : "";
+		const right = cursor.column > 0 ? `\u001B[${cursor.column}C` : "";
+		this.output.write(`${HIDE_CURSOR}${body}${up}\r${right}${focus ? SHOW_CURSOR : ""}`);
+	}
+	/** 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() {
+		this.clearRegion();
+		if (this.escapeTimer !== void 0) clearTimeout(this.escapeTimer);
+		if (this.readsKeys) {
+			this.output.write(SHOW_CURSOR);
+			this.output.write(DISABLE_PASTE_MARKERS);
+			this.input.setRawMode?.(false);
+			this.input.pause();
+		}
+		this.rl?.close();
+		this.end();
+	}
+};
+
+//#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 menu = view.candidates.slice(0, MENU_LIMIT);
+		const width = Math.max(...menu.map((candidate) => displayWidth(candidate.value)));
+		menu.forEach((candidate, index) => {
+			const chosen = index === view.selected;
+			const matched = view.token !== "" && candidate.value.startsWith(view.token) ? view.token.length : 0;
+			const head = theme.tool(candidate.value.slice(0, matched));
+			const tail = candidate.value.slice(matched);
+			const label = `${head}${chosen ? theme.bold(tail) : 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));
+		});
+		if (view.candidates.length > menu.length) rows.push(theme.dim(`  … ${view.candidates.length - menu.length} 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. */
+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))];
+		this.spec.options.forEach((option, index) => {
+			rows.push(this.row(index, this.label(option, theme), option.detail, theme, columns));
+		});
+		if (this.spec.custom !== void 0) rows.push(this.row(this.spec.options.length, theme.dim(this.spec.custom), void 0, theme, columns));
+		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(label) : label}${trail}`, columns);
+	}
+};
+
+//#endregion
+//#region src/prompt.ts
+/** 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;
+	/** 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;
+	/**
+	* 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) {
+		this.hint = text;
+		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;
+		}
+		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);
+				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)));
+		}
+		if (this.hint !== void 0) rows.push(this.hint);
+		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) {
+	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 theme.bold(starBold.slice(2, -2));
+		if (underBold !== void 0) return theme.bold(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 theme.bold(starEm.slice(1, -1));
+		if (underEm !== void 0) return theme.bold(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, or fall back to its source lines.
+*
+* Cells print verbatim — padding is by display width, and styled text would
+* make the two disagree. Only the frame carries styling: the header is bold and
+* the rule under it dim.
+* @param rows - the raw `|`-delimited lines, in order.
+* @param theme - styling for the frame.
+* @param budget - display columns available; a wider table degrades to source.
+* @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 cells = rows.map((row) => row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim()));
+	const delimiter = cells[1];
+	if (cells.length < 2 || delimiter === void 0 || !delimiter.every((cell) => TABLE_DELIMITER.test(cell))) return asSource();
+	const body = [cells[0] ?? [], ...cells.slice(2)];
+	const count = Math.max(...body.map((row) => row.length));
+	const widths = Array.from({ length: count }, (_, column) => Math.max(...body.map((row) => displayWidth(row[column] ?? ""))));
+	if (widths.reduce((sum, width) => sum + width, 0) + 2 * (count - 1) > budget) return asSource();
+	const aligned = (row) => Array.from({ length: count }, (_, column) => {
+		const cell = row[column] ?? "";
+		const pad = " ".repeat(Math.max(0, (widths[column] ?? 0) - displayWidth(cell)));
+		return /^:?-+:$/.test(delimiter[column] ?? "") && !/^:-+:$/.test(delimiter[column] ?? "") ? `${pad}${cell}` : `${cell}${pad}`;
+	}).join("  ").trimEnd();
+	return [
+		theme.bold(aligned(cells[0] ?? [])),
+		theme.dim(widths.map((width) => "─".repeat(width)).join("  ")),
+		...cells.slice(2).map((row) => aligned(row))
+	];
+}
+/**
+* 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.
+	*/
+	start() {
+		if (this.timer !== void 0 || !this.surface.isTty) return;
+		this.startedAt = this.now();
+		this.frame = 0;
+		this.draw();
+		this.timer = setInterval(() => {
+			this.frame += 1;
+			this.draw();
+		}, TICK_MS);
+		this.timer.unref();
+	}
+	/** Stop the indicator and clear its line. */
+	stop() {
+		if (this.timer === void 0) return;
+		clearInterval(this.timer);
+		this.timer = void 0;
+		this.surface.setLive(void 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 summarizes the rest. */
+const MAX_DIFF_LINES = 40;
+/** Result body lines printed for one completed call before the card summarizes the rest. */
+const MAX_RESULT_LINES = 16;
+/**
+* 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} more lines`)];
+}
+/** Renders one session's appended events as terminal lines. */
+var Transcript = class {
+	calls = /* @__PURE__ */ new Map();
+	/** The most recent result whose body the cap clipped, kept in full. */
+	clipped;
+	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");
+			if (raw.length > MAX_RESULT_LINES) this.clipped = {
+				title: "(result)",
+				lines: raw
+			};
+			return [
+				`${marker} ${theme.dim("(result)")}`,
+				...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);
+		if (full !== void 0) this.clipped = {
+			title,
+			lines: full
+		};
+		return [
+			...failed || title !== pending.title ? [`${marker} ${theme.tool(title)}${suffix === "" ? "" : ` ${suffix}`}`] : suffix !== "" ? [`  ${suffix}`] : body.length === 0 ? [`  ${theme.success("✓")}`] : [],
+			...body,
+			""
+		];
+	}
+	/**
+	* The last clipped result, rendered without its cap.
+	*
+	* Ctrl-O's answer. The full body is kept from the render itself because a
+	* tool's own output limits are upstream of the log — this is everything the
+	* model saw, which is everything recoverable.
+	* @returns the header and full body, or undefined when nothing was clipped.
+	*/
+	expandLast() {
+		if (this.clipped === void 0) return void 0;
+		const { theme } = this.options;
+		return [
+			`${theme.dim("—")} ${theme.tool(this.clipped.title)} ${theme.dim("— full output —")}`,
+			...this.clipped.lines,
+			""
+		];
+	}
+	/**
+	* 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;
+/**
+* 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: () => {
+			const full = live.transcript.expandLast();
+			if (full === void 0) {
+				prompt.write(theme.dim("  no clipped output to expand"));
+				return;
+			}
+			for (const line of full) prompt.write(line);
+		}
+	}, "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);
+				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.columns);
+	const thinking = new TextStream(theme, () => io.console.columns, true);
+	/**
+	* 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;
+				spinner.stop();
+				if (!thinking.streamed) emit([theme.dim("✻ thinking")]);
+				const step$1 = thinking.push(chunk.text);
+				emit(step$1.lines, step$1.live);
+				return;
+			}
+			if (chunk.type !== "text-delta") return;
+			spinner.stop();
+			if (thinking.streamed) emit([...thinking.flush(), ""]);
+			const step = stream.push(chunk.text);
+			emit(step.lines, step.live);
+			return;
+		}
+		if (event.type === "assistant/message") {
+			if (thinking.streamed) emit([...thinking.flush(), ""]);
+			if (stream.streamed) {
+				emit([...stream.flush(), ""]);
+				if (live.agent.status === "running") spinner.start();
+				return;
+			}
+		}
+		emit(live.transcript.render(event));
+	});
+	/** Pause the indicator around a decision, and resume it if work continues. */
+	const whileDeciding = async (decide) => {
+		spinner.stop();
+		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));
+		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" });
+		if (thinking.streamed) emit([...thinking.flush(), ""]);
+		if (stream.streamed) emit([...stream.flush(), ""]);
+		if (busy) prompt.write(theme.dim("  interrupted"));
+		return busy;
+	};
+	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;
+		}
+		prompt.clear();
+		io.console.close();
+		io.exit(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);
+		if (thinking.streamed) emit([...thinking.flush(), ""]);
+		if (stream.streamed) emit([...stream.flush(), ""]);
+		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;
+		}
+	};
+	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;
+		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);
+	prompt.clear();
+	io.console.write(theme.dim(`session ${live.agent.session.id}`));
+	io.console.close();
+	io.exit(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.write(`dsh: ${error instanceof Error ? error.message : String(error)}`);
+	io.console.close();
+	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
+	};
+	run(ctx, config, io).catch((error) => {
+		fail(io, error);
+	});
+}
+
+//#endregion
+export { Config, apply, inject, internals, name };