codsh-bundle 0.4.0 → 0.6.0

package/lib/index.js

@@ -1,12 +1,13 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { copyFile, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, parse } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { admitEncodedImages, isImageAdmissionError } from "@deepseek-ai/dsh-attachment";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import stringWidth from "string-width";
 import { readdirSync } from "node:fs";
 import { createInterface } from "node:readline";
@@ -586,9 +587,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 +698,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,7 +794,9 @@ const CONTROLS = {
 	"\v": { kind: "kill-line" },
 	"\f": { kind: "clear-screen" },
 	"": { kind: "expand-output" },
+	"": { kind: "toggle-todos" },
 	"": { kind: "kill-input" },
+	"": { kind: "paste-image" },
 	"": { kind: "kill-word" }
 };
 /** Decodes terminal bytes into keys, holding partial sequences between reads. */
@@ -855,6 +866,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 +1002,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 +1021,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 +1048,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 +1061,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 +1108,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 +1149,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 +1177,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 +1234,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 +1258,7 @@ var Screen = class {
 					at
 				}] : [];
 			});
+			this.hovered = void 0;
 			this.rewrap();
 		}
 		this.render();
@@ -1213,17 +1271,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 +1297,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 +1309,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 +1325,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 +1341,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 +1433,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 +1454,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 +1505,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 +1523,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 +1585,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 +1595,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 +1610,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 +1624,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 +1660,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 +1708,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 +1731,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 +2008,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 +2029,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 +2039,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 +2071,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 +2127,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;
@@ -1988,6 +2227,158 @@ var TerminalConsole = class {
 	}
 };
 
