codsh-bundle 0.6.0 → 0.7.0

package/lib/index.js

@@ -4,6 +4,7 @@ import { copyFile, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node
 import { basename, dirname, join, parse } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { isUserInvocable } from "@deepseek-ai/dsh-skill";
 import { admitEncodedImages, isImageAdmissionError } from "@deepseek-ai/dsh-attachment";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
@@ -314,14 +315,15 @@ async function gitBranch(cwd) {
 * 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.
+* @param columns - display columns available; a longer line is cut, never
+*   wrapped. Omit to keep the full line, so a later paint can re-fit it.
 * @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([
+	const line = [
 		theme.tool(facts.model),
 		...facts.preset === void 0 ? [] : [theme.dim(facts.preset)],
 		...facts.permission === void 0 ? [] : [theme.dim(facts.permission)],
@@ -329,7 +331,8 @@ function statusLine(facts, theme, columns) {
 		...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);
+	].join(theme.dim(" · "));
+	return columns === void 0 ? line : truncate(line, columns);
 }
 /**
 * Render the fuller readout `/status` answers with.
@@ -370,21 +373,59 @@ function statusReport(facts, session) {
 /** The product name, shown as the framed headline. */
 const NAME$1 = "dsh code";
 /**
-* The lettermark, drawn in half-block glyphs.
+* Half-block sprite of `assets/logo.svg`: a › chevron, a hull, a wave, and a
+* whale tail. Each character is two vertical pixels (`▀` `▄` `█`).
 *
-* Forty columns wide: it fits an eighty-column terminal with room to spare,
-* and anything narrower falls back to the plain headline anyway.
+* `.` empty, `c` chevron, `h` hull, `w` water and fluke.
 */
-const LOGO = [
-	" ██████╗ ██████╗ ██████╗ ███████╗██╗  ██╗",
-	"██╔════╝██╔═══██╗██╔══██╗██╔════╝██║  ██║",
-	"██║     ██║   ██║██║  ██║███████╗███████║",
-	"██║     ██║   ██║██║  ██║╚════██║██╔══██║",
-	"╚██████╗╚██████╔╝██████╔╝███████║██║  ██║",
-	" ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝"
+const SPRITE = [
+	"........c...........",
+	"........ccc.........",
+	"........c.ccc.......",
+	"........c..cc.......",
+	"........c.ccc.......",
+	"........ccc.........",
+	"......hhhhhhhh......",
+	".......hhhhhh.......",
+	"....w.ww..ww.ww.....",
+	"....wwwwwwwwwwww....",
+	".....w...ww...w.....",
+	"......ww.ww.ww......",
+	".......ww..ww.......",
+	"........wwww........"
 ];
-/** Display width of the widest logo row. */
-const LOGO_WIDTH = 41;
+/** Display width of the sprite, plus the leading pad. */
+const LOGO_WIDTH = SPRITE[0].length + 1;
+/** Truecolor fills matching `assets/logo.svg`, used only on a coloured TTY. */
+const FILL = {
+	c: "\x1B[38;2;126;150;245m",
+	h: "\x1B[38;2;238;241;251m",
+	w: "\x1B[38;2;61;86;214m"
+};
+/**
+* Paint one half-block cell from a pair of pixels.
+*/
+function paintCell(upper, lower, theme) {
+	const ink = (role, ch) => theme.colored ? `${FILL[role]}${ch}\u001B[0m` : ch;
+	if (upper === ".") return lower === "." ? " " : ink(lower, "▄");
+	if (lower === ".") return ink(upper, "▀");
+	if (upper === lower) return ink(upper, "█");
+	return ink(upper, "▀");
+}
+/**
+* Paint the first-screen mark as half-block rows.
+*/
+function logoLines(theme) {
+	const rows = [];
+	for (let y = 0; y < SPRITE.length; y += 2) {
+		const top = SPRITE[y] ?? "";
+		const bot = SPRITE[y + 1] ?? "";
+		let line = " ";
+		for (let x = 0; x < top.length; x += 1) line += paintCell(top[x] ?? ".", bot[x] ?? ".", theme);
+		rows.push(line);
+	}
+	return rows;
+}
 /**
 * Frame one headline in a rounded box sized to its content.
 *
@@ -423,11 +464,11 @@ function bannerLines(facts, theme, columns) {
 		theme.dim(truncate(`  /help for commands · Tab completes · ⇧Tab plan mode · ${interrupt} interrupts · /exit leaves`, columns)),
 		""
 	];
-	if (facts.readsKeys && !facts.resumed && columns >= LOGO_WIDTH + 2) return [
+	if (facts.readsKeys && !facts.resumed && columns >= Math.max(LOGO_WIDTH + 2, 40)) return [
 		"",
-		...LOGO.map((row) => theme.user(` ${row}`)),
+		...logoLines(theme),
 		"",
-		` ${theme.bold("✻ Welcome to codsh")}${theme.dim(` · ${composition}`)}`,
+		truncate(` ${theme.bold("✻ Welcome to codsh")}${theme.dim(` · ${composition}`)}`, columns),
 		"",
 		...details
 	];
@@ -479,6 +520,33 @@ function fuzzyScore(needle, hay) {
 	}
 	return score * 100 - have.length;
 }
+/**
+* Rank candidates that contain `typed`, prefix hits first.
+*
+* A fragment anywhere in the name is enough to offer it; an exact prefix still
+* outranks a buried hit, so `/p` keeps `plan` above `compact`.
+* @param items - the candidates.
+* @param typed - what was typed, without a leading `/` `$` `@`.
+* @param nameOf - the name to match against.
+* @returns matching items, prefix then substring.
+*/
+function rankContains(items, typed, nameOf) {
+	if (typed === "") return [...items];
+	const needle = typed.toLowerCase();
+	const prefixed = [];
+	const contained = [];
+	for (const item of items) {
+		const have = nameOf(item).toLowerCase();
+		if (have.startsWith(needle)) prefixed.push(item);
+		else if (have.includes(needle)) contained.push(item);
+	}
+	contained.sort((left, right) => {
+		const a = nameOf(left).toLowerCase();
+		const b = nameOf(right).toLowerCase();
+		return a.indexOf(needle) - b.indexOf(needle) || a.length - b.length;
+	});
+	return [...prefixed, ...contained];
+}
 let cached;
 /**
 * Walk the workspace into a flat list of relative paths.
@@ -558,20 +626,20 @@ function createCompleter(commands, cwd) {
 		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];
+		return [rankContains(commands(), typed, (command) => command.name).map((command) => `/${command.name}`).slice(0, LIMIT), line];
 	};
 }
+/**
+* Turn `$name` skill gestures into the `/name` tokens dsh injects.
+*
+* Only names in `known` are rewritten, so an ordinary `$amount` stays prose.
+* @param text - the submitted line.
+* @param known - user-invocable skill names.
+* @returns the line with known `$name` tokens rewritten as `/name`.
+*/
+function expandSkillGestures(text, known) {
+	return text.replace(/(^|\s)\$([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/g, (match, bound, name$1) => known.has(name$1) ? `${bound}/${name$1}` : match);
+}
 
 //#endregion
 //#region src/custom-commands.ts
@@ -795,6 +863,8 @@ const CONTROLS = {
 	"\f": { kind: "clear-screen" },
 	"": { kind: "expand-output" },
 	"": { kind: "toggle-todos" },
+	"": { kind: "history-search" },
+	"": { kind: "transcript-search" },
 	"": { kind: "kill-input" },
 	"": { kind: "paste-image" },
 	"": { kind: "kill-word" }
@@ -1056,6 +1126,8 @@ function wrapStyled(text, columns) {
 //#region src/screen.ts
 /** Logical transcript lines kept before the oldest are dropped. */
 const MAX_SCROLLBACK = 5e3;
+/** Blank columns to the left of every painted row, so text is not flush to the window. */
+const GUTTER = 2;
 /** Enter the alternate screen, saving the cursor and the current buffer. */
 const ENTER_ALT = "\x1B[?1049h";
 /** Leave it, restoring both. */
@@ -1108,23 +1180,30 @@ const STYLES = /\u001B\[[0-9;]*m/gu;
 const INVERSE = "\x1B[7m";
 /** End reverse video only, leaving any other attributes alone. */
 const INVERSE_OFF = "\x1B[27m";
-/** Start underline, which is how the block under the pointer shows itself. */
-const UNDERLINE = "\x1B[4m";
-/** End underline only, leaving any other attributes alone. */
-const UNDERLINE_OFF = "\x1B[24m";
+/** Dark-background hover fill, a slight lift off the default black. */
+const FILL_DARK = "\x1B[48;5;236m";
+/** Light-background hover fill, a slight drop off the default white. */
+const FILL_LIGHT = "\x1B[48;5;253m";
+/** Restore the terminal's default background, leaving other attributes. */
+const FILL_OFF = "\x1B[49m";
 /** A full SGR reset, which every styled span this surface prints ends with. */
 const RESET = "\x1B[0m";
 /**
-* Underline a whole rendered row.
+* Fill a row with the hover panel colour, padded to the content width.
 *
 * Every styled span this surface prints ends in a full reset, which would drop
-* the underline partway along the row — so the attribute is armed again after
-* each one, and turned off alone at the end so nothing else is disturbed.
+* the fill partway along the row — so the attribute is armed again after each
+* one, and turned off alone at the end. Spaces pad to the viewport width so
+* the block reads as a panel, the way opencode fills `backgroundElement`.
 * @param row - the styled row.
-* @returns the row, underlined end to end.
+* @param columns - display columns the panel should occupy.
+* @param light - whether the terminal background is light.
+* @returns the row, filled end to end.
 */
-function underline(row) {
-	return `${UNDERLINE}${row.replaceAll(RESET, `${RESET}${UNDERLINE}`)}${UNDERLINE_OFF}`;
+function fill(row, columns, light) {
+	const bg = light ? FILL_LIGHT : FILL_DARK;
+	const pad = Math.max(0, columns - displayWidth(row));
+	return `${bg}${`${row}${" ".repeat(pad)}`.replaceAll(RESET, `${RESET}${bg}`)}${FILL_OFF}`;
 }
 /**
 * The string index where a display column begins.
@@ -1173,12 +1252,16 @@ var Screen = class {
 	offset = 0;
 	/** What to show while scrolled back, drawn over the viewport's top row. */
 	notice = "";
+	/** Completion menu painted over the viewport, just above the chrome. */
+	overlay = [];
 	/** A mouse selection over the transcript, in physical-row coordinates. */
 	selection;
 	/** Collapsed blocks in the transcript, in order, with both of their forms. */
 	folds = [];
 	/** The block the pointer rests on, or undefined when it rests on none. */
 	hovered;
+	/** Whether OSC 11 named a light background; the hover fill picks a shade. */
+	light = false;
 	/**
 	* Physical row ranges the blocks occupy, or undefined when they need
 	* measuring again.
@@ -1191,22 +1274,51 @@ var Screen = class {
 	ranges;
 	/** Whether the folds currently show their full form. */
 	expanded = false;
+	/** Incremental find over the owned scrollback, absent when find is closed. */
+	find;
 	/** The last painted frame, so a repaint only touches rows that changed. */
 	painted = [];
 	/** Width the current frame was painted at, to detect a resize. */
 	paintedColumns = 0;
 	active = false;
+	/** Opens a child session when a view-card is clicked. */
+	enterHandler;
 	constructor(host) {
 		this.host = host;
 	}
+	/**
+	* What a click on a view-card does.
+	* @param handler - receives the child session id; omit to restore folding.
+	*/
+	setEnter(handler) {
+		this.enterHandler = handler;
+	}
 	/** Whether the alternate screen is currently held. */
 	get entered() {
 		return this.active;
 	}
+	/**
+	* Adopt the light- or dark-background hover fill.
+	* @param light - true when OSC 11 named a light color.
+	*/
+	setLight(light) {
+		if (this.light === light) return;
+		this.light = light;
+		if (this.hovered !== void 0) this.render();
+	}
 	/** Physical rows scrolled up out of view; zero means the tail is showing. */
 	get scrolledBy() {
 		return this.offset;
 	}
+	/** Incremental find over the scrollback, absent when find is closed. */
+	get transcriptSearch() {
+		if (this.find === void 0) return void 0;
+		return {
+			query: this.find.query,
+			hits: this.find.hits.length,
+			index: this.find.index
+		};
+	}
 	/** Take the alternate screen and start reporting the mouse. */
 	enter() {
 		if (this.active) return;
@@ -1273,8 +1385,9 @@ var Screen = class {
 	* @param full - the expanded lines, already styled.
 	* @param rule - a styled left rule for the whole block, `''` for none.
 	* @param label - what the block is, for the hover readout that names it.
+	* @param enter - child session a click opens instead of folding, when set.
 	*/
-	appendFold(summary, full, rule = "", label = "") {
+	appendFold(summary, full, rule = "", label = "", enter) {
 		const shown = this.expanded ? full : summary;
 		this.folds.push({
 			at: this.logical.length,
@@ -1283,7 +1396,8 @@ var Screen = class {
 			full: [...full],
 			expanded: this.expanded,
 			rule,
-			label
+			label,
+			...enter === void 0 ? {} : { enter }
 		});
 		this.append(shown, rule);
 	}
@@ -1354,6 +1468,10 @@ var Screen = class {
 	clickFold(row) {
 		const fold = this.foldAt(row);
 		if (fold === void 0) return;
+		if (fold.enter !== void 0 && this.enterHandler !== void 0) {
+			this.enterHandler(fold.enter);
+			return;
+		}
 		this.setFold(fold, !fold.expanded);
 	}
 	/**
@@ -1474,6 +1592,18 @@ var Screen = class {
 		if (this.offset > 0) this.render();
 	}
 	/**
+	* Float rows over the viewport just above the chrome.
+	*
+	* The chrome's height does not change, so opening a completion menu cannot
+	* shake the transcript. Empty clears the layer.
+	* @param rows - the overlay, top to bottom.
+	*/
+	setOverlay(rows) {
+		if (rows.length === this.overlay.length && rows.every((row, index) => row === this.overlay[index])) return;
+		this.overlay = [...rows];
+		this.render();
+	}
+	/**
 	* Scroll the transcript.
 	* @param delta - rows to move; negative scrolls back into history.
 	*/
@@ -1498,6 +1628,78 @@ var Screen = class {
 		this.render();
 	}
 	/**
+	* Search the owned scrollback.
+	*
+	* Hits are physical rows, case-insensitive. A new query starts on the
+	* newest hit so recent output is what find lands on first.
+	* @param query - the needle; empty means no hits yet.
+	* @returns the current find state.
+	*/
+	searchTranscript(query) {
+		const hits = [];
+		const needle = query.toLowerCase();
+		if (needle !== "") for (const [row, line] of this.physical.entries()) {
+			const lower = line.replaceAll(STYLES, "").toLowerCase();
+			let from = 0;
+			for (;;) {
+				const at = lower.indexOf(needle, from);
+				if (at < 0) break;
+				hits.push({
+					row,
+					start: at,
+					end: at + needle.length
+				});
+				from = at + needle.length;
+			}
+		}
+		const index = hits.length === 0 ? 0 : hits.length - 1;
+		this.find = {
+			query,
+			hits,
+			index
+		};
+		this.revealFindHit();
+		return {
+			query,
+			hits: hits.length,
+			index
+		};
+	}
+	/**
+	* Step to another hit of the current query.
+	* @param direction - 1 towards the tail, -1 towards the head.
+	* @returns the current find state, or undefined when find is closed.
+	*/
+	nextTranscriptHit(direction) {
+		if (this.find === void 0 || this.find.hits.length === 0) return this.transcriptSearch;
+		const count = this.find.hits.length;
+		this.find.index = (this.find.index + direction + count) % count;
+		this.revealFindHit();
+		return this.transcriptSearch;
+	}
+	/** Close find. Transcript content is untouched. */
+	clearTranscriptSearch() {
+		if (this.find === void 0) return;
+		this.find = void 0;
+		this.render();
+	}
+	/** Scroll so the current hit is in the viewport, then paint. */
+	revealFindHit() {
+		const hit = this.find?.hits[this.find.index];
+		if (hit === void 0) {
+			this.render();
+			return;
+		}
+		const height = this.viewportHeight();
+		const end = this.physical.length - this.offset;
+		const start = Math.max(0, end - height);
+		if (hit.row < start || hit.row >= end) {
+			const limit = Math.max(0, this.physical.length - height);
+			this.offset = Math.min(limit, Math.max(0, this.physical.length - hit.row - 1));
+		}
+		this.render();
+	}
+	/**
 	* Drop the transcript, keeping the chrome.
 	*
 	* Ctrl-L on a shared terminal clears a viewport the person may want back; on
@@ -1511,6 +1713,7 @@ var Screen = class {
 		this.folds = [];
 		this.ranges = void 0;
 		this.hovered = void 0;
+		this.find = void 0;
 		this.expanded = false;
 		this.offset = 0;
 		this.painted = [];
@@ -1535,6 +1738,13 @@ var Screen = class {
 	* every time, so a caller need not track the changes itself.
 	*/
 	mouseMove(row, column) {
+		if (this.coversOverlay(row)) {
+			if (this.hovered !== void 0) {
+				this.hovered = void 0;
+				this.render();
+			}
+			return;
+		}
 		const at = this.locate(row, column, false);
 		const fold = at === void 0 ? void 0 : this.foldAt(at.row);
 		if (fold !== this.hovered) {
@@ -1545,7 +1755,8 @@ var Screen = class {
 		return {
 			label: fold.label,
 			lines: fold.full.length,
-			expanded: fold.expanded
+			expanded: fold.expanded,
+			...fold.enter === void 0 ? {} : { enter: true }
 		};
 	}
 	/**
@@ -1560,6 +1771,10 @@ var Screen = class {
 	mouseDown(row, column) {
 		const had = this.selection !== void 0;
 		this.selection = void 0;
+		if (this.coversOverlay(row)) {
+			if (had) this.render();
+			return;
+		}
 		const at = this.locate(row, column, false);
 		if (at !== void 0) this.selection = {
 			anchor: at,
@@ -1639,6 +1854,13 @@ var Screen = class {
 	* way dragging past an edge keeps selecting, instead of refusing it.
 	* @returns the position, or undefined when it misses the content.
 	*/
+	/** Whether a terminal row sits on the floating completion layer. */
+	coversOverlay(row) {
+		if (this.overlay.length === 0) return false;
+		const chromeStart = this.host.rows() - this.chrome.length;
+		const overlayStart = chromeStart - this.overlay.length;
+		return row - 1 >= overlayStart && row - 1 < chromeStart;
+	}
 	locate(row, column, clamp) {
 		if (this.physical.length === 0) return void 0;
 		const height = this.viewportHeight();
@@ -1649,7 +1871,7 @@ var Screen = class {
 		index = Math.min(Math.max(index, start), end - 1);
 		return {
 			row: index,
-			column: Math.max(0, column - 1)
+			column: Math.max(0, column - 1 - GUTTER)
 		};
 	}
 	/** Rows the transcript viewport occupies. */
@@ -1658,7 +1880,7 @@ var Screen = class {
 	}
 	/** Columns content is laid out for, one short of the width so no row wraps. */
 	contentColumns() {
-		return Math.max(1, this.host.columns() - 1);
+		return Math.max(1, this.host.columns() - 1 - GUTTER);
 	}
 	/**
 	* Wrap one logical line, repeating its rule on every row.
@@ -1731,24 +1953,48 @@ var Screen = class {
 				visible[index] = `${plain.slice(0, start)}${INVERSE}${marked}${INVERSE_OFF}${plain.slice(stop)}`;
 			}
 		}
+		const findHit = this.find?.hits[this.find.index];
+		if (findHit !== void 0) {
+			const first = Math.max(0, end - height);
+			const index = findHit.row - first;
+			if (index >= 0 && index < visible.length) {
+				const plain = (visible[index] ?? "").replaceAll(STYLES, "");
+				const marked = plain.slice(findHit.start, findHit.end);
+				if (marked !== "") visible[index] = `${plain.slice(0, findHit.start)}${INVERSE}${marked}${INVERSE_OFF}${plain.slice(findHit.end)}`;
+			}
+		}
 		const hovered = this.hovered;
 		if (hovered !== void 0) {
-			const head = this.foldRanges().find((range) => range.fold === hovered)?.from;
-			const index = head === void 0 ? -1 : head - Math.max(0, end - height);
-			if (index >= 0 && index < visible.length) visible[index] = underline(visible[index] ?? "");
+			const range = this.foldRanges().find((entry) => entry.fold === hovered);
+			if (range !== void 0) {
+				const first = Math.max(0, end - height);
+				const width = this.contentColumns();
+				for (let at = range.from; at <= range.to; at += 1) {
+					const index = at - first;
+					if (index >= 0 && index < visible.length) visible[index] = fill(visible[index] ?? "", width, this.light);
+				}
+			}
 		}
 		const viewport = [...visible, ...padding];
 		if (this.offset > 0 && this.notice !== "" && viewport.length > 0) viewport[0] = truncate(this.notice, this.contentColumns());
+		if (this.overlay.length > 0 && viewport.length > 0) {
+			const width = this.contentColumns();
+			const start = Math.max(0, viewport.length - this.overlay.length);
+			this.overlay.forEach((row, index) => {
+				const at = start + index;
+				if (at < viewport.length) viewport[at] = fill(truncate(row, width), width, this.light);
+			});
+		}
 		const frame = [...viewport, ...this.chrome];
 		let out = SYNC_BEGIN + HIDE_CURSOR;
 		frame.forEach((row, index) => {
 			if (this.painted[index] === row) return;
-			out += `\u001B[${index + 1};1H${CLEAR_LINE}${row}`;
+			out += `\u001B[${index + 1};1H${CLEAR_LINE}${" ".repeat(GUTTER)}${row}`;
 		});
 		for (let index = frame.length; index < this.painted.length; index += 1) out += `\u001B[${index + 1};1H${CLEAR_LINE}`;
 		if (this.chromeFocus) {
 			const row = frame.length - this.chrome.length + this.chromeCursor.row + 1;
-			out += `\u001B[${row};${this.chromeCursor.column + 1}H${SHOW_CURSOR}`;
+			out += `\u001B[${row};${this.chromeCursor.column + 1 + GUTTER}H${SHOW_CURSOR}`;
 		}
 		out += SYNC_END;
 		this.host.write(out);
@@ -1837,13 +2083,16 @@ var TerminalConsole = class {
 		return Math.max(this.output.columns ?? FALLBACK_COLUMNS, MIN_COLUMNS);
 	}
 	/**
-	* Columns content may be laid out for: one less than the width, because the
-	* viewport wraps at that boundary. Markdown layout MUST use this figure — a
-	* table laid out one column wider is refolded by the viewport, and its rows
-	* shear apart.
+	* Columns content may be laid out for.
+	*
+	* One less than the width so a row cannot wrap the terminal, and on a
+	* viewport two less again for the left gutter. Markdown, the live line, and
+	* the chrome MUST use this figure — a box laid out one gutter wider is
+	* truncated with an ellipsis on every row, and a live line that fills the
+	* width wraps into the box beneath it.
 	*/
 	get contentColumns() {
-		return Math.max(1, this.columns - 1);
+		return Math.max(1, this.columns - 1 - (this.screen !== void 0 ? GUTTER : 0));
 	}
 	/** Whether the output stream is a terminal. */
 	get isTty() {
@@ -1886,6 +2135,32 @@ var TerminalConsole = class {
 	leaveScreen() {
 		this.screen?.leave();
 	}
+	/**
+	* Hand the real TTY to a child, then take the viewport back.
+	*
+	* Raw mode and the alternate screen both have to go: the shell needs cooked
+	* input and the person's own buffer, the way Claude Code and opencode yield
+	* `!` to sh. SIGINT is swallowed here so Ctrl-C reaches the child.
+	* @param work - runs while this process is not reading the keyboard.
+	*/
+	async runInForeground(work) {
+		if (!this.readsKeys) return work();
+		this.input.pause();
+		this.input.setRawMode?.(false);
+		this.output.write(DISABLE_PASTE_MARKERS);
+		this.screen?.leave();
+		const ignore = () => {};
+		process.on("SIGINT", ignore);
+		try {
+			return await work();
+		} finally {
+			process.removeListener("SIGINT", ignore);
+			this.input.setRawMode?.(true);
+			this.output.write(ENABLE_PASTE_MARKERS);
+			this.input.resume();
+			this.screen?.enter();
+		}
+	}
 	/** Whether this surface currently holds its own screen. */
 	get owningScreen() {
 		return this.screen?.entered === true;
@@ -1905,6 +2180,13 @@ var TerminalConsole = class {
 		this.screen?.setScrollNotice(text);
 	}
 	/**
+	* Float rows over the transcript just above the chrome.
+	* @param rows - the overlay, or empty to clear it.
+	*/
+	setOverlay(rows) {
+		this.screen?.setOverlay(rows);
+	}
+	/**
 	* Scroll the transcript by a whole viewport.
 	* @param direction - -1 for back into history, 1 towards the tail.
 	*/
@@ -1915,6 +2197,28 @@ var TerminalConsole = class {
 	scrollToBottom() {
 		this.screen?.scrollToBottom();
 	}
+	/**
+	* Search the owned scrollback.
+	* @param query - the needle.
+	*/
+	searchTranscript(query) {
+		return this.screen?.searchTranscript(query);
+	}
+	/**
+	* Step to another hit of the current query.
+	* @param direction - 1 towards the tail, -1 towards the head.
+	*/
+	nextTranscriptHit(direction) {
+		return this.screen?.nextTranscriptHit(direction);
+	}
+	/** Close find. Transcript content is untouched. */
+	clearTranscriptSearch() {
+		this.screen?.clearTranscriptSearch();
+	}
+	/** Incremental find over the scrollback, absent when find is closed. */
+	get transcriptSearch() {
+		return this.screen?.transcriptSearch;
+	}
 	/** Physical rows currently scrolled out of view; zero means at the tail. */
 	get scrolledBy() {
 		return this.screen?.scrolledBy ?? 0;
@@ -2042,15 +2346,23 @@ var TerminalConsole = class {
 	* @param rule - a styled left rule for the whole block, `''` for none.
 	* @param label - what the block is, for the readout naming what the pointer
 	* is over.
+	* @param enter - child session a click opens instead of folding, when set.
 	*/
-	appendFold(summary, full, rule = "", label = "") {
+	appendFold(summary, full, rule = "", label = "", enter) {
 		if (this.screen !== void 0) {
-			this.screen.appendFold(summary, full, rule, label);
+			this.screen.appendFold(summary, full, rule, label, enter);
 			return;
 		}
 		for (const line of summary) this.output.write(`${line}\n`);
 	}
 	/**
+	* What a click on a view-card does.
+	* @param handler - receives the child session id; omit to restore folding.
+	*/
+	setEnter(handler) {
+		this.screen?.setEnter(handler);
+	}
+	/**
 	* Swap every collapsible block between summary and full form.
 	* @returns false when there is nothing to toggle.
 	*/
@@ -2142,6 +2454,7 @@ var TerminalConsole = class {
 	}
 	/** Take the pinned rows down, leaving the transcript alone. */
 	clearRegion() {
+		this.screen?.setOverlay([]);
 		this.screen?.setChrome([], {
 			row: 0,
 			column: 0
@@ -2165,6 +2478,13 @@ var TerminalConsole = class {
 		if (this.background !== void 0) handler(this.background);
 	}
 	/**
+	* Adopt the light- or dark-background hover fill.
+	* @param light - true when OSC 11 named a light color.
+	*/
+	setLight(light) {
+		this.screen?.setLight(light);
+	}
+	/**
 	* Set the terminal window title.
 	* @param title - the title text; control bytes are the terminal's to reject.
 	*/
@@ -2406,6 +2726,8 @@ var Editor = class {
 	browsing = 0;
 	/** The buffer set aside while history is being browsed. */
 	stashed;
+	/** Reverse-i-search over {@link history}, absent when the box is typing. */
+	search;
 	constructor(sources) {
 		this.sources = sources;
 	}
@@ -2417,7 +2739,13 @@ var Editor = class {
 			column: this.column,
 			candidates: this.candidates,
 			selected: this.selected,
-			token: this.token()
+			token: this.token(),
+			hits: this.gestureHits(),
+			...this.search === void 0 ? {} : { search: {
+				query: this.search.query,
+				hits: this.searchHits().length,
+				index: this.search.index
+			} }
 		};
 	}
 	/** The buffer as one string. */
@@ -2462,7 +2790,9 @@ var Editor = class {
 	* @returns what the caller must do about it.
 	*/
 	handle(key) {
+		if (this.search !== void 0) return this.handleSearch(key);
 		switch (key.kind) {
+			case "history-search": return this.openSearch();
 			case "text": return this.insert(key.text);
 			case "paste": return this.insert(key.text);
 			case "enter": return this.accept();
@@ -2575,6 +2905,40 @@ var Editor = class {
 		return points(this.line()).slice(this.tokenStart(), this.column).join("");
 	}
 	/**
+	* Spans in the buffer that name a registered command or skill.
+	*
+	* `/` only counts at the start of the first line, matching how a command is
+	* submitted. `$` counts as a word anywhere, matching how a skill is invoked.
+	*/
+	gestureHits() {
+		const commands = new Set(this.sources.commands().map((entry) => entry.name));
+		const skills = new Set((this.sources.skills?.() ?? []).map((entry) => entry.name));
+		const hits = [];
+		this.lines.forEach((line, row) => {
+			if (row === 0) {
+				const found = /^\/([a-z][a-z0-9_-]*)(?=\s|$)/u.exec(line);
+				if (found?.[1] !== void 0 && commands.has(found[1])) hits.push({
+					row,
+					start: 0,
+					end: points(found[0]).length,
+					kind: "command"
+				});
+			}
+			for (const match of line.matchAll(/(^|\s)\$([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/gu)) {
+				const name$1 = match[2] ?? "";
+				if (!skills.has(name$1) || match.index === void 0) continue;
+				const dollarAt = match.index + (match[1] ?? "").length;
+				hits.push({
+					row,
+					start: points(line.slice(0, dollarAt)).length,
+					end: points(line.slice(0, dollarAt + 1 + name$1.length)).length,
+					kind: "skill"
+				});
+			}
+		});
+		return hits;
+	}
+	/**
 	* Recompute the candidate list for the token under the cursor.
 	*
 	* Recomputed on every edit rather than only on Tab, which is what makes the
@@ -2592,7 +2956,13 @@ var Editor = class {
 				value,
 				detail: ""
 			}));
-		} else if (wholeLine && token.startsWith("/")) this.candidates = this.sources.commands().filter((entry) => `/${entry.name}`.startsWith(token)).map((entry) => ({
+		} else if (token.startsWith("$")) {
+			const typed = token.slice(1);
+			this.candidates = rankContains(this.sources.skills?.() ?? [], typed, (entry) => entry.name).map((entry) => ({
+				value: `$${entry.name}`,
+				detail: entry.description
+			}));
+		} else if (wholeLine && token.startsWith("/")) this.candidates = rankContains(this.sources.commands(), token.slice(1), (entry) => entry.name).map((entry) => ({
 			value: `/${entry.name}`,
 			detail: entry.description
 		}));
@@ -2745,6 +3115,102 @@ var Editor = class {
 		return { kind: "none" };
 	}
 	/**
+	* Open reverse search over history, stashing the draft.
+	* @returns always `none`.
+	*/
+	openSearch() {
+		this.search = {
+			query: "",
+			index: 0,
+			stash: [...this.lines],
+			row: this.row,
+			column: this.column
+		};
+		this.candidates = [];
+		this.applySearch();
+		return { kind: "none" };
+	}
+	/**
+	* Keys while reverse-i-search is open.
+	* @param key - the decoded keystroke.
+	* @returns what the caller must do about it.
+	*/
+	handleSearch(key) {
+		switch (key.kind) {
+			case "history-search":
+				if (this.search !== void 0) this.search.index += 1;
+				this.applySearch();
+				return { kind: "none" };
+			case "text":
+				if (this.search !== void 0) {
+					this.search.query += key.text;
+					this.search.index = 0;
+				}
+				this.applySearch();
+				return { kind: "none" };
+			case "paste":
+				if (this.search !== void 0) {
+					this.search.query += key.text.replaceAll("\n", "");
+					this.search.index = 0;
+				}
+				this.applySearch();
+				return { kind: "none" };
+			case "backspace":
+				if (this.search !== void 0 && this.search.query.length > 0) {
+					this.search.query = points(this.search.query).slice(0, -1).join("");
+					this.search.index = 0;
+				}
+				this.applySearch();
+				return { kind: "none" };
+			case "enter":
+				this.search = void 0;
+				this.candidates = [];
+				return { kind: "none" };
+			case "escape":
+				this.restoreSearchStash();
+				this.search = void 0;
+				this.candidates = [];
+				return { kind: "none" };
+			case "interrupt":
+				this.restoreSearchStash();
+				this.search = void 0;
+				return { kind: "interrupt" };
+			default: return { kind: "none" };
+		}
+	}
+	/** History entries matching the query, newest first. */
+	searchHits() {
+		const needle = (this.search?.query ?? "").toLowerCase();
+		const hits = [];
+		for (let i = this.history.length - 1; i >= 0; i -= 1) {
+			const entry = this.history[i] ?? "";
+			if (needle === "" || entry.toLowerCase().includes(needle)) hits.push(entry);
+		}
+		return hits;
+	}
+	/** Put the current hit in the buffer, or the stashed draft when none match. */
+	applySearch() {
+		const hits = this.searchHits();
+		if (this.search !== void 0 && this.search.index >= hits.length) this.search.index = Math.max(0, hits.length - 1);
+		const hit = hits[this.search?.index ?? 0];
+		if (hit === void 0) {
+			this.restoreSearchStash();
+			return;
+		}
+		this.lines = hit.split("\n");
+		this.row = this.lines.length - 1;
+		this.column = points(this.line()).length;
+		this.candidates = [];
+	}
+	/** Put the draft that search set aside back in the buffer. */
+	restoreSearchStash() {
+		const stash = this.search?.stash;
+		if (stash === void 0) return;
+		this.lines = [...stash];
+		this.row = this.search?.row ?? 0;
+		this.column = this.search?.column ?? 0;
+	}
+	/**
 	* Close the menu, or report Escape when there is none to close.
 	* @returns `none` when a menu was dismissed, otherwise `escape`.
 	*/
@@ -2767,6 +3233,10 @@ const FRAME_WIDTH = 4;
 const GUTTER_WIDTH = 2;
 /** Content rows shown before the box windows around the cursor. */
 const MAX_CONTENT_ROWS = 6;
+/** Underline on, used only for the typed fragment inside a menu label. */
+const UNDERLINE_ON = "\x1B[4m";
+/** Underline off, without resetting other attributes. */
+const UNDERLINE_OFF = "\x1B[24m";
 /**
 * Wrap one logical line into segments no wider than the budget.
 * @param line - the logical line.
@@ -2807,6 +3277,83 @@ function wrapLine(line, logical, budget) {
 	return rows;
 }
 /**
+* Paint a menu label so the typed fragment and the selection never share a
+* colour: the contained span is underlined, the selected name stays full
+* intensity, and the rest recedes.
+*/
+function paintMenuLabel(value, token, chosen, theme) {
+	const rest = (text) => chosen ? text : theme.dim(text);
+	const match = (text) => theme.colored ? `${UNDERLINE_ON}${text}${UNDERLINE_OFF}` : text;
+	if (token === "") return rest(value);
+	const lower = value.toLowerCase();
+	let at = lower.indexOf(token.toLowerCase());
+	let span = token.length;
+	if (at < 0 && /^[/@$]/u.test(token) && token.length > 1) {
+		const inner = token.slice(1);
+		at = lower.indexOf(inner.toLowerCase());
+		span = inner.length;
+	}
+	if (at < 0) return rest(value);
+	return `${rest(value.slice(0, at))}${match(value.slice(at, at + span))}${rest(value.slice(at + span))}`;
+}
+/**
+* Shift first-line hits left by one when the leading `!` is the gutter, not
+* buffer text the person sees.
+*/
+function displayHits(hits, shell) {
+	if (!shell) return [...hits];
+	return hits.flatMap((hit) => {
+		if (hit.row !== 0) return [hit];
+		const start = Math.max(0, hit.start - 1);
+		const end = Math.max(0, hit.end - 1);
+		return end > start ? [{
+			...hit,
+			start,
+			end
+		}] : [];
+	});
+}
+/**
+* Colour a wrapped segment's known `/command` and `$skill` spans.
+*/
+function paintGestures(text, logical, start, hits, theme) {
+	const end = start + Array.from(text).length;
+	const here = hits.filter((hit) => hit.row === logical && hit.start < end && hit.end > start).sort((left, right) => left.start - right.start);
+	if (here.length === 0) return text;
+	const cells = Array.from(text);
+	let out = "";
+	let at = 0;
+	for (const hit of here) {
+		const from = Math.max(0, hit.start - start);
+		const to = Math.min(cells.length, hit.end - start);
+		if (from >= to) continue;
+		out += cells.slice(at, from).join("");
+		const slice = cells.slice(from, to).join("");
+		out += hit.kind === "skill" ? theme.user(slice) : theme.tool(slice);
+		at = to;
+	}
+	return out + cells.slice(at).join("");
+}
+/** Candidate rows painted as a floating layer, empty when the menu is closed. */
+function menuRows(view, theme, columns) {
+	if (view.candidates.length === 0) return [];
+	const first = Math.min(Math.max(0, view.selected - MENU_LIMIT + 1), Math.max(0, view.candidates.length - MENU_LIMIT));
+	const menu = view.candidates.slice(first, first + MENU_LIMIT);
+	const width = Math.max(...menu.map((candidate) => displayWidth(candidate.value)));
+	const rows = [];
+	if (first > 0) rows.push(theme.dim(`  ↑ ${first} more`));
+	for (const [index, candidate] of menu.entries()) {
+		const chosen = first + index === view.selected;
+		const label = paintMenuLabel(candidate.value, view.token, chosen, theme);
+		const pad = " ".repeat(Math.max(0, width - displayWidth(candidate.value)));
+		const detail = candidate.detail === "" ? "" : `  ${candidate.detail}`;
+		rows.push(truncate(`${chosen ? theme.user("❯") : " "} ${label}${pad}${theme.dim(detail)}`, columns));
+	}
+	const below = view.candidates.length - first - menu.length;
+	if (below > 0) rows.push(theme.dim(`  ↓ ${below} more`));
+	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.
@@ -2815,53 +3362,47 @@ function wrapLine(line, logical, budget) {
 * @returns the rows and cursor position.
 */
 function inputBox(view, theme, columns, options = {}) {
+	const shell = options.shell === true && (view.lines[0] ?? "").startsWith("!");
 	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 lines = shell ? [(view.lines[0] ?? "").slice(1), ...view.lines.slice(1)] : view.lines;
+	const column = shell && view.row === 0 ? Math.max(0, view.column - 1) : view.column;
+	const visual = lines.flatMap((line, index) => wrapLine(line, index, budget));
+	const cursorVisual = visual.findIndex((row) => row.logical === view.row && column >= row.start && (column < row.start + row.length || row.last && 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 empty = lines.length === 1 && lines[0] === "";
+	const mark$1 = shell ? theme.pending("!") : theme.user("›");
+	const hits = displayHits(view.hits, shell);
+	const overlay = menuRows(view, theme, columns);
 	const rows = [accent(`╭${rule}╮`)];
-	if (empty && options.placeholder !== void 0) {
-		const text = truncate(options.placeholder, budget);
+	if (empty && (shell || options.placeholder !== void 0)) {
+		const text = truncate(shell ? "command" : options.placeholder ?? "", budget);
 		const pad = " ".repeat(Math.max(0, budget - displayWidth(text)));
-		rows.push(`${accent("│")} ${theme.user("›")} ${theme.dim(text)}${pad} ${accent("│")}`);
+		rows.push(`${accent("│")} ${mark$1} ${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 gutter = clippedAbove || clippedBelow ? theme.dim("…") : first ? mark$1 : " ";
+		const painted = paintGestures(row.text, row.logical, row.start, hits, theme);
 		const pad = " ".repeat(Math.max(0, budget - displayWidth(row.text)));
-		rows.push(`${accent("│")} ${gutter} ${row.text}${pad} ${accent("│")}`);
+		rows.push(`${accent("│")} ${gutter} ${painted}${pad} ${accent("│")}`);
 	});
 	rows.push(accent(`╰${rule}╯`));
-	if (view.candidates.length > 0) {
-		const first = Math.min(Math.max(0, view.selected - MENU_LIMIT + 1), Math.max(0, view.candidates.length - MENU_LIMIT));
-		const menu = view.candidates.slice(first, first + MENU_LIMIT);
-		const width = Math.max(...menu.map((candidate) => displayWidth(candidate.value)));
-		if (first > 0) rows.push(theme.dim(`  ↑ ${first} more`));
-		menu.forEach((candidate, index) => {
-			const chosen = first + index === view.selected;
-			const matched = view.token !== "" && candidate.value.startsWith(view.token) ? view.token.length : 0;
-			const head = candidate.value.slice(0, matched);
-			const tail = candidate.value.slice(matched);
-			const label = chosen ? theme.bold(theme.tool(candidate.value)) : `${theme.tool(head)}${tail}`;
-			const pad = " ".repeat(Math.max(0, width - displayWidth(candidate.value)));
-			const detail = candidate.detail === "" ? "" : `  ${candidate.detail}`;
-			rows.push(truncate(`${chosen ? theme.user("❯") : " "} ${label}${pad}${theme.dim(detail)}`, columns));
-		});
-		const below = view.candidates.length - first - menu.length;
-		if (below > 0) rows.push(theme.dim(`  ↓ ${below} more`));
-	} else if (options.hint !== void 0) rows.push(theme.dim(truncate(options.hint, columns)));
+	if (view.candidates.length === 0 && view.search !== void 0) {
+		const label = view.search.hits === 0 ? "failing bck-i-search" : "bck-i-search";
+		rows.push(theme.dim(truncate(`  ${label}: ${view.search.query}`, columns)));
+	} else if (view.candidates.length === 0 && 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("");
+	const before = inCursorRow === void 0 ? "" : Array.from(lines[view.row] ?? "").slice(inCursorRow.start, column).join("");
 	return {
 		rows,
+		overlay,
 		cursorRow: 1 + (cursorAt - start),
 		cursorColumn: FRAME_WIDTH + Math.min(displayWidth(before), budget)
 	};
@@ -2874,17 +3415,25 @@ function inputBox(view, theme, columns, options = {}) {
 const VISIBLE_ROWS = 10;
 var Selector = class {
 	selected = 0;
+	query = "";
 	checked = /* @__PURE__ */ new Set();
 	constructor(spec) {
 		this.spec = spec;
 	}
+	/** Original option indices currently shown, in order. */
+	matching() {
+		const options = this.spec.options;
+		if (this.query === "" || this.spec.filterable !== true) return options.map((_, index) => index);
+		const needle = this.query.toLowerCase();
+		return options.flatMap((option, index) => `${option.label} ${option.detail ?? ""}`.toLowerCase().includes(needle) ? [index] : []);
+	}
 	/** How many rows the widget offers, the custom row included. */
 	get count() {
-		return this.spec.options.length + (this.spec.custom === void 0 ? 0 : 1);
+		return this.matching().length + (this.spec.custom === void 0 ? 0 : 1);
 	}
-	/** Whether a row index is the custom "type your own" row. */
+	/** Whether a visible row index is the custom "type your own" row. */
 	isCustom(index) {
-		return this.spec.custom !== void 0 && index === this.spec.options.length;
+		return this.spec.custom !== void 0 && index === this.matching().length;
 	}
 	/**
 	* Apply one key.
@@ -2894,10 +3443,12 @@ var Selector = class {
 	handle(key) {
 		switch (key.kind) {
 			case "up":
+				if (this.count === 0) return { kind: "pending" };
 				this.selected = (this.selected - 1 + this.count) % this.count;
 				return { kind: "pending" };
 			case "down":
 			case "tab":
+				if (this.count === 0) return { kind: "pending" };
 				this.selected = (this.selected + 1) % this.count;
 				return { kind: "pending" };
 			case "enter": return this.accept(this.selected);
@@ -2905,6 +3456,12 @@ var Selector = class {
 				kind: "done",
 				outcome: { kind: "cancelled" }
 			};
+			case "backspace":
+				if (this.spec.filterable === true && this.query.length > 0) {
+					this.query = Array.from(this.query).slice(0, -1).join("");
+					this.selected = 0;
+				}
+				return { kind: "pending" };
 			case "text": return this.typed(key.text);
 			default: return { kind: "pending" };
 		}
@@ -2915,28 +3472,41 @@ var Selector = class {
 	* @returns whether the selection settled.
 	*/
 	typed(text) {
+		if (this.spec.filterable === true) {
+			if (this.query === "") {
+				const shortcut$1 = this.spec.options.findIndex((option) => option.shortcut === text.toLowerCase());
+				if (shortcut$1 >= 0) return this.acceptOriginal(shortcut$1);
+			}
+			this.query += text;
+			this.selected = 0;
+			return { kind: "pending" };
+		}
 		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);
+			if (!this.isCustom(this.selected)) {
+				const original = this.matching()[this.selected];
+				if (original !== void 0) if (this.checked.has(original)) this.checked.delete(original);
+				else this.checked.add(original);
+			}
 			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);
+				const original = this.matching()[digit - 1];
+				if (original !== void 0) if (this.checked.has(original)) this.checked.delete(original);
+				else this.checked.add(original);
 				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);
+		if (shortcut >= 0) return this.acceptOriginal(shortcut);
 		return { kind: "pending" };
 	}
 	/**
-	* Settle on a row.
-	* @param index - the row accepted.
+	* Settle on a visible row.
+	* @param index - the visible row accepted.
 	* @returns the settled step.
 	*/
 	accept(index) {
@@ -2944,18 +3514,28 @@ var Selector = class {
 			kind: "done",
 			outcome: { kind: "custom" }
 		};
+		const original = this.matching()[index];
+		if (original === void 0) return { kind: "pending" };
+		return this.acceptOriginal(original);
+	}
+	/**
+	* Settle on an original option index.
+	* @param original - the option's index in the spec.
+	* @returns the settled step.
+	*/
+	acceptOriginal(original) {
 		if (this.spec.multi === true) return {
 			kind: "done",
 			outcome: {
 				kind: "chosen",
-				indices: this.checked.size > 0 ? [...this.checked].sort((a, b) => a - b) : [index]
+				indices: this.checked.size > 0 ? [...this.checked].sort((a, b) => a - b) : [original]
 			}
 		};
 		return {
 			kind: "done",
 			outcome: {
 				kind: "chosen",
-				indices: [index]
+				indices: [original]
 			}
 		};
 	}
@@ -2967,17 +3547,22 @@ var Selector = class {
 	*/
 	view(theme, columns) {
 		const rows = [theme.bold(truncate(this.spec.title, columns))];
+		if (this.spec.filterable === true && this.query !== "") rows.push(theme.dim(truncate(`  filter: ${this.query}`, columns)));
+		const shown = this.matching();
 		const total = this.count;
 		const first = Math.min(Math.max(0, this.selected - VISIBLE_ROWS + 1), Math.max(0, total - VISIBLE_ROWS));
 		if (first > 0) rows.push(theme.dim(`  ↑ ${first} more`));
 		for (let index = first; index < Math.min(total, first + VISIBLE_ROWS); index += 1) {
-			const option = this.spec.options[index];
+			if (this.isCustom(index)) {
+				rows.push(this.row(index, theme.dim(this.spec.custom ?? ""), void 0, theme, columns));
+				continue;
+			}
+			const option = this.spec.options[shown[index] ?? -1];
 			if (option !== void 0) rows.push(this.row(index, this.label(option, theme), option.detail, theme, columns));
-			else if (this.spec.custom !== void 0) rows.push(this.row(index, theme.dim(this.spec.custom), void 0, theme, columns));
 		}
 		const below = total - first - VISIBLE_ROWS;
 		if (below > 0) rows.push(theme.dim(`  ↓ ${below} more`));
-		const how = this.spec.multi === true ? "Space toggles · Enter confirms · Esc cancels" : "↑↓ move · Enter accepts · Esc cancels";
+		const how = this.spec.multi === true ? "Space toggles · Enter confirms · Esc cancels" : this.spec.filterable === true ? "type to filter · ↑↓ move · Enter accepts · Esc cancels" : "↑↓ move · Enter accepts · Esc cancels";
 		rows.push(theme.dim(truncate(`  ${how}`, columns)));
 		return rows;
 	}
@@ -3003,7 +3588,7 @@ var Selector = class {
 	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 box = this.spec.multi === true && !this.isCustom(index) ? this.checked.has(this.matching()[index] ?? index) ? theme.success("◉ ") : theme.dim("○ ") : "";
 		const number = theme.dim(`${index + 1}.`);
 		const trail = detail === void 0 || detail === "" ? "" : theme.dim(`  ${detail}`);
 		return truncate(`${marker} ${number} ${box}${marked ? theme.bold(theme.tool(label)) : label}${trail}`, columns);
@@ -3172,6 +3757,10 @@ var Prompt = class {
 	todos = [];
 	/** Whether the todo readout shows every item or only the one in flight. */
 	todosExpanded = false;
+	/** Incremental find over the transcript, absent when find is closed. */
+	finding;
+	/** Whether the shortcuts overlay is occupying chrome. */
+	shortcutsOpen = false;
 	/** The assistant line still arriving, shown above the box. */
 	streaming;
 	/** Frame styling for the current mode, e.g. plan mode's accent. */
@@ -3264,7 +3853,8 @@ var Prompt = class {
 	}
 	/**
 	* Set the status row, the region's always-current last line.
-	* @param text - the styled row, or undefined to drop it.
+	* @param text - the full styled row, or undefined to drop it. Truncation is
+	*   applied at paint time so a resize can grow the line back.
 	*/
 	setStatus(text) {
 		if (text === this.status) return;
@@ -3384,6 +3974,7 @@ var Prompt = class {
 	*/
 	onKey(key) {
 		if (key.kind === "interrupt") {
+			this.shortcutsOpen = false;
 			this.handlers.interrupt();
 			return;
 		}
@@ -3405,6 +3996,31 @@ var Prompt = class {
 			this.render();
 			return;
 		}
+		if (key.kind === "transcript-search") {
+			if (this.finding === void 0) {
+				this.finding = "";
+				this.console.searchTranscript("");
+			} else this.console.nextTranscriptHit(1);
+			this.render();
+			return;
+		}
+		if (this.finding !== void 0) {
+			this.onFindKey(key);
+			return;
+		}
+		if (this.shortcutsOpen) {
+			if (key.kind === "escape" || key.kind === "text" && key.text === "?") {
+				this.shortcutsOpen = false;
+				this.render();
+				return;
+			}
+			this.shortcutsOpen = false;
+		}
+		if (key.kind === "text" && key.text === "?" && this.editor.empty) {
+			this.shortcutsOpen = true;
+			this.render();
+			return;
+		}
 		if (key.kind === "page") {
 			this.console.scrollPage(key.direction);
 			this.render();
@@ -3441,7 +4057,7 @@ var Prompt = class {
 		}
 		if (key.kind === "mouse-move") {
 			const block = this.console.mouseMove(key.row, key.column);
-			const readout = block === void 0 ? void 0 : this.theme.dim(`  ${block.label} · ${block.lines} lines · click to ${block.expanded ? "fold" : "expand"}`);
+			const readout = block === void 0 ? void 0 : this.theme.dim(`  ${block.label} · ${block.lines} lines · click to ${block.enter === true ? "enter" : block.expanded ? "fold" : "expand"}`);
 			if (readout === this.hover) return;
 			this.hover = readout;
 			this.render();
@@ -3487,6 +4103,14 @@ var Prompt = class {
 				break;
 			}
 			case "escape":
+				if (this.queued.length > 0) {
+					const last = this.queued.pop();
+					if (last !== void 0) {
+						for (const image of last.images) this.pendingImages.set(image.id, image);
+						this.editor.prefill(last.text);
+					}
+					break;
+				}
 				this.handlers.escape();
 				break;
 			case "eof": {
@@ -3593,27 +4217,88 @@ var Prompt = class {
 			limit: TODO_ROWS
 		});
 	}
+	/**
+	* Keys while transcript find is open: typing is the query, arrows step,
+	* Escape closes. The transcript is not edited.
+	* @param key - the decoded keystroke.
+	*/
+	onFindKey(key) {
+		if (key.kind === "escape") {
+			this.finding = void 0;
+			this.console.clearTranscriptSearch();
+			this.render();
+			return;
+		}
+		if (key.kind === "up") {
+			this.console.nextTranscriptHit(-1);
+			this.render();
+			return;
+		}
+		if (key.kind === "down") {
+			this.console.nextTranscriptHit(1);
+			this.render();
+			return;
+		}
+		if (key.kind === "backspace") {
+			this.finding = Array.from(this.finding ?? "").slice(0, -1).join("");
+			this.console.searchTranscript(this.finding);
+			this.render();
+			return;
+		}
+		if (key.kind === "text") {
+			this.finding = `${this.finding ?? ""}${key.text}`;
+			this.console.searchTranscript(this.finding);
+			this.render();
+			return;
+		}
+		if (key.kind === "paste") {
+			this.finding = `${this.finding ?? ""}${key.text.replaceAll("\n", "")}`;
+			this.console.searchTranscript(this.finding);
+			this.render();
+			return;
+		}
+	}
+	/**
+	* The find readout, or undefined when find is closed.
+	* @param columns - display columns available.
+	*/
+	findRow(columns) {
+		if (this.finding === void 0) return void 0;
+		const found = this.console.transcriptSearch;
+		const hits = found?.hits ?? 0;
+		const at = hits === 0 ? 0 : (found?.index ?? 0) + 1;
+		const status = hits === 0 ? "no matches" : `${at}/${hits}`;
+		return this.theme.dim(truncate(`  find: ${this.finding}  ${status}  ↑↓ next  Esc closes`, columns));
+	}
 	/** Recompose and redraw the bottom region. */
 	render() {
 		if (!this.console.readsKeys) return;
-		const columns = this.console.columns - 1;
+		const columns = this.console.contentColumns;
 		const rows = [];
 		let cursor = {
 			row: 0,
 			column: 0
 		};
 		if (this.streaming !== void 0) rows.push(this.streaming);
+		let menuOverlay = [];
 		if (this.select_ !== void 0) rows.push(...this.select_.selector.view(this.theme, columns));
 		else if (this.engaged || this.reading) {
+			const bang = (this.editor.view.lines[0] ?? "").startsWith("!");
 			const box = inputBox(this.editor.view, this.theme, columns, {
 				placeholder: this.placeholder,
-				accent: this.accent
+				accent: bang ? (text) => this.theme.pending(text) : this.accent,
+				shell: bang
 			});
 			cursor = {
 				row: rows.length + box.cursorRow,
 				column: box.cursorColumn
 			};
 			rows.push(...box.rows);
+			menuOverlay = box.overlay;
+		}
+		if (this.shortcutsOpen) {
+			rows.push(this.theme.dim(truncate("  Ctrl+R history · Ctrl+F find · Ctrl+O folds · Ctrl+T todos", columns)));
+			rows.push(this.theme.dim(truncate("  Ctrl+V image · Shift-Enter newline · Esc interrupt · ? closes", columns)));
 		}
 		if (this.queued.length > 0) {
 			const preview = this.queued[0]?.text ?? "";
@@ -3622,9 +4307,10 @@ var Prompt = class {
 		}
 		rows.push(...this.todoRows(columns));
 		this.console.setScrollNotice(this.console.scrolledBy > 0 ? this.theme.dim(truncate(`  ↑ ${this.console.scrolledBy} rows above · PgDn returns to the latest`, columns)) : "");
-		const notice = this.flash ?? this.hover ?? this.hint;
-		if (notice !== void 0) rows.push(notice);
-		if (this.status !== void 0) rows.push(this.status);
+		const overlay = this.flash ?? this.findRow(columns) ?? this.hover;
+		if (overlay !== void 0) rows.push(overlay);
+		else if (this.hint !== void 0) rows.push(this.hint);
+		if (this.status !== void 0 && (overlay === void 0 || this.hint !== void 0)) rows.push(truncate(this.status, columns));
 		if (rows.length === 0) {
 			this.console.clearRegion();
 			return;
@@ -3634,6 +4320,7 @@ var Prompt = class {
 			row: rows.length - 1,
 			column: 0
 		};
+		this.console.setOverlay(menuOverlay);
 		this.console.setRegion(rows, cursor, focus$1);
 	}
 };
@@ -4132,16 +4819,28 @@ var TerminalQuestions = class {
 	}
 };
 
+//#endregion
+//#region src/bang.ts
+/**
+* Running a `!` line in the person's own shell.
+* @module codsh-bundle/src/bang
+*/
+/** The login shell, falling back to sh. */
+function userShell() {
+	return process.env["SHELL"] ?? (process.platform === "win32" ? process.env["ComSpec"] ?? "cmd.exe" : "/bin/sh");
+}
+
 //#endregion
 //#region src/ship.ts
 /**
 * The `/ship` prompt: a canned workflow that takes a one-sentence requirement
-* from idea to shipped, verified code — a research-grounded interview, a
-* confirmed spec (gate 1), an approved plan (gate 2), then autonomous landing
-* until the spec's acceptance criteria pass.
+* from idea to shipped, verified code — a grill-me interview (design tree,
+* frontier rounds), then automatic to-spec (gate 1), automatic to-tickets
+* (gate 2), then autonomous TDD landing until the spec's acceptance criteria
+* pass.
 *
 * The spec FILE is the workflow's memory, not the conversation: the approved
-* plan is written into it, its Status line names the phase, its checkboxes
+* tickets are written into it, its Status line names the phase, its checkboxes
 * are the progress, and a bare /ship offers to resume whatever it finds
 * unfinished. Conversations get interrupted, compacted, and cleared; the file
 * survives all three, which is what makes the landing reliable rather than
@@ -4156,13 +4855,13 @@ $ARGUMENTS
 
 If the idea between the <idea> tags is empty, that is not an error. First look for unfinished work: scan the repository's spec directory (docs/specs/, or the repo's own design-document convention) for a spec whose Status line is not \`shipped\` — a bare /ship most likely means "carry on", so offer through ask_user_question to resume that spec from the phase its Status names, with everything below applying from that phase onward. Only when there is nothing to resume, ask for the one-sentence requirement with ask_user_question and use the answer as the idea. Images accompanying the command — [Image #N] tokens, <pasted-image> context, attached image blocks — are part of the requirement: a mockup or a screenshot is requirements material, so read it and cite what it shows in the interview.
 
-Phase 1 — grounded interview. Research before you ask: read the repository layout, the docs, and the code paths the idea touches, so every question is informed by what actually exists. Then interrogate the idea with ask_user_question, one focused question per call, never a batch. Cover, as far as they are genuinely open: who this is for and what success looks like, scope and explicit non-goals, constraints (compatibility, performance, security, dependencies), edge cases and failure behavior, and how the result should be verified. Prefer concrete options grounded in what you found over open-ended prompts. Do not ask what inspection can answer — where code lives or how current behavior works is yours to find out. Stop when answers stop changing the design; do not pad the interview to look thorough.
+Phase 1 — grill-me. Research before you ask: read the repository layout, CONTEXT.md if it exists, the docs, ADRs, and the code paths the idea touches. Finding facts is your job, never the user's — where code lives or how current behavior works is yours to find out; do not ask anything inspection can answer. Then map the idea as a design tree: every decision branches into the decisions that hang off it. Work the tree in rounds. The frontier is every decision whose prerequisites are already settled — the questions you can ask now without guessing at answers you have not heard yet. Each round, put the whole frontier into a single ask_user_question call (the tool accepts a list of questions; do not serialize independent frontier questions across separate calls). For each question: a short title, a body grounded in what you found, concrete options rather than an open prompt, and your recommended answer as the first option with a description that says so. Then wait for that call to return before the next round. A question whose answer depends on another still open in this round belongs to a later round. Each round of answers reshapes the tree — settled decisions push the frontier outward. The session is done when the frontier is empty: every branch visited, nothing left silently assumed. Confirm shared understanding through ask_user_question before writing the spec. Do not pad the interview to look thorough, and do not act on the design until that confirmation.
 
-Phase 2 — the spec (gate 1). Write the agreed design to a spec file inside the repository. Follow the repo's existing convention for design documents if one exists (a specs, rfcs, or ADR directory); otherwise create docs/specs/<kebab-case-slug>.md. The spec must stand alone for a reader without this conversation: the one-sentence requirement, background, each interview decision with its reason, scope and non-goals, constraints, edge cases, and a numbered list of acceptance criteria where every criterion names the exact command that proves it and the output that counts as passing — the final phase runs those commands verbatim, so a criterion without a command is not finished. Give the file a \`Status:\` line (interviewing, confirmed, planned, landing, shipped) and keep it current at every phase change: it is what lets an interrupted /ship resume instead of starting over. Present the spec file path and a compact summary through ask_user_question and get an explicit yes. If the answer amends or rejects it, update the file and ask again. Do not proceed on silence or a vague reply.
+Phase 2 — automatic to-spec (gate 1). Do not interview further — synthesize what the grill already settled and what the codebase already is. Write the spec to a file inside the repository. Follow the repo's existing convention for design documents if one exists (a specs, rfcs, or ADR directory); otherwise create docs/specs/<kebab-case-slug>.md. Use the project's domain glossary throughout, and respect ADRs in the area you are touching. The spec must stand alone for a reader without this conversation, with these sections in order: a \`Status:\` line (interviewing, confirmed, planned, landing, shipped) kept current at every phase change; the one-sentence requirement; Problem Statement (from the user's perspective); Solution (from the user's perspective); each grill decision with its reason; User Stories (numbered, "As an <actor>, I want a <feature>, so that <benefit>", covering the feature); Implementation Decisions (modules, interfaces, architecture, contracts — no file paths or code snippets unless a prototype encoded a decision more precisely than prose); Testing Decisions (what a good test is here: external behavior at public seams, not internals; the seams this spec will be tested at, preferring existing ones; prior art in the repo); Out of Scope; and a numbered list of acceptance criteria where every criterion names the exact command that proves it and the output that counts as passing — the final phase runs those commands verbatim, so a criterion without a command is not finished. Record the proposed seams in Testing Decisions; the fewer across the codebase, the better — the ideal number is one. Present the spec file path and a compact summary through ask_user_question and get an explicit yes. If the answer amends or rejects it, update the file and ask again. Do not proceed on silence or a vague reply.
 
-Phase 3 — the plan (gate 2). Only after the spec is confirmed, produce an implementation plan: ordered milestones with the files each touches, the tests each milestone adds or changes, which acceptance criterion each milestone satisfies, and the commands that prove the whole thing (build, typecheck, test). Present the plan through ask_user_question and get an explicit yes; fold rejections back in and present again. Once approved, write the plan into the spec file as a \`## Plan\` section with one checkbox per milestone — an approved plan lives on disk, not in a conversation that can be compacted or lost. Then, still before any implementation code, establish the ground: check the working tree is clean (uncommitted unrelated changes are the user's to decide about — ask), and run the plan's proof commands once, recording the baseline in the spec. A baseline that is already red changes what "green" will mean, so surface it here rather than discovering it under your own diff. Write no implementation code before this gate passes, and do not use todo_write before it either — it tracks landing, not the interview.
+Phase 3 — automatic to-tickets (gate 2). Only after the spec is confirmed, and without another interview, break the spec into tracer-bullet tickets: each a narrow but complete vertical slice through every layer it needs (not a horizontal slice of one layer), demoable or verifiable on its own, sized to fit a single fresh context window. Give each ticket its blocking edges — the other tickets that must complete before it can start. Prefactoring that makes the change easy comes first. A wide refactor (one mechanical change whose blast radius fans across the codebase) is the exception: sequence it expand–contract, not as a fake tracer bullet. Present the breakdown through ask_user_question as a numbered list (title, blocked by, what it delivers) and get an explicit yes; fold rejections back in and present again. Once approved, write the tickets into the spec file as a \`## Plan\` section with one checkbox per ticket — an approved plan lives on disk, not in a conversation that can be compacted or lost. Each checkbox names the ticket, what it delivers, and which tickets block it. Then, still before any implementation code, establish the ground: check the working tree is clean (uncommitted unrelated changes are the user's to decide about — ask), and run the spec's proof commands once, recording the baseline in the spec. A baseline that is already red changes what "green" will mean, so surface it here rather than discovering it under your own diff. Write no implementation code before this gate passes, and do not use todo_write before it either — it tracks landing, not the grill.
 
-Phase 4 — landing. After gate 2, work autonomously; return to the user only for a genuine blocker that contradicts the spec, never for routine decisions. Either way the spec file — not this conversation — is the working memory: re-read it before starting each milestone, tick the milestone's checkbox and update Status as you go, and commit after each milestone turns green — small commits are the progress that survives a crash and the history a reviewer can walk. Choose the mechanism by the approved plan's size. If it has at most three milestones and you expect the whole change to fit comfortably in this session's context, implement in-session: track the milestones with todo_write, and for each one implement, run the tests, fix until green, then commit before moving on. If it is larger — four or more substantially independent milestones, or work you expect to exceed what one session can hold — the user running /ship is their explicit request for a fresh-agent Ralph loop: call the ralph tool once, with an objective that names the spec file path as the single source of truth, instructs each round to read the spec from disk (plan, checkboxes, baseline), pick the first unchecked milestone, implement and test it, then commit and tick its checkbox, and defines completion as every acceptance criterion in the spec passing. Bound the loop: budget about three rounds per milestone, and instruct it to stop and report rather than continue past two consecutive rounds that tick nothing.
+Phase 4 — automatic landing. After gate 2, work autonomously; return to the user only for a genuine blocker that contradicts the spec, never for routine decisions. Either way the spec file — not this conversation — is the working memory: re-read it before starting each ticket, tick the ticket's checkbox and update Status as you go, and commit after each ticket turns green — small commits are the progress that survives a crash and the history a reviewer can walk. Implement test-first at the seams the spec recorded: red before green, one seam and one test and one minimal implementation per cycle, through the public interface, never internals. Do not write a test at an unconfirmed seam. Do not bulk-write tests then bulk-implement — vertical slices, matching the tickets. Run typecheck and the focused tests each cycle; run the full suite the spec named once at the end of the ticket. Choose the mechanism by the approved plan's size. If it has at most three tickets and you expect the whole change to fit comfortably in this session's context, implement in-session: track the tickets with todo_write, and for each one red-green, run the tests, fix until green, then commit before moving on. If it is larger — four or more substantially independent tickets, or work you expect to exceed what one session can hold — the user running /ship is their explicit request for a fresh-agent Ralph loop: call the ralph tool once, with an objective that names the spec file path as the single source of truth, instructs each round to read the spec from disk (plan, checkboxes, baseline, seams), pick the first unchecked ticket whose blockers are ticked, implement it test-first at those seams, then commit and tick its checkbox, and defines completion as every acceptance criterion in the spec passing. Bound the loop: budget about three rounds per ticket, and instruct it to stop and report rather than continue past two consecutive rounds that tick nothing.
 
 Phase 5 — done means verified. The workflow ends only when every acceptance criterion passes with you actually running its named command and reading the real output. After a Ralph loop returns, run every proof command again yourself — the loop's word is a report, not a verification. Never report a result you did not run, and never weaken a criterion to make it pass; if one cannot be met, say so plainly and why. When a decision changes mid-flight, update the spec file first so the file on disk stays the truth. Set Status to shipped only after that final run, and close with an honest report listing each criterion, the command that proved it, and what it printed — plus anything left open.
 
@@ -4210,7 +4909,10 @@ var Spinner = class {
 		this.theme = theme;
 		this.label = label;
 		this.now = now;
+		this.activity = label.verb;
 	}
+	/** Current verb, updated as tools fire so the line names what is in flight. */
+	activity;
 	/** Whether the indicator is running. */
 	get running() {
 		return this.timer !== void 0;
@@ -4245,10 +4947,22 @@ var Spinner = class {
 		this.pause();
 		this.startedAt = 0;
 		this.frame = 0;
+		this.activity = this.label.verb;
+	}
+	/**
+	* Name what is in flight. The next tick (or this one, if running) shows it.
+	* @param verb - e.g. `Reading`, `Running`. Empty restores the default verb.
+	*/
+	setActivity(verb) {
+		this.activity = verb === "" ? this.label.verb : verb;
+		if (this.timer !== void 0) this.draw();
 	}
 	/** Paint the current frame. */
 	draw() {
-		this.surface.setLive(spinnerText(this.frame, this.now() - this.startedAt, this.label, this.theme));
+		this.surface.setLive(spinnerText(this.frame, this.now() - this.startedAt, {
+			...this.label,
+			verb: this.activity
+		}, this.theme));
 	}
 };
 
@@ -4564,6 +5278,25 @@ const FOLD_LABELS = {
 	thinking: "thinking",
 	answer: "answer"
 };
+/**
+* The child session a continuable subagent result names, when the card can
+* open that session.
+*
+* Continuable starts return `started subagent <id>` (and a JSON form with the
+* same id). One-shot background jobs name a job, not a session, and are not a
+* view.
+* @param text - the tool result's visible text.
+* @returns the child session id, or undefined when this result is not a view.
+*/
+function childSessionId(text) {
+	const trimmed = text.trim();
+	const started = /^started subagent (\S+)/u.exec(trimmed.split("\n")[0] ?? trimmed);
+	if (started?.[1] !== void 0) return started[1];
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (parsed !== null && typeof parsed === "object" && "kind" in parsed && parsed.kind === "continuable" && "subagentId" in parsed && typeof parsed.subagentId === "string" && parsed.subagentId !== "") return parsed.subagentId;
+	} catch {}
+}
 /** A finished answer longer than this many rendered lines becomes a fold. */
 const ANSWER_FOLD_LINES = 24;
 /** How many of its head lines a collapsed answer keeps visible. */
@@ -4657,6 +5390,8 @@ var Transcript = class {
 	label = "";
 	/** The left rule the block {@link render} just returned belongs to. */
 	rule = "";
+	/** Child session a click on this card should open, when the result names one. */
+	enter;
 	constructor(options, presenters) {
 		this.options = options;
 		this.presenters = presenters;
@@ -4701,6 +5436,7 @@ var Transcript = class {
 		const { theme } = this.options;
 		const rules = blockRules(theme);
 		this.rule = "";
+		this.enter = void 0;
 		switch (event.type) {
 			case "user/message": {
 				if (event.data.source.kind !== "user") return [];
@@ -4798,37 +5534,54 @@ var Transcript = class {
 		if (failed) this.rule = blockRules(theme).error;
 		const marker = failed ? theme.error("✗") : theme.success("●");
 		if (pending === void 0) {
-			const raw = this.resultText(block.content).split("\n");
+			const text = this.resultText(block.content);
+			const raw = text.split("\n");
 			const head$1 = `${marker} ${theme.dim("(result)")}`;
+			const enter$1 = failed ? void 0 : childSessionId(text);
+			const hint$1 = enter$1 === void 0 ? [] : [theme.dim("  click to enter")];
 			if (raw.length > MAX_RESULT_LINES) {
 				this.fold = [
 					head$1,
 					...raw,
+					...hint$1,
 					""
 				];
 				this.label = "tool result";
 			}
+			if (enter$1 !== void 0) {
+				this.enter = enter$1;
+				this.label = "tool result";
+			}
 			return [
 				head$1,
 				...cap(raw, MAX_RESULT_LINES, theme),
+				...hint$1,
 				""
 			];
 		}
 		const view = this.safeResult(pending, block.content, failed, meta);
 		const title = view?.title === void 0 ? pending.title : this.relativizeIn(view.title);
 		const { suffix, body, full } = this.outcome(view, block);
-		const head = failed || title !== pending.title ? [`${marker} ${theme.tool(title)}${suffix === "" ? "" : ` ${suffix}`}`] : suffix !== "" ? [`  ${suffix}`] : body.length === 0 ? [`  ${theme.success("✓")}`] : [];
+		const enter = failed ? void 0 : childSessionId(this.resultText(block.content));
+		const hint = enter === void 0 ? [] : [theme.dim("  click to enter")];
+		const head = failed || title !== pending.title ? [`${marker} ${theme.tool(title)}${suffix === "" ? "" : ` ${suffix}`}`] : suffix !== "" ? [`  ${suffix}`] : body.length === 0 && hint.length === 0 ? [`  ${theme.success("✓")}`] : [];
 		if (full !== void 0) {
 			this.fold = [
 				...head,
 				...full,
+				...hint,
 				""
 			];
 			this.label = title;
 		}
+		if (enter !== void 0) {
+			this.enter = enter;
+			this.label = title;
+		}
 		return [
 			...head,
 			...body,
+			...hint,
 			""
 		];
 	}
@@ -4858,6 +5611,18 @@ var Transcript = class {
 		return label;
 	}
 	/**
+	* The child session the block {@link render} just returned can open.
+	*
+	* A click on that card enters the child's transcript rather than folding
+	* the card. Taken once, like {@link takeFold}.
+	* @returns the child session id, or undefined when the card is not a view.
+	*/
+	takeEnter() {
+		const enter = this.enter;
+		this.enter = void 0;
+		return enter;
+	}
+	/**
 	* The left rule for the block {@link render} just returned, `''` when the
 	* block stands flush.
 	*
@@ -5092,8 +5857,9 @@ function replay(session, transcript, io, theme) {
 		const full = transcript.takeFold();
 		const rule = transcript.takeRule();
 		const label = transcript.takeLabel();
-		if (full !== void 0) {
-			io.console.appendFold(lines, full, rule, label);
+		const enter = transcript.takeEnter();
+		if (enter !== void 0 || full !== void 0) {
+			io.console.appendFold(lines, full ?? lines, rule, label, enter);
 			continue;
 		}
 		for (const line of lines) io.console.write(line, rule);
@@ -5102,6 +5868,15 @@ function replay(session, transcript, io, theme) {
 		if (summary !== void 0) io.console.foldRecent(lines.length, summary, FOLD_LABELS.answer);
 	}
 }
+/** Working-line verb from the in-flight tool name. */
+function toolActivity(name$1) {
+	const n = name$1.toLowerCase();
+	if (n.includes("bash") || n.includes("shell") || n.includes("terminal") || n.includes("pwsh")) return "Running";
+	if (n.includes("read")) return "Reading";
+	if (n.includes("search") || n.includes("grep") || n.includes("glob") || n.includes("find")) return "Searching";
+	if (n.includes("edit") || n.includes("write") || n.includes("apply")) return "Editing";
+	return name$1;
+}
 async function turn(agent, text, working, source = { kind: "user" }, extra) {
 	agent.followup(createUserMessage({
 		content: [
@@ -5176,8 +5951,15 @@ function capture(file, args, options) {
 			]
 		});
 		let output = "";
+		let pending = "";
 		const take = (chunk) => {
-			output += chunk.toString();
+			const text = chunk.toString().replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+			output += text;
+			if (options.onLine === void 0) return;
+			pending += text;
+			const parts = pending.split("\n");
+			pending = parts.pop() ?? "";
+			for (const line of parts) options.onLine(line);
 		};
 		child.stdout.on("data", take);
 		child.stderr.on("data", take);
@@ -5198,6 +5980,7 @@ function capture(file, args, options) {
 		child.on("close", (code, signal) => {
 			if (timer !== void 0) clearTimeout(timer);
 			options.signal?.removeEventListener("abort", onAbort);
+			if (pending !== "" && options.onLine !== void 0) options.onLine(pending);
 			resolve({
 				output,
 				code,
@@ -5310,7 +6093,10 @@ async function run(ctx, config, io) {
 	const theme = createTheme(io.console.isTty, process.env);
 	io.console.onBackground((payload) => {
 		const light = backgroundIsLight(payload);
-		if (light !== void 0) theme.setLight(light);
+		if (light !== void 0) {
+			theme.setLight(light);
+			io.console.setLight(light);
+		}
 	});
 	const preset = await installPackagedPreset();
 	if (preset.installed) io.console.write(theme.dim(`installed preset into ${preset.path}`));
@@ -5330,6 +6116,8 @@ async function run(ctx, config, io) {
 			cwd
 		}, presentersFor(ctx, composed.handle.agent))
 	};
+	/** Nested view of a child subagent session; Esc restores the parent. */
+	let viewing;
 	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);
@@ -5342,7 +6130,7 @@ async function run(ctx, config, io) {
 		session: live.agent.session.id,
 		readsKeys: io.console.readsKeys,
 		resumed: config.resume !== ""
-	}, theme, io.console.columns)) io.console.write(line);
+	}, theme, io.console.contentColumns)) io.console.write(line);
 	const disposers = [];
 	const commands = ctx.get("commands");
 	/** The advertised model catalog, fetched once and refreshed per /model call. */
@@ -5368,14 +6156,23 @@ async function run(ctx, config, io) {
 	/**
 	* Whether the current route explicitly accepts image input.
 	*
-	* The same explicit-true test the adapter applies before throwing
-	* UNSUPPORTED_CONTENT: absent modalities mean unknown, and unknown gets the
-	* text fallback — which degrades, where the block path would crash the turn.
+	* Exact-model metadata, not the advisory catalog, owns this decision. The
+	* catalog is fetched in the background and can be empty or stale while a
+	* saved route is already usable. The same explicit-true test the adapter
+	* applies before throwing UNSUPPORTED_CONTENT remains fail-closed: absent
+	* modalities or a failed resolution get the text fallback, which degrades,
+	* where the block path would crash the turn.
 	*/
-	const routeAcceptsImages = () => {
+	const routeAcceptsImages = async () => {
 		const current = selection.current;
 		if (current === void 0) return false;
-		return modelCatalog.find((model$1) => model$1.provider === current.provider && model$1.id === current.model)?.inputModalities?.includes("image") === true;
+		const llm = ctx.get("llm");
+		if (llm === void 0) return false;
+		try {
+			return (await llm.resolveModelInfo(current.provider, current.model)).inputModalities?.includes("image") === true;
+		} catch {
+			return false;
+		}
 	};
 	/**
 	* Resolve a /model argument to a selection.
@@ -5420,7 +6217,7 @@ async function run(ctx, config, io) {
 		},
 		{
 			name: "ship",
-			description: "take a one-sentence idea to shipped code"
+			description: "grill an idea, then spec, tickets, and verified code"
 		},
 		...custom.commands.map((command) => ({
 			name: command.name,
@@ -5431,6 +6228,24 @@ async function run(ctx, config, io) {
 			description: "leave the session"
 		}
 	];
+	let userSkills = [];
+	const refreshSkills = async () => {
+		try {
+			userSkills = (await ctx.get("skills")?.list({
+				cwd,
+				scope: live.agent
+			}) ?? []).filter(isUserInvocable).map((entry) => ({
+				name: entry.name,
+				description: entry.description
+			}));
+		} catch {
+			userSkills = [];
+		}
+	};
+	refreshSkills();
+	ctx.on("skills/change", () => {
+		refreshSkills();
+	});
 	const completePath$1 = createCompleter(completable, cwd);
 	/**
 	* The first-argument candidates per command, read live: plan's argument
@@ -5474,7 +6289,8 @@ async function run(ctx, config, io) {
 	const prompt = new Prompt(io.console, theme, {
 		commands: completable,
 		paths: completePath$1,
-		commandArguments: argumentsFor
+		commandArguments: argumentsFor,
+		skills: () => userSkills
 	}, {
 		interrupt: () => {
 			onInterruptKey();
@@ -5493,7 +6309,7 @@ async function run(ctx, config, io) {
 			if (!io.console.toggleFolds()) prompt.write(theme.dim("  nothing to expand"));
 		},
 		readClipboardImage: () => readClipboardImage(process.env)
-	}, "Ask anything · / for commands · @ for files · ⇧Tab plan mode");
+	}, "Ask anything · / for commands · $ for skills · ! shell · @ for files · ⇧Tab plan mode");
 	let turnBaseTokens = 0;
 	const spinner = new Spinner({
 		setLive: (text) => {
@@ -5524,6 +6340,7 @@ async function run(ctx, config, io) {
 		const old = live.handle;
 		adopt(next, replayLog);
 		await old.dispose();
+		refreshSkills();
 	};
 	if (commands !== void 0) {
 		disposers.push(commands.register({
@@ -5561,7 +6378,7 @@ async function run(ctx, config, io) {
 					session: live.agent.session.id,
 					readsKeys: io.console.readsKeys,
 					resumed: false
-				}, theme, io.console.columns)) prompt.write(line);
+				}, theme, io.console.contentColumns)) prompt.write(line);
 				return {
 					kind: "success",
 					text: `new session ${live.agent.session.id}`
@@ -5620,7 +6437,8 @@ async function run(ctx, config, io) {
 					options: rows.map((row) => ({
 						label: row.label,
 						detail: row.detail
-					}))
+					})),
+					filterable: true
 				}, signal);
 				if (outcome.kind !== "chosen") return {
 					kind: "success",
@@ -5703,7 +6521,8 @@ async function run(ctx, config, io) {
 								label: `${entry.provider}/${entry.id}`,
 								detail: active ? `${entry.name} · current` : entry.name
 							};
-						})
+						}),
+						filterable: true
 					});
 					if (outcome.kind !== "chosen") return {
 						kind: "success",
@@ -5770,16 +6589,79 @@ async function run(ctx, config, io) {
 	/** 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 (viewing !== void 0) {
+			prompt.setStatus(theme.dim("subagent · Esc returns to the parent"));
+			return;
+		}
+		prompt.setStatus(statusLine(facts(branch), theme));
 		prompt.setTodos(todoList(ctx, live.agent));
 	};
 	if (planModeFrom(live.agent.session.events)) prompt.setAccent((text) => theme.pending(text));
 	refreshStatus();
+	/**
+	* Open a child subagent's transcript in place of the parent's.
+	* @param id - the child session the card named.
+	*/
+	const enterView = (id) => {
+		const session = sessions.get(SessionId(id));
+		if (session === void 0) {
+			prompt.setFlash(theme.dim("  subagent is no longer running"));
+			return;
+		}
+		viewing = {
+			session,
+			transcript: new Transcript({
+				theme,
+				columns: io.console.columns,
+				cwd
+			}, presentersFor(ctx, live.agent))
+		};
+		spinner.pause();
+		io.console.clearScreen();
+		replay(session, viewing.transcript, io, theme);
+		refreshStatus();
+	};
+	/** Restore the parent session's transcript. */
+	const exitView = () => {
+		if (viewing === void 0) return;
+		viewing = void 0;
+		live.transcript = new Transcript({
+			theme,
+			columns: io.console.columns,
+			cwd
+		}, presentersFor(ctx, live.agent));
+		io.console.clearScreen();
+		replay(live.agent.session, live.transcript, io, theme);
+		refreshStatus();
+		if (live.agent.status === "running") spinner.start();
+	};
+	io.console.setEnter(enterView);
 	ctx.on("session/event", (session, event) => {
+		if (session === live.agent.session) {
+			if (event.type === "plan/mode") prompt.setAccent(event.data.active ? (text) => theme.pending(text) : void 0);
+			refreshStatus();
+			if (event.type === "todo/write") prompt.setTodos(event.data.todos);
+		}
+		if (viewing !== void 0) {
+			if (session !== viewing.session) return;
+			if (event.type === "tool/call") spinner.setActivity(toolActivity(event.data.name));
+			if (event.type === "tool/result") spinner.setActivity("working");
+			const lines$1 = viewing.transcript.render(event);
+			const full$1 = viewing.transcript.takeFold();
+			const rule$1 = viewing.transcript.takeRule();
+			const label$1 = viewing.transcript.takeLabel();
+			const enter$1 = viewing.transcript.takeEnter();
+			if (enter$1 !== void 0 || full$1 !== void 0) {
+				prompt.setStreaming(void 0);
+				io.console.appendFold(lines$1, full$1 ?? lines$1, rule$1, label$1, enter$1);
+				return;
+			}
+			emit(lines$1, void 0, rule$1);
+			return;
+		}
 		if (session !== live.agent.session) return;
-		if (event.type === "plan/mode") prompt.setAccent(event.data.active ? (text) => theme.pending(text) : void 0);
-		refreshStatus();
-		if (event.type === "todo/write") prompt.setTodos(event.data.todos);
+		if (event.type === "tool/call") spinner.setActivity(toolActivity(event.data.name));
+		if (event.type === "tool/result") spinner.setActivity("working");
 		if (config.print && event.type === "user/message") return;
 		if (event.type === "assistant/chunk") {
 			const { chunk } = event.data;
@@ -5809,12 +6691,13 @@ async function run(ctx, config, io) {
 		const full = live.transcript.takeFold();
 		const rule = live.transcript.takeRule();
 		const label = live.transcript.takeLabel();
-		if (full === void 0) {
+		const enter = live.transcript.takeEnter();
+		if (enter === void 0 && full === void 0) {
 			emit(lines, void 0, rule);
 			return;
 		}
 		prompt.setStreaming(void 0);
-		io.console.appendFold(lines, full, rule, label);
+		io.console.appendFold(lines, full ?? lines, rule, label, enter);
 	});
 	/** Pause the indicator around a decision, and resume it if work continues. */
 	const whileDeciding = async (decide) => {
@@ -5859,6 +6742,8 @@ async function run(ctx, config, io) {
 	});
 	ctx.on("approval/request", (req, next) => req.agent === live.agent ? approval.decide(req) : next());
 	adopt = (next, replayLog) => {
+		viewing = void 0;
+		prompt.setHint(void 0);
 		live.handle = next;
 		live.agent = next.agent;
 		live.transcript = new Transcript({
@@ -5917,6 +6802,10 @@ async function run(ctx, config, io) {
 	let lastInterrupt = 0;
 	let recallArmed;
 	onEscapeKey = () => {
+		if (viewing !== void 0) {
+			exitView();
+			return;
+		}
 		if (interrupt()) return;
 		if (!prompt.empty) return;
 		const last = prompt.history.findLast((entry) => !entry.startsWith("/") && !entry.startsWith("!"));
@@ -5969,7 +6858,7 @@ async function run(ctx, config, io) {
 		if (images.length === 0) return void 0;
 		const store = ctx.get("attachments");
 		const limits = store?.imageLimits ?? DEFAULT_IMAGE_LIMITS;
-		if (routeAcceptsImages() && store !== void 0) try {
+		if (await routeAcceptsImages() && store !== void 0) try {
 			return {
 				leading: (await admitEncodedImages(store, await Promise.all(images.map((pending) => fitWithinLimits(pending.image, limits))))).map((attachment) => ({
 					type: "image",
@@ -6046,34 +6935,31 @@ async function run(ctx, config, io) {
 	* @param command - the line after the `!`.
 	*/
 	const passthrough = async (command) => {
-		prompt.write(`${theme.user("›")} ${theme.tool(`!${command}`)}`);
+		prompt.write(`${theme.pending("●")} ${theme.tool("bash")}`);
+		prompt.write(`  $ ${command}`);
 		running = new AbortController();
 		try {
-			const result = await capture(process.env["SHELL"] ?? "/bin/sh", ["-c", command], {
+			let streamed = 0;
+			const result = await capture(userShell(), process.platform === "win32" ? ["/c", command] : ["-c", command], {
 				cwd,
 				signal: running.signal,
-				timeoutMs: config.bangTimeoutMs
+				timeoutMs: config.bangTimeoutMs,
+				onLine: (line) => {
+					if (streamed < config.bangOutputLines) prompt.write(`  ${line}`);
+					streamed += 1;
+				}
 			});
-			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`));
+			if (streamed > config.bangOutputLines) prompt.write(theme.dim(`  … ${streamed - config.bangOutputLines} 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"
-				}
-			}));
+			const lines = result.output.trimEnd() === "" ? [] : result.output.trimEnd().split("\n");
+			const kept = lines.slice(0, config.bangOutputLines);
+			const dropped = lines.length - kept.length;
+			await answer(`<bash-input>${command}</bash-input>\n<bash-output>\n${[...kept, ...dropped > 0 ? [`… ${dropped} more lines`] : []].join("\n")}\n</bash-output>\n<bash-exit>${result.signal !== null ? `killed by ${result.signal}` : String(result.code ?? 0)}</bash-exit>`, {
+				kind: "plugin",
+				plugin: "coding-cli"
+			});
 		} finally {
 			running = void 0;
 		}
@@ -6099,10 +6985,15 @@ async function run(ctx, config, io) {
 		const trimmed = line.trim();
 		if (trimmed === "") continue;
 		if (trimmed === "/exit" || trimmed === "/quit") break;
+		if (viewing !== void 0) {
+			prompt.setFlash(theme.dim("  Esc returns to the parent"));
+			continue;
+		}
 		if (trimmed.startsWith("!")) {
 			if (images.length > 0) prompt.setFlash(theme.dim("  images do not ride ! commands — send them with a prompt"));
 			const command = trimmed.slice(1).trim();
-			if (command !== "") await passthrough(command);
+			if (command === "") continue;
+			await passthrough(command);
 			continue;
 		}
 		if (trimmed.startsWith("/")) {
@@ -6131,7 +7022,7 @@ async function run(ctx, config, io) {
 				continue;
 			}
 			let batch = [];
-			if (images.length > 0) if (routeAcceptsImages()) {
+			if (images.length > 0) if (await routeAcceptsImages()) {
 				const limits = ctx.get("attachments")?.imageLimits ?? DEFAULT_IMAGE_LIMITS;
 				batch = await Promise.all(images.map((pending) => fitWithinLimits(pending.image, limits)));
 			} else prompt.setFlash(theme.error("  this model does not accept images with commands — they were dropped"));
@@ -6143,7 +7034,7 @@ async function run(ctx, config, io) {
 			}
 			continue;
 		}
-		await answer(trimmed, void 0, images);
+		await answer(expandSkillGestures(trimmed, new Set(userSkills.map((entry) => entry.name))), void 0, images);
 	}
 	await sessions.flush(live.agent.session);
 	try {