@chantier/tui 0.3.0 → 0.5.0

package/dist/index.mjs

@@ -1,5 +1,711 @@
-import { Box, Static, Text, render, useApp, useInput, useIsScreenReaderEnabled } from "ink";
-import { createElement, useEffect, useSyncExternalStore } from "react";
+import { Box, Static, Text, render, useAnimation, useApp, useInput, useIsScreenReaderEnabled, usePaste, useWindowSize } from "ink";
+import { createElement, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region src/keys.ts
+/**
+* The chord table. "app.queue.edit" and "app.history.prev" share the
+* up-arrow chord on purpose: callers disambiguate by state (queued rows
+* exist vs history recall), which is how OMP treats Alt+Up vs plain Up.
+*/
+const ACTION_CHORDS = {
+	"app.interrupt": [{ escape: true }],
+	"app.quit": [{
+		input: "c",
+		ctrl: true
+	}],
+	"app.decide.allow": [{ input: "y" }],
+	"app.decide.always": [{ input: "a" }],
+	"app.decide.deny": [{ input: "n" }],
+	"app.decide.abort": [{ escape: true }],
+	"app.submit": [{ return: true }],
+	"app.history.prev": [{ upArrow: true }],
+	"app.history.next": [{ downArrow: true }],
+	"app.queue.edit": [{ upArrow: true }],
+	"app.editor.home": [{
+		input: "a",
+		ctrl: true
+	}],
+	"app.editor.end": [{
+		input: "e",
+		ctrl: true
+	}],
+	"app.editor.char.back": [{
+		input: "b",
+		ctrl: true
+	}],
+	"app.editor.char.forward": [{
+		input: "f",
+		ctrl: true
+	}],
+	"app.editor.kill.to-end": [{
+		input: "k",
+		ctrl: true
+	}],
+	"app.editor.kill.line": [{
+		input: "u",
+		ctrl: true
+	}],
+	"app.editor.kill.word": [{
+		input: "w",
+		ctrl: true
+	}],
+	"app.editor.backspace": [{ backspace: true }, { delete: true }],
+	"app.redraw": [{
+		input: "l",
+		ctrl: true
+	}]
+};
+function chordMatches(chord, event) {
+	for (const field of Object.keys(chord)) if (event[field] !== chord[field]) return false;
+	return true;
+}
+/**
+* Whether the keypress resolves to the action id. Input chunks are
+* normalized by stripping CR/LF first: a PTY can deliver "y\r" as one chunk
+* while ink sets key.return only for a lone CR.
+*/
+function matches(event, id) {
+	const chords = ACTION_CHORDS[id];
+	if (chords === void 0) return false;
+	const normalized = event.input === void 0 ? event : {
+		...event,
+		input: event.input.replace(/[\r\n]/g, "")
+	};
+	return chords.some((chord) => chordMatches(chord, normalized));
+}
+/** Hint line for the approval card, verbatim spec §7 mockup. */
+const APPROVAL_HINT_PARTS = [
+	"y allow",
+	"a always",
+	"n deny",
+	"esc abort"
+];
+/**
+* Maps a prompt keypress to a decision; null = key not handled by the
+* prompt. Moved here unchanged from app.ts (spec §7): this stays the pure
+* dispatch surface, unit-tested without mounting ink.
+*/
+function keypressToDecision(key) {
+	const clean = key.replace(/[\r\n]/g, "");
+	if (clean === "y") return { approved: true };
+	if (clean === "a") return {
+		approved: true,
+		remember: true
+	};
+	if (clean === "n") return {
+		approved: false,
+		reason: "user denied"
+	};
+	return null;
+}
+//#endregion
+//#region src/input.ts
+function emptyEditor() {
+	return {
+		text: "",
+		cursor: 0
+	};
+}
+function editorInsert(state, insert) {
+	return {
+		text: state.text.slice(0, state.cursor) + insert + state.text.slice(state.cursor),
+		cursor: state.cursor + insert.length
+	};
+}
+function editorBackspace(state) {
+	if (state.cursor === 0) return state;
+	return {
+		text: state.text.slice(0, state.cursor - 1) + state.text.slice(state.cursor),
+		cursor: state.cursor - 1
+	};
+}
+/**
+* Emacs set (§6f) as pure (text, cursor) transforms: ctrl+a/e home/end,
+* ctrl+b/f char moves, ctrl+k kill to end, ctrl+u clear, ctrl+w kill word
+* back. Single-line editor only; multiline ctrl+j is v0.6.
+*/
+function applyEditorAction(state, action) {
+	const len = state.text.length;
+	switch (action) {
+		case "home": return {
+			text: state.text,
+			cursor: 0
+		};
+		case "end": return {
+			text: state.text,
+			cursor: len
+		};
+		case "char.back": return {
+			text: state.text,
+			cursor: Math.max(0, cursorAt(state) - 1)
+		};
+		case "char.forward": return {
+			text: state.text,
+			cursor: Math.min(len, cursorAt(state) + 1)
+		};
+		case "kill.to-end": return {
+			text: state.text.slice(0, cursorAt(state)),
+			cursor: cursorAt(state)
+		};
+		case "kill.line": return emptyEditor();
+		case "kill.word": {
+			const cursor = cursorAt(state);
+			let index = cursor;
+			while (index > 0 && state.text[index - 1] === " ") index -= 1;
+			while (index > 0 && state.text[index - 1] !== " ") index -= 1;
+			return {
+				text: state.text.slice(0, index) + state.text.slice(cursor),
+				cursor: index
+			};
+		}
+	}
+}
+function cursorAt(state) {
+	return Math.min(state.cursor, state.text.length);
+}
+/**
+* Chip thresholds (§6e): >3 lines or >800 chars chips; under 12 terminal
+* rows the CC narrow rule applies (1 line / 200 chars).
+*/
+function pasteChip(text, rows) {
+	const lines = text.split("\n").length;
+	const narrow = rows !== void 0 && rows < 12;
+	const lineLimit = narrow ? 1 : 3;
+	const charLimit = narrow ? 200 : 800;
+	return {
+		chip: lines > lineLimit || text.length > charLimit ? `[pasted +${lines} lines]` : null,
+		lines
+	};
+}
+/** Restores full paste text from its chip markers before submit. */
+function expandPasteChips(text, chunks) {
+	let expanded = text;
+	for (const [chip, full] of chunks) if (expanded.includes(chip)) expanded = expanded.split(chip).join(full);
+	return expanded;
+}
+/** File-backed history; the path is injectable so tests never touch $HOME. */
+function historyPath(home = homedir()) {
+	return join(home, ".chantier", "history.jsonl");
+}
+function createHistoryStore(opts = {}) {
+	const entries = [...opts.entries ?? []];
+	let index = null;
+	return {
+		get entries() {
+			return entries;
+		},
+		async record(text) {
+			if (text.trim().length === 0) return;
+			if (entries[entries.length - 1] === text) return;
+			entries.push(text);
+			if (opts.file === void 0) return;
+			try {
+				await mkdir(join(opts.file, ".."), { recursive: true });
+				await appendFile(opts.file, `${JSON.stringify({ text })}\n`, "utf8");
+			} catch {
+				return;
+			}
+		},
+		prev() {
+			if (entries.length === 0) return null;
+			index = index === null ? entries.length - 1 : Math.max(0, index - 1);
+			return entries[index] ?? null;
+		},
+		next() {
+			if (index === null) return null;
+			index += 1;
+			if (index >= entries.length) {
+				index = null;
+				return null;
+			}
+			return entries[index] ?? null;
+		},
+		reset() {
+			index = null;
+		}
+	};
+}
+/** Reads the JSONL history; silent failure yields an empty list. */
+async function loadHistory(file) {
+	try {
+		const raw = await readFile(file, "utf8");
+		const texts = [];
+		for (const line of raw.split("\n")) {
+			if (line.trim().length === 0) continue;
+			try {
+				const parsed = JSON.parse(line);
+				if (typeof parsed === "object" && parsed !== null && "text" in parsed && typeof parsed.text === "string") texts.push(parsed.text);
+			} catch {}
+		}
+		return texts;
+	} catch {
+		return [];
+	}
+}
+const QUIT_HINT = "press ctrl-c again to quit";
+const INPUT_HINT_PARTS = [
+	"type a task",
+	"enter run",
+	"q quit"
+];
+/** Default two-stage quit window (§6c). */
+/** Two-stage quit window (§6c); exported so the App's armed-hint display matches. */
+const QUIT_WINDOW_MS = 2e3;
+function TaskInput({ editor, onEditorChange, onSubmit, running, queuedCount, onQueueEdit, locked = false, rows, history, onQuit, onQuitArm, quitWindowMs = QUIT_WINDOW_MS, symbols, screenReader = false }) {
+	const pasteChunks = useRef(/* @__PURE__ */ new Map());
+	const quitTimer = useRef(void 0);
+	const quitArmed = useRef(false);
+	usePaste((text) => {
+		if (locked) return;
+		const { chip } = pasteChip(text, rows);
+		if (chip === null) {
+			onEditorChange(editorInsert(editor, text));
+			return;
+		}
+		let chipText = chip;
+		let suffix = 2;
+		while (pasteChunks.current.has(chipText)) {
+			chipText = `${chip} #${suffix}`;
+			suffix += 1;
+		}
+		pasteChunks.current.set(chipText, text);
+		onEditorChange(editorInsert(editor, chipText));
+	}, { isActive: !locked });
+	useInput((input, key) => {
+		if (locked) return;
+		const event = {
+			input,
+			ctrl: key.ctrl,
+			escape: key.escape,
+			upArrow: key.upArrow,
+			downArrow: key.downArrow,
+			return: key.return,
+			backspace: key.backspace,
+			delete: key.delete
+		};
+		if (matches(event, "app.quit")) {
+			if (!running || quitArmed.current) {
+				quitArmed.current = false;
+				clearTimeout(quitTimer.current);
+				onQuit();
+				return;
+			}
+			quitArmed.current = true;
+			onEditorChange(emptyEditor());
+			onQuitArm();
+			clearTimeout(quitTimer.current);
+			quitTimer.current = setTimeout(() => {
+				quitArmed.current = false;
+				quitTimer.current = void 0;
+			}, quitWindowMs);
+			return;
+		}
+		if (matches(event, "app.redraw")) return;
+		if (key.escape) {
+			if (!running && editor.text.length > 0 && history !== void 0) {
+				history.record(editor.text);
+				onEditorChange(emptyEditor());
+			}
+			return;
+		}
+		if (matches(event, "app.editor.home")) return onEditorChange(applyEditorAction(editor, "home"));
+		if (matches(event, "app.editor.end")) return onEditorChange(applyEditorAction(editor, "end"));
+		if (matches(event, "app.editor.char.back")) return onEditorChange(applyEditorAction(editor, "char.back"));
+		if (matches(event, "app.editor.char.forward")) return onEditorChange(applyEditorAction(editor, "char.forward"));
+		if (matches(event, "app.editor.kill.to-end")) return onEditorChange(applyEditorAction(editor, "kill.to-end"));
+		if (matches(event, "app.editor.kill.line")) return onEditorChange(applyEditorAction(editor, "kill.line"));
+		if (matches(event, "app.editor.kill.word")) return onEditorChange(applyEditorAction(editor, "kill.word"));
+		if (matches(event, "app.editor.backspace")) return onEditorChange(editorBackspace(editor));
+		if (key.upArrow) {
+			if (running && queuedCount > 0) return onQueueEdit();
+			if (!running && history !== void 0) {
+				const recalled = history.prev();
+				if (recalled !== null) return onEditorChange({
+					text: recalled,
+					cursor: recalled.length
+				});
+				return;
+			}
+			return;
+		}
+		if (key.downArrow) {
+			if (history !== void 0 && !running) {
+				const recalled = history.next();
+				if (recalled === null) return onEditorChange(emptyEditor());
+				return onEditorChange({
+					text: recalled,
+					cursor: recalled.length
+				});
+			}
+			return;
+		}
+		const bundledReturn = /[\r\n]/.test(input ?? "");
+		let current = editor;
+		if (input !== void 0 && input.length > 0) {
+			const printable = [...input].filter((char) => char !== "\r" && char !== "\n");
+			if (printable.length > 0) {
+				current = editorInsert(current, printable.join(""));
+				onEditorChange(current);
+			}
+		}
+		if (key.return || bundledReturn) {
+			const expanded = expandPasteChips(current.text, pasteChunks.current);
+			pasteChunks.current.clear();
+			history?.record(expanded);
+			history?.reset();
+			onSubmit(expanded);
+		}
+	});
+	if (screenReader) return createElement(Box, { flexDirection: "column" }, createElement(Text, { "aria-label": "task input" }, editor.text), createElement(Text, { dimColor: true }, `  ${INPUT_HINT_PARTS.join(` ${symbols.hintSeparator} `)}`));
+	const cursor = Math.min(editor.cursor, editor.text.length);
+	return createElement(Box, {
+		borderStyle: symbols.border,
+		borderColor: "green",
+		paddingX: 1
+	}, createElement(Text, { color: "green" }, "> "), createElement(Text, null, editor.text.slice(0, cursor)), createElement(Text, { inverse: true }, editor.text.slice(cursor, cursor + 1) || " "), createElement(Text, null, editor.text.slice(cursor + 1)), createElement(Text, { dimColor: true }, `  ${INPUT_HINT_PARTS.join(` ${symbols.hintSeparator} `)}`));
+}
+//#endregion
+//#region src/markdown.ts
+const FENCE_OPEN_RE = /^ {0,3}(`{3,}|~{3,})/;
+function fenceMarker(line) {
+	const match = FENCE_OPEN_RE.exec(line);
+	return match === null ? null : match[1] ?? null;
+}
+/** A closing fence is the same marker run plus optional whitespace, nothing else. */
+function closesFence(line, marker) {
+	const rest = line.replace(/^ {0,3}/, "");
+	const first = marker[0];
+	if (first === void 0 || !rest.startsWith(first)) return false;
+	let run = 0;
+	while (run < rest.length && rest[run] === first) run += 1;
+	return run >= marker.length && rest.slice(run).trim() === "";
+}
+/**
+* Splits a stream buffer at its last safe split point: the final `\n\n`
+* outside an open fence. When the buffer ends inside an open fence and no
+* outside boundary exists, it splits BEFORE the fence start instead, so a
+* half-open code block is never emitted into the finalized transcript. With
+* neither a boundary nor an open fence, nothing flushes.
+*/
+function takeSafeFlush(buffer) {
+	if (buffer.length === 0) return {
+		flushed: "",
+		rest: buffer
+	};
+	const lines = buffer.split("\n");
+	const offsets = [];
+	let cursor = 0;
+	for (const line of lines) {
+		offsets.push(cursor);
+		cursor += line.length + 1;
+	}
+	let inFence = false;
+	let openMarker = "";
+	let fenceStart = -1;
+	let lastBoundaryLine = -1;
+	for (let k = 0; k < lines.length; k += 1) {
+		const line = lines[k];
+		if (line === void 0) break;
+		if (inFence) {
+			if (closesFence(line, openMarker)) {
+				inFence = false;
+				openMarker = "";
+			}
+			continue;
+		}
+		const marker = fenceMarker(line);
+		if (marker !== null) {
+			inFence = true;
+			openMarker = marker;
+			fenceStart = k;
+			continue;
+		}
+		if (line === "" && k > 0 && k < lines.length - 1) lastBoundaryLine = k;
+	}
+	if (lastBoundaryLine >= 0) {
+		const boundary = (offsets[lastBoundaryLine] ?? 0) + 1;
+		return {
+			flushed: buffer.slice(0, boundary),
+			rest: buffer.slice(boundary)
+		};
+	}
+	if (inFence && fenceStart > 0) {
+		const boundary = offsets[fenceStart] ?? 0;
+		return {
+			flushed: buffer.slice(0, boundary),
+			rest: buffer.slice(boundary)
+		};
+	}
+	return {
+		flushed: "",
+		rest: buffer
+	};
+}
+/**
+* Cheap streaming fast path (CC ch13): scans only the first 500 chars so a
+* plain-prose stream skips the block parser entirely. Triggers mirror the
+* parser's styled block set — headings, fences, lists, rules, and pipe-led
+* table rows — so a table or rule is never swallowed by the plain path.
+*/
+const FAST_PATH_WINDOW = 500;
+const MARKDOWN_TRIGGER_RE = /(^ {0,3}(#{1,6}\s|```|~~~|[-*+]\s|\d{1,9}[.)]\s))|(^ {0,3}(-{3,}|\*{3,}|_{3,})\s*$)|(^\s*\|)/m;
+function hasMarkdownSyntax(text) {
+	return MARKDOWN_TRIGGER_RE.test(text.slice(0, FAST_PATH_WINDOW));
+}
+/**
+* Tool output and model text can embed ANSI escapes (color codes survive an
+* adapter round-trip); ink renders the raw escape bytes as garbage, so fenced
+* content is stripped before display. No ANSI passthrough, ever.
+*/
+const ANSI_RE = /\u001B\[[0-9;:?]*[A-Za-z]|\u001B/g;
+function stripAnsi(text) {
+	return text.replace(ANSI_RE, "");
+}
+const HEADING_RE = /^ {0,3}#{1,6}\s+(.+)$/;
+const HR_RE = /^ {0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/;
+const LIST_ITEM_RE = /^ {0,3}(?:[-*+]|\d{1,9}[.)])\s+/;
+const TABLE_SEPARATOR_RE = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+/** Splits one table row into trimmed cells; edge pipes are dropped. */
+function tableCells(line) {
+	let cells = line.split("|");
+	if (line.trimStart().startsWith("|")) cells = cells.slice(1);
+	if (line.trimEnd().endsWith("|")) cells = cells.slice(0, -1);
+	return cells.map((cell) => cell.trim());
+}
+/** Line-based block parser (spec §2b). Blank lines are paragraph separators. */
+function parseBlocks(text) {
+	const lines = text.split("\n");
+	const lineAt = (index) => lines[index] ?? "";
+	const blocks = [];
+	let k = 0;
+	while (k < lines.length) {
+		const line = lineAt(k);
+		if (line.trim() === "") {
+			k += 1;
+			continue;
+		}
+		const heading = HEADING_RE.exec(line);
+		if (heading !== null) {
+			blocks.push({
+				kind: "heading",
+				text: heading[1]?.trim() ?? ""
+			});
+			k += 1;
+			continue;
+		}
+		const marker = fenceMarker(line);
+		if (marker !== null) {
+			const body = [];
+			let closed = false;
+			k += 1;
+			while (k < lines.length) {
+				if (closesFence(lineAt(k), marker)) {
+					closed = true;
+					k += 1;
+					break;
+				}
+				body.push(lineAt(k));
+				k += 1;
+			}
+			blocks.push({
+				kind: "fence",
+				lines: body,
+				closed
+			});
+			continue;
+		}
+		if (HR_RE.test(line)) {
+			blocks.push({ kind: "rule" });
+			k += 1;
+			continue;
+		}
+		if (LIST_ITEM_RE.test(line)) {
+			const block = [];
+			while (k < lines.length && lineAt(k).trim() !== "" && LIST_ITEM_RE.test(lineAt(k))) {
+				block.push(lineAt(k));
+				k += 1;
+			}
+			blocks.push({
+				kind: "list",
+				lines: block
+			});
+			continue;
+		}
+		if (line.includes("|") && k + 1 < lines.length && TABLE_SEPARATOR_RE.test(lineAt(k + 1))) {
+			const rows = [tableCells(line)];
+			k += 2;
+			while (k < lines.length && lineAt(k).includes("|") && lineAt(k).trim() !== "") {
+				rows.push(tableCells(lineAt(k)));
+				k += 1;
+			}
+			blocks.push({
+				kind: "table",
+				rows
+			});
+			continue;
+		}
+		const paragraph = [];
+		while (k < lines.length && lineAt(k).trim() !== "" && HEADING_RE.test(lineAt(k)) === false && fenceMarker(lineAt(k)) === null && HR_RE.test(lineAt(k)) === false && LIST_ITEM_RE.test(lineAt(k)) === false) {
+			paragraph.push(lineAt(k));
+			k += 1;
+		}
+		blocks.push({
+			kind: "paragraph",
+			lines: paragraph
+		});
+	}
+	return blocks;
+}
+const DIVIDER_UNICODE = "─";
+const DIVIDER_ASCII = "-";
+const DIVIDER_WIDTH = 40;
+/**
+* Divider/hr rule character. symbols.ts belongs to the parallel activity
+* worker; its `border` field already encodes the ASCII-mode decision, so the
+* rule glyph derives from it until the integration owner migrates both call
+* sites onto that worker's dedicated symbols extension.
+*/
+function dividerGlyph(symbols) {
+	return symbols.border === "single" ? DIVIDER_ASCII : DIVIDER_UNICODE;
+}
+/** Longest cell per column; rows are padded to these for space alignment. */
+function columnWidths(rows) {
+	const widths = [];
+	for (const row of rows) row.forEach((cell, column) => {
+		widths[column] = Math.max(widths[column] ?? 0, cell.length);
+	});
+	return widths;
+}
+/** A dim rule wrapped around `text`; screen readers get the plain text only. */
+function markdownDivider(text, symbols, screenReader) {
+	if (screenReader) return createElement(Text, null, text);
+	const rule = dividerGlyph(symbols).repeat(DIVIDER_WIDTH);
+	return createElement(Text, { dimColor: true }, `${rule} ${text} ${rule}`);
+}
+/** Parses text into render rows; pure, so tests can assert without ink. */
+function renderRows$1(text, symbols) {
+	if (!hasMarkdownSyntax(text)) return text.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim() !== "").map((line) => ({ text: line }));
+	const rows = [];
+	for (const block of parseBlocks(text)) switch (block.kind) {
+		case "heading":
+			rows.push({
+				text: block.text,
+				bold: true
+			});
+			break;
+		case "fence":
+			if (block.closed) for (const line of block.lines) rows.push({
+				text: `  ${stripAnsi(line)}`,
+				dim: true
+			});
+			else for (const line of block.lines) rows.push({ text: stripAnsi(line) });
+			break;
+		case "list":
+			for (const line of block.lines) rows.push({ text: `  ${line.replace(/^ {1,3}/, "")}` });
+			break;
+		case "rule":
+			rows.push({
+				text: dividerGlyph(symbols).repeat(DIVIDER_WIDTH),
+				dim: true,
+				srLabel: "divider"
+			});
+			break;
+		case "table": {
+			const widths = columnWidths(block.rows);
+			for (const row of block.rows) rows.push({ text: row.map((cell, column) => cell.padEnd(widths[column] ?? cell.length)).join("  ") });
+			break;
+		}
+		case "paragraph": for (const line of block.lines) rows.push({ text: line });
+	}
+	return rows;
+}
+/**
+* Renders markdown text into ink elements (spec §2b): headings bold, lists
+* indented, fences dim + 2-space indented, rules as divider rows, tables as
+* space-aligned rows. Screen-reader mode renders the same rows unstyled, with
+* decorative rows replaced by their label, and plain input takes the fast
+* path and skips parsing entirely. Tolerant streaming: an unclosed fence
+* renders as plain text until closed, so the strict styling only ever
+* applies to balanced blocks.
+*/
+function markdownToElements(text, symbols, screenReader) {
+	const rows = renderRows$1(text, symbols);
+	if (screenReader) return rows.filter((row) => row.text.trim() !== "").map((row, index) => createElement(Text, { key: index }, row.srLabel ?? row.text));
+	return rows.map((row, index) => createElement(Text, {
+		key: index,
+		...row.dim === true ? { dimColor: true } : {},
+		...row.bold === true ? { bold: true } : {}
+	}, row.text));
+}
+//#endregion
+//#region src/screen-reader.ts
+/**
+* Screen-reader mode: ink serializes the tree to plain linear text (no
+* borders, no colors), keeps `<Static>` append-only, and rewrites the dynamic
+* region only when it changes. Enabled by the `--screen-reader` flag or the
+* CHANTIER_SCREEN_READER=1 environment alias.
+*/
+function resolveScreenReader(flag, env) {
+	return flag === true || env === "1";
+}
+//#endregion
+//#region src/symbols.ts
+const UNICODE_SYMBOLS = {
+	border: "round",
+	hintSeparator: "·",
+	ellipsis: "…",
+	spinnerFrames: [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	],
+	runGlyph: "▸",
+	subGlyph: "└",
+	errorGlyph: "✗",
+	rule: "─",
+	barFilled: "▮",
+	barEmpty: "▯",
+	arrow: "→",
+	arrowUp: "↑",
+	minus: "−"
+};
+const ASCII_SYMBOLS = {
+	border: "single",
+	hintSeparator: "|",
+	ellipsis: "...",
+	spinnerFrames: [
+		"|",
+		"/",
+		"-",
+		"\\"
+	],
+	runGlyph: ">",
+	subGlyph: "+",
+	errorGlyph: "x",
+	rule: "-",
+	barFilled: "#",
+	barEmpty: "-",
+	arrow: "->",
+	arrowUp: "^",
+	minus: "-"
+};
+function resolveSymbols(ascii) {
+	return ascii ? ASCII_SYMBOLS : UNICODE_SYMBOLS;
+}
+/** CHANTIER_ASCII=1 requests the ASCII-safe rendering. */
+function isAsciiEnv(env) {
+	return env === "1";
+}
+//#endregion
 //#region src/diff.ts
 const META_PREFIXES = [
 	"diff --git ",
@@ -34,79 +740,433 @@ function summarizeUnifiedDiff(diff, maxLines = 10) {
 	};
 }
 //#endregion
