codsh-cli 0.1.0 → 0.2.0

package/lib/index.js

@@ -7,6 +7,7 @@ import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { homedir } from "node:os";
+import stringWidth from "string-width";
 import { readdirSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
@@ -72,13 +73,8 @@ function answerForKey(key) {
 
 //#endregion
 //#region src/theme.ts
-/**
-* Terminal styling and display metrics: SGR sequences that degrade to plain
-* text off a TTY, and the display-column width a rendered string occupies.
-* @module codsh-cli/src/theme
-*/
 /** SGR codes applied by {@link Theme}, by role. */
-const SGR = {
+const SGR$1 = {
 	reset: "\x1B[0m",
 	dim: "\x1B[2m",
 	bold: "\x1B[1m",
@@ -125,80 +121,49 @@ const PLAIN = {
 function createTheme(isTty, env) {
 	if (!isTty || env.NO_COLOR !== void 0) return PLAIN;
 	const palette = env.TERM?.includes("256color") === true || env.COLORTERM !== void 0;
-	const wrap = (code) => (text) => `${code}${text}${SGR.reset}`;
+	const wrap = (code) => (text) => `${code}${text}${SGR$1.reset}`;
 	return {
 		colored: true,
-		dim: wrap(palette ? "\x1B[38;5;245m" : SGR.dim),
-		bold: wrap(SGR.bold),
-		error: wrap(SGR.red),
-		success: wrap(SGR.green),
-		pending: wrap(SGR.yellow),
-		tool: wrap(SGR.cyan),
-		path: wrap(SGR.blue),
-		user: wrap(SGR.magenta),
+		dim: wrap(palette ? "\x1B[38;5;245m" : SGR$1.dim),
+		bold: wrap(SGR$1.bold),
+		error: wrap(SGR$1.red),
+		success: wrap(SGR$1.green),
+		pending: wrap(SGR$1.yellow),
+		tool: wrap(SGR$1.cyan),
+		path: wrap(SGR$1.blue),
+		user: wrap(SGR$1.magenta),
 		syntax: {
-			keyword: wrap(SGR.magenta),
-			string: wrap(SGR.green),
-			number: wrap(SGR.cyan),
-			comment: wrap(SGR.dim)
+			keyword: wrap(SGR$1.magenta),
+			string: wrap(SGR$1.green),
+			number: wrap(SGR$1.cyan),
+			comment: wrap(SGR$1.dim)
 		}
 	};
 }
 /**
-* Inclusive code-point ranges rendered two columns wide by a terminal: the
-* East Asian Wide and Fullwidth classes of Unicode TR11, which cover the CJK
-* blocks, Hangul, the fullwidth forms, and the emoji planes this surface
-* prints.
-*/
-const WIDE_RANGES = [
-	[4352, 4447],
-	[11904, 12350],
-	[12353, 13311],
-	[13312, 19903],
-	[19968, 40959],
-	[40960, 42191],
-	[43360, 43391],
-	[44032, 55203],
-	[63744, 64255],
-	[65040, 65049],
-	[65072, 65135],
-	[65280, 65376],
-	[65504, 65510],
-	[127744, 128591],
-	[129280, 129535],
-	[131072, 196605],
-	[196608, 262141]
-];
-/** Matches one SGR sequence, which occupies no display column. */
-const SGR_PATTERN = /\u001B\[[0-9;]*m/gu;
-/**
-* Whether one code point occupies two display columns.
-* @param code - the code point to classify.
-* @returns true when the terminal renders it double-width.
-*/
-function isWide(code) {
-	return WIDE_RANGES.some(([low, high]) => code >= low && code <= high);
-}
-/**
 * Display columns a string occupies once printed, ignoring styling sequences.
 *
-* Combining marks are counted as zero and East Asian Wide/Fullwidth code
-* points as two, which is what a terminal's own cursor arithmetic does. This
-* covers the alignment and wrapping this surface needs; it is not a complete
-* grapheme segmenter, so a ZWJ emoji sequence still counts each joined code
-* point ({@link ../README.md | Known Limitations}).
+* Measured by `string-width` — the width authority cli-table3, ink, and every
+* maintained terminal renderer sit on — so East Asian Wide, emoji presentation
+* (`⚡` included), combining marks, and ZWJ sequences all match what a
+* terminal's cursor actually does. A hand-kept range table here mis-sized `⚡`
+* and sheared a real table's columns; widths are exactly the kind of data
+* nobody should maintain by hand.
 * @param text - the string to measure, possibly carrying SGR sequences.
 * @returns the number of display columns.
 */
 function displayWidth(text) {
-	let width = 0;
-	for (const character of text.replace(SGR_PATTERN, "")) {
-		const code = character.codePointAt(0);
-		if (code === void 0) continue;
-		if (code >= 768 && code <= 879) continue;
-		width += isWide(code) ? 2 : 1;
+	if (text === "") return 0;
+	let ascii = true;
+	for (let index = 0; index < text.length; index += 1) {
+		const code = text.charCodeAt(index);
+		if (code < 32 || code > 126) {
+			ascii = false;
+			break;
+		}
 	}
-	return width;
+	if (ascii) return text.length;
+	return stringWidth(text);
 }
 /** Matches one SGR sequence at the start of a string. */
 const SGR_AT_START = /^\u001B\[[0-9;]*m/u;
@@ -231,7 +196,7 @@ function truncate(text, columns) {
 		}
 		const code = text.codePointAt(at) ?? 0;
 		const cell = String.fromCodePoint(code);
-		const step = code >= 768 && code <= 879 ? 0 : isWide(code) ? 2 : 1;
+		const step = displayWidth(cell);
 		if (width + step > columns - 1) break;
 		width += step;
 		out += cell;
@@ -380,6 +345,22 @@ function statusReport(facts, session) {
 /** The product name, shown as the framed headline. */
 const NAME$1 = "dsh code";
 /**
+* The lettermark, drawn in half-block glyphs.
+*
+* Forty columns wide: it fits an eighty-column terminal with room to spare,
+* and anything narrower falls back to the plain headline anyway.
+*/
+const LOGO = [
+	" ██████╗ ██████╗ ██████╗ ███████╗██╗  ██╗",
+	"██╔════╝██╔═══██╗██╔══██╗██╔════╝██║  ██║",
+	"██║     ██║   ██║██║  ██║███████╗███████║",
+	"██║     ██║   ██║██║  ██║╚════██║██╔══██║",
+	"╚██████╗╚██████╔╝██████╔╝███████║██║  ██║",
+	" ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝"
+];
+/** Display width of the widest logo row. */
+const LOGO_WIDTH = 41;
+/**
 * Frame one headline in a rounded box sized to its content.
 *
 * Drawn from the measured display width rather than the character count, so a
@@ -410,14 +391,22 @@ function bannerLines(facts, theme, columns) {
 	const interrupt = facts.readsKeys ? "ESC" : "Ctrl-C";
 	const plain = `${NAME$1} · ${composition}`;
 	const headline = `${theme.bold(NAME$1)}${theme.dim(` · ${composition}`)}`;
-	return [
-		...displayWidth(plain) + 4 <= columns ? framed(headline, displayWidth(plain), theme) : [truncate(plain, columns)],
+	const details = [
 		theme.dim(`  ${truncate(where, columns - 2)}`),
 		theme.dim(`  session ${facts.session}${facts.resumed ? " (resumed)" : ""}`),
 		"",
 		theme.dim(truncate(`  /help for commands · Tab completes · ⇧Tab plan mode · ${interrupt} interrupts · /exit leaves`, columns)),
 		""
 	];
+	if (facts.readsKeys && !facts.resumed && columns >= LOGO_WIDTH + 2) return [
+		"",
+		...LOGO.map((row) => theme.user(` ${row}`)),
+		"",
+		` ${theme.bold("✻ Welcome to codsh")}${theme.dim(` · ${composition}`)}`,
+		"",
+		...details
+	];
+	return [...displayWidth(plain) + 4 <= columns ? framed(headline, displayWidth(plain), theme) : [truncate(plain, columns)], ...details];
 }
 
 //#endregion
@@ -654,8 +643,41 @@ async function loadCustomCommands(roots, taken) {
 const PASTE_START = "\x1B[200~";
 /** Bracketed paste end. */
 const PASTE_END = "\x1B[201~";
+/**
+* Rows one wheel event moves.
+*
+* One, not three: trackpads and hi-res wheels emit a stream of events per
+* gesture, so a multiplier here compounds into overshoot. The smoothness comes
+* from coalescing the stream into one repaint, not from bigger steps.
+*/
+const WHEEL_LINES = 1;
+/** An SGR mouse report: `ESC [ < button ; column ; row (M|m)`. */
+const MOUSE = /^\u001B\[<(\d+);(\d+);(\d+)([Mm])/;
+/** Wheel-up button code in the SGR encoding; wheel-down is one higher. */
+const WHEEL_UP = 64;
+/** Modifier bits in an SGR button code: Shift, Meta, and Control. */
+const MOUSE_MODIFIERS = 28;
+/** The motion bit, set on reports sent while a button is held. */
+const MOUSE_MOTION = 32;
 /** Sequences that resolve to one key, longest first so a prefix never wins. */
 const SEQUENCES = [
+	["\x1B[5~", {
+		kind: "page",
+		direction: -1
+	}],
+	["\x1B[6~", {
+		kind: "page",
+		direction: 1
+	}],
+	["\x1B[1;2A", {
+		kind: "scroll",
+		lines: -1
+	}],
+	["\x1B[1;2B", {
+		kind: "scroll",
+		lines: 1
+	}],
+	["\x1B[1;5F", { kind: "scroll-end" }],
 	["\x1B[1;5D", { kind: "word-left" }],
 	["\x1B[1;5C", { kind: "word-right" }],
 	["\x1B[1;3D", { kind: "word-left" }],
@@ -761,6 +783,40 @@ var KeyDecoder = class {
 			return [];
 		}
 		if (PASTE_START.startsWith(this.held)) return void 0;
+		const mouse = MOUSE.exec(this.held);
+		if (mouse !== null) {
+			this.held = this.held.slice(mouse[0].length);
+			const button = Number(mouse[1]);
+			if (button === WHEEL_UP) return [{
+				kind: "scroll",
+				lines: -WHEEL_LINES
+			}];
+			if (button === WHEEL_UP + 1) return [{
+				kind: "scroll",
+				lines: WHEEL_LINES
+			}];
+			const column = Number(mouse[2]);
+			const row = Number(mouse[3]);
+			if ((button & ~MOUSE_MOTION) === 0 && (button & MOUSE_MODIFIERS) === 0) {
+				if (mouse[4] === "m") return [{
+					kind: "mouse-up",
+					row,
+					column
+				}];
+				if ((button & MOUSE_MOTION) !== 0) return [{
+					kind: "mouse-drag",
+					row,
+					column
+				}];
+				return [{
+					kind: "mouse-down",
+					row,
+					column
+				}];
+			}
+			return [];
+		}
+		if (/^\u001B(\[(<\d*(;\d*){0,2})?)?$/.test(this.held)) return void 0;
 		for (const [sequence, key] of SEQUENCES) {
 			if (this.held.startsWith(sequence)) {
 				this.held = this.held.slice(sequence.length);
@@ -817,6 +873,543 @@ const ENABLE_PASTE_MARKERS = "\x1B[?2004h";
 /** Stop the terminal wrapping pasted text, restoring what it did before. */
 const DISABLE_PASTE_MARKERS = "\x1B[?2004l";
 
+//#endregion
+//#region src/wrap.ts
+/** One SGR sequence, which occupies no display columns. */
+const SGR = /^\u001B\[[0-9;]*m/;
+/** Any other escape sequence, also zero-width. */
+const ESCAPE = /^(?:\u001B\[[0-9;?]*[A-Za-z]|\u001B\][^\u0007]*\u0007|\u001B.)/;
+/** Closes every style a row opened, so a row never bleeds into the next. */
+const RESET = "\x1B[0m";
+/**
+* Break one styled line into rows no wider than `columns` display columns.
+*
+* Styles carry across the break: each continuation row re-opens whatever was
+* active where the cut fell, and every row that opened a style closes it.
+* @param text - the styled line, without a terminator.
+* @param columns - display columns available per row.
+* @returns the rows, at least one (an empty line yields one empty row).
+*/
+function wrapStyled(text, columns) {
+	if (columns <= 0) return [text];
+	const rows = [];
+	/** SGR sequences active at the cursor, in the order they were applied. */
+	let active = [];
+	let row = "";
+	let width = 0;
+	let rest = text;
+	const flush = () => {
+		rows.push(active.length > 0 ? `${row}${RESET}` : row);
+		row = active.join("");
+		width = 0;
+	};
+	while (rest !== "") {
+		const sgr = SGR.exec(rest);
+		if (sgr !== null) {
+			const sequence = sgr[0];
+			if (sequence === "\x1B[0m" || sequence === "\x1B[m") active = [];
+			else active.push(sequence);
+			row += sequence;
+			rest = rest.slice(sequence.length);
+			continue;
+		}
+		const other = ESCAPE.exec(rest);
+		if (other !== null) {
+			row += other[0];
+			rest = rest.slice(other[0].length);
+			continue;
+		}
+		const character = [...rest][0] ?? "";
+		const cost = displayWidth(character);
+		if (width + cost > columns && width > 0) flush();
+		row += character;
+		width += cost;
+		rest = rest.slice(character.length);
+	}
+	rows.push(active.length > 0 ? `${row}${RESET}` : row);
+	return rows;
+}
+/**
+* Wrap many lines, keeping their order.
+* @param lines - styled lines.
+* @param columns - display columns per row.
+* @returns the physical rows they occupy.
+*/
+function wrapAll(lines, columns) {
+	return lines.flatMap((line) => wrapStyled(line, columns));
+}
+
+//#endregion
+//#region src/screen.ts
+/** Logical transcript lines kept before the oldest are dropped. */
+const MAX_SCROLLBACK = 5e3;
+/** Enter the alternate screen, saving the cursor and the current buffer. */
+const ENTER_ALT = "\x1B[?1049h";
+/** Leave it, restoring both. */
+const LEAVE_ALT = "\x1B[?1049l";
+/**
+* Report wheel and button events, in the SGR encoding.
+*
+* Button tracking (1002) rather than any-motion (1003): the wheel and clicks
+* are all this surface reads, and motion reporting floods the input for
+* nothing. Most terminals still hand a Shift-drag to their own selection, so
+* copying text keeps working.
+*/
+const ENABLE_MOUSE = "\x1B[?1002h\x1B[?1006h";
+/** Stop reporting them. */
+const DISABLE_MOUSE = "\x1B[?1006l\x1B[?1002l";
+/** Ask the terminal to paint a frame atomically, so no half-frame is shown. */
+const SYNC_BEGIN = "\x1B[?2026h";
+/** End the atomic frame. */
+const SYNC_END = "\x1B[?2026l";
+/** Erase the row from the cursor rightwards. */
+const CLEAR_LINE = "\x1B[K";
+/** Hide the cursor while a frame is painted. */
+const HIDE_CURSOR = "\x1B[?25l";
+/** Show it again. */
+const SHOW_CURSOR = "\x1B[?25h";
+/** Styling escapes, removed before a row is measured or copied. */
+const STYLES = /\u001B\[[0-9;]*m/gu;
+/** Start reverse video, which is how the selection shows itself. */
+const INVERSE = "\x1B[7m";
+/** End reverse video only, leaving any other attributes alone. */
+const INVERSE_OFF = "\x1B[27m";
+/**
+* The string index where a display column begins.
+*
+* Columns are what the mouse reports and characters are what strings hold;
+* this is the bridge. A column landing inside a wide character snaps past it.
+* @param text - plain text, no escapes.
+* @param column - display column, 0-based.
+* @returns the index of the first character at or beyond that column.
+*/
+function columnIndex(text, column) {
+	let width = 0;
+	let index = 0;
+	for (const character of text) {
+		if (width >= column) return index;
+		width += displayWidth(character);
+		index += character.length;
+	}
+	return text.length;
+}
+/** An alternate-screen viewport over a scrollback buffer this surface owns. */
+var Screen = class {
+	/** Logical transcript lines, unwrapped, oldest first. */
+	logical = [];
+	/** The same lines wrapped to the current width — what the viewport slices. */
+	physical = [];
+	/** The bottom rows: input box, menu, indicator, status. */
+	chrome = [];
+	chromeCursor = {
+		row: 0,
+		column: 0
+	};
+	/** Whether the chrome holds input focus, which is when the cursor shows. */
+	chromeFocus = true;
+	/** Physical rows hidden below the viewport; zero means following the tail. */
+	offset = 0;
+	/** What to show while scrolled back, drawn over the viewport's top row. */
+	notice = "";
+	/** A mouse selection over the transcript, in physical-row coordinates. */
+	selection;
+	/** Collapsed blocks in the transcript, in order, with both of their forms. */
+	folds = [];
+	/** Whether the folds currently show their full form. */
+	expanded = false;
+	/** The last painted frame, so a repaint only touches rows that changed. */
+	painted = [];
+	/** Width the current frame was painted at, to detect a resize. */
+	paintedColumns = 0;
+	active = false;
+	constructor(host) {
+		this.host = host;
+	}
+	/** Whether the alternate screen is currently held. */
+	get entered() {
+		return this.active;
+	}
+	/** Physical rows scrolled up out of view; zero means the tail is showing. */
+	get scrolledBy() {
+		return this.offset;
+	}
+	/** Take the alternate screen and start reporting the mouse. */
+	enter() {
+		if (this.active) return;
+		this.active = true;
+		this.host.write(`${ENTER_ALT}${ENABLE_MOUSE}${HIDE_CURSOR}`);
+		this.painted = [];
+		this.render();
+	}
+	/**
+	* Give the terminal back exactly as it was.
+	*
+	* Idempotent, because every exit path calls it — a normal quit, an
+	* interrupt, and a crash handler all have to leave the terminal usable.
+	*/
+	leave() {
+		if (!this.active) return;
+		this.active = false;
+		this.host.write(`${DISABLE_MOUSE}${SHOW_CURSOR}${LEAVE_ALT}`);
+		this.painted = [];
+	}
+	/**
+	* Append finished transcript lines.
+	*
+	* Following the tail is the default; a person who has scrolled up stays
+	* where they are, and the new rows accumulate below them.
+	* @param lines - the lines to keep, already styled.
+	*/
+	append(lines) {
+		if (lines.length === 0) return;
+		const columns = this.contentColumns();
+		for (const line of lines) {
+			this.logical.push(line);
+			this.physical.push(...wrapStyled(line, columns));
+		}
+		if (this.logical.length > MAX_SCROLLBACK) {
+			const dropped = this.logical.length - MAX_SCROLLBACK;
+			this.logical.splice(0, dropped);
+			this.folds = this.folds.flatMap((fold) => {
+				const at = fold.at - dropped;
+				return at >= 0 ? [{
+					...fold,
+					at
+				}] : [];
+			});
+			this.rewrap();
+		}
+		this.render();
+	}
+	/**
+	* Append one collapsible block: its summary now, its full form on demand.
+	*
+	* This is what makes every long block — not merely the latest — expandable:
+	* the buffer keeps both forms, and toggling rebuilds the transcript in
+	* place, exactly like a details/summary element.
+	* @param summary - the collapsed lines, already styled.
+	* @param full - the expanded lines, already styled.
+	*/
+	appendFold(summary, full) {
+		const shown = this.expanded ? full : summary;
+		this.folds.push({
+			at: this.logical.length,
+			shownLength: shown.length,
+			summary: [...summary],
+			full: [...full],
+			expanded: this.expanded
+		});
+		this.append(shown);
+	}
+	/**
+	* Turn the last `count` appended lines into a collapsible block after the
+	* fact.
+	*
+	* This is how a finished answer becomes foldable without ever having been
+	* withheld: it streamed in the open, and only once complete does it grow a
+	* summary form. The block starts expanded — the person is reading it — and
+	* collapses with the rest when the conversation moves on.
+	* @param count - how many trailing lines the block owns.
+	* @param summary - the collapsed lines, already styled.
+	*/
+	foldBack(count, summary) {
+		const at = this.logical.length - count;
+		if (count <= 0 || at < 0) return;
+		const last = this.folds.at(-1);
+		if (last !== void 0 && at < last.at + last.shownLength) return;
+		this.folds.push({
+			at,
+			shownLength: count,
+			summary: [...summary],
+			full: this.logical.slice(at),
+			expanded: true
+		});
+	}
+	/** Whether any collapsible block exists. */
+	get hasFolds() {
+		return this.folds.length > 0;
+	}
+	/** Whether the folds currently show their full form. */
+	get foldsExpanded() {
+		return this.expanded;
+	}
+	/**
+	* Swap every fold between its summary and its full form.
+	* @returns false when there is nothing to toggle.
+	*/
+	toggleFolds() {
+		if (this.folds.length === 0) return false;
+		this.setFolds(!this.expanded);
+		return true;
+	}
+	/** Return every fold to its summary, the way moving on reads as dismissal. */
+	collapseFolds() {
+		if (this.folds.some((fold) => fold.expanded)) this.setFolds(false);
+		else this.expanded = false;
+	}
+	/** Put every fold into one form, whatever mix of states they are in now. */
+	setFolds(expanded) {
+		this.expanded = expanded;
+		const deltas = /* @__PURE__ */ new Map();
+		for (const fold of [...this.folds].reverse()) {
+			if (fold.expanded === expanded) {
+				deltas.set(fold, 0);
+				continue;
+			}
+			const shown = expanded ? fold.full : fold.summary;
+			this.logical.splice(fold.at, fold.shownLength, ...shown);
+			deltas.set(fold, shown.length - fold.shownLength);
+			fold.shownLength = shown.length;
+			fold.expanded = expanded;
+		}
+		let shift = 0;
+		for (const fold of this.folds) {
+			fold.at += shift;
+			shift += deltas.get(fold) ?? 0;
+		}
+		this.rewrap();
+		this.offset = 0;
+		this.painted = [];
+		this.render();
+	}
+	/**
+	* Replace the bottom rows.
+	* @param rows - the chrome, top to bottom.
+	* @param cursor - where the cursor belongs among them.
+	* @param focus - whether to show the cursor there.
+	*/
+	setChrome(rows, cursor, focus) {
+		this.chrome = rows.map((row) => truncate(row, this.contentColumns()));
+		this.chromeCursor = { ...cursor };
+		this.chromeFocus = focus;
+		this.render();
+	}
+	/**
+	* Set the line shown while the reader is away from the tail.
+	*
+	* Drawn OVER the viewport's top row rather than added to the chrome: a notice
+	* that changed the chrome's height would move the input box as a side effect
+	* of scrolling, and would make a page up and a page down different sizes.
+	* @param text - the styled notice, already fitted.
+	*/
+	setScrollNotice(text) {
+		if (text === this.notice) return;
+		this.notice = text;
+		if (this.offset > 0) this.render();
+	}
+	/**
+	* Scroll the transcript.
+	* @param delta - rows to move; negative scrolls back into history.
+	*/
+	scrollBy(delta) {
+		const limit = Math.max(0, this.physical.length - this.viewportHeight());
+		const next = Math.min(limit, Math.max(0, this.offset - delta));
+		if (next === this.offset) return;
+		this.offset = next;
+		this.render();
+	}
+	/**
+	* Scroll by a whole viewport, which is what the page keys mean.
+	* @param direction - -1 for back into history, 1 towards the tail.
+	*/
+	scrollPage(direction) {
+		this.scrollBy(direction * Math.max(1, this.viewportHeight() - 1));
+	}
+	/** Jump back to the tail, which is also what a new submission does. */
+	scrollToBottom() {
+		if (this.offset === 0) return;
+		this.offset = 0;
+		this.render();
+	}
+	/**
+	* Drop the transcript, keeping the chrome.
+	*
+	* Ctrl-L on a shared terminal clears a viewport the person may want back; on
+	* our own screen the buffer IS the session's history, so this empties it.
+	*/
+	clearTranscript() {
+		this.logical = [];
+		this.physical = [];
+		this.folds = [];
+		this.expanded = false;
+		this.offset = 0;
+		this.painted = [];
+		this.render();
+	}
+	/** Re-wrap and repaint after the terminal changed size. */
+	resize() {
+		this.rewrap();
+		this.painted = [];
+		this.render();
+	}
+	/**
+	* Anchor a selection where the left button went down.
+	*
+	* The terminal cannot select for us while mouse reporting is on, so the
+	* viewport does it: press anchors, motion extends, release copies — the
+	* shape opencode and Claude give the same gesture.
+	* @param row - terminal row, 1-based.
+	* @param column - terminal column, 1-based.
+	*/
+	mouseDown(row, column) {
+		const had = this.selection !== void 0;
+		this.selection = void 0;
+		const at = this.locate(row, column, false);
+		if (at !== void 0) this.selection = {
+			anchor: at,
+			focus: at,
+			dragged: false
+		};
+		if (had) this.render();
+	}
+	/**
+	* Extend the selection to where the pointer moved.
+	* @param row - terminal row, 1-based.
+	* @param column - terminal column, 1-based.
+	*/
+	mouseDrag(row, column) {
+		if (this.selection === void 0) return;
+		const at = this.locate(row, column, true);
+		if (at === void 0) return;
+		this.selection.focus = at;
+		this.selection.dragged = true;
+		this.render();
+	}
+	/**
+	* Finish the gesture.
+	*
+	* The highlight stays up — the copy already happened, and the marks show
+	* what it took — until the next click or reflow dismisses it.
+	* @returns the selected text, or undefined for a bare click.
+	*/
+	mouseUp() {
+		const selection = this.selection;
+		if (selection === void 0) return void 0;
+		if (!selection.dragged) {
+			this.selection = void 0;
+			return;
+		}
+		const text = this.selectedText();
+		if (text === "") {
+			this.selection = void 0;
+			this.render();
+			return;
+		}
+		return text;
+	}
+	/** The selection's bounds in order, top-left first. */
+	orderedSelection() {
+		const selection = this.selection;
+		if (selection === void 0 || !selection.dragged) return void 0;
+		const { anchor, focus } = selection;
+		const [from, to] = focus.row < anchor.row || focus.row === anchor.row && focus.column < anchor.column ? [focus, anchor] : [anchor, focus];
+		return {
+			from,
+			to
+		};
+	}
+	/** The plain text under the selection, visual rows joined by newlines. */
+	selectedText() {
+		const bounds = this.orderedSelection();
+		if (bounds === void 0) return "";
+		const rows = [];
+		for (let index = bounds.from.row; index <= bounds.to.row; index += 1) {
+			const plain = (this.physical[index] ?? "").replaceAll(STYLES, "");
+			const start = index === bounds.from.row ? columnIndex(plain, bounds.from.column) : 0;
+			const end = index === bounds.to.row ? columnIndex(plain, bounds.to.column + 1) : plain.length;
+			rows.push(plain.slice(start, end));
+		}
+		return rows.join("\n").replace(/^\n+|\n+$/gu, "") === "" ? "" : rows.join("\n");
+	}
+	/**
+	* Map a terminal position to a physical buffer position.
+	* @param row - terminal row, 1-based.
+	* @param column - terminal column, 1-based.
+	* @param clamp - pull an outside position to the nearest content row, the
+	* way dragging past an edge keeps selecting, instead of refusing it.
+	* @returns the position, or undefined when it misses the content.
+	*/
+	locate(row, column, clamp) {
+		if (this.physical.length === 0) return void 0;
+		const height = this.viewportHeight();
+		const end = this.physical.length - this.offset;
+		const start = Math.max(0, end - height);
+		let index = start + row - 1;
+		if (!clamp && (row - 1 >= height || index >= end || index < start)) return void 0;
+		index = Math.min(Math.max(index, start), end - 1);
+		return {
+			row: index,
+			column: Math.max(0, column - 1)
+		};
+	}
+	/** Rows the transcript viewport occupies. */
+	viewportHeight() {
+		return Math.max(1, this.host.rows() - this.chrome.length);
+	}
+	/** Columns content is laid out for, one short of the width so no row wraps. */
+	contentColumns() {
+		return Math.max(1, this.host.columns() - 1);
+	}
+	/** Re-wrap every kept line at the current width. */
+	rewrap() {
+		this.selection = void 0;
+		this.physical = wrapAll(this.logical, this.contentColumns());
+		const limit = Math.max(0, this.physical.length - this.viewportHeight());
+		this.offset = Math.min(this.offset, limit);
+	}
+	/**
+	* Compose and paint the frame.
+	*
+	* The viewport is padded at the top when the transcript is shorter than the
+	* screen, which is what puts the chrome at the bottom from the first frame
+	* rather than wherever output happened to reach.
+	*/
+	render() {
+		if (!this.active) return;
+		const columns = this.host.columns();
+		if (columns !== this.paintedColumns) {
+			this.physical = wrapAll(this.logical, this.contentColumns());
+			this.painted = [];
+			this.paintedColumns = columns;
+		}
+		const height = this.viewportHeight();
+		const end = this.physical.length - this.offset;
+		const visible = this.physical.slice(Math.max(0, end - height), Math.max(0, end));
+		const padding = Array.from({ length: Math.max(0, height - visible.length) }, () => "");
+		const bounds = this.orderedSelection();
+		if (bounds !== void 0) {
+			const first = Math.max(0, end - height);
+			for (let index = 0; index < visible.length; index += 1) {
+				const at = first + index;
+				if (at < bounds.from.row || at > bounds.to.row) continue;
+				const plain = (visible[index] ?? "").replaceAll(STYLES, "");
+				const start = at === bounds.from.row ? columnIndex(plain, bounds.from.column) : 0;
+				const stop = at === bounds.to.row ? columnIndex(plain, bounds.to.column + 1) : plain.length;
+				let marked = plain.slice(start, stop);
+				if (marked === "" && at > bounds.from.row && at < bounds.to.row) marked = " ";
+				if (marked === "" && start >= stop) continue;
+				visible[index] = `${plain.slice(0, start)}${INVERSE}${marked}${INVERSE_OFF}${plain.slice(stop)}`;
+			}
+		}
+		const viewport = [...visible, ...padding];
+		if (this.offset > 0 && this.notice !== "" && viewport.length > 0) viewport[0] = truncate(this.notice, this.contentColumns());
+		const frame = [...viewport, ...this.chrome];
+		let out = SYNC_BEGIN + HIDE_CURSOR;
+		frame.forEach((row, index) => {
+			if (this.painted[index] === row) return;
+			out += `\u001B[${index + 1};1H${CLEAR_LINE}${row}`;
+		});
+		for (let index = frame.length; index < this.painted.length; index += 1) out += `\u001B[${index + 1};1H${CLEAR_LINE}`;
+		if (this.chromeFocus) {
+			const row = frame.length - this.chrome.length + this.chromeCursor.row + 1;
+			out += `\u001B[${row};${this.chromeCursor.column + 1}H${SHOW_CURSOR}`;
+		}
+		out += SYNC_END;
+		this.host.write(out);
+		this.painted = frame;
+	}
+};
+
 //#endregion
 //#region src/console.ts
 /** Columns assumed when the output stream reports none (a pipe). */
@@ -829,14 +1422,8 @@ const FALLBACK_COLUMNS = 80;
 * this floor the lines overflow instead, which stays readable.
 */
 const MIN_COLUMNS = 20;
-/** Erase the current line from the cursor rightwards. */
-const CLEAR_LINE = "\x1B[K";
-/** Erase from the cursor to the end of the screen. */
-const CLEAR_BELOW = "\x1B[0J";
-/** Hide the cursor while a region is redrawn, so it does not visibly jump. */
-const HIDE_CURSOR = "\x1B[?25l";
-/** Show the cursor again. */
-const SHOW_CURSOR = "\x1B[?25h";
+/** Rows assumed when the output stream reports none. */
+const FALLBACK_ROWS = 24;
 /**
 * How long a held Escape waits for a successor before it counts as the key.
 *
@@ -857,21 +1444,22 @@ var TerminalConsole = class {
 	earlyKeys = [];
 	escapeTimer;
 	ended = false;
-	/** Rows currently drawn in the bottom region. */
-	regionRows = [];
-	/** Where among those rows the cursor was left. */
-	regionCursor = {
-		row: 0,
-		column: 0
-	};
-	/** Whether the region currently holds input focus, which shows the cursor. */
-	regionFocus = true;
+	/** The viewport this surface owns on a terminal; absent off one. */
+	screen;
 	constructor(input, output) {
 		this.input = input;
 		this.output = output;
 		if (this.readsKeys) {
 			input.setRawMode?.(true);
 			this.output.write(ENABLE_PASTE_MARKERS);
+			this.screen = new Screen({
+				write: (data) => void this.output.write(data),
+				columns: () => this.columns,
+				rows: () => Math.max(2, this.output.rows ?? FALLBACK_ROWS)
+			});
+			this.output.on("resize", () => {
+				this.screen?.resize();
+			});
 			input.on("data", (chunk) => {
 				this.onBytes(chunk);
 			});
@@ -897,6 +1485,15 @@ var TerminalConsole = class {
 	get columns() {
 		return Math.max(this.output.columns ?? FALLBACK_COLUMNS, MIN_COLUMNS);
 	}
+	/**
+	* Columns content may be laid out for: one less than the width, because the
+	* viewport wraps at that boundary. Markdown layout MUST use this figure — a
+	* table laid out one column wider is refolded by the viewport, and its rows
+	* shear apart.
+	*/
+	get contentColumns() {
+		return Math.max(1, this.columns - 1);
+	}
 	/** Whether the output stream is a terminal. */
 	get isTty() {
 		return this.output.isTTY === true;
@@ -926,19 +1523,59 @@ var TerminalConsole = class {
 		return () => void this.output.off("resize", handler);
 	}
 	/**
-	* Clear the visible screen.
+	* Take the viewport: the transcript and the prompt live on their own screen
+	* from here, and the terminal keeps the buffer the person had.
+	*/
+	enterScreen() {
+		this.screen?.enter();
+	}
+	/**
+	* Give the terminal back. Idempotent: every exit path calls it.
+	*/
+	leaveScreen() {
+		this.screen?.leave();
+	}
+	/** Whether this surface currently holds its own screen. */
+	get owningScreen() {
+		return this.screen?.entered === true;
+	}
+	/**
+	* Scroll the transcript inside the viewport.
+	* @param delta - rows to move; negative goes back into history.
+	*/
+	scrollBy(delta) {
+		this.screen?.scrollBy(delta);
+	}
+	/**
+	* Set the notice shown while the transcript is scrolled back.
+	* @param text - the styled line, or the empty string for none.
+	*/
+	setScrollNotice(text) {
+		this.screen?.setScrollNotice(text);
+	}
+	/**
+	* Scroll the transcript by a whole viewport.
+	* @param direction - -1 for back into history, 1 towards the tail.
+	*/
+	scrollPage(direction) {
+		this.screen?.scrollPage(direction);
+	}
+	/** Return to the tail of the transcript. */
+	scrollToBottom() {
+		this.screen?.scrollToBottom();
+	}
+	/** Physical rows currently scrolled out of view; zero means at the tail. */
+	get scrolledBy() {
+		return this.screen?.scrolledBy ?? 0;
+	}
+	/**
+	* Clear the transcript this session accumulated.
 	*
-	* The scrollback survives — this wipes the viewport the way a shell's clear
-	* does. The managed region is forgotten with it, so the caller redraws.
+	* On its own screen there is no shell scrollback to preserve, so this empties
+	* the buffer the viewport shows rather than wiping a shared terminal.
 	*/
 	clearScreen() {
-		if (!this.readsKeys) return;
-		this.output.write("\x1B[2J\x1B[H");
-		this.regionRows = [];
-		this.regionCursor = {
-			row: 0,
-			column: 0
-		};
+		this.screen?.clearTranscript();
 	}
 	/**
 	* Route decoded keys to a handler.
@@ -1003,77 +1640,133 @@ var TerminalConsole = class {
 		}
 	}
 	/**
-	* Write one finished line above the managed region.
+	* Keep one finished transcript line.
 	*
-	* The region is erased first and redrawn after, so the transcript stays
-	* append-only while the input box keeps its place at the bottom.
+	* On its own screen the line goes into the viewport's scrollback, which is
+	* what lets the transcript scroll under a prompt that does not move. Off one
+	* it is written straight out, because a pipe's reader wants exactly that.
 	* @param line - the line, without its terminator.
 	*/
 	write(line) {
-		if (this.regionRows.length === 0) {
-			this.output.write(`${line}\n`);
+		if (this.screen !== void 0) {
+			this.screen.append([line]);
 			return;
 		}
-		const rows = this.regionRows;
-		const cursor = this.regionCursor;
-		this.eraseRegion();
 		this.output.write(`${line}\n`);
-		this.drawRegion(rows, cursor, this.regionFocus);
 	}
 	/**
-	* Replace the managed region at the bottom of the screen.
+	* Replace the rows pinned below the transcript.
 	*
 	* This is the whole live area: an input box, a completion menu, a working
-	* indicator. Everything the transcript keeps goes through {@link write}
-	* instead, because a terminal cannot revise a row that has scrolled. Off a
-	* terminal the call is ignored — a redirected transcript must not collect
-	* frames of a box nobody can see.
+	* indicator, the status row. Off a terminal the call is ignored — a
+	* redirected transcript must not collect frames of a box nobody can see.
 	* @param rows - the rows to display, top to bottom.
 	* @param cursor - where to leave the terminal cursor among them.
-	* @param focus - whether the region holds input focus. Without it the cursor
-	*   stays hidden: a block cursor parked on a display row (the status line,
-	*   a streaming line) reads as content colliding with it.
+	* @param focus - whether the rows hold input focus, which is when the cursor
+	*   shows. Parked anywhere else it reads as content colliding with it.
 	*/
 	setRegion(rows, cursor, focus = true) {
-		if (!this.readsKeys) return;
-		this.eraseRegion();
-		this.drawRegion(rows, cursor, focus);
-		this.regionRows = [...rows];
-		this.regionCursor = { ...cursor };
-		this.regionFocus = focus;
-	}
-	/** Remove the region, leaving the cursor where the next write will land. */
-	clearRegion() {
-		if (this.regionRows.length === 0) return;
-		this.eraseRegion();
-		if (!this.regionFocus) this.output.write(SHOW_CURSOR);
-		this.regionRows = [];
-		this.regionCursor = {
-			row: 0,
-			column: 0
-		};
-		this.regionFocus = true;
+		this.screen?.setChrome(rows, cursor, focus);
+	}
+	/**
+	* Keep one collapsible block: summary now, full form behind the toggle.
+	*
+	* Off a terminal only the summary is written — a pipe has no keys to toggle
+	* with, and scripts want the digest.
+	* @param summary - the collapsed lines.
+	* @param full - the expanded lines.
+	*/
+	appendFold(summary, full) {
+		if (this.screen !== void 0) {
+			this.screen.appendFold(summary, full);
+			return;
+		}
+		for (const line of summary) this.output.write(`${line}\n`);
+	}
+	/**
+	* Swap every collapsible block between summary and full form.
+	* @returns false when there is nothing to toggle.
+	*/
+	/**
+	* Anchor a mouse selection at a terminal position.
+	* @param row - terminal row, 1-based.
+	* @param column - terminal column, 1-based.
+	*/
+	mouseDown(row, column) {
+		this.screen?.mouseDown(row, column);
+	}
+	/**
+	* Extend the mouse selection to a terminal position.
+	* @param row - terminal row, 1-based.
+	* @param column - terminal column, 1-based.
+	*/
+	mouseDrag(row, column) {
+		this.screen?.mouseDrag(row, column);
 	}
-	/** Move to the region's first row and erase everything from there down. */
-	eraseRegion() {
-		if (this.regionRows.length === 0) return;
-		const up = this.regionCursor.row > 0 ? `\u001B[${this.regionCursor.row}A` : "";
-		this.output.write(`${HIDE_CURSOR}${up}\r${CLEAR_BELOW}`);
+	/**
+	* Finish the mouse selection.
+	* @returns the selected text, or undefined for a bare click.
+	*/
+	mouseUp() {
+		return this.screen?.mouseUp();
 	}
 	/**
-	* Draw rows from the cursor down and place the cursor among them.
-	* @param rows - the rows to draw.
-	* @param cursor - the target position.
-	* @param focus - whether to show the cursor at that position afterwards.
+	* Put text on the clipboard.
+	*
+	* Two channels, because neither is universal: OSC 52 reaches through SSH and
+	* works wherever the terminal permits it, and the platform helper covers the
+	* terminals that refuse the escape. `CODSH_CLIPBOARD` narrows it to `osc52`,
+	* `system`, or `off` — tests use `osc52` so a run never touches the real
+	* clipboard.
+	* @param text - the plain text to copy.
+	* @returns whether a copy was attempted at all.
 	*/
-	drawRegion(rows, cursor, focus = true) {
-		if (rows.length === 0) return;
-		const fitted = rows.map((row) => truncate(row, this.columns - 1));
-		const body = fitted.map((row) => `${CLEAR_LINE}${row}`).join("\n");
-		const back = fitted.length - 1 - cursor.row;
-		const up = back > 0 ? `\u001B[${back}A` : "";
-		const right = cursor.column > 0 ? `\u001B[${cursor.column}C` : "";
-		this.output.write(`${HIDE_CURSOR}${body}${up}\r${right}${focus ? SHOW_CURSOR : ""}`);
+	copyText(text) {
+		const mode = process.env["CODSH_CLIPBOARD"] ?? "both";
+		if (mode === "off" || text === "") return false;
+		if (mode !== "system") this.output.write(`\u001B]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`);
+		if (mode !== "osc52") {
+			const command = process.platform === "darwin" ? ["pbcopy"] : process.platform === "win32" ? ["clip"] : process.env["WAYLAND_DISPLAY"] === void 0 ? [
+				"xclip",
+				"-selection",
+				"clipboard"
+			] : ["wl-copy"];
+			try {
+				const child = spawn(command[0] ?? "", command.slice(1), { stdio: [
+					"pipe",
+					"ignore",
+					"ignore"
+				] });
+				child.on("error", () => {});
+				child.stdin.end(text);
+			} catch {}
+		}
+		return true;
+	}
+	/**
+	* Make the last `count` written lines a collapsible block after the fact.
+	*
+	* Screen-only on purpose: a pipe already carries the full text, and a
+	* summary would subtract from it.
+	* @param count - how many trailing lines the block owns.
+	* @param summary - the collapsed lines, already styled.
+	*/
+	foldRecent(count, summary) {
+		this.screen?.foldBack(count, summary);
+	}
+	toggleFolds() {
+		return this.screen?.toggleFolds() ?? false;
+	}
+	/** Return every block to its summary. */
+	collapseFolds() {
+		this.screen?.collapseFolds();
+	}
+	/** Take the pinned rows down, leaving the transcript alone. */
+	clearRegion() {
+		this.screen?.setChrome([], {
+			row: 0,
+			column: 0
+		}, false);
 	}
 	/** Ring the terminal bell; a pipe gets nothing to beep with. */
 	bell() {
@@ -1120,10 +1813,9 @@ var TerminalConsole = class {
 	}
 	/** Restore the terminal and stop reading. */
 	close() {
-		this.clearRegion();
 		if (this.escapeTimer !== void 0) clearTimeout(this.escapeTimer);
 		if (this.readsKeys) {
-			this.output.write(SHOW_CURSOR);
+			this.screen?.leave();
 			this.output.write(DISABLE_PASTE_MARKERS);
 			this.input.setRawMode?.(false);
 			this.input.pause();
@@ -1131,6 +1823,17 @@ var TerminalConsole = class {
 		this.rl?.close();
 		this.end();
 	}
+	/**
+	* Write one line to the terminal the person keeps, not to our viewport.
+	*
+	* The exit summary is what needs this: the session's own screen disappears
+	* with it, so the few facts worth keeping — the session id, what it cost —
+	* have to land in the buffer that survives.
+	* @param line - the line, without its terminator.
+	*/
+	writeAfterScreen(line) {
+		this.output.write(`${line}\n`);
+	}
 };
 
 //#endregion
@@ -1593,19 +2296,22 @@ function inputBox(view, theme, columns, options = {}) {
 	});
 	rows.push(accent(`╰${rule}╯`));
 	if (view.candidates.length > 0) {
-		const menu = view.candidates.slice(0, MENU_LIMIT);
+		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 = index === view.selected;
+			const chosen = first + index === view.selected;
 			const matched = view.token !== "" && candidate.value.startsWith(view.token) ? view.token.length : 0;
-			const head = theme.tool(candidate.value.slice(0, matched));
+			const head = candidate.value.slice(0, matched);
 			const tail = candidate.value.slice(matched);
-			const label = `${head}${chosen ? theme.bold(tail) : tail}`;
+			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));
 		});
-		if (view.candidates.length > menu.length) rows.push(theme.dim(`  … ${view.candidates.length - menu.length} more`));
+		const below = view.candidates.length - first - menu.length;
+		if (below > 0) rows.push(theme.dim(`  ↓ ${below} more`));
 	} else if (options.hint !== void 0) rows.push(theme.dim(truncate(options.hint, columns)));
 	const inCursorRow = visual[cursorAt];
 	const before = inCursorRow === void 0 ? "" : Array.from(view.lines[view.row] ?? "").slice(inCursorRow.start, view.column).join("");
@@ -1619,6 +2325,8 @@ function inputBox(view, theme, columns, options = {}) {
 //#endregion
 //#region src/selector.ts
 /** An in-progress selection. */
+/** Option rows shown at once; the window follows the marked row. */
+const VISIBLE_ROWS = 10;
 var Selector = class {
 	selected = 0;
 	checked = /* @__PURE__ */ new Set();
@@ -1714,10 +2422,16 @@ var Selector = class {
 	*/
 	view(theme, columns) {
 		const rows = [theme.bold(truncate(this.spec.title, columns))];
-		this.spec.options.forEach((option, index) => {
-			rows.push(this.row(index, this.label(option, theme), option.detail, theme, columns));
-		});
-		if (this.spec.custom !== void 0) rows.push(this.row(this.spec.options.length, theme.dim(this.spec.custom), void 0, theme, columns));
+		const total = this.count;
+		const first = Math.min(Math.max(0, this.selected - VISIBLE_ROWS + 1), Math.max(0, total - VISIBLE_ROWS));
+		if (first > 0) rows.push(theme.dim(`  ↑ ${first} more`));
+		for (let index = first; index < Math.min(total, first + VISIBLE_ROWS); index += 1) {
+			const option = this.spec.options[index];
+			if (option !== void 0) rows.push(this.row(index, this.label(option, theme), option.detail, theme, columns));
+			else if (this.spec.custom !== void 0) rows.push(this.row(index, theme.dim(this.spec.custom), void 0, theme, columns));
+		}
+		const below = total - first - VISIBLE_ROWS;
+		if (below > 0) rows.push(theme.dim(`  ↓ ${below} more`));
 		const how = this.spec.multi === true ? "Space toggles · Enter confirms · Esc cancels" : "↑↓ move · Enter accepts · Esc cancels";
 		rows.push(theme.dim(truncate(`  ${how}`, columns)));
 		return rows;
@@ -1747,12 +2461,14 @@ var Selector = class {
 		const box = this.spec.multi === true && !this.isCustom(index) ? this.checked.has(index) ? theme.success("◉ ") : theme.dim("○ ") : "";
 		const number = theme.dim(`${index + 1}.`);
 		const trail = detail === void 0 || detail === "" ? "" : theme.dim(`  ${detail}`);
-		return truncate(`${marker} ${number} ${box}${marked ? theme.bold(label) : label}${trail}`, columns);
+		return truncate(`${marker} ${number} ${box}${marked ? theme.bold(theme.tool(label)) : label}${trail}`, columns);
 	}
 };
 
 //#endregion
 //#region src/prompt.ts
+/** How long a flash notice holds the hint row. */
+const FLASH_MS = 1500;
 /** Drives the input box and answers reads and selections. */
 var Prompt = class {
 	editor;
@@ -1767,6 +2483,9 @@ var Prompt = class {
 	queued = [];
 	/** The working indicator shown under the box. */
 	hint;
+	/** A short-lived notice that borrows the hint row, e.g. the copy toast. */
+	flash;
+	flashTimer;
 	/** The always-current session facts shown as the region's last row. */
 	status;
 	/** The assistant line still arriving, shown above the box. */
@@ -1775,6 +2494,9 @@ var Prompt = class {
 	accent;
 	/** Whether a read is outstanding, which decides where a submission goes. */
 	reading = false;
+	/** Wheel rows accumulated this tick, painted once — scrolling per event janks. */
+	pendingScroll = 0;
+	scrollFlushQueued = false;
 	/**
 	* Whether the interactive session is running, which is when the box is worth
 	* drawing. The box stays up while the agent works — typing ahead must be
@@ -1833,10 +2555,30 @@ var Prompt = class {
 	* @param text - the text, or undefined to drop the row.
 	*/
 	setHint(text) {
+		if (text === this.hint) return;
 		this.hint = text;
 		this.render();
 	}
 	/**
+	* Show a notice on the hint row briefly, then give the row back.
+	*
+	* The hint row belongs to the working indicator, which repaints itself
+	* continuously — a notice written through setHint would last one tick. The
+	* flash outranks the hint until its moment passes.
+	* @param text - the styled notice.
+	*/
+	setFlash(text) {
+		this.flash = text;
+		if (this.flashTimer !== void 0) clearTimeout(this.flashTimer);
+		this.flashTimer = setTimeout(() => {
+			this.flash = void 0;
+			this.flashTimer = void 0;
+			this.render();
+		}, FLASH_MS);
+		this.flashTimer.unref();
+		this.render();
+	}
+	/**
 	* Set the status row, the region's always-current last line.
 	* @param text - the styled row, or undefined to drop it.
 	*/
@@ -1957,6 +2699,48 @@ var Prompt = class {
 			this.handlers.expandOutput?.();
 			return;
 		}
+		if (key.kind === "page") {
+			this.console.scrollPage(key.direction);
+			this.render();
+			return;
+		}
+		if (key.kind === "scroll") {
+			this.pendingScroll += key.lines;
+			if (!this.scrollFlushQueued) {
+				this.scrollFlushQueued = true;
+				queueMicrotask(() => {
+					this.scrollFlushQueued = false;
+					const delta = this.pendingScroll;
+					this.pendingScroll = 0;
+					if (delta !== 0) {
+						this.console.scrollBy(delta);
+						this.render();
+					}
+				});
+			}
+			return;
+		}
+		if (key.kind === "scroll-end") {
+			this.console.scrollToBottom();
+			this.render();
+			return;
+		}
+		if (key.kind === "mouse-down") {
+			this.console.mouseDown(key.row, key.column);
+			return;
+		}
+		if (key.kind === "mouse-drag") {
+			this.console.mouseDrag(key.row, key.column);
+			return;
+		}
+		if (key.kind === "mouse-up") {
+			const text = this.console.mouseUp();
+			if (text !== void 0 && this.console.copyText(text)) {
+				const rows = text.split("\n").length;
+				this.setFlash(this.theme.dim(rows > 1 ? `  ✓ copied ${rows} lines` : "  ✓ copied"));
+			}
+			return;
+		}
 		const selecting = this.select_;
 		if (selecting !== void 0) {
 			const step = selecting.selector.handle(key);
@@ -1978,6 +2762,7 @@ var Prompt = class {
 				}
 				waiting.dispose();
 				waiting.resolve(action.text);
+				this.console.scrollToBottom();
 				break;
 			}
 			case "escape":
@@ -2023,7 +2808,9 @@ var Prompt = class {
 			const more = this.queued.length > 1 ? ` (+${this.queued.length - 1} more)` : "";
 			rows.push(this.theme.dim(truncate(`  ↳ queued: ${preview.split("\n")[0] ?? ""}${more}`, columns)));
 		}
-		if (this.hint !== void 0) rows.push(this.hint);
+		this.console.setScrollNotice(this.console.scrolledBy > 0 ? this.theme.dim(truncate(`  ↑ ${this.console.scrolledBy} rows above · PgDn returns to the latest`, columns)) : "");
+		const notice = this.flash ?? this.hint;
+		if (notice !== void 0) rows.push(notice);
 		if (this.status !== void 0) rows.push(this.status);
 		if (rows.length === 0) {
 			this.console.clearRegion();
@@ -2213,18 +3000,19 @@ function highlightCode(line, syntax) {
 * @returns the styled line.
 */
 function renderInline(text, theme) {
+	const emphasized = (inner) => inner.split(/(`[^`]+`)/u).map((segment) => segment.startsWith("`") && segment.endsWith("`") && segment.length > 1 ? theme.bold(theme.tool(segment.slice(1, -1))) : segment === "" ? "" : theme.bold(segment)).join("");
 	return text.replace(INLINE, (match, code, starBold, underBold, link, starEm, underEm) => {
 		if (code !== void 0) return theme.tool(code.slice(1, -1));
-		if (starBold !== void 0) return theme.bold(starBold.slice(2, -2));
-		if (underBold !== void 0) return theme.bold(underBold.slice(2, -2));
+		if (starBold !== void 0) return emphasized(starBold.slice(2, -2));
+		if (underBold !== void 0) return emphasized(underBold.slice(2, -2));
 		if (link !== void 0) {
 			const parts = /^\[([^\]]*)\]\(([^)]*)\)$/.exec(link);
 			if (parts === null) return match;
 			const [, label, target] = parts;
 			return `${theme.bold(label ?? "")} ${theme.dim(`(${target ?? ""})`)}`;
 		}
-		if (starEm !== void 0) return theme.bold(starEm.slice(1, -1));
-		if (underEm !== void 0) return theme.bold(underEm.slice(1, -1));
+		if (starEm !== void 0) return emphasized(starEm.slice(1, -1));
+		if (underEm !== void 0) return emphasized(underEm.slice(1, -1));
 		return match;
 	});
 }
@@ -2263,34 +3051,70 @@ function createMarkdownStream(theme, columns) {
 	};
 }
 /**
-* Lay out one buffered table, or fall back to its source lines.
+* Lay out one buffered table as a bordered grid.
 *
-* Cells print verbatim — padding is by display width, and styled text would
-* make the two disagree. Only the frame carries styling: the header is bold and
-* the rule under it dim.
+* Outer borders, one space of padding inside every cell, and a rule between
+* every pair of rows: the padding keeps text off the rules, and the row rules
+* are unconditional because a wrapped cell's continuation must never blur into
+* the record below it. Cells render their inline constructs; every width is of
+* the VISIBLE text. A table wider than the terminal wraps inside its cells,
+* shrinking the widest columns toward an even share; only a terminal too
+* narrow to hold the columns at all falls back to the source lines.
 * @param rows - the raw `|`-delimited lines, in order.
-* @param theme - styling for the frame.
-* @param budget - display columns available; a wider table degrades to source.
+* @param theme - styling for the borders and the header.
+* @param budget - display columns available.
 * @returns the rendered table, or the source lines styled as prose.
 */
 function layoutTable(rows, theme, budget) {
 	const asSource = () => rows.map((row) => renderInline(row, theme));
-	const cells = rows.map((row) => row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim()));
-	const delimiter = cells[1];
-	if (cells.length < 2 || delimiter === void 0 || !delimiter.every((cell) => TABLE_DELIMITER.test(cell))) return asSource();
-	const body = [cells[0] ?? [], ...cells.slice(2)];
-	const count = Math.max(...body.map((row) => row.length));
-	const widths = Array.from({ length: count }, (_, column) => Math.max(...body.map((row) => displayWidth(row[column] ?? ""))));
-	if (widths.reduce((sum, width) => sum + width, 0) + 2 * (count - 1) > budget) return asSource();
-	const aligned = (row) => Array.from({ length: count }, (_, column) => {
-		const cell = row[column] ?? "";
-		const pad = " ".repeat(Math.max(0, (widths[column] ?? 0) - displayWidth(cell)));
-		return /^:?-+:$/.test(delimiter[column] ?? "") && !/^:-+:$/.test(delimiter[column] ?? "") ? `${pad}${cell}` : `${cell}${pad}`;
-	}).join("  ").trimEnd();
+	const raw = rows.map((row) => row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim()));
+	const delimiter = raw[1];
+	const marks = (delimiter ?? []).filter((cell) => cell !== "");
+	if (raw.length < 2 || delimiter === void 0 || marks.length === 0 || !marks.every((cell) => TABLE_DELIMITER.test(cell))) return asSource();
+	let count = Math.max(1, (raw[0] ?? []).length);
+	const content = [raw[0] ?? [], ...raw.slice(2)];
+	while (count > 1 && content.every((row) => (row[count - 1] ?? "") === "")) count -= 1;
+	const styled = content.map((row) => row.slice(0, count).map((cell) => renderInline(cell, theme)));
+	const visible = (cell) => displayWidth(cell.replaceAll(/\u001B\[[0-9;]*m/gu, ""));
+	const natural = Array.from({ length: count }, (_, column) => Math.max(1, ...styled.map((row) => visible(row[column] ?? ""))));
+	const framing = 3 * count + 1;
+	let widths = [...natural];
+	if (natural.reduce((sum, width) => sum + width, 0) + framing > budget) {
+		const available = budget - framing;
+		if (available < count * 2) return asSource();
+		const fair = Math.floor(available / count);
+		const kept = natural.map((width) => Math.min(width, fair));
+		let spare = available - kept.reduce((sum, width) => sum + width, 0);
+		widths = natural.map((width, column) => {
+			const base = kept[column] ?? 0;
+			if (width <= base) return width;
+			const extra = Math.min(width - base, spare);
+			spare -= extra;
+			return base + extra;
+		});
+	}
+	const edge = (left, junction, right) => theme.dim(`${left}${widths.map((width) => "─".repeat(width + 2)).join(junction)}${right}`);
+	const bar = theme.dim("│");
+	const line = (row, style) => {
+		const wrapped = Array.from({ length: count }, (_, column) => wrapStyled(row[column] ?? "", widths[column] ?? 1));
+		const height = Math.max(...wrapped.map((cell) => cell.length));
+		return Array.from({ length: height }, (_, index) => {
+			return `${bar}${wrapped.map((cell, column) => {
+				const piece = cell[index] ?? "";
+				const alignRight = /^:?-+:$/.test(delimiter[column] ?? "") && !/^:-+:$/.test(delimiter[column] ?? "");
+				const pad = " ".repeat(Math.max(0, (widths[column] ?? 0) - visible(piece)));
+				return alignRight ? ` ${pad}${style(piece)} ` : ` ${style(piece)}${pad} `;
+			}).join(bar)}${bar}`;
+		});
+	};
+	const separator = edge("├", "┼", "┤");
+	const body = styled.slice(1).flatMap((row, index) => index > 0 ? [separator, ...line(row, (text) => text)] : line(row, (text) => text));
 	return [
-		theme.bold(aligned(cells[0] ?? [])),
-		theme.dim(widths.map((width) => "─".repeat(width)).join("  ")),
-		...cells.slice(2).map((row) => aligned(row))
+		edge("╭", "┬", "╮"),
+		...line(styled[0] ?? [], (text) => theme.bold(text)),
+		separator,
+		...body,
+		edge("╰", "┴", "╯")
 	];
 }
 /**
@@ -2545,11 +3369,14 @@ var Spinner = class {
 	/**
 	* Start the indicator, or do nothing when it is already running or the
 	* surface has no cursor to rewrite.
+	*
+	* The clock keeps running across a pause: the elapsed figure is the whole
+	* turn's, and an indicator that restarted from zero at every tool call would
+	* report each step instead.
 	*/
 	start() {
 		if (this.timer !== void 0 || !this.surface.isTty) return;
-		this.startedAt = this.now();
-		this.frame = 0;
+		if (this.startedAt === 0) this.startedAt = this.now();
 		this.draw();
 		this.timer = setInterval(() => {
 			this.frame += 1;
@@ -2557,13 +3384,19 @@ var Spinner = class {
 		}, TICK_MS);
 		this.timer.unref();
 	}
-	/** Stop the indicator and clear its line. */
-	stop() {
+	/** Hide the indicator without forgetting when the turn began. */
+	pause() {
 		if (this.timer === void 0) return;
 		clearInterval(this.timer);
 		this.timer = void 0;
 		this.surface.setLive(void 0);
 	}
+	/** Stop the indicator: the turn is over, and the next one starts at zero. */
+	stop() {
+		this.pause();
+		this.startedAt = 0;
+		this.frame = 0;
+	}
 	/** Paint the current frame. */
 	draw() {
 		this.surface.setLive(spinnerText(this.frame, this.now() - this.startedAt, this.label, this.theme));
@@ -2646,10 +3479,15 @@ var TextStream = class {
 //#region src/transcript.ts
 /** Context lines kept on each side of a rendered hunk. */
 const DIFF_CONTEXT = 3;
-/** Diff body lines printed for one file before the card summarizes the rest. */
-const MAX_DIFF_LINES = 40;
-/** Result body lines printed for one completed call before the card summarizes the rest. */
-const MAX_RESULT_LINES = 16;
+/** Diff body lines printed for one file before the card collapses the rest. */
+const MAX_DIFF_LINES = 24;
+/**
+* Result body lines printed for one completed call before the card collapses.
+*
+* Small on purpose: a long output in the transcript is skimmed, not read, and
+* the collapsed remainder is one Ctrl+O away in full.
+*/
+const MAX_RESULT_LINES = 5;
 /**
 * Concatenate a message's text blocks, dropping reasoning and non-text content.
 * @param content - the message content blocks.
@@ -2694,13 +3532,13 @@ function diffBody(diff, theme) {
 */
 function cap(lines, limit, theme) {
 	if (lines.length <= limit) return lines;
-	return [...lines.slice(0, limit), theme.dim(`  … ${lines.length - limit} more lines`)];
+	return [...lines.slice(0, limit), theme.dim(`  … +${lines.length - limit} lines (Ctrl+O expands)`)];
 }
 /** Renders one session's appended events as terminal lines. */
 var Transcript = class {
 	calls = /* @__PURE__ */ new Map();
-	/** The most recent result whose body the cap clipped, kept in full. */
-	clipped;
+	/** The full form of the event just rendered, when its body was collapsed. */
+	fold;
 	constructor(options, presenters) {
 		this.options = options;
 		this.presenters = presenters;
@@ -2839,12 +3677,14 @@ var Transcript = class {
 		const marker = failed ? theme.error("✗") : theme.success("●");
 		if (pending === void 0) {
 			const raw = this.resultText(block.content).split("\n");
-			if (raw.length > MAX_RESULT_LINES) this.clipped = {
-				title: "(result)",
-				lines: raw
-			};
+			const head$1 = `${marker} ${theme.dim("(result)")}`;
+			if (raw.length > MAX_RESULT_LINES) this.fold = [
+				head$1,
+				...raw,
+				""
+			];
 			return [
-				`${marker} ${theme.dim("(result)")}`,
+				head$1,
 				...cap(raw, MAX_RESULT_LINES, theme),
 				""
 			];
@@ -2852,32 +3692,30 @@ var Transcript = class {
 		const view = this.safeResult(pending, block.content, failed, meta);
 		const title = view?.title === void 0 ? pending.title : this.relativizeIn(view.title);
 		const { suffix, body, full } = this.outcome(view, block);
-		if (full !== void 0) this.clipped = {
-			title,
-			lines: full
-		};
+		const head = failed || title !== pending.title ? [`${marker} ${theme.tool(title)}${suffix === "" ? "" : ` ${suffix}`}`] : suffix !== "" ? [`  ${suffix}`] : body.length === 0 ? [`  ${theme.success("✓")}`] : [];
+		if (full !== void 0) this.fold = [
+			...head,
+			...full,
+			""
+		];
 		return [
-			...failed || title !== pending.title ? [`${marker} ${theme.tool(title)}${suffix === "" ? "" : ` ${suffix}`}`] : suffix !== "" ? [`  ${suffix}`] : body.length === 0 ? [`  ${theme.success("✓")}`] : [],
+			...head,
 			...body,
 			""
 		];
 	}
 	/**
-	* The last clipped result, rendered without its cap.
-	*
-	* Ctrl-O's answer. The full body is kept from the render itself because a
-	* tool's own output limits are upstream of the log — this is everything the
-	* model saw, which is everything recoverable.
-	* @returns the header and full body, or undefined when nothing was clipped.
+	* The expanded form of the lines {@link render} just returned, when that
+	* event's body was collapsed — the whole event re-rendered without its cap,
+	* because a fold swaps entire blocks, not just the clipped tail. The full
+	* body is kept from the render itself: what a tool truncated before
+	* returning is upstream of the log and unrecoverable everywhere.
+	* @returns the full lines, or undefined when nothing was collapsed.
 	*/
-	expandLast() {
-		if (this.clipped === void 0) return void 0;
-		const { theme } = this.options;
-		return [
-			`${theme.dim("—")} ${theme.tool(this.clipped.title)} ${theme.dim("— full output —")}`,
-			...this.clipped.lines,
-			""
-		];
+	takeFold() {
+		const fold = this.fold;
+		this.fold = void 0;
+		return fold;
 	}
 	/**
 	* Render one completed call's status suffix and body from its declared view.
@@ -3138,6 +3976,10 @@ async function runCommand(ctx, agent, line, io, theme, signal) {
 const RECALL_WINDOW_MS = 1500;
 /** Turns longer than this ring the bell on completion, when the bell is on. */
 const BELL_TURN_MS = 1e4;
+/** A finished answer longer than this many rendered lines becomes a fold. */
+const ANSWER_FOLD_LINES = 24;
+/** How many of its head lines a collapsed answer keeps visible. */
+const ANSWER_HEAD_LINES = 8;
 /**
 * Run one subprocess and capture everything it printed.
 * @param file - the executable, or a shell when `shell` is given.
@@ -3449,12 +4291,7 @@ async function run(ctx, config, io) {
 			commands?.execute(live.agent, line, new AbortController().signal);
 		},
 		expandOutput: () => {
-			const full = live.transcript.expandLast();
-			if (full === void 0) {
-				prompt.write(theme.dim("  no clipped output to expand"));
-				return;
-			}
-			for (const line of full) prompt.write(line);
+			if (!io.console.toggleFolds()) prompt.write(theme.dim("  nothing to expand"));
 		}
 	}, "Ask anything · / for commands · @ for files · ⇧Tab plan mode");
 	let turnBaseTokens = 0;
@@ -3502,6 +4339,15 @@ async function run(ctx, config, io) {
 			description: "start a fresh session in place",
 			handler: async () => {
 				await switchTo(await composed.createAnother(), false);
+				for (const line of bannerLines({
+					model,
+					preset: presetId,
+					cwd,
+					branch,
+					session: live.agent.session.id,
+					readsKeys: io.console.readsKeys,
+					resumed: false
+				}, theme, io.console.columns)) prompt.write(line);
 				return {
 					kind: "success",
 					text: `new session ${live.agent.session.id}`
@@ -3674,8 +4520,36 @@ async function run(ctx, config, io) {
 			}
 		}));
 	}
-	const stream = new TextStream(theme, () => io.console.columns);
-	const thinking = new TextStream(theme, () => io.console.columns, true);
+	const stream = new TextStream(theme, () => io.console.contentColumns);
+	let answerLines = [];
+	const finishAnswer = () => {
+		if (!stream.streamed) return;
+		const tail = stream.flush();
+		emit([...tail, ""]);
+		answerLines.push(...tail);
+		if (answerLines.length > ANSWER_FOLD_LINES) io.console.foldRecent(answerLines.length + 1, [
+			...answerLines.slice(0, ANSWER_HEAD_LINES),
+			theme.dim(`  … +${answerLines.length - ANSWER_HEAD_LINES} lines (Ctrl+O expands)`),
+			""
+		]);
+		answerLines = [];
+	};
+	const thinking = new TextStream(theme, () => io.console.contentColumns, true);
+	let thinkingLines = [];
+	let thinkingStartedAt = 0;
+	const flushThinking = () => {
+		thinkingLines.push(...thinking.flush());
+		if (thinkingLines.length === 0) return;
+		const seconds = ((performance.now() - thinkingStartedAt) / 1e3).toFixed(1);
+		prompt.setStreaming(void 0);
+		io.console.appendFold([theme.dim(`✻ thought for ${seconds}s · +${thinkingLines.length} lines (Ctrl+O expands)`), ""], [
+			theme.dim(`✻ thought for ${seconds}s`),
+			...thinkingLines,
+			""
+		]);
+		thinkingLines = [];
+		thinkingStartedAt = 0;
+	};
 	/**
 	* Append the lines an event produced, and show the line still being typed.
 	* @param lines - finished lines for the transcript.
@@ -3702,32 +4576,38 @@ async function run(ctx, config, io) {
 			const { chunk } = event.data;
 			if (chunk.type === "reasoning-delta") {
 				if (chunk.text === "") return;
-				spinner.stop();
-				if (!thinking.streamed) emit([theme.dim("✻ thinking")]);
+				if (thinkingStartedAt === 0) thinkingStartedAt = performance.now();
 				const step$1 = thinking.push(chunk.text);
-				emit(step$1.lines, step$1.live);
+				thinkingLines.push(...step$1.lines);
+				prompt.setStreaming(step$1.live ?? thinkingLines.at(-1) ?? theme.dim("✻ thinking"));
 				return;
 			}
 			if (chunk.type !== "text-delta") return;
-			spinner.stop();
-			if (thinking.streamed) emit([...thinking.flush(), ""]);
+			flushThinking();
 			const step = stream.push(chunk.text);
 			emit(step.lines, step.live);
+			answerLines.push(...step.lines);
 			return;
 		}
 		if (event.type === "assistant/message") {
-			if (thinking.streamed) emit([...thinking.flush(), ""]);
+			flushThinking();
 			if (stream.streamed) {
-				emit([...stream.flush(), ""]);
-				if (live.agent.status === "running") spinner.start();
+				finishAnswer();
 				return;
 			}
 		}
-		emit(live.transcript.render(event));
+		const lines = live.transcript.render(event);
+		const full = live.transcript.takeFold();
+		if (full === void 0) {
+			emit(lines);
+			return;
+		}
+		prompt.setStreaming(void 0);
+		io.console.appendFold(lines, full);
 	});
 	/** Pause the indicator around a decision, and resume it if work continues. */
 	const whileDeciding = async (decide) => {
-		spinner.stop();
+		spinner.pause();
 		if (config.bell) io.console.bell();
 		try {
 			return await decide();
@@ -3775,6 +4655,7 @@ async function run(ctx, config, io) {
 			columns: io.console.columns,
 			cwd
 		}, presentersFor(ctx, next.agent));
+		io.console.clearScreen();
 		approval.clear();
 		turnBaseTokens = 0;
 		prompt.setAccent(planModeFrom(next.agent.session.events) ? (text) => theme.pending(text) : void 0);
@@ -3800,11 +4681,28 @@ async function run(ctx, config, io) {
 		spinner.stop();
 		running?.abort();
 		live.agent.cancel({ kind: "user" });
-		if (thinking.streamed) emit([...thinking.flush(), ""]);
-		if (stream.streamed) emit([...stream.flush(), ""]);
+		flushThinking();
+		finishAnswer();
 		if (busy) prompt.write(theme.dim("  interrupted"));
 		return busy;
 	};
+	/**
+	* Hand the terminal back and leave.
+	*
+	* The session's own screen disappears with it, so the few facts a person
+	* still needs — which session this was, what it cost, how to reopen it — are
+	* written to the buffer that survives instead.
+	* @param code - the exit status to request.
+	*/
+	const leave = (code) => {
+		prompt.clear();
+		io.console.close();
+		const usage = totalTokens(facts(branch).usage);
+		const spent = usage === void 0 || usage === 0 ? "" : ` · ${formatTokens(usage)} tokens`;
+		io.console.writeAfterScreen(theme.dim(`codsh session ${live.agent.session.id}${spent}`));
+		io.console.writeAfterScreen(theme.dim(`  reopen with: codsh --resume ${live.agent.session.id}`));
+		io.exit(code);
+	};
 	let lastInterrupt = 0;
 	let recallArmed;
 	onEscapeKey = () => {
@@ -3834,9 +4732,7 @@ async function run(ctx, config, io) {
 			prompt.write(theme.dim("  Ctrl-C again to exit"));
 			return;
 		}
-		prompt.clear();
-		io.console.close();
-		io.exit(130);
+		leave(130);
 	};
 	/**
 	* Run one turn and report what it cost.
@@ -3865,8 +4761,8 @@ async function run(ctx, config, io) {
 	};
 	if (config.print) {
 		await turn(live.agent, config.task, spinner);
-		if (thinking.streamed) emit([...thinking.flush(), ""]);
-		if (stream.streamed) emit([...stream.flush(), ""]);
+		flushThinking();
+		finishAnswer();
 		await sessions.flush(live.agent.session);
 		prompt.clear();
 		io.console.close();
@@ -3914,6 +4810,7 @@ async function run(ctx, config, io) {
 			running = void 0;
 		}
 	};
+	io.console.enterScreen();
 	prompt.setEngaged(true);
 	if (config.task !== "") await answer(config.task);
 	let shownStatus;
@@ -3929,6 +4826,7 @@ async function run(ctx, config, io) {
 		}
 		const line = await prompt.read();
 		if (line === void 0) break;
+		io.console.collapseFolds();
 		const trimmed = line.trim();
 		if (trimmed === "") continue;
 		if (trimmed === "/exit" || trimmed === "/quit") break;
@@ -3972,10 +4870,7 @@ async function run(ctx, config, io) {
 	} catch {}
 	for (const dispose of disposers.splice(0)) dispose();
 	prompt.setEngaged(false);
-	prompt.clear();
-	io.console.write(theme.dim(`session ${live.agent.session.id}`));
-	io.console.close();
-	io.exit(0);
+	leave(0);
 }
 /**
 * Report an unexpected surface failure and request a failing exit.
@@ -3983,8 +4878,8 @@ async function run(ctx, config, io) {
 * @param error - the failure.
 */
 function fail(io, error) {
-	io.console.write(`dsh: ${error instanceof Error ? error.message : String(error)}`);
 	io.console.close();
+	io.console.writeAfterScreen(`codsh: ${error instanceof Error ? error.message : String(error)}`);
 	io.exit(1);
 }
 /**
@@ -3999,6 +4894,14 @@ function apply(ctx, config) {
 		console: new TerminalConsole(internals.input, internals.output),
 		exit
 	};
+	const restore = () => {
+		io.console.leaveScreen();
+	};
+	process.once("exit", restore);
+	for (const signal of ["SIGTERM", "SIGHUP"]) process.once(signal, () => {
+		restore();
+		process.exit(signal === "SIGTERM" ? 143 : 129);
+	});
 	run(ctx, config, io).catch((error) => {
 		fail(io, error);
 	});