codsh-bundle 0.4.0 → 0.5.0

package/lib/index.js

@@ -586,9 +586,9 @@ function parseCommandFile(source) {
 	if (source.startsWith("---\n")) {
 		const end = source.indexOf("\n---\n", 4);
 		if (end >= 0) {
-			const header = source.slice(4, end);
+			const header$1 = source.slice(4, end);
 			return {
-				description: /^description:\s*(.+)$/m.exec(header)?.[1]?.trim() ?? "",
+				description: /^description:\s*(.+)$/m.exec(header$1)?.[1]?.trim() ?? "",
 				body: source.slice(end + 5).trim()
 			};
 		}
@@ -697,9 +697,17 @@ const KITTY_CTRL = 4;
 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. */
+/** The motion bit, set on every report the pointer's movement produces. */
 const MOUSE_MOTION = 32;
 /**
+* The button code any-motion tracking sends when no button is held.
+*
+* Motion with a button reports that button; motion with none reports 3, the
+* same code a release carries — so a move is the motion bit over this, which
+* is what tells the surface which block the pointer is merely resting on.
+*/
+const MOUSE_NO_BUTTON = 3;
+/**
 * An OSC reply from the terminal: `ESC ] code ; payload (BEL | ESC \)`.
 *
 * The viewport asks for the background color (OSC 11) on entry; the reply
@@ -785,6 +793,7 @@ const CONTROLS = {
 	"\v": { kind: "kill-line" },
 	"\f": { kind: "clear-screen" },
 	"": { kind: "expand-output" },
+	"": { kind: "toggle-todos" },
 	"": { kind: "kill-input" },
 	"": { kind: "kill-word" }
 };
@@ -855,6 +864,11 @@ var KeyDecoder = class {
 			}];
 			const column = Number(mouse[2]);
 			const row = Number(mouse[3]);
+			if ((button & ~MOUSE_MODIFIERS) === (MOUSE_MOTION | MOUSE_NO_BUTTON)) return [{
+				kind: "mouse-move",
+				row,
+				column
+			}];
 			if ((button & ~MOUSE_MOTION) === 0 && (button & MOUSE_MODIFIERS) === 0) {
 				if (mouse[4] === "m") return [{
 					kind: "mouse-up",
@@ -986,7 +1000,7 @@ 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";
+const RESET$1 = "\x1B[0m";
 /**
 * Break one styled line into rows no wider than `columns` display columns.
 *
@@ -1005,7 +1019,7 @@ function wrapStyled(text, columns) {
 	let width = 0;
 	let rest = text;
 	const flush = () => {
-		rows.push(active.length > 0 ? `${row}${RESET}` : row);
+		rows.push(active.length > 0 ? `${row}${RESET$1}` : row);
 		row = active.join("");
 		width = 0;
 	};
@@ -1032,18 +1046,9 @@ function wrapStyled(text, columns) {
 		width += cost;
 		rest = rest.slice(character.length);
 	}
-	rows.push(active.length > 0 ? `${row}${RESET}` : row);
+	rows.push(active.length > 0 ? `${row}${RESET$1}` : 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
@@ -1054,16 +1059,19 @@ const ENTER_ALT = "\x1B[?1049h";
 /** Leave it, restoring both. */
 const LEAVE_ALT = "\x1B[?1049l";
 /**
-* Report wheel and button events, in the SGR encoding.
+* Report wheel, button, and pointer-motion 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.
+* Any-motion tracking (1003) is what lets the surface say which block the
+* pointer rests on — the blocks are clickable, and a target that gives no
+* feedback until it is hit is not an affordance. Button tracking (1002) is
+* pushed under it so terminals that implement only that one keep the drag
+* that selects. Motion is a report per cell crossed, so the surface repaints
+* only when the block under the pointer changes, not on every report. Most
+* terminals still hand a Shift-drag to their own selection either way.
 */
-const ENABLE_MOUSE = "\x1B[?1002h\x1B[?1006h";
+const ENABLE_MOUSE = "\x1B[?1002h\x1B[?1003h\x1B[?1006h";
 /** Stop reporting them. */
-const DISABLE_MOUSE = "\x1B[?1006l\x1B[?1002l";
+const DISABLE_MOUSE = "\x1B[?1006l\x1B[?1003l\x1B[?1002l";
 /**
 * Push the kitty keyboard protocol's disambiguate flag — what Claude Code
 * pushes — so Shift+Enter, Esc, and control chords report unambiguously on
@@ -1098,6 +1106,24 @@ 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";
+/** A full SGR reset, which every styled span this surface prints ends with. */
+const RESET = "\x1B[0m";
+/**
+* Underline a whole rendered row.
+*
+* 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.
+* @param row - the styled row.
+* @returns the row, underlined end to end.
+*/
+function underline(row) {
+	return `${UNDERLINE}${row.replaceAll(RESET, `${RESET}${UNDERLINE}`)}${UNDERLINE_OFF}`;
+}
 /**
 * The string index where a display column begins.
 *
@@ -1121,8 +1147,18 @@ function columnIndex(text, column) {
 var Screen = class {
 	/** Logical transcript lines, unwrapped, oldest first. */
 	logical = [];
+	/**
+	* The left rule each logical line carries, `''` for none.
+	*
+	* Kept beside the text rather than inside it: a rule has to repeat on every
+	* row a line wraps to, and it must never reach the clipboard — it is a mark
+	* the surface draws, not something the person wrote.
+	*/
+	rules = [];
 	/** The same lines wrapped to the current width — what the viewport slices. */
 	physical = [];
+	/** Display columns the rule occupies on each physical row, for copy and hits. */
+	ruleWidths = [];
 	/** The bottom rows: input box, menu, indicator, status. */
 	chrome = [];
 	chromeCursor = {
@@ -1139,6 +1175,18 @@ var Screen = class {
 	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;
+	/**
+	* Physical row ranges the blocks occupy, or undefined when they need
+	* measuring again.
+	*
+	* Motion arrives a report per cell crossed, and measuring a block's row from
+	* the wrapped height of everything above it is a walk over the buffer — far
+	* too much to redo per report. The walk happens once after the buffer
+	* changes instead, and every report in between is a lookup.
+	*/
+	ranges;
 	/** Whether the folds currently show their full form. */
 	expanded = false;
 	/** The last painted frame, so a repaint only touches rows that changed. */
@@ -1184,16 +1232,23 @@ var Screen = class {
 	* where they are, and the new rows accumulate below them.
 	* @param lines - the lines to keep, already styled.
 	*/
-	append(lines) {
+	append(lines, rule = "") {
 		if (lines.length === 0) return;
 		const columns = this.contentColumns();
 		for (const line of lines) {
+			const own = line === "" ? "" : rule;
 			this.logical.push(line);
-			this.physical.push(...wrapStyled(line, columns));
+			this.rules.push(own);
+			for (const row of this.wrapLine(line, own, columns)) {
+				this.physical.push(row);
+				this.ruleWidths.push(displayWidth(own));
+			}
 		}
+		this.ranges = void 0;
 		if (this.logical.length > MAX_SCROLLBACK) {
 			const dropped = this.logical.length - MAX_SCROLLBACK;
 			this.logical.splice(0, dropped);
+			this.rules.splice(0, dropped);
 			this.folds = this.folds.flatMap((fold) => {
 				const at = fold.at - dropped;
 				return at >= 0 ? [{
@@ -1201,6 +1256,7 @@ var Screen = class {
 					at
 				}] : [];
 			});
+			this.hovered = void 0;
 			this.rewrap();
 		}
 		this.render();
@@ -1213,17 +1269,21 @@ var Screen = class {
 	* place, exactly like a details/summary element.
 	* @param summary - the collapsed lines, already styled.
 	* @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.
 	*/
-	appendFold(summary, full) {
+	appendFold(summary, full, rule = "", label = "") {
 		const shown = this.expanded ? full : summary;
 		this.folds.push({
 			at: this.logical.length,
 			shownLength: shown.length,
 			summary: [...summary],
 			full: [...full],
-			expanded: this.expanded
+			expanded: this.expanded,
+			rule,
+			label
 		});
-		this.append(shown);
+		this.append(shown, rule);
 	}
 	/**
 	* Turn the last `count` appended lines into a collapsible block after the
@@ -1235,8 +1295,9 @@ var Screen = class {
 	* 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.
+	* @param label - what the block is, for the hover readout that names it.
 	*/
-	foldBack(count, summary) {
+	foldBack(count, summary, label = "") {
 		const at = this.logical.length - count;
 		if (count <= 0 || at < 0) return;
 		const last = this.folds.at(-1);
@@ -1246,8 +1307,11 @@ var Screen = class {
 			shownLength: count,
 			summary: [...summary],
 			full: this.logical.slice(at),
-			expanded: true
+			expanded: true,
+			rule: this.rules.slice(at).find((rule) => rule !== "") ?? "",
+			label
 		});
+		this.ranges = void 0;
 	}
 	/** Whether any collapsible block exists. */
 	get hasFolds() {
@@ -1259,11 +1323,15 @@ var Screen = class {
 	}
 	/**
 	* Swap every fold between its summary and its full form.
+	*
+	* What the blocks show decides the direction, not what the last Ctrl+O did:
+	* clicking blocks open one at a time would otherwise leave the key pointing
+	* the wrong way, and a press that visibly does nothing reads as broken.
 	* @returns false when there is nothing to toggle.
 	*/
 	toggleFolds() {
 		if (this.folds.length === 0) return false;
-		this.setFolds(!this.expanded);
+		this.setFolds(!this.folds.every((fold) => fold.expanded));
 		return true;
 	}
 	/** Return every fold to its summary, the way moving on reads as dismissal. */
@@ -1271,6 +1339,87 @@ var Screen = class {
 		if (this.folds.some((fold) => fold.expanded)) this.setFolds(false);
 		else this.expanded = false;
 	}
+	/**
+	* Work the block a bare click landed on, the way a details element opens.
+	*
+	* The whole block is the target, in both forms: collapsed, the `+N lines`
+	* line is what a person aims at, and open, anywhere inside the text folds it
+	* back — hunting for a head row that has scrolled off the top is not an
+	* affordance. Selecting text inside a block is a drag, which never reaches
+	* here, so reading is unaffected.
+	* @param row - physical buffer row the press anchored on.
+	*/
+	clickFold(row) {
+		const fold = this.foldAt(row);
+		if (fold === void 0) return;
+		this.setFold(fold, !fold.expanded);
+	}
+	/**
+	* Where each block sits in physical rows.
+	*
+	* Blocks are recorded in logical lines while the mouse reports physical
+	* rows, so the wrapped height of everything above a block is what bridges
+	* the two — measured under each line's own rule, which costs columns and so
+	* changes the height.
+	* @returns one range per block, in buffer order.
+	*/
+	foldRanges() {
+		if (this.ranges !== void 0) return this.ranges;
+		const columns = this.contentColumns();
+		const height = (index$1) => this.wrapLine(this.logical[index$1] ?? "", this.rules[index$1] ?? "", columns).length;
+		const ranges = [];
+		let physical = 0;
+		let index = 0;
+		for (const fold of this.folds) {
+			for (; index < fold.at; index += 1) physical += height(index);
+			const from = physical;
+			for (; index < fold.at + fold.shownLength; index += 1) physical += height(index);
+			ranges.push({
+				fold,
+				from,
+				to: physical - 1
+			});
+		}
+		this.ranges = ranges;
+		return ranges;
+	}
+	/**
+	* The block covering a physical row.
+	* @param row - physical buffer row, 0-based.
+	* @returns the block, or undefined when the row is not in one.
+	*/
+	foldAt(row) {
+		return this.foldRanges().find((range) => row >= range.from && row <= range.to)?.fold;
+	}
+	/**
+	* Swap one block, leaving the reader where they were.
+	*
+	* Someone who opened a block halfway up their history did not ask to be
+	* moved to the tail: the rows above the block keep their screen positions,
+	* and the transcript grows or shrinks below them. Following the tail there
+	* is nothing to hold on to, so the frame keeps following it — which is what
+	* Ctrl+O does for every block at once.
+	* @param fold - the block to swap.
+	* @param expanded - the form to put on screen.
+	*/
+	setFold(fold, expanded) {
+		const shown = expanded ? fold.full : fold.summary;
+		const delta = shown.length - fold.shownLength;
+		this.logical.splice(fold.at, fold.shownLength, ...shown);
+		this.rules.splice(fold.at, fold.shownLength, ...shown.map(() => fold.rule));
+		fold.shownLength = shown.length;
+		fold.expanded = expanded;
+		for (const other of this.folds) if (other.at > fold.at) other.at += delta;
+		const before = this.physical.length;
+		const offset = this.offset;
+		this.rewrap();
+		if (offset > 0) {
+			const limit = Math.max(0, this.physical.length - this.viewportHeight());
+			this.offset = Math.min(limit, Math.max(0, offset + this.physical.length - before));
+		}
+		this.painted = [];
+		this.render();
+	}
 	/** Put every fold into one form, whatever mix of states they are in now. */
 	setFolds(expanded) {
 		this.expanded = expanded;
@@ -1282,6 +1431,7 @@ var Screen = class {
 			}
 			const shown = expanded ? fold.full : fold.summary;
 			this.logical.splice(fold.at, fold.shownLength, ...shown);
+			this.rules.splice(fold.at, fold.shownLength, ...shown.map(() => fold.rule));
 			deltas.set(fold, shown.length - fold.shownLength);
 			fold.shownLength = shown.length;
 			fold.expanded = expanded;
@@ -1302,10 +1452,10 @@ var Screen = class {
 	* @param cursor - where the cursor belongs among them.
 	* @param focus - whether to show the cursor there.
 	*/
-	setChrome(rows, cursor, focus) {
+	setChrome(rows, cursor, focus$1) {
 		this.chrome = rows.map((row) => truncate(row, this.contentColumns()));
 		this.chromeCursor = { ...cursor };
-		this.chromeFocus = focus;
+		this.chromeFocus = focus$1;
 		this.render();
 	}
 	/**
@@ -1353,8 +1503,12 @@ var Screen = class {
 	*/
 	clearTranscript() {
 		this.logical = [];
+		this.rules = [];
 		this.physical = [];
+		this.ruleWidths = [];
 		this.folds = [];
+		this.ranges = void 0;
+		this.hovered = void 0;
 		this.expanded = false;
 		this.offset = 0;
 		this.painted = [];
@@ -1367,6 +1521,32 @@ var Screen = class {
 		this.render();
 	}
 	/**
+	* Note where the pointer is resting, with nothing held down.
+	*
+	* A block is clickable, so it says so while the pointer is on it rather
+	* than only once it is hit. Reports arrive a cell at a time, so the frame is
+	* only touched when the block under the pointer actually changes — moving
+	* along one block, or across the chrome, costs a lookup and nothing else.
+	* @param row - terminal row, 1-based.
+	* @param column - terminal column, 1-based.
+	* @returns the block under the pointer, or undefined for none — reported
+	* every time, so a caller need not track the changes itself.
+	*/
+	mouseMove(row, column) {
+		const at = this.locate(row, column, false);
+		const fold = at === void 0 ? void 0 : this.foldAt(at.row);
+		if (fold !== this.hovered) {
+			this.hovered = fold;
+			this.render();
+		}
+		if (fold === void 0) return void 0;
+		return {
+			label: fold.label,
+			lines: fold.full.length,
+			expanded: fold.expanded
+		};
+	}
+	/**
 	* Anchor a selection where the left button went down.
 	*
 	* The terminal cannot select for us while mouse reporting is on, so the
@@ -1403,7 +1583,9 @@ var Screen = class {
 	* 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.
+	* what it took — until the next click or reflow dismisses it. A press that
+	* never moved is not a selection but a click, and a click on a collapsible
+	* block works that one block: open it, or fold it back.
 	* @returns the selected text, or undefined for a bare click.
 	*/
 	mouseUp() {
@@ -1411,6 +1593,7 @@ var Screen = class {
 		if (selection === void 0) return void 0;
 		if (!selection.dragged) {
 			this.selection = void 0;
+			this.clickFold(selection.anchor.row);
 			return;
 		}
 		const text = this.selectedText();
@@ -1425,8 +1608,8 @@ var Screen = class {
 	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];
+		const { anchor, focus: focus$1 } = selection;
+		const [from, to] = focus$1.row < anchor.row || focus$1.row === anchor.row && focus$1.column < anchor.column ? [focus$1, anchor] : [anchor, focus$1];
 		return {
 			from,
 			to
@@ -1439,9 +1622,10 @@ var Screen = class {
 		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 rule = this.ruleWidths[index] ?? 0;
+			const start = columnIndex(plain, index === bounds.from.row ? Math.max(bounds.from.column, rule) : rule);
 			const end = index === bounds.to.row ? columnIndex(plain, bounds.to.column + 1) : plain.length;
-			rows.push(plain.slice(start, end));
+			rows.push(plain.slice(start, Math.max(start, end)));
 		}
 		return rows.join("\n").replace(/^\n+|\n+$/gu, "") === "" ? "" : rows.join("\n");
 	}
@@ -1474,10 +1658,40 @@ var Screen = class {
 	contentColumns() {
 		return Math.max(1, this.host.columns() - 1);
 	}
+	/**
+	* Wrap one logical line, repeating its rule on every row.
+	*
+	* The rule costs columns, so the text wraps inside what is left of the width;
+	* a continuation row without the rule would break the block's left edge
+	* exactly where a long line made it matter most.
+	* @param line - the styled logical line.
+	* @param rule - the styled left rule, `''` for none.
+	* @param columns - display columns available for rule and text together.
+	* @returns the physical rows, rule included.
+	*/
+	wrapLine(line, rule, columns) {
+		if (rule === "") return wrapStyled(line, columns);
+		return wrapStyled(line, Math.max(1, columns - displayWidth(rule))).map((row) => `${rule}${row}`);
+	}
+	/** Re-wrap every kept line at the current width, rules and all. */
+	wrapBuffer() {
+		const columns = this.contentColumns();
+		this.ranges = void 0;
+		this.physical = [];
+		this.ruleWidths = [];
+		for (const [at, line] of this.logical.entries()) {
+			const rule = this.rules[at] ?? "";
+			const width = displayWidth(rule);
+			for (const row of this.wrapLine(line, rule, columns)) {
+				this.physical.push(row);
+				this.ruleWidths.push(width);
+			}
+		}
+	}
 	/** Re-wrap every kept line at the current width. */
 	rewrap() {
 		this.selection = void 0;
-		this.physical = wrapAll(this.logical, this.contentColumns());
+		this.wrapBuffer();
 		const limit = Math.max(0, this.physical.length - this.viewportHeight());
 		this.offset = Math.min(this.offset, limit);
 	}
@@ -1492,7 +1706,7 @@ var Screen = class {
 		if (!this.active) return;
 		const columns = this.host.columns();
 		if (columns !== this.paintedColumns) {
-			this.physical = wrapAll(this.logical, this.contentColumns());
+			this.wrapBuffer();
 			this.painted = [];
 			this.paintedColumns = columns;
 		}
@@ -1515,6 +1729,12 @@ var Screen = class {
 				visible[index] = `${plain.slice(0, start)}${INVERSE}${marked}${INVERSE_OFF}${plain.slice(stop)}`;
 			}
 		}
+		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 viewport = [...visible, ...padding];
 		if (this.offset > 0 && this.notice !== "" && viewport.length > 0) viewport[0] = truncate(this.notice, this.contentColumns());
 		const frame = [...viewport, ...this.chrome];
@@ -1786,10 +2006,12 @@ var TerminalConsole = class {
 	* 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.
+	* @param rule - a styled left rule to draw down the line, `''` for none. Off
+	*   a terminal it is dropped: a pipe's reader wants the text, not the frame.
 	*/
-	write(line) {
+	write(line, rule = "") {
 		if (this.screen !== void 0) {
-			this.screen.append([line]);
+			this.screen.append([line], rule);
 			return;
 		}
 		this.output.write(`${line}\n`);
@@ -1805,8 +2027,8 @@ var TerminalConsole = class {
 	* @param focus - whether the rows hold input focus, which is when the cursor
 	*   shows. Parked anywhere else it reads as content colliding with it.
 	*/
-	setRegion(rows, cursor, focus = true) {
-		this.screen?.setChrome(rows, cursor, focus);
+	setRegion(rows, cursor, focus$1 = true) {
+		this.screen?.setChrome(rows, cursor, focus$1);
 	}
 	/**
 	* Keep one collapsible block: summary now, full form behind the toggle.
@@ -1815,10 +2037,13 @@ var TerminalConsole = class {
 	* with, and scripts want the digest.
 	* @param summary - the collapsed lines.
 	* @param full - the expanded lines.
+	* @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.
 	*/
-	appendFold(summary, full) {
+	appendFold(summary, full, rule = "", label = "") {
 		if (this.screen !== void 0) {
-			this.screen.appendFold(summary, full);
+			this.screen.appendFold(summary, full, rule, label);
 			return;
 		}
 		for (const line of summary) this.output.write(`${line}\n`);
@@ -1844,6 +2069,16 @@ var TerminalConsole = class {
 		this.screen?.mouseDrag(row, column);
 	}
 	/**
+	* Note where the pointer is resting, nothing held down.
+	* @param row - terminal row, 1-based.
+	* @param column - terminal column, 1-based.
+	* @returns the block now under the pointer when it changed, undefined
+	* otherwise.
+	*/
+	mouseMove(row, column) {
+		return this.screen?.mouseMove(row, column);
+	}
+	/**
 	* Finish the mouse selection.
 	* @returns the selected text, or undefined for a bare click.
 	*/
@@ -1890,9 +2125,11 @@ var TerminalConsole = class {
 	* summary would subtract from it.
 	* @param count - how many trailing lines the block owns.
 	* @param summary - the collapsed lines, already styled.
+	* @param label - what the block is, for the readout naming what the pointer
+	* is over.
 	*/
-	foldRecent(count, summary) {
-		this.screen?.foldBack(count, summary);
+	foldRecent(count, summary, label = "") {
+		this.screen?.foldBack(count, summary, label);
 	}
 	toggleFolds() {
 		return this.screen?.toggleFolds() ?? false;
@@ -2617,10 +2854,131 @@ var Selector = class {
 	}
 };
 
+//#endregion
+//#region src/todos.ts
+/**
+* Mark for one lifecycle state, styled by what the state means.
+*
+* The three marks are codsh's own (`✔`/`▶`/`○`), not the reference agent's
+* squares: the transcript has used them since todos first rendered, and one
+* surface speaking two alphabets for the same list is worse than differing from
+* the reference on a glyph.
+* @param status - the item's lifecycle state.
+* @param theme - styling for the mark.
+* @returns the styled mark.
+*/
+function mark(status, theme) {
+	if (status === "completed") return theme.success("✔");
+	if (status === "in_progress") return theme.pending("▶");
+	return theme.dim("○");
+}
+/**
+* Count each lifecycle state once, so callers never fold the list twice.
+* @param todos - the list to count.
+* @returns done, active, and open counts alongside the total.
+*/
+function tally(todos) {
+	let done = 0;
+	let active = 0;
+	for (const todo of todos) if (todo.status === "completed") done += 1;
+	else if (todo.status === "in_progress") active += 1;
+	return {
+		done,
+		active,
+		open: todos.length - done - active,
+		total: todos.length
+	};
+}
+/**
+* The header both the card and the expanded list carry.
+*
+* Progress leads because it is the figure a glance wants; the state breakdown
+* follows, and a state with nothing in it is dropped rather than shown as zero —
+* the same rule the status line follows.
+* @param todos - the list to summarize.
+* @param theme - styling for the segments.
+* @param hint - a trailing note, e.g. the key that collapses the list.
+* @returns the header line.
+*/
+function header(todos, theme, hint) {
+	const { done, active, open, total } = tally(todos);
+	const segments = [
+		theme.dim(`${done}/${total}`),
+		...active === 0 ? [] : [theme.dim(`${active} in progress`)],
+		...open === 0 ? [] : [theme.dim(`${open} open`)],
+		...hint === void 0 ? [] : [theme.dim(hint)]
+	];
+	return `${theme.tool("todos")} ${segments.join(theme.dim(" · "))}`;
+}
+/**
+* The item a person watching the run cares about: what is being worked now,
+* or, with nothing active, what comes next.
+* @param todos - the list to look through.
+* @returns the item, or undefined when every item is finished.
+*/
+function focus(todos) {
+	return todos.find((todo) => todo.status === "in_progress") ?? todos.find((todo) => todo.status === "pending");
+}
+/**
+* Render the pinned row: one line naming the work in flight and the progress
+* around it.
+*
+* This row is the whole point of reading from a projection rather than from the
+* write event: the card that announced the list scrolls away, the row does not,
+* so the list stays answerable at a glance for the rest of the session.
+* @param todos - the current list.
+* @param theme - styling for the segments.
+* @param columns - display columns available; a longer row is cut, never wrapped.
+* @param hint - a trailing note, e.g. the key that expands the list.
+* @returns the row, or undefined when there is no list to report.
+*/
+function todoRow(todos, theme, columns, hint) {
+	if (todos.length === 0) return void 0;
+	const { done, total } = tally(todos);
+	const next = focus(todos);
+	const body = next === void 0 ? `${theme.success("✔")} ${theme.dim("all done")}` : `${mark(next.status, theme)} ${next.status === "in_progress" ? next.content : `next: ${next.content}`}`;
+	return truncate([
+		theme.tool("todos"),
+		theme.dim(`${done}/${total}`),
+		body,
+		...hint === void 0 ? [] : [theme.dim(hint)]
+	].join(theme.dim(" · ")), columns);
+}
+/**
+* Render the whole list: the header, then every item under it.
+*
+* A surface that cannot scroll passes `limit`, and the items past it are
+* counted rather than dropped in silence — a list that looks complete but is
+* not is worse than an honest tail.
+* @param todos - the current list.
+* @param theme - styling for the marks and text.
+* @param columns - display columns available; longer lines are cut.
+* @param options - header note and item cap.
+* @returns the lines, empty when there is no list.
+*/
+function todoReport(todos, theme, columns, options = {}) {
+	if (todos.length === 0) return [];
+	const { hint, limit } = options;
+	const shown = limit === void 0 ? todos : todos.slice(0, Math.max(0, limit));
+	const hidden = todos.length - shown.length;
+	return [
+		truncate(header(todos, theme, hint), columns),
+		...shown.map((todo) => truncate(`  ${mark(todo.status, theme)} ${todo.status === "completed" ? theme.dim(todo.content) : todo.content}`, columns)),
+		...hidden === 0 ? [] : [theme.dim(truncate(`  … +${hidden} more`, columns))]
+	];
+}
+
 //#endregion
 //#region src/prompt.ts
 /** How long a flash notice holds the hint row. */
 const FLASH_MS = 1500;
+/**
+* Most todo items the expanded list may occupy.
+*
+* The chrome never scrolls, so an unbounded list would push the box off a short
+* terminal; the items past the cap are counted, never silently dropped.
+*/
+const TODO_ROWS = 10;
 /** Drives the input box and answers reads and selections. */
 var Prompt = class {
 	editor;
@@ -2637,9 +2995,18 @@ var Prompt = class {
 	hint;
 	/** A short-lived notice that borrows the hint row, e.g. the copy toast. */
 	flash;
+	/** What the pointer is resting on, borrowing the hint row while it rests. */
+	hover;
 	flashTimer;
 	/** The always-current session facts shown as the region's last row. */
 	status;
+	/**
+	* The agent's current todo list, kept in the chrome rather than only in the
+	* transcript: the card that announced it scrolls away, this does not.
+	*/
+	todos = [];
+	/** Whether the todo readout shows every item or only the one in flight. */
+	todosExpanded = false;
 	/** The assistant line still arriving, shown above the box. */
 	streaming;
 	/** Frame styling for the current mode, e.g. plan mode's accent. */
@@ -2740,6 +3107,18 @@ var Prompt = class {
 		this.render();
 	}
 	/**
+	* Set the todo readout to the list the session now holds.
+	*
+	* Compared by content, not identity: this is pushed on every session event,
+	* and a repaint per event would flicker the chrome for nothing.
+	* @param todos - the current list, empty to drop the readout.
+	*/
+	setTodos(todos) {
+		if (todos.length === this.todos.length && todos.every((todo, at) => todo.content === this.todos[at]?.content && todo.status === this.todos[at]?.status)) return;
+		this.todos = todos;
+		this.render();
+	}
+	/**
 	* Set the frame accent, which is how a mode shows on the box itself.
 	* @param accent - the styling, or undefined for the default frame.
 	*/
@@ -2758,9 +3137,10 @@ var Prompt = class {
 	/**
 	* Write one finished transcript line above the region.
 	* @param line - the line to keep.
+	* @param rule - a styled left rule marking which block the line belongs to.
 	*/
-	write(line) {
-		this.console.write(line);
+	write(line, rule = "") {
+		this.console.write(line, rule);
 	}
 	/**
 	* Wait for the next submitted text.
@@ -2851,6 +3231,11 @@ var Prompt = class {
 			this.handlers.expandOutput?.();
 			return;
 		}
+		if (key.kind === "toggle-todos") {
+			this.todosExpanded = !this.todosExpanded;
+			this.render();
+			return;
+		}
 		if (key.kind === "page") {
 			this.console.scrollPage(key.direction);
 			this.render();
@@ -2885,6 +3270,14 @@ var Prompt = class {
 			this.console.mouseDrag(key.row, key.column);
 			return;
 		}
+		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"}`);
+			if (readout === this.hover) return;
+			this.hover = readout;
+			this.render();
+			return;
+		}
 		if (key.kind === "mouse-up") {
 			const text = this.console.mouseUp();
 			if (text !== void 0 && this.console.copyText(text)) {
@@ -2933,6 +3326,22 @@ var Prompt = class {
 		}
 		this.render();
 	}
+	/**
+	* The todo readout's rows: the one in flight, or the whole list once opened.
+	* @param columns - display columns available.
+	* @returns the rows, empty when no list is live.
+	*/
+	todoRows(columns) {
+		if (this.todos.length === 0) return [];
+		if (!this.todosExpanded) {
+			const row = todoRow(this.todos, this.theme, columns, "Ctrl+T opens the list");
+			return row === void 0 ? [] : [row];
+		}
+		return todoReport(this.todos, this.theme, columns, {
+			hint: "Ctrl+T closes",
+			limit: TODO_ROWS
+		});
+	}
 	/** Recompose and redraw the bottom region. */
 	render() {
 		if (!this.console.readsKeys) return;
@@ -2960,20 +3369,21 @@ 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)));
 		}
+		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.hint;
+		const notice = this.flash ?? this.hover ?? this.hint;
 		if (notice !== void 0) rows.push(notice);
 		if (this.status !== void 0) rows.push(this.status);
 		if (rows.length === 0) {
 			this.console.clearRegion();
 			return;
 		}
-		const focus = this.select_ === void 0 && (this.engaged || this.reading);
-		if (!focus) cursor = {
+		const focus$1 = this.select_ === void 0 && (this.engaged || this.reading);
+		if (!focus$1) cursor = {
 			row: rows.length - 1,
 			column: 0
 		};
-		this.console.setRegion(rows, cursor, focus);
+		this.console.setRegion(rows, cursor, focus$1);
 	}
 };
 
@@ -3377,9 +3787,9 @@ function questionLines(question, theme) {
 		if (question.detail !== void 0) lines.push(...question.detail.split("\n"));
 		lines.push("", theme.bold(question.question));
 		(question.options ?? []).forEach((option, index) => {
-			const mark = option.label === plan.approve ? theme.success(String(index + 1)) : theme.error(String(index + 1));
+			const mark$1 = option.label === plan.approve ? theme.success(String(index + 1)) : theme.error(String(index + 1));
 			const description = option.description === void 0 ? "" : theme.dim(` — ${option.description}`);
-			lines.push(`  ${mark}. ${option.label}${description}`);
+			lines.push(`  ${mark$1}. ${option.label}${description}`);
 		});
 		lines.push(theme.dim("  (a number, or type your own answer)"));
 		return lines;
@@ -3471,6 +3881,35 @@ var TerminalQuestions = class {
 	}
 };
 
+//#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.
+*/
+/** The `/ship` prompt body; `$ARGUMENTS` is the typed one-sentence requirement. */
+const SHIP_PROMPT = `Run the /ship workflow: take the one-sentence requirement below from idea to shipped, verified code in this repository. The requirement, exactly as typed:
+
+<idea>
+$ARGUMENTS
+</idea>
+
+If the idea between the <idea> tags is empty, that is not an error: before anything else, ask for the one-sentence requirement with ask_user_question, and use the answer as the idea for the rest of this workflow.
+
+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 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 is objectively checkable — named tests, commands with expected output, observable behavior. 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. Write no implementation code before this gate passes, and do not use todo_write before it either — it tracks landing, not the interview.
+
+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. 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, and fix until green 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 durable source of truth, instructs each round to read the spec and plan from disk, pick up the next unfinished milestone, implement and test it, and record progress in the workspace, and defines completion as every acceptance criterion in the spec passing.
+
+Phase 5 — done means verified. The workflow ends only when every acceptance criterion passes with you actually running the named tests and commands and reading their real output. 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. Close with a short honest report: what shipped, what was verified and how, and anything left open.
+
+If the session is in plan mode, the plan-mode rules win: nothing here authorizes writes while it is active. Tell the user this workflow needs to write the spec file and ask them to leave plan mode before continuing past the interview.`;
+
 //#endregion
 //#region src/spinner.ts
 /** Braille frames, one cell wide each, so the line never changes width. */
@@ -3498,10 +3937,10 @@ const TICK_MS = 90;
 */
 function spinnerText(frame, elapsedMs, label, theme) {
 	const seconds = (elapsedMs / 1e3).toFixed(elapsedMs < 1e4 ? 1 : 0);
-	const mark = FRAMES[frame % FRAMES.length] ?? FRAMES[0];
+	const mark$1 = FRAMES[frame % FRAMES.length] ?? FRAMES[0];
 	const extra = label.detail?.();
 	const detail = extra === void 0 || extra === "" ? "" : `${extra} · `;
-	return `${theme.pending(mark)} ${label.verb} ${theme.dim(`${seconds}s · ${detail}${label.interrupt} to interrupt`)}`;
+	return `${theme.pending(mark$1)} ${label.verb} ${theme.dim(`${seconds}s · ${detail}${label.interrupt} to interrupt`)}`;
 }
 /** Drives the working indicator for as long as the agent is busy. */
 var Spinner = class {
@@ -3637,7 +4076,7 @@ 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.
+* the collapsed remainder is one click — or one Ctrl+O — away in full.
 */
 const MAX_RESULT_LINES = 5;
 /**
@@ -3649,6 +4088,85 @@ function visibleText(content) {
 	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
 }
 /**
+* The left rules the transcript draws down a block's edge, one per kind.
+*
+* A rule is how a segment shows where it starts and ends without a frame or a
+* background fill: the references converge on a left border (Claude Code's
+* `borderLeft`, opencode's `border: ["left"]`), and a border costs one column
+* where a fill costs the terminal's own background — which is the theme's to
+* decide, not this surface's (ADR-0001).
+*
+* The person's own words get the heavy mark; a tool block gets the light one,
+* in the error colour when the call failed. What a person actually reads — an
+* answer, a thinking summary — stays flush, so the rules mark the machinery
+* around it rather than everything equally.
+* @param theme - styling for the marks.
+* @returns the rule per block kind.
+*/
+function blockRules(theme) {
+	return {
+		user: theme.user("┃ "),
+		tool: theme.tool("│ "),
+		error: theme.error("│ ")
+	};
+}
+/**
+* What the two nameless block kinds are called when a readout names them.
+*
+* A tool block answers with its card's own title, which is already on screen;
+* thinking and an answer have no title of their own, so these are theirs.
+*/
+const FOLD_LABELS = {
+	thinking: "thinking",
+	answer: "answer"
+};
+/** 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;
+/**
+* The collapsed form of a finished answer, when it is long enough to fold.
+*
+* Shared by the live turn and by replay: a resumed session must offer the same
+* summary the turn itself left behind, or history would read as a different
+* conversation from the one that happened.
+* @param lines - the answer's rendered lines, without its trailing blank.
+* @param theme - styling for the count line.
+* @returns the collapsed lines, or undefined when the answer is short enough
+*   to stand as it is.
+*/
+function answerSummary(lines, theme) {
+	if (lines.length <= ANSWER_FOLD_LINES) return void 0;
+	return [
+		...lines.slice(0, ANSWER_HEAD_LINES),
+		theme.dim(`  … +${lines.length - ANSWER_HEAD_LINES} lines (click or Ctrl+O expands)`),
+		""
+	];
+}
+/**
+* The two forms of a thinking block: one dim line, and the deliberation behind
+* it.
+*
+* Pages of reasoning would bury the conversation, so the transcript keeps the
+* summary and hands the rest to Ctrl+O — live and on replay alike.
+* @param lines - the rendered thinking lines, already styled.
+* @param theme - styling for the header.
+* @param seconds - how long the thinking took, when the surface timed it; a
+*   replayed log carries no clock, so the header simply says it thought.
+* @returns the collapsed and expanded forms.
+*/
+function thinkingFold(lines, theme, seconds) {
+	const head = seconds === void 0 ? "✻ thought" : `✻ thought for ${seconds.toFixed(1)}s`;
+	return {
+		summary: [theme.dim(`${head} · +${lines.length} lines (click or Ctrl+O expands)`), ""],
+		full: [
+			theme.dim(head),
+			...lines,
+			""
+		]
+	};
+}
+/**
 * Render one file's change as unified-diff body lines.
 *
 * A {@link FileDiff} carries one hunk's old and new blocks including their
@@ -3684,13 +4202,17 @@ 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} lines (Ctrl+O expands)`)];
+	return [...lines.slice(0, limit), theme.dim(`  … +${lines.length - limit} lines (click or Ctrl+O expands)`)];
 }
 /** Renders one session's appended events as terminal lines. */
 var Transcript = class {
 	calls = /* @__PURE__ */ new Map();
 	/** The full form of the event just rendered, when its body was collapsed. */
 	fold;
+	/** What the block {@link render} just returned is, for a hover readout. */
+	label = "";
+	/** The left rule the block {@link render} just returned belongs to. */
+	rule = "";
 	constructor(options, presenters) {
 		this.options = options;
 		this.presenters = presenters;
@@ -3733,9 +4255,12 @@ var Transcript = class {
 	*/
 	render(event) {
 		const { theme } = this.options;
+		const rules = blockRules(theme);
+		this.rule = "";
 		switch (event.type) {
 			case "user/message": {
 				if (event.data.source.kind !== "user") return [];
+				this.rule = rules.user;
 				const [first = "", ...rest] = visibleText(event.data.content).split("\n");
 				return [
 					`${theme.user("›")} ${first}`,
@@ -3747,24 +4272,22 @@ var Transcript = class {
 				const text = visibleText(event.data.message.content);
 				return text === "" ? [] : [...renderMarkdown(text, theme), ""];
 			}
-			case "tool/call": return this.renderCall(event.data.callId, event.data.name, event.data.arguments);
-			case "tool/result": return this.renderResult(event.data);
+			case "tool/call":
+				this.rule = rules.tool;
+				return this.renderCall(event.data.callId, event.data.name, event.data.arguments);
+			case "tool/result":
+				this.rule = rules.tool;
+				return this.renderResult(event.data);
 			case "todo/write": {
-				const { todos } = event.data;
-				if (todos.length === 0) return [];
-				const done = todos.filter((todo) => todo.status === "completed").length;
-				return [
-					`${theme.tool("todos")} ${theme.dim(`${done}/${todos.length}`)}`,
-					...todos.map((todo) => {
-						if (todo.status === "completed") return theme.dim(`  ✔ ${todo.content}`);
-						if (todo.status === "in_progress") return `  ${theme.pending("▶")} ${todo.content}`;
-						return theme.dim(`  ○ ${todo.content}`);
-					}),
-					""
-				];
+				this.rule = rules.tool;
+				const lines = todoReport(event.data.todos, theme, this.options.columns);
+				return lines.length === 0 ? [] : [...lines, ""];
 			}
 			case "plan/mode": return event.data.active ? [theme.pending("▲ plan mode — exploring only; no files will change until you approve a plan"), ""] : [theme.dim("▼ plan mode off"), ""];
-			case "turn/end": return event.data.reason.kind === "error" ? [theme.error(`✗ ${event.data.reason.error.code}: ${event.data.reason.error.message}`), ""] : [];
+			case "turn/end":
+				if (event.data.reason.kind !== "error") return [];
+				this.rule = rules.error;
+				return [theme.error(`✗ ${event.data.reason.error.code}: ${event.data.reason.error.message}`), ""];
 			default: return [];
 		}
 	}
@@ -3794,11 +4317,11 @@ var Transcript = class {
 		};
 		if (view === void 0) return record(name$1, [`${theme.pending("●")} ${theme.tool(name$1)}`]);
 		if (view.card === "terminal") {
-			const header = view.cwd === void 0 ? "" : theme.dim(` (${this.relative(view.cwd)})`);
+			const header$1 = view.cwd === void 0 ? "" : theme.dim(` (${this.relative(view.cwd)})`);
 			const description = view.description === void 0 ? [] : [theme.dim(`  ${view.description}`)];
 			const command = this.relativizeIn(view.title);
 			return record(command, [
-				`${theme.pending("●")} ${theme.tool(name$1)}${header}`,
+				`${theme.pending("●")} ${theme.tool(name$1)}${header$1}`,
 				`  $ ${truncate(command, columns - 4)}`,
 				...description
 			]);
@@ -3826,15 +4349,19 @@ var Transcript = class {
 		const pending = this.calls.get(callId);
 		this.calls.delete(callId);
 		const failed = error !== void 0 || block.isError === true;
+		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 head$1 = `${marker} ${theme.dim("(result)")}`;
-			if (raw.length > MAX_RESULT_LINES) this.fold = [
-				head$1,
-				...raw,
-				""
-			];
+			if (raw.length > MAX_RESULT_LINES) {
+				this.fold = [
+					head$1,
+					...raw,
+					""
+				];
+				this.label = "tool result";
+			}
 			return [
 				head$1,
 				...cap(raw, MAX_RESULT_LINES, theme),
@@ -3845,11 +4372,14 @@ var Transcript = class {
 		const title = view?.title === void 0 ? pending.title : this.relativizeIn(view.title);
 		const { suffix, body, full } = this.outcome(view, block);
 		const head = failed || title !== pending.title ? [`${marker} ${theme.tool(title)}${suffix === "" ? "" : ` ${suffix}`}`] : suffix !== "" ? [`  ${suffix}`] : body.length === 0 ? [`  ${theme.success("✓")}`] : [];
-		if (full !== void 0) this.fold = [
-			...head,
-			...full,
-			""
-		];
+		if (full !== void 0) {
+			this.fold = [
+				...head,
+				...full,
+				""
+			];
+			this.label = title;
+		}
 		return [
 			...head,
 			...body,
@@ -3870,6 +4400,31 @@ var Transcript = class {
 		return fold;
 	}
 	/**
+	* What the block {@link takeFold} just described is called.
+	*
+	* The card's title, so the readout that names what the pointer rests on says
+	* the same thing the block's own head line says.
+	* @returns the label, or `''` when the block has no name of its own.
+	*/
+	takeLabel() {
+		const label = this.label;
+		this.label = "";
+		return label;
+	}
+	/**
+	* The left rule for the block {@link render} just returned, `''` when the
+	* block stands flush.
+	*
+	* Paired with the lines rather than baked into them: the rule repeats on
+	* every row the block wraps to, which only the buffer that wraps them knows.
+	* @returns the styled rule, or `''`.
+	*/
+	takeRule() {
+		const rule = this.rule;
+		this.rule = "";
+		return rule;
+	}
+	/**
 	* Render one completed call's status suffix and body from its declared view.
 	* @param view - the result view, absent when no presenter answered.
 	* @param block - the model-facing result block, used by the generic fallback.
@@ -4060,14 +4615,46 @@ function statusFacts(ctx, agent, cwd, selection, presetId, branch) {
 	};
 }
 /**
+* The agent's todo list as the chrome's readout wants it.
+*
+* Read from the projection rather than remembered from the write event, so a
+* resumed session shows the list it left off with and a `/clear` shows none.
+* @param ctx - plugin context carrying the projection service.
+* @param agent - the live agent.
+* @returns the current list, empty before any write.
+*/
+function todoList(ctx, agent) {
+	return ctx.get("sessionProjections")?.snapshot(agent.session).values.todos ?? [];
+}
+/**
 * Render every event a resumed session already holds, so the person sees the
 * conversation they are continuing.
 * @param session - the reconstructed session.
 * @param transcript - the renderer, which also learns the pending call table.
 * @param io - the terminal to write to.
 */
-function replay(session, transcript, io) {
-	for (const event of session.events) for (const line of transcript.render(event)) io.console.write(line);
+function replay(session, transcript, io, theme) {
+	for (const event of session.events) {
+		if (event.type === "assistant/message") {
+			const thought = event.data.message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+			if (thought !== "") {
+				const { summary: summary$1, full: full$1 } = thinkingFold(thought.split("\n").map((line) => theme.dim(`  ${line}`)), theme);
+				io.console.appendFold(summary$1, full$1, "", FOLD_LABELS.thinking);
+			}
+		}
+		const lines = transcript.render(event);
+		const full = transcript.takeFold();
+		const rule = transcript.takeRule();
+		const label = transcript.takeLabel();
+		if (full !== void 0) {
+			io.console.appendFold(lines, full, rule, label);
+			continue;
+		}
+		for (const line of lines) io.console.write(line, rule);
+		if (event.type !== "assistant/message") continue;
+		const summary = answerSummary(lines.at(-1) === "" ? lines.slice(0, -1) : lines, theme);
+		if (summary !== void 0) io.console.foldRecent(lines.length, summary, FOLD_LABELS.answer);
+	}
 }
 /**
 * Run one conversation turn and wait for the agent to go idle.
@@ -4114,7 +4701,7 @@ async function runCommand(ctx, agent, line, io, theme, signal) {
 		io.console.write("");
 		return;
 	}
-	const execution = await commands.execute(agent, line, signal);
+	const execution = await commands.execute(agent, line, [], signal);
 	if (execution === void 0) {
 		io.console.write(theme.error(`  unknown command: ${line}`));
 		return;
@@ -4128,10 +4715,6 @@ 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.
@@ -4308,7 +4891,7 @@ async function run(ctx, config, io) {
 	const facts = (branch$1) => statusFacts(ctx, live.agent, cwd, selection, presetId, branch$1);
 	io.console.setTitle(`dsh code — ${basename(cwd)}`);
 	let branch = await gitBranch(cwd);
-	if (config.resume !== "") replay(live.agent.session, live.transcript, io);
+	if (config.resume !== "") replay(live.agent.session, live.transcript, io, theme);
 	for (const line of bannerLines({
 		model,
 		preset: presetId,
@@ -4365,6 +4948,7 @@ async function run(ctx, config, io) {
 		"quit",
 		"help",
 		"init",
+		"ship",
 		"status",
 		"model",
 		"clear",
@@ -4379,6 +4963,10 @@ async function run(ctx, config, io) {
 			name: "init",
 			description: "analyze the repo and draft AGENTS.md"
 		},
+		{
+			name: "ship",
+			description: "take a one-sentence idea to shipped code"
+		},
 		...custom.commands.map((command) => ({
 			name: command.name,
 			description: command.description
@@ -4444,7 +5032,7 @@ async function run(ctx, config, io) {
 		},
 		shiftTab: () => {
 			const line = planModeFrom(live.agent.session.events) ? "/plan off" : "/plan";
-			commands?.execute(live.agent, line, new AbortController().signal);
+			commands?.execute(live.agent, line, [], new AbortController().signal);
 		},
 		expandOutput: () => {
 			if (!io.console.toggleFolds()) prompt.write(theme.dim("  nothing to expand"));
@@ -4490,6 +5078,20 @@ async function run(ctx, config, io) {
 				text: statusReport(facts(branch), live.agent.session.id)
 			})
 		}));
+		disposers.push(commands.register({
+			name: "todos",
+			description: "print the agent's todo list as it now stands",
+			handler: () => {
+				const lines = todoReport(todoList(ctx, live.agent), theme, io.console.columns);
+				return lines.length === 0 ? {
+					kind: "success",
+					text: "no todos yet"
+				} : {
+					kind: "success",
+					text: lines.join("\n")
+				};
+			}
+		}));
 		disposers.push(commands.register({
 			name: "clear",
 			description: "start a fresh session in place",
@@ -4626,14 +5228,14 @@ async function run(ctx, config, io) {
 				if (typed === "") {
 					await refreshModelCatalog();
 					const current = selection.current;
-					const header = `current ${current?.provider ?? "?"}/${current?.model ?? "?"}`;
+					const header$1 = `current ${current?.provider ?? "?"}/${current?.model ?? "?"}`;
 					if (modelCatalog.length === 0) return {
 						kind: "success",
-						text: header
+						text: header$1
 					};
 					if (!io.console.readsKeys) return {
 						kind: "success",
-						text: `${header}\n${modelCatalog.map((entry) => {
+						text: `${header$1}\n${modelCatalog.map((entry) => {
 							return `${entry.provider === current?.provider && entry.id === current.model ? "❯" : " "} ${entry.provider}/${entry.id}  ${entry.name}`;
 						}).join("\n")}`
 					};
@@ -4683,11 +5285,8 @@ async function run(ctx, config, io) {
 		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)`),
-			""
-		]);
+		const summary = answerSummary(answerLines, theme);
+		if (summary !== void 0) io.console.foldRecent(answerLines.length + 1, summary, FOLD_LABELS.answer);
 		answerLines = [];
 	};
 	const thinking = new TextStream(theme, () => io.console.contentColumns, true);
@@ -4696,13 +5295,9 @@ async function run(ctx, config, io) {
 	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,
-			""
-		]);
+		const { summary, full } = thinkingFold(thinkingLines, theme, (performance.now() - thinkingStartedAt) / 1e3);
+		io.console.appendFold(summary, full, "", FOLD_LABELS.thinking);
 		thinkingLines = [];
 		thinkingStartedAt = 0;
 	};
@@ -4711,15 +5306,16 @@ async function run(ctx, config, io) {
 	* @param lines - finished lines for the transcript.
 	* @param live - the in-progress line, or undefined to release the region.
 	*/
-	const emit = (lines, live$1) => {
+	const emit = (lines, live$1, rule = "") => {
 		if (lines.length > 0) prompt.setStreaming(void 0);
-		for (const line of lines) prompt.write(line);
+		for (const line of lines) prompt.write(line, rule);
 		prompt.setStreaming(live$1);
 	};
 	/** Push the always-current status row; the pipe shape prints it instead. */
 	const refreshStatus = () => {
 		if (!io.console.readsKeys) return;
 		prompt.setStatus(statusLine(facts(branch), theme, io.console.columns - 1));
+		prompt.setTodos(todoList(ctx, live.agent));
 	};
 	if (planModeFrom(live.agent.session.events)) prompt.setAccent((text) => theme.pending(text));
 	refreshStatus();
@@ -4727,6 +5323,7 @@ async function run(ctx, config, io) {
 		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 (config.print && event.type === "user/message") return;
 		if (event.type === "assistant/chunk") {
 			const { chunk } = event.data;
@@ -4754,12 +5351,14 @@ async function run(ctx, config, io) {
 		}
 		const lines = live.transcript.render(event);
 		const full = live.transcript.takeFold();
+		const rule = live.transcript.takeRule();
+		const label = live.transcript.takeLabel();
 		if (full === void 0) {
-			emit(lines);
+			emit(lines, void 0, rule);
 			return;
 		}
 		prompt.setStreaming(void 0);
-		io.console.appendFold(lines, full);
+		io.console.appendFold(lines, full, rule, label);
 	});
 	/** Pause the indicator around a decision, and resume it if work continues. */
 	const whileDeciding = async (decide) => {
@@ -4815,7 +5414,7 @@ async function run(ctx, config, io) {
 		approval.clear();
 		turnBaseTokens = 0;
 		prompt.setAccent(planModeFrom(next.agent.session.events) ? (text) => theme.pending(text) : void 0);
-		if (replayLog) replay(next.agent.session, live.transcript, io);
+		if (replayLog) replay(next.agent.session, live.transcript, io, theme);
 		refreshStatus();
 	};
 	const questions = ctx.get("userQuestions");
@@ -5001,6 +5600,13 @@ async function run(ctx, config, io) {
 				});
 				continue;
 			}
+			if (name$1 === "ship") {
+				await answer(expandTemplate(SHIP_PROMPT, rest.trim()), {
+					kind: "plugin",
+					plugin: "coding-cli"
+				});
+				continue;
+			}
 			const canned = customByName.get(name$1);
 			if (canned !== void 0) {
 				await answer(expandTemplate(canned.template, rest.trim()), {