-//#region src/screen-reader.ts
+//#region src/widgets.ts
+/** Ladder set (§2c): these tools render a second detail line when present. */
+const TWO_LINE_TOOLS = {
+	task: true,
+	read: true,
+	edit: true
+};
+/** First non-empty line of a tool result, capped for the row preview. */
+function previewLine(content, ellipsis, cap = 120) {
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length > 0) return trimmed.length > cap ? `${trimmed.slice(0, cap)}${ellipsis}` : trimmed;
+	}
+	return "";
+}
+function formatDuration(ms) {
+	if (ms === void 0) return "";
+	if (ms < 1e3) return `${Math.max(1, Math.round(ms))}ms`;
+	const seconds = ms / 1e3;
+	if (seconds < 60) return `${Math.round(seconds)}s`;
+	const minutes = Math.floor(seconds / 60);
+	const rest = Math.round(seconds - minutes * 60);
+	return rest > 0 ? `${minutes}m ${rest}s` : `${minutes}m`;
+}
+/** "24k"-style token counts for the compaction divider (§2d mockup). */
+function formatTokens(tokens) {
+	if (tokens < 1e3) return String(tokens);
+	const k = tokens / 1e3;
+	const rounded = Math.round(k * 10) / 10;
+	return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1)}k`;
+}
+function renderRows(rows) {
+	return createElement(Box, { flexDirection: "column" }, ...rows.map((row, index) => createElement(Text, {
+		key: index,
+		color: row.color,
+		bold: row.bold === true,
+		dimColor: row.dim === true
+	}, row.text)));
+}
 /**
-* Screen-reader mode: ink serializes the tree to plain linear text (no
-* borders, no colors), keeps `<Static>` append-only, and rewrites the dynamic
-* region only when it changes. Enabled by the `--screen-reader` flag or the
-* CHANTIER_SCREEN_READER=1 environment alias.
+* Collapse ladder: task/read/edit render two lines (args + detail preview);
+* everything else renders one line. Errors turn the glyph red (§2c). The
+* full output stays in the transcript log; expand/collapse is v0.6.
 */
-function resolveScreenReader(flag, env) {
-	return flag === true || env === "1";
+function toolRowLines(item, symbols) {
+	const duration = formatDuration(item.durationMs);
+	const durationTail = duration.length > 0 ? ` ${duration}` : "";
+	const failed = item.outcome === "error";
+	const head = {
+		text: `${failed ? symbols.errorGlyph : symbols.runGlyph} ${item.toolName}(${item.argsSummary})${durationTail}`,
+		...failed ? { color: "red" } : {}
+	};
+	const detail = item.detail ?? "";
+	if (TWO_LINE_TOOLS[item.toolName] !== true || detail.length === 0) return [head];
+	return [head, {
+		text: `  ${detail}`,
+		dim: true,
+		...failed ? { color: "red" } : {}
+	}];
 }
-//#endregion
-//#region src/symbols.ts
-const UNICODE_SYMBOLS = {
-	border: "round",
-	hintSeparator: "·",
-	ellipsis: "…"
-};
-const ASCII_SYMBOLS = {
-	border: "single",
-	hintSeparator: "|",
-	ellipsis: "..."
-};
-function resolveSymbols(ascii) {
-	return ascii ? ASCII_SYMBOLS : UNICODE_SYMBOLS;
+/** SR parity (§8): `tool: read(src/config.ts) done`. */
+function toolRowSrText(item) {
+	return `tool: ${item.toolName}(${item.argsSummary}) ${item.outcome}`;
 }
-/** CHANTIER_ASCII=1 requests the ASCII-safe rendering. */
-function isAsciiEnv(env) {
-	return env === "1";
+function ToolRow({ item, symbols, screenReader = false }) {
+	if (screenReader) return createElement(Text, { key: "sr" }, toolRowSrText(item));
+	const child = item.subagent;
+	if (child !== void 0) return createElement(SubagentCard, {
+		item: {
+			...item,
+			subagent: child
+		},
+		symbols
+	});
+	return renderRows(toolRowLines(item, symbols));
+}
+/** Summary block cap: 8 dim lines, then the tail pointer to the child session. */
+const SUBAGENT_SUMMARY_MAX_LINES = 8;
+function subagentLines(item, symbols) {
+	const sessionId = item.subagent.sessionId.slice(0, 8);
+	const duration = formatDuration(item.durationMs);
+	const durationTail = duration.length > 0 ? ` ${duration}` : "";
+	const head = { text: `${symbols.runGlyph} task ${symbols.arrow} subagent (session ${sessionId})${durationTail}` };
+	const shown = item.subagent.summary.split("\n").slice(0, 8).map((line) => ({
+		text: `    ${line}`,
+		dim: true
+	}));
+	const tail = {
+		text: `    ${symbols.ellipsis} full summary in child session`,
+		dim: true
+	};
+	return [
+		head,
+		...shown,
+		tail
+	];
+}
+function SubagentCard({ item, symbols }) {
+	return renderRows(subagentLines(item, symbols));
+}
+const STATUS_VERB_WIDTH = Math.max(...[
+	"working",
+	"delegating",
+	"thinking"
+].map((verb) => verb.length));
+/** Elapsed clock with a bounded tail: s → "1m 12s" → "1h 2m" → "99h+". */
+function formatElapsed(ms) {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds - minutes * 60;
+	if (minutes < 60) return `${minutes}m ${seconds}s`;
+	const hours = Math.floor(minutes / 60);
+	if (hours > 99) return "99h+";
+	return `${hours}h ${minutes - hours * 60}m`;
+}
+function spinnerFrame(frame, symbols) {
+	const frames = symbols.spinnerFrames;
+	return frames[(frame % frames.length + frames.length) % frames.length] ?? "";
+}
+/**
+* The one-line running status: spinner + anti-jitter-padded verb + elapsed +
+* interrupt hint, with the detail line underneath. The verb padding is the
+* Hermes trick: the tail never shifts while the spinner cycles because the
+* verb column width is pinned to the widest verb the widget can show.
+*/
+function statusLines(frame, running, status, symbols, elapsedMs) {
+	const verb = running.detail?.startsWith("task") ? "delegating" : status.startsWith("thinking") ? "thinking" : "working";
+	const separator = ` ${symbols.hintSeparator} `;
+	return [{
+		text: `${spinnerFrame(frame, symbols)} ${verb.padEnd(STATUS_VERB_WIDTH)}${separator}${formatElapsed(elapsedMs)}${separator}esc to interrupt`,
+		dim: true
+	}, ...(running.detail ?? "").split("\n").slice(0, 3).filter((l) => l.length > 0).map((line) => ({
+		text: `${symbols.subGlyph} ${line}`,
+		dim: true
+	}))];
+}
+function StatusWidget({ running, status, symbols, now = Date.now, screenReader = false }) {
+	const { frame } = useAnimation({ interval: 120 });
+	if (running === null || screenReader) return null;
+	return renderRows(statusLines(frame, running, status, symbols, now() - running.sinceMs));
+}
+function formatTokenCount(tokens) {
+	if (tokens < 1e3) return String(tokens);
+	return `${(Math.round(tokens / 1e3 * 10) / 10).toFixed(1)}k`;
+}
+/** 8-cell context bar; filled cells round to nearest, clamped to [0, 8]. */
+function ctxBar(fraction, symbols) {
+	const filled = Math.min(8, Math.max(0, Math.round(fraction * 8)));
+	return `${symbols.barFilled.repeat(filled)}${symbols.barEmpty.repeat(8 - filled)}`;
+}
+function ctxLevel(fraction) {
+	if (fraction < .5) return { color: "gray" };
+	if (fraction < .8) return { color: "yellow" };
+	return fraction >= .95 ? {
+		color: "red",
+		bold: true
+	} : { color: "red" };
+}
+/**
+* Segment list under the width breakpoints: <64 → model + ctx%; <80 → +
+* session; ≥80 → all four. Whole segments only — never mid-truncate.
+*/
+function footerSegments(props) {
+	const { model, ctxFraction, compactSoon, usage, sessionId, columns, symbols } = props;
+	const showSession = columns >= 64;
+	const showTokens = columns >= 80;
+	const separator = ` ${symbols.hintSeparator} `;
+	const parts = [model];
+	if (ctxFraction !== void 0) {
+		const soon = compactSoon === true ? `${separator}compaction soon` : "";
+		parts.push(`${ctxBar(ctxFraction, symbols)} ${Math.round(ctxFraction * 100)}%${soon}`);
+	}
+	if (showTokens && usage !== void 0) parts.push(`${formatTokenCount(usage.inputTokens)} in / ${formatTokenCount(usage.outputTokens)} out`);
+	if (showSession) parts.push(sessionId.slice(0, 8));
+	const level = ctxLevel(ctxFraction ?? 0);
+	return [{
+		text: parts.join(separator),
+		...level
+	}];
+}
+function FooterBar({ model, ctxFraction, compactSoon, usage, sessionId, columns, symbols, hidden = false }) {
+	if (hidden) return null;
+	const [row] = footerSegments({
+		model,
+		ctxFraction,
+		compactSoon,
+		usage,
+		sessionId,
+		columns,
+		symbols
+	});
+	if (row === void 0) return null;
+	return createElement(Box, { "aria-hidden": true }, createElement(Text, {
+		color: row.color,
+		bold: row.bold === true,
+		dimColor: row.dim === true
+	}, row.text));
+}
+const QUEUE_PREVIEW_MAX_ROWS = 2;
+/** ≤2 dimmed rows + "+N more"; collapses runs of whitespace per row. */
+function queuePreviewLines(queued, symbols) {
+	if (queued.length === 0) return [];
+	const rows = queued.slice(0, 2).map((text) => ({
+		text: `queued: ${text.replace(/\s+/g, " ").trim()} (${symbols.arrowUp} to edit)`,
+		dim: true
+	}));
+	const more = queued.length - 2;
+	if (more > 0) rows.push({
+		text: `+${more} more`,
+		dim: true
+	});
+	return rows;
+}
+function QueuePreview({ queued, symbols }) {
+	const rows = queuePreviewLines(queued, symbols);
+	if (rows.length === 0) return null;
+	return createElement(Box, {
+		flexDirection: "column",
+		"aria-label": `${queued.length} task${queued.length === 1 ? "" : "s"} queued`
+	}, ...rows.map((row, index) => createElement(Text, {
+		key: index,
+		color: row.color,
+		bold: row.bold === true,
+		dimColor: row.dim === true
+	}, row.text)));
+}
+const COMMAND_CAP = 80;
+function stringField(input, keys) {
+	if (typeof input !== "object" || input === null) return "";
+	const record = input;
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return "";
+}
+/** CC-style shortening: a path under the session cwd renders as ~/rest. */
+function shortenPath(path, cwd) {
+	if (cwd === void 0 || cwd.length === 0) return path;
+	const prefix = cwd.endsWith("/") ? cwd : `${cwd}/`;
+	return path.startsWith(prefix) ? `~/${path.slice(prefix.length)}` : path;
+}
+function elide(text, cap, ellipsis) {
+	return text.length > cap ? `${text.slice(0, cap)}${ellipsis}` : text;
+}
+/** The ~-shortened edit/write target path (no counts; the SR label reuses it). */
+function editTargetPath(input, cwd) {
+	return shortenPath(stringField(input, [
+		"file_path",
+		"path",
+		"file"
+	]), cwd);
+}
+/**
+* Humanized subject per tool (§7): edit/write → ~-shortened path + ±counts
+* from the diff detail; bash → command (80 cap); read/grep → the pattern,
+* glob → its pattern; task → first line of the prompt.
+*/
+function humanizeApproval(tool, input, detail, symbols, cwd) {
+	if (tool === "edit" || tool === "write") {
+		const path = editTargetPath(input, cwd);
+		if (detail?.diff !== void 0 && detail.diff.length > 0) {
+			const preview = summarizeUnifiedDiff(detail.diff);
+			return `${path}  +${preview.additions} ${symbols.minus}${preview.deletions}`;
+		}
+		return path;
+	}
+	if (tool === "bash") return elide(stringField(input, ["command"]), COMMAND_CAP, symbols.ellipsis);
+	if (tool === "task") return elide(stringField(input, ["prompt"]).split("\n")[0] ?? "", COMMAND_CAP, symbols.ellipsis);
+	if (tool === "grep") return stringField(input, [
+		"pattern",
+		"query",
+		"path"
+	]);
+	if (tool === "glob") return stringField(input, ["pattern", "path"]);
+	return stringField(input, [
+		"path",
+		"file_path",
+		"file",
+		"pattern",
+		"query",
+		"url"
+	]);
+}
+/** SR parity (§8): `edit src/x.ts: +3 -1`. */
+function approvalSrLabel(tool, input, detail, symbols, cwd) {
+	if (tool === "edit" || tool === "write") {
+		const preview = detail?.diff !== void 0 && detail.diff.length > 0 ? summarizeUnifiedDiff(detail.diff) : null;
+		const counts = preview === null ? "" : `: +${preview.additions} -${preview.deletions}`;
+		return `${tool} ${editTargetPath(input, cwd)}${counts}`;
+	}
+	return `approve ${tool} ${humanizeApproval(tool, input, detail, symbols, cwd)}`.trim();
+}
+/** Pure card spec so tests assert content without mounting ink. */
+function approvalCardSpec(props) {
+	const { request, detail, symbols, cwd } = props;
+	const subjectText = humanizeApproval(request.tool, request.input, detail, symbols, cwd);
+	const subject = subjectText.length > 0 ? { text: subjectText } : null;
+	let diffLines = [];
+	let hiddenLines = 0;
+	if (detail?.diff !== void 0 && detail.diff.length > 0) {
+		const preview = summarizeUnifiedDiff(detail.diff);
+		diffLines = preview.lines.map((line) => {
+			const kind = classifyUnifiedDiffLine(line);
+			if (kind === "add") return {
+				text: line,
+				color: "green"
+			};
+			if (kind === "del") return {
+				text: line,
+				color: "red"
+			};
+			if (kind === "meta") return {
+				text: line,
+				dim: true
+			};
+			return { text: line };
+		});
+		hiddenLines = preview.hiddenLines;
+	}
+	return {
+		title: `approve ${request.tool}?`,
+		subject,
+		diffLines,
+		hiddenLines,
+		hints: APPROVAL_HINT_PARTS.join(` ${symbols.hintSeparator} `),
+		srLabel: approvalSrLabel(request.tool, request.input, detail, symbols, cwd)
+	};
+}
+function ApprovalCardV2({ request, detail, symbols, cwd, screenReader = false }) {
+	const spec = approvalCardSpec({
+		request,
+		detail,
+		symbols,
+		cwd
+	});
+	if (screenReader) return createElement(Text, null, spec.srLabel);
+	return createElement(Box, {
+		flexDirection: "column",
+		borderStyle: symbols.border,
+		borderColor: "yellow",
+		paddingX: 1,
+		"aria-role": "button",
+		"aria-label": spec.srLabel
+	}, createElement(Text, {
+		bold: true,
+		color: "yellow"
+	}, spec.title), spec.subject !== null ? createElement(Text, {
+		key: "subject",
+		dimColor: true
+	}, spec.subject.text) : null, ...spec.diffLines.map((row, index) => createElement(Text, {
+		key: index,
+		color: row.color,
+		bold: row.bold === true,
+		dimColor: row.dim === true
+	}, row.text)), spec.hiddenLines > 0 ? createElement(Text, {
+		key: "more",
+		dimColor: true
+	}, `${symbols.ellipsis} ${spec.hiddenLines} more lines`) : null, createElement(Text, { key: "hints" }, spec.hints));
+}
+/** `── {text} ──` with the ASCII `--` fallback. */
+function dividerLine(text, symbols) {
+	const rule = symbols.rule.repeat(2);
+	return `${rule} ${text} ${rule}`;
+}
+function Divider({ text, symbols, screenReader = false }) {
+	return createElement(Text, { dimColor: !screenReader }, screenReader ? text : dividerLine(text, symbols));
+}
+/**
+* Hermes mechanism: when no tool item survives a visibility filter, the last
+* error item is forced back into view — quiet mode must never hide failures.
+*/
+function withErrorBackstop(items, isVisible) {
+	const visible = items.filter(isVisible);
+	if (visible.some((item) => item.kind === "tool")) return visible;
+	let lastError;
+	for (const item of items) if (item.kind === "error") lastError = item;
+	if (lastError === void 0) return visible;
+	const forced = new Set(visible);
+	forced.add(lastError);
+	return items.filter((item) => forced.has(item));
 }
 //#endregion
 //#region src/app.ts
-const PROMPT_HINT_PARTS = [
-	"y allow",
-	"a always",
-	"n deny",
-	"esc abort"
-];
-const INPUT_HINT_PARTS = [
-	"type a task",
-	"enter run",
-	"q quit"
-];
-function TuiApp({ store }) {
+function TuiApp({ store, footer }) {
 	const state = useSyncExternalStore(store.subscribe, () => store.state);
 	const screenReader = useIsScreenReaderEnabled();
 	const symbols = resolveSymbols(screenReader || isAsciiEnv(process.env.CHANTIER_ASCII));
 	const { exit } = useApp();
+	const { columns, rows } = useWindowSize();
+	const [editor, setEditor] = useState(emptyEditor());
+	const [quitArmed, setQuitArmed] = useState(false);
+	const quitHintTimer = useRef(void 0);
+	const armQuitHint = () => {
+		setQuitArmed(true);
+		clearTimeout(quitHintTimer.current);
+		quitHintTimer.current = setTimeout(() => {
+			setQuitArmed(false);
+			quitHintTimer.current = void 0;
+		}, QUIT_WINDOW_MS);
+	};
+	const [history, setHistory] = useState(void 0);
+	useEffect(() => {
+		loadHistory(historyPath()).then((entries) => {
+			setHistory(createHistoryStore({
+				entries,
+				file: historyPath()
+			}));
+		});
+	}, []);
 	useInput((input, key) => {
-		const { mode, prompt } = store.state;
-		if (key.ctrl) {
-			store.abort("ctrl-c");
-			return;
-		}
-		if (key.escape) {
-			store.abort("escape");
-			return;
-		}
-		if (mode === "input" && prompt === null) {
-			if (key.backspace || key.delete) {
-				store.backspaceInput();
+		const { prompt, running } = store.state;
+		if (prompt !== null) {
+			const decision = keypressToDecision((input ?? "").replace(/[\r\n]/g, ""));
+			if (decision !== null) {
+				store.decide(decision);
 				return;
 			}
-			const bundledReturn = /[\r\n]/.test(input ?? "");
-			if (input !== void 0 && input.length > 0) {
-				for (const char of input) if (char !== "\r" && char !== "\n") store.typeInput(char);
+			if (key.escape) {
+				store.abort("escape");
+				return;
 			}
-			if (key.return || bundledReturn) store.submitTask(store.state.inputText);
+			if (key.ctrl) store.abort("ctrl-c");
 			return;
 		}
-		if (prompt !== null) {
-			const decision = keypressToDecision(input.replace(/[\r\n]/g, ""));
-			if (decision !== null) store.decide(decision);
-		}
+		if (key.escape && running !== null) store.abort("escape");
 	});
 	useEffect(() => {
 		if (!store.state.finished) return;
@@ -114,60 +1174,103 @@ function TuiApp({ store }) {
 		return () => clearTimeout(timer);
 	});
 	const children = [createElement(Static, {
-		items: [...state.lines],
-		children: (item, index) => createElement(Text, { key: index }, String(item))
+		items: [...state.items],
+		children: (item, index) => itemNode(item, index, symbols, screenReader)
 	})];
 	if (state.streamText.length > 0) children.push(createElement(Text, {
 		color: "cyan",
 		"aria-hidden": screenReader
 	}, state.streamText));
-	if (state.status.length > 0) children.push(createElement(Text, { dimColor: true }, state.status));
+	if (state.running !== null && state.prompt === null) children.push(createElement(StatusWidget, {
+		running: state.running,
+		status: state.statusFlash.length > 0 ? state.statusFlash : state.status,
+		symbols,
+		screenReader
+	}));
 	if (state.prompt !== null) {
-		const { tool, input } = state.prompt;
-		children.push(createElement(Box, {
-			flexDirection: "column",
-			borderStyle: symbols.border,
-			borderColor: "yellow",
-			paddingX: 1,
-			"aria-role": "button"
-		}, createElement(Text, {
-			bold: true,
-			color: "yellow",
-			"aria-label": approvalLabel(tool, input)
-		}, `approve ${tool}?`), createElement(Text, { dimColor: true }, summarizeInput(input, symbols.ellipsis)), diffCard(state.promptDetail, symbols), createElement(Text, null, PROMPT_HINT_PARTS.join(` ${symbols.hintSeparator} `))));
+		const detail = state.promptDetail;
+		children.push(createElement(ApprovalCardV2, {
+			request: state.prompt,
+			detail: detail === null ? null : { diff: detail.diff },
+			symbols,
+			screenReader
+		}));
 	}
-	if (state.mode === "input" && !state.finished) children.push(createElement(Box, {
-		borderStyle: symbols.border,
-		borderColor: "green",
-		paddingX: 1
-	}, createElement(Text, { color: "green" }, "> "), createElement(Text, null, state.inputText), createElement(Text, { dimColor: true }, `  ${INPUT_HINT_PARTS.join(` ${symbols.hintSeparator} `)}`)));
+	if (!state.finished) {
+		if (quitArmed) children.push(createElement(Text, { dimColor: true }, "press ctrl-c again to quit"));
+		children.push(createElement(TaskInput, {
+			editor,
+			onEditorChange: (next) => setEditor(next),
+			onSubmit: (text) => {
+				setEditor(emptyEditor());
+				if (store.state.running !== null) {
+					store.pushQueued(text);
+					return;
+				}
+				store.submitTask(text);
+			},
+			running: state.running !== null,
+			queuedCount: state.queued.length,
+			onQueueEdit: () => {
+				const last = store.state.queued.at(-1);
+				if (last === void 0) return;
+				store.dropQueued();
+				setEditor({
+					text: last,
+					cursor: last.length
+				});
+			},
+			locked: state.prompt !== null,
+			rows,
+			history,
+			onQuit: () => store.abort("ctrl-c"),
+			onQuitArm: armQuitHint,
+			symbols,
+			screenReader
+		}));
+	}
+	children.push(createElement(QueuePreview, {
+		queued: state.queued,
+		symbols
+	}));
+	const footerData = footer?.data?.();
+	children.push(createElement(FooterBar, {
+		model: footer?.model ?? "chantier",
+		ctxFraction: footerData?.ctxFraction,
+		compactSoon: footerData?.compactSoon === true ? true : void 0,
+		usage: state.usage,
+		sessionId: footer?.sessionId ?? "",
+		columns,
+		symbols,
+		hidden: state.prompt !== null
+	}));
 	return createElement(Box, { flexDirection: "column" }, ...children);
 }
-/** The unified-diff attachment card, or null when the ask carries no diff. */
-function diffCard(detail, symbols) {
-	if (detail === null) return null;
-	if (typeof detail.diff !== "string" || detail.diff.length === 0) return null;
-	const preview = summarizeUnifiedDiff(detail.diff);
-	return createElement(Box, {
-		flexDirection: "column",
-		borderStyle: symbols.border,
-		borderColor: "cyan",
-		paddingX: 1,
-		"aria-label": `proposed change: ${preview.additions} ${preview.additions === 1 ? "addition" : "additions"}, ${preview.deletions} ${preview.deletions === 1 ? "deletion" : "deletions"}`
-	}, createElement(Text, { dimColor: true }, "proposed change"), ...preview.lines.map((line, index) => createElement(Text, {
-		key: index,
-		...diffTextStyle(classifyUnifiedDiffLine(line))
-	}, line)), preview.hiddenLines > 0 ? createElement(Text, { dimColor: true }, `+${preview.hiddenLines} more lines`) : null);
-}
-function diffTextStyle(kind) {
-	if (kind === "add") return { color: "green" };
-	if (kind === "del") return { color: "red" };
-	if (kind === "meta") return { dimColor: true };
-	return {};
-}
-function summarizeInput(input, ellipsis) {
-	const json = JSON.stringify(input);
-	return json.length > 160 ? `${json.slice(0, 160)}${ellipsis}` : json;
+/** Renders one finalized transcript item (spec §1). */
+function itemNode(item, index, symbols, screenReader) {
+	switch (item.kind) {
+		case "markdown": return createElement(Box, {
+			key: index,
+			flexDirection: "column"
+		}, ...markdownToElements(item.text, symbols, screenReader));
+		case "divider": return createElement(Divider, {
+			key: index,
+			text: item.text,
+			symbols,
+			screenReader
+		});
+		case "tool": return createElement(ToolRow, {
+			key: index,
+			item,
+			symbols,
+			screenReader
+		});
+		case "info": return createElement(Text, { key: index }, item.text);
+		case "error": return createElement(Text, {
+			key: index,
+			color: "red"
+		}, item.text);
+	}
 }
 /** Screen-reader label for the approval card (ink serializes it as the button name). */
 function approvalLabel(tool, input) {
@@ -187,24 +1290,12 @@ function inputSubject(input) {
 	}
 	return "";
 }
-/** Maps a prompt keypress to a decision; null = key not handled by the prompt. */
-function keypressToDecision(key) {
-	const clean = key.replace(/[\r\n]/g, "");
-	if (clean === "y") return { approved: true };
-	if (clean === "a") return {
-		approved: true,
-		remember: true
-	};
-	if (clean === "n") return {
-		approved: false,
-		reason: "user denied"
-	};
-	return null;
-}
-/** Mounts the TUI. The store drives everything; the caller drives the agent. */
 function startTui(store, options = {}) {
 	const screenReader = resolveScreenReader(options.screenReader, process.env.CHANTIER_SCREEN_READER);
-	const instance = render(createElement(TuiApp, { store }), {
+	const instance = render(createElement(TuiApp, {
+		store,
+		...options.footer === void 0 ? {} : { footer: options.footer }
+	}), {
 		exitOnCtrlC: false,
 		...screenReader ? { isScreenReaderEnabled: true } : {}
 	});
@@ -215,9 +1306,13 @@ function startTui(store, options = {}) {
 function createTuiStore(handlers, isQuitCommand = (text) => /^(q|exit|quit)$/i.test(text.trim())) {
 	let state = {
 		mode: "input",
-		lines: [],
+		items: [],
 		streamText: "",
 		status: "",
+		running: null,
+		queued: [],
+		usage: void 0,
+		statusFlash: "",
 		prompt: null,
 		promptDetail: null,
 		inputText: "",
@@ -252,6 +1347,14 @@ function createTuiStore(handlers, isQuitCommand = (text) => /^(q|exit|quit)$/i.t
 			set({ streamText: state.streamText + chunk });
 		}, STREAM_COALESCE_MS);
 	};
+	const STATUS_FLASH_MS = 5e3;
+	let flashTimer = null;
+	const disarmFlashTimer = () => {
+		if (flashTimer !== null) {
+			clearTimeout(flashTimer);
+			flashTimer = null;
+		}
+	};
 	/** Normalizes an ask detail: only a non-empty string diff survives. */
 	const normalizeDetail = (detail) => {
 		if (typeof detail?.diff === "string" && detail.diff.length > 0) return { diff: detail.diff };
@@ -261,30 +1364,93 @@ function createTuiStore(handlers, isQuitCommand = (text) => /^(q|exit|quit)$/i.t
 		get state() {
 			return state;
 		},
+		get items() {
+			return state.items;
+		},
+		get running() {
+			return state.running;
+		},
+		get queued() {
+			return state.queued;
+		},
+		get usage() {
+			return state.usage;
+		},
+		get statusFlash() {
+			return state.statusFlash;
+		},
 		subscribe(listener) {
 			listeners.add(listener);
 			return () => listeners.delete(listener);
 		},
-		pushLine(line) {
-			set({ lines: [...state.lines, line] });
+		pushItem(item) {
+			set({ items: [...state.items, item] });
 		},
 		appendStream(text) {
 			pendingStream += text;
 			if (pendingStream.length > 0) armStreamTimer();
 		},
-		flushStream() {
+		flushStream(options) {
 			disarmStreamTimer();
 			const buffered = `${state.streamText}${pendingStream}`;
 			pendingStream = "";
 			if (buffered.length === 0) return;
+			if (options?.safe === true) {
+				const { flushed, rest } = takeSafeFlush(buffered);
+				if (flushed.length === 0) {
+					if (rest !== state.streamText) set({ streamText: rest });
+					return;
+				}
+				set({
+					items: [...state.items, {
+						kind: "markdown",
+						text: flushed
+					}],
+					streamText: rest
+				});
+				return;
+			}
 			set({
-				lines: [...state.lines, ...buffered.split("\n")],
+				items: [...state.items, {
+					kind: "markdown",
+					text: buffered
+				}],
 				streamText: ""
 			});
 		},
 		setStatus(status) {
 			set({ status });
 		},
+		setRunning(running) {
+			set({ running });
+		},
+		pushQueued(text) {
+			set({ queued: [...state.queued, text] });
+		},
+		editQueued(text) {
+			const queued = state.queued;
+			if (queued.length === 0) return;
+			set({ queued: [...queued.slice(0, -1), text] });
+		},
+		dropQueued() {
+			if (state.queued.length === 0) return;
+			set({ queued: state.queued.slice(0, -1) });
+		},
+		setUsage(usage) {
+			set({ usage });
+		},
+		flashStatus(text) {
+			disarmFlashTimer();
+			if (text.length === 0) {
+				set({ statusFlash: "" });
+				return;
+			}
+			flashTimer = setTimeout(() => {
+				flashTimer = null;
+				set({ statusFlash: "" });
+			}, STATUS_FLASH_MS);
+			set({ statusFlash: text });
+		},
 		backspaceInput() {
 			set({ inputText: state.inputText.slice(0, -1) });
 		},
@@ -370,4 +1536,4 @@ function createTuiStore(handlers, isQuitCommand = (text) => /^(q|exit|quit)$/i.t
 	};
 }
 //#endregion
-export { TuiApp, approvalLabel, classifyUnifiedDiffLine, createTuiStore, isAsciiEnv, keypressToDecision, resolveScreenReader, resolveSymbols, startTui, summarizeUnifiedDiff };
+export { ACTION_CHORDS, APPROVAL_HINT_PARTS, ApprovalCardV2, Divider, FooterBar, QUEUE_PREVIEW_MAX_ROWS, QUIT_HINT, QueuePreview, STATUS_VERB_WIDTH, SUBAGENT_SUMMARY_MAX_LINES, StatusWidget, SubagentCard, TaskInput, ToolRow, TuiApp, applyEditorAction, approvalCardSpec, approvalLabel, approvalSrLabel, classifyUnifiedDiffLine, createHistoryStore, createTuiStore, ctxBar, dividerLine, editorBackspace, editorInsert, emptyEditor, expandPasteChips, footerSegments, formatDuration, formatElapsed, formatTokenCount, formatTokens, hasMarkdownSyntax, historyPath, humanizeApproval, isAsciiEnv, keypressToDecision, loadHistory, markdownDivider, markdownToElements, matches, pasteChip, previewLine, queuePreviewLines, resolveScreenReader, resolveSymbols, spinnerFrame, startTui, statusLines, subagentLines, summarizeUnifiedDiff, takeSafeFlush, toolRowLines, toolRowSrText, withErrorBackstop };