+//#endregion
+//#region src/clipboard-image.ts
+/** The most a clipboard image may be; beyond this the read reports none. */
+const MAX_CLIPBOARD_IMAGE_BYTES = 64 * 1024 * 1024;
+/**
+* Run one command, capturing binary stdout.
+* @param command - the executable.
+* @param args - its arguments.
+* @returns stdout as bytes, or undefined on any failure or empty output.
+*/
+function run$1(command, args) {
+	return new Promise((resolve) => {
+		execFile(command, [...args], {
+			encoding: "buffer",
+			maxBuffer: MAX_CLIPBOARD_IMAGE_BYTES,
+			timeout: 1e4
+		}, (error, stdout) => {
+			if (error !== null || stdout.length === 0) resolve(void 0);
+			else resolve(stdout);
+		});
+	});
+}
+/**
+* What image type these bytes are, from their magic numbers.
+*
+* Sniffed rather than taken from the reader's word: the store verifies the
+* declared type against the decoded bytes and refuses a mismatch, so lying
+* here would only defer the failure to a worse moment.
+* @param data - the bytes.
+* @returns the media type, or undefined for anything that is not an image.
+*/
+function sniffImageType(data) {
+	if (data.length < 12) return void 0;
+	if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "image/png";
+	if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg";
+	if (data[0] === 71 && data[1] === 73 && data[2] === 70 && data[3] === 56) return "image/gif";
+	if (data.subarray(0, 4).toString("latin1") === "RIFF" && data.subarray(8, 12).toString("latin1") === "WEBP") return "image/webp";
+}
+/** The clipboard's image on macOS: AppleScript writes the PNG to a file. */
+async function readDarwin() {
+	const dir = await mkdtemp(join(tmpdir(), "codsh-clip-"));
+	const file = join(dir, "clipboard.png");
+	try {
+		const script = [
+			"-e",
+			"set png_data to (the clipboard as «class PNGf»)",
+			"-e",
+			`set fp to open for access POSIX file "${file}" with write permission`,
+			"-e",
+			"write png_data to fp",
+			"-e",
+			"close access fp"
+		];
+		if (!await new Promise((resolve) => {
+			execFile("osascript", script, { timeout: 1e4 }, (error) => void resolve(error === null));
+		})) return void 0;
+		return await readFile(file).catch(() => void 0);
+	} finally {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** The clipboard's image on Linux, Wayland first, X11 as the fallback. */
+async function readLinux(env) {
+	if (env.WAYLAND_DISPLAY !== void 0) {
+		const offered$1 = (await run$1("wl-paste", ["-l"]))?.toString("utf8").match(/image\/(?:png|jpeg|webp|gif)/u)?.[0];
+		if (offered$1 === void 0) return void 0;
+		return run$1("wl-paste", ["-t", offered$1]);
+	}
+	const offered = (await run$1("xclip", [
+		"-selection",
+		"clipboard",
+		"-t",
+		"TARGETS",
+		"-o"
+	]))?.toString("utf8").match(/image\/(?:png|jpeg|webp|gif)/u)?.[0];
+	if (offered === void 0) return void 0;
+	return run$1("xclip", [
+		"-selection",
+		"clipboard",
+		"-t",
+		offered,
+		"-o"
+	]);
+}
+/** The clipboard's image on Windows: PowerShell saves it as a PNG file. */
+async function readWin32() {
+	const dir = await mkdtemp(join(tmpdir(), "codsh-clip-"));
+	const file = join(dir, "clipboard.png");
+	try {
+		const script = `$img = Get-Clipboard -Format Image; if ($img) { $img.Save('${file.replaceAll("\\", "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png) }`;
+		if (!await new Promise((resolve) => {
+			execFile("powershell", [
+				"-NoProfile",
+				"-Command",
+				script
+			], { timeout: 1e4 }, (error) => void resolve(error === null));
+		})) return void 0;
+		return await readFile(file).catch(() => void 0);
+	} finally {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Pixel dimensions from the image header, best effort.
+*
+* sharp decodes properly, but it is a native module and the flash line does
+* not justify failing a paste over it — an unreadable header simply reports
+* no dimensions.
+* @param data - the image bytes.
+* @returns width and height, or undefined.
+*/
+async function probeDimensions(data) {
+	try {
+		const { default: sharp } = await import("sharp");
+		const meta = await sharp(data).metadata();
+		if (typeof meta.width === "number" && typeof meta.height === "number") return {
+			width: meta.width,
+			height: meta.height
+		};
+		return;
+	} catch {
+		return;
+	}
+}
+/**
+* The image on the system clipboard, or undefined when it holds none.
+*
+* `CODSH_CLIPBOARD_IMAGE_CMD` overrides the platform reader with a shell
+* command whose stdout is the image bytes — the seam the tests use, exactly
+* as `CODSH_CLIPBOARD=osc52` keeps the write path off the real clipboard.
+* @param env - the environment, for the override and the display probes.
+* @returns the image with its sniffed type and dimensions, or undefined.
+*/
+async function readClipboardImage(env) {
+	const override = env.CODSH_CLIPBOARD_IMAGE_CMD;
+	const data = override !== void 0 && override !== "" ? await run$1(env.SHELL ?? "/bin/sh", ["-c", override]) : process.platform === "darwin" ? await readDarwin() : process.platform === "win32" ? await readWin32() : await readLinux(env);
+	if (data === void 0) return void 0;
+	const mediaType = sniffImageType(data);
+	if (mediaType === void 0) return void 0;
+	return {
+		data,
+		mediaType,
+		...await probeDimensions(data)
+	};
+}
+
 //#endregion
 //#region src/editor.ts
 /** Longest run of history the editor keeps for one session. */
@@ -2214,9 +2605,11 @@ var Editor = class {
 	backspace() {
 		if (this.column > 0) {
 			const cells = points(this.line());
-			cells.splice(this.column - 1, 1);
+			const token = /\[Image #\d+\]$/u.exec(cells.slice(0, this.column).join(""));
+			const width = token === null ? 1 : points(token[0]).length;
+			cells.splice(this.column - width, width);
 			this.setLine(cells.join(""));
-			this.column -= 1;
+			this.column -= width;
 		} else if (this.row > 0) {
 			const previous = this.lines[this.row - 1] ?? "";
 			const current = this.line();
@@ -2617,10 +3010,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;
@@ -2633,13 +3147,31 @@ var Prompt = class {
 	* not be lost; the queue is what a line reader provides for free.
 	*/
 	queued = [];
+	/** Images pasted into the box, by the number their `[Image #N]` token wears. */
+	pendingImages = /* @__PURE__ */ new Map();
+	/** Numbers are never reused within a session: a recalled token must not
+	* silently pick up a different image. */
+	imageCounter = 0;
+	/** The images belonging to the line the last read handed out. */
+	submittedImages = [];
+	/** Whether a clipboard read is already in flight; a second Ctrl+V waits. */
+	pastingImage = false;
 	/** The working indicator shown under the box. */
 	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 +3272,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 +3302,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.
@@ -2770,7 +3315,10 @@ var Prompt = class {
 	read(signal) {
 		if (!this.console.readsKeys) return this.console.readLine(signal);
 		const typedAhead = this.queued.shift();
-		if (typedAhead !== void 0) return Promise.resolve(typedAhead);
+		if (typedAhead !== void 0) {
+			this.submittedImages = typedAhead.images;
+			return Promise.resolve(typedAhead.text);
+		}
 		if (this.console.finished) return Promise.resolve(void 0);
 		this.reading = true;
 		this.render();
@@ -2778,6 +3326,7 @@ var Prompt = class {
 			const settle = (text) => {
 				this.pending = void 0;
 				this.reading = false;
+				this.submittedImages = text === void 0 ? [] : this.claimImages(text);
 				resolve(text);
 			};
 			const onAbort = () => {
@@ -2851,6 +3400,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 +3439,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)) {
@@ -2904,12 +3466,19 @@ var Prompt = class {
 			this.render();
 			return;
 		}
+		if (key.kind === "paste-image") {
+			this.pasteImage();
+			return;
+		}
 		const action = this.editor.handle(key);
 		switch (action.kind) {
 			case "submit": {
 				const waiting = this.pending;
 				if (waiting === void 0) {
-					this.queued.push(action.text);
+					this.queued.push({
+						text: action.text,
+						images: this.claimImages(action.text)
+					});
 					break;
 				}
 				waiting.dispose();
@@ -2933,6 +3502,97 @@ var Prompt = class {
 		}
 		this.render();
 	}
+	/**
+	* Read the clipboard and attach its image behind an `[Image #N]` token.
+	*
+	* The read shells out and takes real time, so it runs off the key handler;
+	* a second Ctrl+V during it is dropped rather than raced. Numbers count up
+	* for the whole session — a token in a recalled line must never quietly
+	* name a different image than the one it was minted for.
+	*/
+	async pasteImage() {
+		const read = this.handlers.readClipboardImage;
+		if (read === void 0 || this.pastingImage) return;
+		this.pastingImage = true;
+		try {
+			const found = await read();
+			if (found === void 0) {
+				this.setFlash(this.theme.dim("  no image in the clipboard"));
+				return;
+			}
+			this.imageCounter += 1;
+			const id = this.imageCounter;
+			const pending = {
+				id,
+				image: {
+					mediaType: found.mediaType,
+					data: found.data.toString("base64"),
+					name: `Pasted image #${id}`
+				}
+			};
+			if (found.width !== void 0) pending.width = found.width;
+			if (found.height !== void 0) pending.height = found.height;
+			this.pendingImages.set(id, pending);
+			this.editor.handle({
+				kind: "paste",
+				text: `[Image #${id}]`
+			});
+			const size = found.width !== void 0 && found.height !== void 0 ? ` (${found.width}×${found.height} ${found.mediaType.slice(6)})` : "";
+			this.setFlash(this.theme.dim(`  ✓ image #${id} attached${size}`));
+		} finally {
+			this.pastingImage = false;
+			this.render();
+		}
+	}
+	/**
+	* The images a submitted line actually references, in token order.
+	*
+	* The tokens are the source of truth: a token the person deleted drops its
+	* image, a token duplicated by editing still names one attachment once.
+	* Claimed images leave the pending pool, so a token recalled from history
+	* later submits as plain text rather than resurrecting consumed bytes.
+	* @param text - the submitted line.
+	* @returns the referenced images, ready to ride the submission.
+	*/
+	claimImages(text) {
+		const images = [];
+		for (const match of text.matchAll(/\[Image #(\d+)\]/gu)) {
+			const id = Number(match[1]);
+			const pending = this.pendingImages.get(id);
+			if (pending === void 0) continue;
+			this.pendingImages.delete(id);
+			images.push(pending);
+		}
+		return images;
+	}
+	/**
+	* The images belonging to the line the last read returned.
+	*
+	* A drain, in the transcript's `take*` idiom: the caller reads the line,
+	* then takes its images exactly once.
+	* @returns the images in token order, empty for a plain line.
+	*/
+	takeAttachments() {
+		const images = this.submittedImages;
+		this.submittedImages = [];
+		return images;
+	}
+	/**
+	* 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;
@@ -2956,24 +3616,25 @@ var Prompt = class {
 			rows.push(...box.rows);
 		}
 		if (this.queued.length > 0) {
-			const preview = this.queued[0] ?? "";
+			const preview = this.queued[0]?.text ?? "";
 			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 +4038,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 +4132,42 @@ 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 spec FILE is the workflow's memory, not the conversation: the approved
+* plan is written into it, its Status line names the phase, its checkboxes
+* are the progress, and a bare /ship offers to resume whatever it finds
+* unfinished. Conversations get interrupted, compacted, and cleared; the file
+* survives all three, which is what makes the landing reliable rather than
+* merely well-intentioned.
+*/
+/** 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. First look for unfinished work: scan the repository's spec directory (docs/specs/, or the repo's own design-document convention) for a spec whose Status line is not \`shipped\` — a bare /ship most likely means "carry on", so offer through ask_user_question to resume that spec from the phase its Status names, with everything below applying from that phase onward. Only when there is nothing to resume, ask for the one-sentence requirement with ask_user_question and use the answer as the idea. Images accompanying the command — [Image #N] tokens, <pasted-image> context, attached image blocks — are part of the requirement: a mockup or a screenshot is requirements material, so read it and cite what it shows in the interview.
+
+Phase 1 — grounded interview. Research before you ask: read the repository layout, the docs, and the code paths the idea touches, so every question is informed by what actually exists. Then interrogate the idea with ask_user_question, one focused question per call, never a batch. Cover, as far as they are genuinely open: who this is for and what success looks like, scope and explicit non-goals, constraints (compatibility, performance, security, dependencies), edge cases and failure behavior, and how the result should be verified. Prefer concrete options grounded in what you found over open-ended prompts. Do not ask what inspection can answer — where code lives or how current behavior works is yours to find out. Stop when answers stop changing the design; do not pad the interview to look thorough.
+
+Phase 2 — the spec (gate 1). Write the agreed design to a spec file inside the repository. Follow the repo's existing convention for design documents if one exists (a specs, rfcs, or ADR directory); otherwise create docs/specs/<kebab-case-slug>.md. The spec must stand alone for a reader without this conversation: the one-sentence requirement, background, each interview decision with its reason, scope and non-goals, constraints, edge cases, and a numbered list of acceptance criteria where every criterion names the exact command that proves it and the output that counts as passing — the final phase runs those commands verbatim, so a criterion without a command is not finished. Give the file a \`Status:\` line (interviewing, confirmed, planned, landing, shipped) and keep it current at every phase change: it is what lets an interrupted /ship resume instead of starting over. Present the spec file path and a compact summary through ask_user_question and get an explicit yes. If the answer amends or rejects it, update the file and ask again. Do not proceed on silence or a vague reply.
+
+Phase 3 — the plan (gate 2). Only after the spec is confirmed, produce an implementation plan: ordered milestones with the files each touches, the tests each milestone adds or changes, which acceptance criterion each milestone satisfies, and the commands that prove the whole thing (build, typecheck, test). Present the plan through ask_user_question and get an explicit yes; fold rejections back in and present again. Once approved, write the plan into the spec file as a \`## Plan\` section with one checkbox per milestone — an approved plan lives on disk, not in a conversation that can be compacted or lost. Then, still before any implementation code, establish the ground: check the working tree is clean (uncommitted unrelated changes are the user's to decide about — ask), and run the plan's proof commands once, recording the baseline in the spec. A baseline that is already red changes what "green" will mean, so surface it here rather than discovering it under your own diff. Write no implementation code before this gate passes, and do not use todo_write before it either — it tracks landing, not the interview.
+
+Phase 4 — landing. After gate 2, work autonomously; return to the user only for a genuine blocker that contradicts the spec, never for routine decisions. Either way the spec file — not this conversation — is the working memory: re-read it before starting each milestone, tick the milestone's checkbox and update Status as you go, and commit after each milestone turns green — small commits are the progress that survives a crash and the history a reviewer can walk. Choose the mechanism by the approved plan's size. If it has at most three milestones and you expect the whole change to fit comfortably in this session's context, implement in-session: track the milestones with todo_write, and for each one implement, run the tests, fix until green, then commit before moving on. If it is larger — four or more substantially independent milestones, or work you expect to exceed what one session can hold — the user running /ship is their explicit request for a fresh-agent Ralph loop: call the ralph tool once, with an objective that names the spec file path as the single source of truth, instructs each round to read the spec from disk (plan, checkboxes, baseline), pick the first unchecked milestone, implement and test it, then commit and tick its checkbox, and defines completion as every acceptance criterion in the spec passing. Bound the loop: budget about three rounds per milestone, and instruct it to stop and report rather than continue past two consecutive rounds that tick nothing.
+
+Phase 5 — done means verified. The workflow ends only when every acceptance criterion passes with you actually running its named command and reading the real output. After a Ralph loop returns, run every proof command again yourself — the loop's word is a report, not a verification. Never report a result you did not run, and never weaken a criterion to make it pass; if one cannot be met, say so plainly and why. When a decision changes mid-flight, update the spec file first so the file on disk stays the truth. Set Status to shipped only after that final run, and close with an honest report listing each criterion, the command that proved it, and what it printed — plus anything left open.
+
+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 +4195,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 {
@@ -3555,6 +4252,166 @@ var Spinner = class {
 	}
 };
 
+//#endregion
+//#region src/vision.ts
+/** How long one description may take before the paste falls back to file-only. */
+const VISION_TIMEOUT_MS = 3e4;
+/**
+* The one instruction the sidecar gets.
+*
+* It is the eyes for a model that has none, so completeness beats brevity and
+* verbatim beats summary: a truncated error message or a paraphrased line of
+* code is exactly the part the coding agent needed.
+*/
+const VISION_PROMPT = "You are the eyes for a text-only coding agent. Describe this image precisely and completely. Transcribe ALL visible text, code, commands, error messages, numbers and labels verbatim. When it shows a UI, terminal, diagram or chart, describe its structure and layout so the agent can reason about it. Do not speculate beyond what is visible.";
+/**
+* The sidecar from the environment, or undefined when none is configured.
+* @param env - the process environment.
+* @returns the config when both the base URL and the model are set.
+*/
+function visionConfigFromEnv(env) {
+	const baseUrl = env.CODSH_VISION_BASE_URL;
+	const model = env.CODSH_VISION_MODEL;
+	if (baseUrl === void 0 || baseUrl === "" || model === void 0 || model === "") return void 0;
+	const config = {
+		baseUrl: baseUrl.replace(/\/$/u, ""),
+		model
+	};
+	const key = env.CODSH_VISION_API_KEY;
+	if (key !== void 0 && key !== "") config.apiKey = key;
+	return config;
+}
+/**
+* Ask the sidecar what an image shows.
+* @param image - the encoded image.
+* @param config - which endpoint and model to ask.
+* @param signal - cancels the request, on top of the built-in timeout.
+* @returns the description.
+* @throws on timeout, a non-2xx answer, or an answer with no text.
+*/
+async function describeImage(image, config, signal) {
+	const timeout = AbortSignal.timeout(VISION_TIMEOUT_MS);
+	const response = await fetch(`${config.baseUrl}/chat/completions`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			...config.apiKey === void 0 ? {} : { authorization: `Bearer ${config.apiKey}` }
+		},
+		body: JSON.stringify({
+			model: config.model,
+			messages: [{
+				role: "user",
+				content: [{
+					type: "image_url",
+					image_url: { url: `data:${image.mediaType};base64,${image.data}` }
+				}, {
+					type: "text",
+					text: VISION_PROMPT
+				}]
+			}]
+		}),
+		signal: signal === void 0 ? timeout : AbortSignal.any([signal, timeout])
+	});
+	if (!response.ok) throw new Error(`vision endpoint answered ${response.status}`);
+	const text = (await response.json()).choices?.[0]?.message?.content?.trim();
+	if (text === void 0 || text === "") throw new Error("vision endpoint answered without text");
+	return text;
+}
+/**
+* The upstream store's default admission limits, for use when no store is
+* mounted: the sidecar payload is bounded by the same line either way.
+*/
+const DEFAULT_IMAGE_LIMITS = {
+	maxImageBytes: 3.5 * 1024 * 1024,
+	maxImagesPerMessage: 20,
+	maxMessageImageBytes: 100 * 1024 * 1024,
+	maxImagePixels: 4e7,
+	maxImageDimension: 2e3,
+	mediaTypes: [
+		"image/png",
+		"image/jpeg",
+		"image/webp",
+		"image/gif"
+	]
+};
+/** File extension per media type, for the saved copy's name. */
+const EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/webp": "webp",
+	"image/gif": "gif"
+};
+/**
+* Save a pasted image where the agent's tools can reach it.
+*
+* The original bytes, never a downscaled copy — the person may want the asset
+* itself committed. Content-addressed under the dsh home so a repeated paste
+* dedupes, nothing lands in the workspace uninvited, and the path stays valid
+* for `--resume`.
+* @param image - the encoded image.
+* @returns the absolute path of the saved file.
+*/
+async function savePastedImage(image) {
+	const data = Buffer.from(image.data, "base64");
+	const digest = createHash("sha256").update(data).digest("hex").slice(0, 12);
+	const dir = dshHomePath("attachments", "pasted");
+	await mkdir(dir, { recursive: true });
+	const path = join(dir, `${digest}.${EXTENSIONS[image.mediaType]}`);
+	await writeFile(path, data);
+	return path;
+}
+/**
+* The context block a pasted image contributes on a text-only route.
+*
+* The same XMLish convention the `!` passthrough uses: the model reads the
+* path (its tools can open the file), the dimensions, and — when the sidecar
+* ran — the description standing in for sight.
+* @param id - the `[Image #N]` number the person's text references.
+* @param image - the encoded image.
+* @param at - where the file was saved and what is known about it.
+* @returns the block text.
+*/
+function pastedImageBlock(id, image, at) {
+	const size = at.width !== void 0 && at.height !== void 0 ? ` dimensions="${at.width}x${at.height}"` : "";
+	const body = at.description === void 0 ? "" : `\n<description>\n${at.description}\n</description>`;
+	return `<pasted-image id="${id}" media="${image.mediaType}"${size} path="${at.path}">${body}\n</pasted-image>`;
+}
+/**
+* Shrink an image until the attachment store will admit it.
+*
+* Retina screenshots exceed the deployed routes' 2000-pixel side limit as a
+* matter of course, and refusing them would make the feature useless on the
+* machines most likely to use it. The downscale re-encodes as PNG; a copy
+* still over the byte limit falls back to JPEG, which is what a photograph
+* that big actually is.
+* @param image - the encoded image.
+* @param limits - the store's admission limits.
+* @returns the image, downscaled only when it had to be.
+*/
+async function fitWithinLimits(image, limits) {
+	const data = Buffer.from(image.data, "base64");
+	const { default: sharp } = await import("sharp");
+	const meta = await sharp(data).metadata();
+	if (!(Math.max(meta.width ?? 0, meta.height ?? 0) > limits.maxImageDimension || data.length > limits.maxImageBytes || (meta.width ?? 0) * (meta.height ?? 0) > limits.maxImagePixels)) return image;
+	const png = await sharp(data).resize({
+		width: limits.maxImageDimension,
+		height: limits.maxImageDimension,
+		fit: "inside",
+		withoutEnlargement: true
+	}).png().toBuffer();
+	if (png.length <= limits.maxImageBytes) return {
+		...image,
+		mediaType: "image/png",
+		data: png.toString("base64")
+	};
+	const jpeg = await sharp(png).jpeg({ quality: 80 }).toBuffer();
+	return {
+		...image,
+		mediaType: "image/jpeg",
+		data: jpeg.toString("base64")
+	};
+}
+
 //#endregion
 //#region src/streaming.ts
 /** Accumulates assistant text deltas into rendered lines. */
@@ -3637,7 +4494,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 +4506,111 @@ function visibleText(content) {
 	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
 }
 /**
+* One dim line per image a user message carried, in place of pixels.
+*
+* An image block's bytes cannot render here, and a `<pasted-image>` context
+* block is the pipeline talking to the model — pages of description would
+* bury the words the person typed. Either becomes a line saying what rode
+* along and what became of it.
+* @param content - the message's blocks.
+* @param theme - styling for the meta lines.
+* @returns the lines, empty for a text-only message.
+*/
+function imageMetaLines(content, theme) {
+	const lines = [];
+	for (const block of content) if (block.type === "image") {
+		const { width, height, mediaType } = block.attachment;
+		lines.push(theme.dim(`  [image · ${width}×${height} ${mediaType.slice(6)} · sent to the model]`));
+	} else if (block.type === "text" && block.text.startsWith("<pasted-image ")) {
+		const id = /id="(\d+)"/u.exec(block.text)?.[1] ?? "?";
+		const dims = /dimensions="(\d+)x(\d+)"/u.exec(block.text);
+		const media = /media="image\/(\w+)"/u.exec(block.text)?.[1] ?? "image";
+		const size = dims === null ? "" : ` · ${dims[1]}×${dims[2]}`;
+		const fate = block.text.includes("<description>") ? "described" : "saved to file";
+		lines.push(theme.dim(`  [image #${id}${size} ${media} · ${fate}]`));
+	}
+	return lines;
+}
+/**
+* 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 +4646,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,13 +4699,18 @@ 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 [];
-				const [first = "", ...rest] = visibleText(event.data.content).split("\n");
+				this.rule = rules.user;
+				const [first = "", ...rest] = event.data.content.filter((block) => block.type === "text").filter((block) => !block.text.startsWith("<pasted-image ")).map((block) => block.text).join("").split("\n");
+				const meta = imageMetaLines(event.data.content, theme);
 				return [
 					`${theme.user("›")} ${first}`,
 					...rest.map((line) => `  ${line}`),
+					...meta,
 					""
 				];
 			}
@@ -3747,24 +4718,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 +4763,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 +4795,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 +4818,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 +4846,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,29 +5061,57 @@ 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.
-* @param agent - the live agent.
-* @param text - the person's message.
-* @param working - the indicator to run while the turn does.
-* @param source - the message source; a canned prompt is plugin-sourced so the
-*   transcript echoes the command that ran it, not its whole body.
-*/
-async function turn(agent, text, working, source = { kind: "user" }) {
+async function turn(agent, text, working, source = { kind: "user" }, extra) {
 	agent.followup(createUserMessage({
-		content: [{
-			type: "text",
-			text
-		}],
+		content: [
+			...extra?.leading ?? [],
+			{
+				type: "text",
+				text
+			},
+			...extra?.trailing ?? []
+		],
 		source
 	}));
 	working?.start();
@@ -4101,7 +5130,7 @@ async function turn(agent, text, working, source = { kind: "user" }) {
 * @param theme - styling for the command's report.
 * @param signal - cancels the command when the person interrupts.
 */
-async function runCommand(ctx, agent, line, io, theme, signal) {
+async function runCommand(ctx, agent, line, io, theme, signal, images = []) {
 	const commands = ctx.get("commands");
 	if (commands === void 0) {
 		io.console.write(theme.error("  commands are unavailable in this composition"));
@@ -4114,7 +5143,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, images, signal);
 	if (execution === void 0) {
 		io.console.write(theme.error(`  unknown command: ${line}`));
 		return;
@@ -4128,10 +5157,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 +5333,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,
@@ -4335,11 +5360,24 @@ async function run(ctx, config, io) {
 		}))).flat().map((entry) => ({
 			provider: entry.provider,
 			id: entry.id,
-			name: entry.name
+			name: entry.name,
+			...entry.inputModalities === void 0 ? {} : { inputModalities: entry.inputModalities }
 		}));
 	};
 	refreshModelCatalog();
 	/**
+	* Whether the current route explicitly accepts image input.
+	*
+	* The same explicit-true test the adapter applies before throwing
+	* UNSUPPORTED_CONTENT: absent modalities mean unknown, and unknown gets the
+	* text fallback — which degrades, where the block path would crash the turn.
+	*/
+	const routeAcceptsImages = () => {
+		const current = selection.current;
+		if (current === void 0) return false;
+		return modelCatalog.find((model$1) => model$1.provider === current.provider && model$1.id === current.model)?.inputModalities?.includes("image") === true;
+	};
+	/**
 	* Resolve a /model argument to a selection.
 	* @param typed - a bare model id, or an explicit `provider/model`.
 	* @returns the selection, or an error message naming what is available.
@@ -4365,6 +5403,7 @@ async function run(ctx, config, io) {
 		"quit",
 		"help",
 		"init",
+		"ship",
 		"status",
 		"model",
 		"clear",
@@ -4379,6 +5418,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,11 +5487,12 @@ 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"));
-		}
+		},
+		readClipboardImage: () => readClipboardImage(process.env)
 	}, "Ask anything · / for commands · @ for files · ⇧Tab plan mode");
 	let turnBaseTokens = 0;
 	const spinner = new Spinner({
@@ -4490,6 +5534,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 +5684,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 +5741,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 +5751,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 +5762,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 +5779,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 +5807,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 +5870,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");
@@ -4898,13 +5953,70 @@ async function run(ctx, config, io) {
 	* than only in the status line.
 	* @param text - the person's message.
 	*/
-	const answer = async (text, source) => {
+	/**
+	* Turn pasted images into what this turn's message can carry.
+	*
+	* Three exits, decided by the route. An image-capable model gets the images
+	* as first-class blocks through the durable store — the runtime's own path.
+	* A text-only model gets each image saved as a file plus, when the vision
+	* sidecar is configured, a description standing in for sight; both ride the
+	* same message so they persist for `--resume`. A failure never loses the
+	* turn: it flashes, and the text still goes.
+	* @param images - the submission's pasted images, in token order.
+	* @returns blocks around the text, or undefined when there is nothing extra.
+	*/
+	const prepareImages = async (images) => {
+		if (images.length === 0) return void 0;
+		const store = ctx.get("attachments");
+		const limits = store?.imageLimits ?? DEFAULT_IMAGE_LIMITS;
+		if (routeAcceptsImages() && store !== void 0) try {
+			return {
+				leading: (await admitEncodedImages(store, await Promise.all(images.map((pending) => fitWithinLimits(pending.image, limits))))).map((attachment) => ({
+					type: "image",
+					attachment
+				})),
+				trailing: []
+			};
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			prompt.setFlash(theme.error(truncate(`  image dropped: ${reason}`, io.console.columns)));
+			if (!isImageAdmissionError(error)) return void 0;
+		}
+		const vision = visionConfigFromEnv(process.env);
+		const trailing = [];
+		for (const pending of images) {
+			const at = { path: await savePastedImage(pending.image) };
+			if (pending.width !== void 0) at.width = pending.width;
+			if (pending.height !== void 0) at.height = pending.height;
+			if (vision !== void 0) {
+				prompt.setHint(theme.dim(`  ✻ describing image #${pending.id} with ${vision.model}…`));
+				try {
+					at.description = await describeImage(await fitWithinLimits(pending.image, limits), vision);
+				} catch (error) {
+					const reason = error instanceof Error ? error.message : String(error);
+					prompt.setFlash(theme.error(truncate(`  image #${pending.id}: description failed (${reason}) — attached as file only`, io.console.columns)));
+				} finally {
+					prompt.setHint(void 0);
+				}
+			}
+			trailing.push({
+				type: "text",
+				text: pastedImageBlock(pending.id, pending.image, at)
+			});
+		}
+		return {
+			leading: [],
+			trailing
+		};
+	};
+	const answer = async (text, source, images = []) => {
+		const extra = await prepareImages(images);
 		const before = totalTokens(facts(branch).usage) ?? 0;
 		turnBaseTokens = before;
 		const started = performance.now();
 		io.console.setTitle(`⚡ dsh code — ${basename(cwd)}`);
 		try {
-			await turn(live.agent, text, spinner, source);
+			await turn(live.agent, text, spinner, source, extra);
 		} finally {
 			io.console.setTitle(`dsh code — ${basename(cwd)}`);
 		}
@@ -4982,11 +6094,13 @@ async function run(ctx, config, io) {
 		}
 		const line = await prompt.read();
 		if (line === void 0) break;
+		const images = prompt.takeAttachments();
 		io.console.collapseFolds();
 		const trimmed = line.trim();
 		if (trimmed === "") continue;
 		if (trimmed === "/exit" || trimmed === "/quit") break;
 		if (trimmed.startsWith("!")) {
+			if (images.length > 0) prompt.setFlash(theme.dim("  images do not ride ! commands — send them with a prompt"));
 			const command = trimmed.slice(1).trim();
 			if (command !== "") await passthrough(command);
 			continue;
@@ -4998,7 +6112,14 @@ async function run(ctx, config, io) {
 				await answer(INIT_PROMPT, {
 					kind: "plugin",
 					plugin: "coding-cli"
-				});
+				}, images);
+				continue;
+			}
+			if (name$1 === "ship") {
+				await answer(expandTemplate(SHIP_PROMPT, rest.trim()), {
+					kind: "plugin",
+					plugin: "coding-cli"
+				}, images);
 				continue;
 			}
 			const canned = customByName.get(name$1);
@@ -5006,18 +6127,23 @@ async function run(ctx, config, io) {
 				await answer(expandTemplate(canned.template, rest.trim()), {
 					kind: "plugin",
 					plugin: "coding-cli"
-				});
+				}, images);
 				continue;
 			}
+			let batch = [];
+			if (images.length > 0) if (routeAcceptsImages()) {
+				const limits = ctx.get("attachments")?.imageLimits ?? DEFAULT_IMAGE_LIMITS;
+				batch = await Promise.all(images.map((pending) => fitWithinLimits(pending.image, limits)));
+			} else prompt.setFlash(theme.error("  this model does not accept images with commands — they were dropped"));
 			running = new AbortController();
 			try {
-				await runCommand(ctx, live.agent, trimmed, io, theme, running.signal);
+				await runCommand(ctx, live.agent, trimmed, io, theme, running.signal, batch);
 			} finally {
 				running = void 0;
 			}
 			continue;
 		}
-		await answer(trimmed);
+		await answer(trimmed, void 0, images);
 	}
 	await sessions.flush(live.agent.session);
 	try {