acryldev 0.1.0

package/bin.js

@@ -0,0 +1,4303 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { join, relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { writeFileSync } from "node:fs";
+import { DEFAULT_PROFILE_BUNDLES, boot, composeEntries, healProfilesModuleFallback, initProfile, loadProfile, resolveProfileDir } from "@deepseek-ai/dsh-app-boot";
+import { diffLines } from "diff";
+import { Container, Editor, Key, KeybindingsManager, ProcessTerminal, ScrollView, TUI_KEYBINDINGS, Text, TuiAltScreen, VStack, matchesKey, setKeybindings, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { readdir } from "node:fs/promises";
+//#region src/cli/node-launcher.ts
+/** Return the child Node invocation required to expose Cordis HMR internals. */
+function exposedInternalsInvocation(input) {
+	if (input.execArgv.includes("--expose-internals")) return void 0;
+	return [
+		"--expose-internals",
+		...input.execArgv,
+		input.script,
+		...input.args
+	];
+}
+/** Re-execute this CLI under Node with the Cordis HMR prerequisite enabled. */
+async function relaunchWithExposedInternals(input) {
+	const invocation = exposedInternalsInvocation(input);
+	if (invocation === void 0) return false;
+	const exitCode = await new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, invocation, { stdio: "inherit" });
+		child.once("error", reject);
+		child.once("exit", (code) => resolve(code ?? 1));
+	});
+	process.exitCode = exitCode;
+	return true;
+}
+//#endregion
+//#region ../acryl-harness-runtime/lib/index.mjs
+function contentText(content) {
+	return content.filter((block) => {
+		return block.type === "text" && typeof block.text === "string";
+	}).map((block) => block.text).join("");
+}
+function transcript(events) {
+	const items = [];
+	for (const event of events) {
+		if (event.type === "user/message" && event.data.source.kind === "user") {
+			const text = contentText(event.data.content);
+			if (text !== "") items.push(Object.freeze({
+				id: `event-${event.seq}`,
+				author: "user",
+				text
+			}));
+		}
+		if (event.type === "assistant/message") {
+			const text = contentText(event.data.message.content);
+			if (text !== "") items.push(Object.freeze({
+				id: `event-${event.seq}`,
+				author: "assistant",
+				text
+			}));
+		}
+	}
+	return Object.freeze(items);
+}
+function tools(events) {
+	const current = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.type === "tool/call") current.set(event.data.callId, Object.freeze({
+			callId: event.data.callId,
+			name: event.data.name,
+			status: "running"
+		}));
+		if (event.type === "tool/result") {
+			const callId = event.data.message.source.callId;
+			const existing = current.get(callId);
+			if (existing !== void 0) current.set(callId, Object.freeze({
+				...existing,
+				status: "succeeded"
+			}));
+		}
+	}
+	return Object.freeze([...current.values()]);
+}
+function status(agent) {
+	return agent.status === "running" ? "running" : "idle";
+}
+/**
+* Runtime-owned adapter over one native DSH agent/session. It creates or resumes
+* the native agent and derives every presentation value from its durable log.
+*/
+function createAcrylSessionBridge(ctx, options) {
+	const handles = /* @__PURE__ */ new Map();
+	const subscribers = /* @__PURE__ */ new Map();
+	const eventListeners = /* @__PURE__ */ new Map();
+	let disposed = false;
+	const notify = (sessionId) => {
+		const listeners = subscribers.get(sessionId);
+		if (listeners === void 0) return;
+		snapshot(sessionId).then((next) => {
+			for (const listener of listeners) try {
+				listener(next);
+			} catch {}
+		});
+	};
+	const offSessionEvent = ctx.on("session/event", (session, event) => {
+		if (!handles.has(session.id)) return;
+		notify(session.id);
+		const listeners = eventListeners.get(session.id);
+		if (listeners === void 0) return;
+		for (const listener of listeners) try {
+			listener(event);
+		} catch {}
+	});
+	const snapshot = async (sessionId) => {
+		const agent = agentFor(sessionId);
+		return Object.freeze({
+			profile: options.profile,
+			generationId: options.generationId,
+			attachment: options.attachment,
+			sessionId: agent.id,
+			agentStatus: status(agent),
+			transcript: transcript(agent.session.events),
+			tools: tools(agent.session.events)
+		});
+	};
+	const agentFor = (sessionId) => {
+		if (disposed) throw new Error("ACRYL session bridge is disposed");
+		const handle = handles.get(sessionId);
+		if (handle === void 0) throw new Error(`ACRYL session ${sessionId} is not active`);
+		return handle.agent;
+	};
+	return Object.freeze({
+		async open(resumeSessionId) {
+			if (disposed) throw new Error("ACRYL session bridge is disposed");
+			if (handles.size !== 0) throw new Error("ACRYL session bridge already has an active session");
+			const defaultModel = ctx.get("agentDefaultModel");
+			if (defaultModel === void 0) throw new Error("ACRYL profile has no default agent model");
+			const selection = defaultModel.currentSelection();
+			const handle = resumeSessionId === void 0 ? await ctx.agents.create({
+				sessionId: SessionId(`acryl-session-${crypto.randomUUID()}`),
+				meta: { cwd: options.cwd },
+				agentOptions: {
+					provider: selection.provider,
+					model: selection.model
+				}
+			}) : await ctx.agents.resume({
+				resumeSessionId: SessionId(resumeSessionId),
+				agentOptions: {
+					provider: selection.provider,
+					model: selection.model
+				}
+			});
+			handles.set(handle.agent.id, handle);
+			return handle.agent.id;
+		},
+		snapshot,
+		events(sessionId) {
+			return agentFor(sessionId).session.events;
+		},
+		async subscribe(sessionId, listener, _onError) {
+			agentFor(sessionId);
+			const listeners = subscribers.get(sessionId) ?? /* @__PURE__ */ new Set();
+			subscribers.set(sessionId, listeners);
+			listeners.add(listener);
+			try {
+				listener(await snapshot(sessionId));
+			} catch {}
+			let active = true;
+			return Object.freeze({
+				whenError() {
+					return new Promise(() => {});
+				},
+				async dispose() {
+					if (!active) return;
+					active = false;
+					listeners.delete(listener);
+					if (listeners.size === 0) subscribers.delete(sessionId);
+				}
+			});
+		},
+		async subscribeEvents(sessionId, listener) {
+			agentFor(sessionId);
+			const listeners = eventListeners.get(sessionId) ?? /* @__PURE__ */ new Set();
+			eventListeners.set(sessionId, listeners);
+			listeners.add(listener);
+			let active = true;
+			return Object.freeze({ async dispose() {
+				if (!active) return;
+				active = false;
+				listeners.delete(listener);
+				if (listeners.size === 0) eventListeners.delete(sessionId);
+			} });
+		},
+		async submitPrompt(input) {
+			const agent = agentFor(input.sessionId);
+			if (input.text.trim() === "") throw new Error("ACRYL prompt must not be empty");
+			const accepted = new Promise((resolve) => {
+				const off = ctx.on("session/event", (session, event) => {
+					if (session !== agent.session || event.type !== "user/message") return;
+					off();
+					resolve();
+				});
+			});
+			agent.followup(createUserMessage({
+				content: [{
+					type: "text",
+					text: input.text
+				}],
+				source: { kind: "user" }
+			}));
+			await accepted;
+		},
+		async cancel(sessionId) {
+			agentFor(sessionId).cancel({ kind: "user" });
+		},
+		async dispose() {
+			if (disposed) return;
+			disposed = true;
+			offSessionEvent();
+			subscribers.clear();
+			eventListeners.clear();
+			const activeHandles = [...handles.values()];
+			handles.clear();
+			const sessions = ctx.get("sessions");
+			for (const handle of activeHandles) {
+				try {
+					await handle.agent.whenIdle();
+				} catch {}
+				try {
+					await sessions?.flush(handle.agent.session);
+				} catch {}
+			}
+			await Promise.all(activeHandles.map((handle) => handle.dispose()));
+		}
+	});
+}
+const dshInstallAnchor = createRequire(import.meta.url).resolve("@deepseek-ai/dsh/package.json");
+const profileRoot = "[]\n";
+const ACRYL_RUNTIME_ROWS = [
+	{
+		id: "system-prompt",
+		name: "@deepseek-ai/dsh-system-prompt",
+		config: { persona: "You are a coding agent powered by the {{model}} model. Your working directory is {{cwd}}." }
+	},
+	{
+		id: "agent-presets",
+		name: "@deepseek-ai/dsh-agent-presets",
+		config: { default: "standard" }
+	},
+	{
+		id: "session-stats",
+		name: "@deepseek-ai/dsh-session-stats"
+	}
+];
+/** Boot one normal pinned-Harness ACRYL profile in a single Cordis root. */
+async function bootAcrylHarnessProfile(options) {
+	if (options.profile.trim() === "") throw new Error("ACRYL Harness profile must not be empty");
+	initProfile(resolveProfileDir(options.profile), DEFAULT_PROFILE_BUNDLES);
+	healProfilesModuleFallback(dshInstallAnchor);
+	const profile = loadProfile("acryl", options.profile, dshInstallAnchor);
+	const rootConfig = join(profile.dir, "cordis.yml");
+	writeFileSync(rootConfig, profileRoot);
+	const patches = structuredClone([
+		...profile.layers.flatMap((layer) => layer.patches),
+		...ACRYL_RUNTIME_ROWS,
+		...profile.patches
+	]);
+	if (composeEntries([patches]).find((entry) => entry.id === "hmr")?.disabled !== true && !process.execArgv.includes("--expose-internals")) throw new Error("ACRYL profile enables Cordis HMR and must be launched with Node --expose-internals");
+	const ctx = await boot("acryl", rootConfig, patches, options.prepare);
+	let disposed = false;
+	return Object.freeze({
+		ctx,
+		profileDirectory: profile.dir,
+		async dispose() {
+			if (disposed) return;
+			disposed = true;
+			await ctx.fiber.dispose();
+		}
+	});
+}
+//#endregion
+//#region src/host/direct.ts
+/** Start one normal local Harness runtime for this terminal surface. */
+/**
+* A local surface owns its normal DSH/Cordis root. Durable DSH sessions, not
+* `.acryl/control` experiments, provide continuity across later launches.
+*/
+async function startDirectHost(options) {
+	if (options.profile.trim() === "") throw new Error("ACRYL direct host profile must not be empty");
+	const runtime = await bootAcrylHarnessProfile({ profile: options.profile });
+	const ctx = runtime.ctx;
+	let disposed = false;
+	return Object.freeze({
+		ctx,
+		profile: options.profile,
+		generationId: options.generationId ?? randomUUID(),
+		runtimeState: ctx.get("sessions") !== void 0 && ctx.get("agents") !== void 0 ? "ready" : "unavailable",
+		async dispose() {
+			if (disposed) return;
+			disposed = true;
+			await runtime.dispose();
+		}
+	});
+}
+//#endregion
+//#region src/tui/theme.ts
+/**
+* DeepSeek brand palette for the TUI. Keep color decisions semantic so every
+* Ink surface and the raw-ANSI `render.ts`/`bannerText.ts` helpers share the
+* same visual language — see `DESIGN.md` for the full rationale and the
+* component-mapping guide this table is drawn from.
+*
+* The terminal still owns its background and default foreground; these are
+* foreground tokens for interactive, stateful, and brand elements only —
+* this TUI renders to native scrollback (no painted panel backgrounds), so
+* DeepSeek's `surface`/`bg-dark`/`border-dim` tokens are deliberately not
+* represented here.
+* @module @tomowang/dsh-tui/tui/theme
+*/
+const theme = {
+	/** DeepSeek Blue — brand banner/ASCII, active input border. */
+	primary: "#4F6BFE",
+	/** Electric Cyan — section headers, streaming/progress indicators. */
+	secondary: "#38BDF8",
+	/** Slate Indigo — badges (active provider/model). */
+	accent: "#818CF8",
+	/** Thought Violet — reasoning/thinking content, set apart from assistant text; see `formatReasoningSummary`/`formatStreamingText` in `src/render.ts`. */
+	reasoning: "#A855F7",
+	/** Mint Emerald. */
+	success: "#34D399",
+	/** Amber Sun. */
+	warning: "#FBBF24",
+	/** Coral Red. */
+	error: "#F87171",
+	/** DeepSeek uses its primary blue for informational UI. */
+	info: "#4F6BFE",
+	/** Slate Gray — dim/secondary text (labels, hints, timestamps). */
+	muted: "#94A3B8"
+};
+/** 24-bit-color ANSI wrapper, shared by every raw-ANSI formatter (`render.ts`, `markdown.ts`, `bannerText.ts`) and every pi-tui component theme adapter. */
+function fg(hex) {
+	const n = Number.parseInt(hex.slice(1), 16);
+	const r = n >> 16 & 255;
+	const g = n >> 8 & 255;
+	const b = n & 255;
+	return (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m`;
+}
+//#endregion
+//#region src/markdown.ts
+/**
+* Terminal Markdown rendering for assistant text. `render.ts` prints
+* assistant/tool output straight to native scrollback via raw ANSI, so this
+* module detects whether a text blob is (at least partly) Markdown before
+* paying the cost of styling it — plain prose keeps rendering exactly as it
+* always has, only text carrying real Markdown syntax gets headers, bold,
+* lists, code spans, tables, etc. converted to ANSI.
+* @module @tomowang/dsh-tui/markdown
+*/
+const ESC$1 = "\x1B[";
+const dim$3 = fg(theme.muted);
+const cyan$1 = fg(theme.secondary);
+const primary$1 = fg(theme.primary);
+const bold$11 = (s) => `${ESC$1}1m${s}${ESC$1}0m`;
+const italic = (s) => `${ESC$1}3m${s}${ESC$1}0m`;
+const strike = (s) => `${ESC$1}9m${s}${ESC$1}0m`;
+const underline = (s) => `${ESC$1}4m${s}${ESC$1}0m`;
+/** Wrap `label` as an OSC 8 terminal hyperlink to `url`; terminals without OSC 8 support just print `label` and ignore the surrounding escapes. */
+function hyperlink(url, label) {
+	return `\x1b]8;;${url}\x1b\\${label}\x1b]8;;\x1b\\`;
+}
+const FENCE_RE = /^(\s*)(`{3,}|~{3,})\s*(\S*)\s*$/;
+const ATX_HEADER_RE = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
+const HR_RE = /^ {0,3}(?:(?:-[ \t]*){3,}|(?:\*[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const BLOCKQUOTE_RE = /^(\s*)((?:>\s?)+)(.*)$/;
+const UNORDERED_RE = /^(\s*)([-*+])\s+(.*)$/;
+const ORDERED_RE = /^(\s*)(\d+)([.)])\s+(.*)$/;
+const TABLE_ROW_RE = /^\s*\|.*\|\s*$/;
+const TABLE_SEPARATOR_CELL_RE = /^:?-+:?$/;
+const LINK_RE = /\[([^\]\n]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/;
+const BOLD_RE = /\*\*([^*\n]+)\*\*|__([^_\n]+)__/;
+const INLINE_CODE_RE = /`([^`\n]+)`/;
+const ITALIC_RE = /(?<!\*)\*(?!\*)([^*\n]+)\*(?!\*)|(?<!_)_(?!_)([^_\n]+)_(?!_)/;
+const STRIKE_RE = /~~([^~\n]+)~~/;
+const LINK_RE_G = new RegExp(LINK_RE.source, "g");
+const BOLD_RE_G = new RegExp(BOLD_RE.source, "g");
+const ITALIC_RE_G = new RegExp(ITALIC_RE.source, "g");
+const STRIKE_RE_G = new RegExp(STRIKE_RE.source, "g");
+const INLINE_CODE_RE_G = new RegExp(INLINE_CODE_RE.source, "g");
+/**
+* Heuristically decides whether `text` carries Markdown markup worth
+* rendering, as opposed to plain prose that happens to contain a stray `*`
+* or `_`. Block-level syntax (fenced code, headers, rules, quotes, lists,
+* table rows) and unambiguous inline syntax (links, bold, strikethrough,
+* inline code) each single-handedly qualify. Lone single-`*`/`_` emphasis is
+* deliberately excluded: it is the highest false-positive-risk cue (globs,
+* multiplication, snake_case, `*args`) and easy to get wrong on its own, so
+* it only ever renders as emphasis when some other signal already confirmed
+* the text is Markdown.
+*/
+function looksLikeMarkdown(text) {
+	for (const line of text.split("\n")) if (FENCE_RE.test(line) || ATX_HEADER_RE.test(line) || HR_RE.test(line) || BLOCKQUOTE_RE.test(line) || UNORDERED_RE.test(line) || ORDERED_RE.test(line) || TABLE_ROW_RE.test(line)) return true;
+	return LINK_RE.test(text) || BOLD_RE.test(text) || STRIKE_RE.test(text) || INLINE_CODE_RE.test(text);
+}
+/** Style links, bold, strikethrough, and emphasis in a span already known to contain no inline code. */
+function applyNonCodeInline(text) {
+	let working = text.replaceAll(LINK_RE_G, (_match, label, url) => hyperlink(url, underline(primary$1(label))));
+	working = working.replaceAll(BOLD_RE_G, (_match, a, b) => bold$11(a ?? b ?? ""));
+	working = working.replaceAll(STRIKE_RE_G, (_match, t) => strike(t));
+	return working.replaceAll(ITALIC_RE_G, (_match, a, b) => italic(a ?? b ?? ""));
+}
+/**
+* Style one line's inline Markdown (links, bold, strikethrough, inline
+* code, emphasis). Splits on inline code spans first — `String.split` with
+* a single-capture-group regex interleaves the code contents (odd indices)
+* between the surrounding plain-text spans (even indices) — so a code
+* span's contents can never be mistaken for bold/italic/link syntax.
+*/
+function applyInline(text) {
+	return text.split(INLINE_CODE_RE_G).map((part, i) => i % 2 === 1 ? cyan$1(part) : applyNonCodeInline(part)).join("");
+}
+/** Split a line already confirmed by `TABLE_ROW_RE` into trimmed cells, dropping the framing `|`. */
+function splitTableRow(line) {
+	return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+}
+/**
+* A GFM delimiter row: every cell is dashes with optional leading/trailing
+* colons for alignment. Returns each column's alignment, or `null` when
+* `line` isn't a valid delimiter row — the caller then treats the preceding
+* line as ordinary text rather than a table header.
+*/
+function parseTableSeparator(line) {
+	const cells = splitTableRow(line);
+	const aligns = [];
+	for (const cell of cells) {
+		if (!TABLE_SEPARATOR_CELL_RE.test(cell)) return null;
+		const left = cell.startsWith(":");
+		const right = cell.endsWith(":");
+		aligns.push(left && right ? "center" : right ? "right" : "left");
+	}
+	return aligns;
+}
+/** Every escape this module's own `fg`/`bold`/`italic`/`strike`/`underline`/`hyperlink` helpers emit: SGR sequences and OSC 8 hyperlinks (BEL- or ST-terminated). */
+const ANSI_RE$1 = /\x1b\][^\x07]*\x07|\x1b\][^\x1b]*\x1b\\|\x1b\[[0-9;]*m/g;
+/**
+* Visible length of an already-styled cell: ANSI escapes have string length
+* but no on-screen width, so measuring `styled.length` directly would
+* overcount by however many escape bytes the cell's markup produced.
+* Stripping them first — rather than measuring the pre-styling raw source
+* — also fixes the companion bug that source length would otherwise cause:
+* `**bold**`'s raw text is 4 characters longer than what it renders as, so
+* a column sized from raw source overcounts a bold cell's true width, and
+* that same bold cell then looks "wide enough" and gets under-padded
+* relative to its plain siblings. Like the rest of this module, "visible"
+* means UTF-16 code units after stripping escapes, not a true display-width
+* count, so a wide/astral cell (CJK, emoji) can still under-pad — a known
+* limitation shared with the fixed-width horizontal rule below.
+*/
+function visibleLength(styled) {
+	return styled.replace(ANSI_RE$1, "").length;
+}
+/** Pad an already-styled cell out to `width`, measuring by `visibleLength` rather than `styled.length`. */
+function padCell(styled, width, align) {
+	const gap = Math.max(0, width - visibleLength(styled));
+	if (align === "right") return " ".repeat(gap) + styled;
+	if (align === "center") {
+		const left = Math.floor(gap / 2);
+		return " ".repeat(left) + styled + " ".repeat(gap - left);
+	}
+	return styled + " ".repeat(gap);
+}
+/** Pad one row of already-styled cells (header or body) to a single column-aligned line. */
+function formatTableRow(styledCells, widths, aligns, isHeader) {
+	return widths.map((width, i) => padCell(isHeader ? bold$11(styledCells[i] ?? "") : styledCells[i] ?? "", width, aligns[i] ?? "left")).join(dim$3(" │ "));
+}
+/** A dim horizontal rule under the header row, with a cross at each column boundary. */
+function formatTableRule(widths) {
+	return dim$3(widths.map((width) => "─".repeat(width)).join("─┼─"));
+}
+/**
+* Render Markdown source to ANSI-styled terminal text: headers, fenced/
+* inline code, block quotes, ordered/unordered lists, rules, tables, links,
+* bold, strikethrough, and emphasis. Text that `looksLikeMarkdown` rejects
+* passes through byte-for-byte unchanged.
+*/
+function renderMarkdown(text) {
+	if (!looksLikeMarkdown(text)) return text;
+	const out = [];
+	let inCode = false;
+	let fenceChar = "";
+	let fenceLen = 0;
+	const lines = text.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!inCode && TABLE_ROW_RE.test(line) && i + 1 < lines.length) {
+			const aligns = TABLE_ROW_RE.test(lines[i + 1]) ? parseTableSeparator(lines[i + 1]) : null;
+			if (aligns !== null) {
+				const styledHeader = splitTableRow(line).map((cell) => applyInline(cell));
+				const styledRows = [];
+				let j = i + 2;
+				for (; j < lines.length && TABLE_ROW_RE.test(lines[j]); j++) styledRows.push(splitTableRow(lines[j]).map((cell) => applyInline(cell)));
+				const columns = Math.max(styledHeader.length, ...styledRows.map((row) => row.length), aligns.length);
+				const widths = Array.from({ length: columns }, (_, col) => Math.max(visibleLength(styledHeader[col] ?? ""), ...styledRows.map((row) => visibleLength(row[col] ?? ""))));
+				const columnAligns = Array.from({ length: columns }, (_, col) => aligns[col] ?? "left");
+				out.push(formatTableRow(styledHeader, widths, columnAligns, true));
+				out.push(formatTableRule(widths));
+				for (const styledRow of styledRows) out.push(formatTableRow(styledRow, widths, columnAligns, false));
+				i = j - 1;
+				continue;
+			}
+		}
+		const fence = FENCE_RE.exec(line);
+		if (fence !== null && (!inCode || fence[2][0] === fenceChar && fence[2].length >= fenceLen)) {
+			if (inCode) inCode = false;
+			else {
+				inCode = true;
+				fenceChar = fence[2][0];
+				fenceLen = fence[2].length;
+				if (fence[3] !== "") out.push(dim$3(fence[3]));
+			}
+			continue;
+		}
+		if (inCode) {
+			out.push(dim$3(line));
+			continue;
+		}
+		const header = ATX_HEADER_RE.exec(line);
+		if (header !== null) {
+			const level = header[1].length;
+			const content = applyInline(header[2]);
+			out.push(level === 1 ? bold$11(primary$1(content)) : level === 2 ? bold$11(cyan$1(content)) : bold$11(content));
+			continue;
+		}
+		if (HR_RE.test(line)) {
+			out.push(dim$3("─".repeat(40)));
+			continue;
+		}
+		const quote = BLOCKQUOTE_RE.exec(line);
+		if (quote !== null) {
+			const depth = (quote[2].match(/>/g) ?? []).length;
+			out.push(`${dim$3("▏".repeat(depth))} ${applyInline(quote[3])}`);
+			continue;
+		}
+		const unordered = UNORDERED_RE.exec(line);
+		if (unordered !== null) {
+			out.push(`${unordered[1]}${cyan$1("•")} ${applyInline(unordered[3])}`);
+			continue;
+		}
+		const ordered = ORDERED_RE.exec(line);
+		if (ordered !== null) {
+			out.push(`${ordered[1]}${cyan$1(`${ordered[2]}${ordered[3]}`)} ${applyInline(ordered[4])}`);
+			continue;
+		}
+		out.push(applyInline(line));
+	}
+	return out.join("\n");
+}
+//#endregion
+//#region src/render.ts
+/**
+* Terminal projection of durable session events. The TUI renders only from the
+* append-only session log, so a resumed session replays through the exact same
+* code path as live events.
+* @module @tomowang/dsh-tui/render
+*/
+const dim$2 = fg(theme.muted);
+const cyan = fg(theme.secondary);
+const red = fg(theme.error);
+const green = fg(theme.success);
+const yellow = fg(theme.warning);
+const violet$1 = fg(theme.reasoning);
+/** Line cap for a settled shell-escape (`!`) run's body in the permanent transcript; `<Static>` prints can't be redrawn, so a long run is summarized there — tool calls/results don't use this cap, since the transcript only ever shows their one-line collapsed summary (see `formatToolCardSummary`), with full detail available via `formatToolCardDetail` in the Tool Cards overlay. */
+const MAX_CARD_LINES = 20;
+/** `diff` package's `maxEditLength`: bounds worst-case diff cost on a huge file, mirroring the removed first-party TUI's default. */
+const MAX_DIFF_EDIT_LENGTH = 1e3;
+/** Clamp one-line summaries so tool arguments cannot flood the transcript. */
+function truncate(text, max) {
+	const oneLine = text.replaceAll("\n", " ");
+	return oneLine.length <= max ? oneLine : `${oneLine.slice(0, max - 1)}…`;
+}
+/** Join the text blocks of a message content array. */
+function textOf(content) {
+	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+/** Join the reasoning/thinking blocks of a message content array, distinct from its visible `textOf`. */
+function reasoningOf(content) {
+	return content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+}
+/** Preview length for a settled step's reasoning summary line — long enough to be useful, short enough that a long thinking block never floods the transcript; the full text is always in `/trajectory`. */
+const REASONING_SUMMARY_LENGTH = 80;
+/** Format one settled message's reasoning/thinking content as a single collapsed line — the label plus a short preview — never the full body, which stays available via `/trajectory`. */
+function formatReasoningSummary(text) {
+	return violet$1(`✦ think · ${truncate(text, REASONING_SUMMARY_LENGTH)}`);
+}
+/**
+* Format one settled step's text (and, ahead of it, a one-line reasoning
+* summary when the step had any), for the permanent transcript.
+*/
+function formatSettledMessage(text, reasoningText) {
+	const parts = [];
+	if (reasoningText !== "") parts.push(formatReasoningSummary(reasoningText));
+	if (text !== "") parts.push(renderMarkdown(text));
+	return parts.length === 0 ? void 0 : `\n${parts.join("\n")}\n`;
+}
+/**
+* Format the in-progress step's live region: while reasoning has started but
+* no visible text has arrived yet, an animated `spinnerChar thinking` line
+* stands in for the raw, fast-scrolling reasoning body (its settled one-line
+* `✦ think · …` summary appears in the transcript once the step lands —
+* see `formatSettledMessage`); once text starts streaming, that text is
+* shown directly.
+*/
+function formatStreamingText(text, reasoningText = "", spinnerChar = "✦") {
+	if (text === "" && reasoningText === "") return void 0;
+	if (text === "") return `\n${violet$1(`${spinnerChar} thinking`)}\n`;
+	return `\n${renderMarkdown(text)}\n`;
+}
+/** One local shell-escape run's header + output lines, shared by the settled and in-flight renderers below. `exitCode` is `null` while still running. */
+function formatShellLines(command, output, exitCode) {
+	const lines = [`${yellow("!")} ${command}`];
+	if (output !== "") lines.push(...splitLines(output).map(dim$2));
+	if (exitCode !== null) lines.push(exitCode === 0 ? dim$2(`[exit ${exitCode}]`) : red(`[exit ${exitCode}]`));
+	return lines;
+}
+/** Format one settled local shell-escape run (`!` prompt-mode) for the permanent transcript, mirroring a `terminal` tool card. */
+function formatShellRun(command, output, exitCode) {
+	return `\n${capLines(formatShellLines(command, output, exitCode), MAX_CARD_LINES).join("\n")}\n`;
+}
+/** Format the in-progress shell-escape run's accumulated output for the live region, mirroring `formatStreamingText`'s settle-without-jump framing. */
+function formatShellRunLive(command, output) {
+	return `\n${capLines(formatShellLines(command, output, null), MAX_CARD_LINES).join("\n")}\n`;
+}
+/** Parse a tool call's JSON-encoded arguments; malformed JSON can't be handed to a presenter. */
+function parseJson(text) {
+	try {
+		return {
+			valid: true,
+			value: JSON.parse(text)
+		};
+	} catch {
+		return { valid: false };
+	}
+}
+/** Render a value for display: a string as-is, anything else as pretty JSON. */
+function pretty(value) {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value, null, 2) ?? String(value);
+}
+/** A string's content lines: empty text is zero lines, a trailing newline terminates the last line. */
+function splitLines(text) {
+	if (text === "") return [];
+	return (text.endsWith("\n") ? text.slice(0, -1) : text).split("\n");
+}
+/** Cap a card body to `max` lines, appending a dim summary of what was omitted. */
+function capLines(lines, max) {
+	if (lines.length <= max) return [...lines];
+	const omitted = lines.length - max;
+	return [...lines.slice(0, max), dim$2(`… +${omitted} line${omitted === 1 ? "" : "s"} omitted`)];
+}
+/**
+* One file's change as +/- diff lines under a dim path header. A `null` prior
+* text (new file, or a call-time overwrite with no before-image) renders the
+* whole new text as additions; a comparison beyond `MAX_DIFF_EDIT_LENGTH` falls
+* back to whole-side add/remove so a huge file can't stall formatting.
+*/
+function renderFileDiff(diff) {
+	const lines = [dim$2(diff.path)];
+	if (diff.oldText === null) {
+		for (const line of splitLines(diff.newText)) lines.push(green(`+ ${line}`));
+		return lines;
+	}
+	const changes = diffLines(diff.oldText, diff.newText, { maxEditLength: MAX_DIFF_EDIT_LENGTH });
+	if (changes === void 0) {
+		lines.push(dim$2(`[diff omitted: over ${MAX_DIFF_EDIT_LENGTH} changed lines]`));
+		for (const line of splitLines(diff.oldText)) lines.push(red(`- ${line}`));
+		for (const line of splitLines(diff.newText)) lines.push(green(`+ ${line}`));
+		return lines;
+	}
+	for (const change of changes) {
+		const prefix = change.added ? "+" : change.removed ? "-" : " ";
+		const color = change.added ? green : change.removed ? red : dim$2;
+		for (const line of splitLines(change.value)) lines.push(color(`${prefix} ${line}`));
+	}
+	return lines;
+}
+/** One or more `FileDiff`s, blank-line separated when there's more than one. */
+function renderFileDiffs(diffs) {
+	return diffs.flatMap((fileDiff, index) => (index > 0 ? [""] : []).concat(renderFileDiff(fileDiff)));
+}
+/** Today's flat one-line fallback for a pending call, unchanged: no tool, no presenter, bad JSON, or a throwing/`undefined` presenter. */
+function fallbackCallLine(name, rawArgs) {
+	return `${cyan("⚙")} ${name} ${dim$2(truncate(rawArgs, 100))}`;
+}
+/** Resolve a `tool/call`'s presented view, or `undefined` for any condition that keeps the flat fallback. */
+function presentCallSafely(name, rawArgs, getTool) {
+	const tool = getTool?.(name);
+	if (tool?.presentCall === void 0) return void 0;
+	const parsed = parseJson(rawArgs);
+	if (!parsed.valid) return void 0;
+	try {
+		return tool.presentCall(parsed.value);
+	} catch {
+		return;
+	}
+}
+/** A presented pending call's lines: a cyan header (the presenter's title) plus card-specific body. */
+function formatCallLines(view) {
+	const header = `${cyan("⚙")} ${view.title}`;
+	if (view.card === "terminal") {
+		const lines = [];
+		if (view.description !== void 0 && view.description !== "") lines.push(dim$2(view.description));
+		lines.push(header);
+		if (view.cwd !== void 0) lines.push(dim$2(view.cwd));
+		return lines;
+	}
+	if (view.card === "diff") return [header, ...renderFileDiffs(view.diffs)];
+	return [header, ...view.rawInput === void 0 ? [] : splitLines(pretty(view.rawInput)).map(dim$2)];
+}
+/**
+* A presented call's one-line identity. A `TerminalCallView`'s `title` is
+* deliberately just the bare command with no verb (unlike a `generic`/`diff`
+* title, which a presenter writes to already read as one, e.g. "Read foo.ts")
+* — so on its own it reads as arbitrary text with no hint it was a shell
+* call. Label it with the tool's own name so the one-line summary still
+* names both what ran and how — the command itself is the detail a reader
+* wants here; its optional `description` stays a detail-view-only addition
+* (`formatCallLines` already shows it above the command there).
+*/
+function callSummaryTitle(name, view) {
+	if (view.card !== "terminal") return view.title;
+	return `${name.length === 0 ? name : name.charAt(0).toUpperCase() + name.slice(1)}: ${view.title}`;
+}
+/** A pending call's one-line title, presenting through the tool's `presentCall` when available — shared by the live region's spinner row. */
+function pendingCallTitle(name, rawArgs, getTool) {
+	const view = presentCallSafely(name, rawArgs, getTool);
+	return view === void 0 ? `${name} ${truncate(rawArgs, 100)}` : callSummaryTitle(name, view);
+}
+/**
+* Format every tool call that's been sent but has no `tool/result` yet, for
+* the live region: one line per call, the shared spinner frame standing in
+* for the settled ✓/✖ icon it'll collapse to once its result lands and it
+* becomes a single transcript line (see `formatToolCardSummary`).
+*/
+function formatPendingToolCalls(calls, spinnerChar, getTool) {
+	if (calls.length === 0) return "";
+	return `\n${calls.map((call) => `${cyan(spinnerChar)} ${pendingCallTitle(call.name, call.arguments, getTool)}`).join("\n")}\n`;
+}
+/** Resolve a `tool/result`'s presented view, or `undefined` for any condition that keeps the flat fallback. */
+function presentResultSafely(callId, result, options) {
+	const call = options.getToolCall?.(callId);
+	if (call === void 0) return void 0;
+	const tool = options.getTool?.(call.name);
+	if (tool?.presentResult === void 0) return void 0;
+	const parsed = parseJson(call.arguments);
+	if (!parsed.valid) return void 0;
+	try {
+		const view = tool.presentResult(parsed.value, result);
+		return view === void 0 ? void 0 : {
+			name: call.name,
+			view
+		};
+	} catch {
+		return;
+	}
+}
+/** A `tool/result`'s paired `tool/call`'s presented one-line identity, when both the call and a presenter for it resolve — the "pending-state title" a result view's own optional `title` defers to when omitted (see `ToolResultView` docs in `@deepseek-ai/dsh-tools`). */
+function resolveCallTitle(callId, options) {
+	const call = options.getToolCall?.(callId);
+	if (call === void 0) return void 0;
+	const view = presentCallSafely(call.name, call.arguments, options.getTool);
+	return view === void 0 ? void 0 : callSummaryTitle(call.name, view);
+}
+/** Shared by the transcript's compact line and the Tool Cards overlay's summary/detail, so all three read the same icon and presented view instead of re-deriving it. */
+function resolveToolResult(event, options) {
+	if (event.data.error !== void 0) return {
+		kind: "error",
+		line: `${red("✖")} ${event.data.error.code}: ${event.data.error.name}`
+	};
+	const [block] = event.data.message.content;
+	const failed = block.isError === true;
+	const icon = failed ? red("✖") : cyan("✓");
+	const callId = event.data.message.source.callId;
+	const presented = presentResultSafely(callId, {
+		content: block.content,
+		isError: failed,
+		...event.data.meta !== void 0 ? { meta: event.data.meta } : {}
+	}, options);
+	return {
+		kind: "ok",
+		icon,
+		content: block.content,
+		presented,
+		callTitle: resolveCallTitle(callId, options)
+	};
+}
+/** A presented completed call's lines: an outcome-colored header plus card-specific body. `callTitle` is the paired call's presented title — a result view's own `title` field defers to it (the "pending-state title") when omitted, so it comes before the flat fallback name. */
+function formatResultLines(fallbackName, callTitle, icon, rawContent, view) {
+	const header = `${icon} ${view.title ?? callTitle ?? fallbackName}`;
+	switch (view.card) {
+		case "generic": return [header, ...splitLines(textOf(view.content ?? rawContent)).map(dim$2)];
+		case "terminal": {
+			const lines = [header];
+			if (view.output !== void 0 && view.output !== "") lines.push(...splitLines(view.output).map(dim$2));
+			if (view.exitCode !== void 0) lines.push(dim$2(`[exit ${view.exitCode}]`));
+			if (view.signal !== void 0) lines.push(red(`[signal ${view.signal}]`));
+			return lines;
+		}
+		case "diff": return [header, ...renderFileDiffs(view.diffs)];
+		case "search": {
+			const lines = [header];
+			let shown = 0;
+			if (view.shape === "matches") for (const file of view.files) {
+				lines.push(dim$2(file.path));
+				for (const match of file.matches) lines.push(dim$2(`  ${match.lineNumber}: ${match.line}`));
+				shown += file.matches.length;
+			}
+			else {
+				for (const path of view.paths) lines.push(dim$2(path));
+				shown = view.paths.length;
+			}
+			if (view.truncated) lines.push(dim$2(`… showing ${shown} of ${view.total}`));
+			return lines;
+		}
+		case "read": {
+			const lines = [`${icon} ${view.title ?? callTitle ?? view.path}`];
+			for (const line of view.lines) lines.push(dim$2(`${line.number}: ${line.text}`));
+			if (view.totalLines > 0) {
+				const last = view.offset + view.lines.length - 1;
+				lines.push(dim$2(`[${view.offset}-${last} of ${view.totalLines}]`));
+			}
+			return lines;
+		}
+		case "web": {
+			const lines = [header];
+			if (view.kind === "search") {
+				for (const source of view.sources) lines.push(dim$2(`${source.title ?? source.url} — ${source.url}`));
+				if (view.answer !== void 0 && view.answer !== "") lines.push(...splitLines(view.answer).map(dim$2));
+			} else lines.push(dim$2(`${view.url} [${view.statusCode}]`));
+			if (view.truncated) lines.push(dim$2("… truncated"));
+			return lines;
+		}
+	}
+}
+/**
+* One `goal/change` mutation's transcript line, mirroring the durable
+* ledger's `operation`. An explicit `switch` with no `default` over the
+* post-`clear` operation union (rather than a sequential `if` chain ending
+* in an implicit "must be block") so a future `dsh-goal` operation the TUI
+* doesn't know about fails to compile here instead of silently rendering
+* the wrong line.
+*/
+function goalChangeLine(change) {
+	if (change.operation === "clear") return `${dim$2("🗑")} goal cleared`;
+	const goal = change.goal;
+	switch (change.operation) {
+		case "create": return `${cyan("🎯")} goal set: ${goal.objective}`;
+		case "edit": return `${cyan("🎯")} goal updated: ${goal.objective}`;
+		case "pause": return `${yellow("⏸")} goal paused: ${goal.objective}`;
+		case "resume": return `${green("▶")} goal resumed: ${goal.objective}`;
+		case "complete": return `${green("✓")} goal complete: ${goal.objective}`;
+		case "block": return `${red("⛔")} goal blocked${goal.blockedReason === void 0 ? "" : `: ${goal.blockedReason.code}: ${goal.blockedReason.message}`}`;
+	}
+}
+/**
+* Format one durable session event as a terminal line, or `undefined` for
+* events this viewer does not present. Unknown event types are silently
+* skipped: the log's vocabulary is merge-extensible and a transcript viewer
+* must tolerate events from plugins it does not know.
+* @param event - the durable session event to project.
+* @param options - replay/live rendering context, plus optional tool-presentation resolvers.
+*/
+function formatEvent(event, options) {
+	switch (event.type) {
+		case "user/message": {
+			const source = event.data.source;
+			if (source.kind === "user") {
+				const text = textOf(event.data.content);
+				return text === "" ? void 0 : `${dim$2("you ›")} ${text}`;
+			}
+			if (source.kind === "plugin") {
+				const summary = source.form === "notice" ? source.summary : void 0;
+				return `${dim$2("⊕ context ›")} ${source.plugin}${summary === void 0 ? "" : ` · ${summary}`}`;
+			}
+			if (source.kind === "goal") return `${dim$2("⊕ goal ›")} round ${source.round}`;
+			return `${dim$2("⊕ context ›")} ${source.kind}`;
+		}
+		case "assistant/message": {
+			const content = event.data.message.content;
+			return formatSettledMessage(textOf(content), reasoningOf(content));
+		}
+		case "tool/call": return;
+		case "tool/result": return formatToolCardSummary(event, options);
+		case "turn/end": {
+			const reason = event.data.reason;
+			if (reason.kind === "error") return `${red("✖")} ${reason.error.code}: ${reason.error.message}`;
+			else if (reason.kind === "aborted") return `${yellow("⏹")} ${dim$2("turn canceled")}`;
+			return;
+		}
+		case "compaction/summary": return `${cyan("⊙")} compacted ${event.data.shadowedSeqs.length} items (~${event.data.shadowedTokenCount} tokens)`;
+		case "compaction/end": return event.data.error === void 0 ? void 0 : `${red("✖")} compaction: ${event.data.error}`;
+		case "goal/change": return goalChangeLine(event.data);
+		default: return;
+	}
+}
+/**
+* A `tool/call`/`tool/result` event's one-line summary — the Tool Cards
+* overlay's collapsed row. Distinct from `formatEvent`'s own card rendering
+* (which can be multi-line even at its most compact), because the overlay
+* needs a genuine single line to toggle open from.
+*/
+function formatToolCardSummary(event, options) {
+	if (event.type === "tool/call") {
+		const view = presentCallSafely(event.data.name, event.data.arguments, options.getTool);
+		return view === void 0 ? fallbackCallLine(event.data.name, event.data.arguments) : `${cyan("⚙")} ${callSummaryTitle(event.data.name, view)}`;
+	}
+	if (event.type === "tool/result") {
+		const resolved = resolveToolResult(event, options);
+		if (resolved.kind === "error") return resolved.line;
+		const { icon, content, presented, callTitle } = resolved;
+		if (presented === void 0) {
+			const text = truncate(textOf(content), 100);
+			return text === "" ? icon : `${icon} ${dim$2(text)}`;
+		}
+		return `${icon} ${presented.view.title ?? callTitle ?? presented.name}`;
+	}
+	return "";
+}
+/**
+* Full, uncapped presentation lines for a `tool/call`/`tool/result` event.
+* Unlike `formatEvent`, this never truncates or omits — the Tool Cards
+* overlay scrolls its own window over the result instead of relying on a
+* fixed line cap, so it needs the complete card body to scroll through.
+*/
+function formatToolCardDetail(event, options) {
+	if (event.type === "tool/call") {
+		const view = presentCallSafely(event.data.name, event.data.arguments, options.getTool);
+		return view === void 0 ? [fallbackCallLine(event.data.name, event.data.arguments)] : formatCallLines(view);
+	}
+	if (event.type === "tool/result") {
+		const resolved = resolveToolResult(event, options);
+		if (resolved.kind === "error") return [resolved.line];
+		const { icon, content, presented, callTitle } = resolved;
+		if (presented === void 0) {
+			const text = textOf(content);
+			return text === "" ? [icon] : [icon, ...splitLines(text)];
+		}
+		return formatResultLines(presented.name, callTitle, icon, content, presented.view);
+	}
+	return [];
+}
+//#endregion
+//#region src/tui/store.ts
+const EMPTY_STATS = {
+	sessionStats: void 0,
+	tokenUsage: void 0,
+	contextPressure: void 0,
+	contextBreakdown: void 0
+};
+const EMPTY_FILE_INDEX = {
+	candidates: void 0,
+	loading: false
+};
+const CLOSED_OVERLAY = { kind: "none" };
+/** Mutable projection; `getSnapshot`/`subscribe` satisfy `useSyncExternalStore`. */
+var TuiStore = class {
+	state;
+	listeners = /* @__PURE__ */ new Set();
+	lastSeq;
+	streamingAssembler;
+	streamingKey;
+	toolCalls = /* @__PURE__ */ new Map();
+	pendingToolCallsMap = /* @__PURE__ */ new Map();
+	constructor(initial) {
+		const lastSeq = initial.events.at(-1)?.seq ?? 0;
+		this.lastSeq = lastSeq;
+		for (const event of initial.events) if (event.type === "tool/call") {
+			const call = {
+				name: event.data.name,
+				arguments: event.data.arguments
+			};
+			this.toolCalls.set(event.data.callId, call);
+			this.pendingToolCallsMap.set(event.data.callId, call);
+		} else if (event.type === "tool/result") this.pendingToolCallsMap.delete(event.data.message.source.callId);
+		this.state = {
+			events: initial.events.filter((event) => event.type !== "assistant/chunk"),
+			replayThrough: lastSeq,
+			status: "idle",
+			queued: [],
+			notice: void 0,
+			overlay: CLOSED_OVERLAY,
+			permission: void 0,
+			goal: void 0,
+			title: void 0,
+			stats: EMPTY_STATS,
+			preset: void 0,
+			streaming: void 0,
+			pendingToolCalls: this.pendingToolCallsSnapshot(),
+			shellRun: void 0,
+			shellHistory: [],
+			fileIndex: EMPTY_FILE_INDEX,
+			updateHint: void 0
+		};
+	}
+	getSnapshot = () => this.state;
+	/** The `tool/call` a later `tool/result` correlates with, by `callId`; `undefined` when its call was never seen (e.g. log truncation). */
+	getToolCall = (callId) => this.toolCalls.get(callId);
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	};
+	/** Append one live session event, ignoring anything already seeded/seen. */
+	appendEvent(event) {
+		if (event.seq <= this.lastSeq) return;
+		this.lastSeq = event.seq;
+		if (event.type === "tool/call") {
+			const call = {
+				name: event.data.name,
+				arguments: event.data.arguments
+			};
+			this.toolCalls.set(event.data.callId, call);
+			this.pendingToolCallsMap.set(event.data.callId, call);
+			this.set({
+				events: [...this.state.events, event],
+				pendingToolCalls: this.pendingToolCallsSnapshot()
+			});
+			return;
+		}
+		if (event.type === "tool/result") {
+			this.pendingToolCallsMap.delete(event.data.message.source.callId);
+			this.set({
+				events: [...this.state.events, event],
+				pendingToolCalls: this.pendingToolCallsSnapshot()
+			});
+			return;
+		}
+		if (event.type === "assistant/chunk") {
+			this.foldChunk(event.data);
+			return;
+		}
+		if (event.type === "assistant/message") {
+			this.streamingAssembler = void 0;
+			this.streamingKey = void 0;
+			this.set({
+				events: [...this.state.events, event],
+				streaming: void 0
+			});
+			return;
+		}
+		this.set({ events: [...this.state.events, event] });
+	}
+	/** Snapshot `pendingToolCallsMap` into `TuiState`'s array shape, in call order. */
+	pendingToolCallsSnapshot() {
+		return [...this.pendingToolCallsMap.entries()].map(([callId, call]) => ({
+			callId,
+			...call
+		}));
+	}
+	/** Fold one raw stream chunk into the in-flight step's live text, keyed by `{turn, step}`. */
+	foldChunk(data) {
+		const { turn, step, chunk } = data;
+		if (this.streamingKey?.turn !== turn || this.streamingKey?.step !== step) {
+			this.streamingAssembler = new BlockAssembler();
+			this.streamingKey = {
+				turn,
+				step
+			};
+		}
+		this.streamingAssembler.push(chunk);
+		const blocks = this.streamingAssembler.blocks();
+		const text = textOf(blocks);
+		const reasoningText = reasoningOf(blocks);
+		this.set({ streaming: text === "" && reasoningText === "" ? void 0 : {
+			turn,
+			step,
+			text,
+			reasoningText
+		} });
+	}
+	setStatus(status) {
+		if (status === this.state.status) return;
+		this.set({ status });
+	}
+	setQueued(queued) {
+		this.set({ queued });
+	}
+	setNotice(notice) {
+		this.set({ notice });
+	}
+	setPermission(permission) {
+		this.set({ permission });
+	}
+	/** Refresh the session's current goal from the 'goal' session projection; `undefined` when the projection unit isn't composed, `null` before the first create or after a clear. */
+	setGoal(goal) {
+		this.set({ goal });
+	}
+	/** Refresh the session's current title from the 'title' session projection; `undefined` when `dsh-session-title` isn't composed, `null` before the first accepted title. */
+	setTitle(title) {
+		this.set({ title });
+	}
+	setStats(stats) {
+		this.set({ stats });
+	}
+	setPreset(preset) {
+		this.set({ preset });
+	}
+	shellRunSeq = 0;
+	/** Begin one local shell-escape run; its output accumulates via `appendShellOutput` until `finishShellRun` settles it into the transcript. */
+	startShellRun(command) {
+		const id = ++this.shellRunSeq;
+		this.set({ shellRun: {
+			id,
+			command,
+			output: ""
+		} });
+		return id;
+	}
+	/** Append one chunk of stdout/stderr to the in-flight run; a no-op once it's settled or superseded by a later run. */
+	appendShellOutput(id, chunk) {
+		if (this.state.shellRun?.id !== id) return;
+		this.set({ shellRun: {
+			...this.state.shellRun,
+			output: this.state.shellRun.output + chunk
+		} });
+	}
+	/** Settle the in-flight run into the permanent transcript; a no-op once it's already settled or superseded. */
+	finishShellRun(id, exitCode) {
+		if (this.state.shellRun?.id !== id) return;
+		const { command, output } = this.state.shellRun;
+		this.set({
+			shellRun: void 0,
+			shellHistory: [...this.state.shellHistory, {
+				id,
+				command,
+				output,
+				exitCode,
+				afterSeq: this.lastSeq
+			}]
+		});
+	}
+	/** Open the `/model` overlay to a fresh, loading provider list. */
+	openModelProfile() {
+		this.set({ overlay: {
+			kind: "modelProfile",
+			modelProfile: {
+				view: "list",
+				providers: void 0,
+				selected: 0,
+				draft: void 0,
+				formKey: 0,
+				discovered: void 0,
+				busy: true,
+				error: void 0
+			}
+		} });
+	}
+	/** Open the `/trajectory` ledger overlay. */
+	openTrajectory() {
+		this.set({ overlay: { kind: "trajectory" } });
+	}
+	/** Open the expandable Tool Cards inspector. */
+	openToolCards() {
+		this.set({ overlay: { kind: "toolCards" } });
+	}
+	/** Open the `/context` usage overlay. */
+	openContext() {
+		this.set({ overlay: { kind: "context" } });
+	}
+	/** Open the `/plugins` loaded-plugin-tree overlay with a snapshotted row list. */
+	openPlugins(rows) {
+		this.set({ overlay: {
+			kind: "plugins",
+			rows
+		} });
+	}
+	/** Open the `/presets` overlay to a fresh, loading roster. */
+	openAgentPresets(init) {
+		this.set({ overlay: {
+			kind: "agentPresets",
+			agentPresets: {
+				rows: [],
+				selected: 0,
+				current: init.current,
+				blank: init.blank,
+				busy: true,
+				error: void 0
+			}
+		} });
+	}
+	/** Present one pending tool-approval decision, taking over the live region. */
+	openApproval(approval) {
+		this.set({ overlay: {
+			kind: "approval",
+			approval
+		} });
+	}
+	/** Present one pending question, taking over the live region. */
+	openUserQuestion(userQuestion) {
+		this.set({ overlay: {
+			kind: "userQuestion",
+			userQuestion
+		} });
+	}
+	/** Close whichever overlay is open, restoring the normal prompt/status controls. */
+	closeOverlay() {
+		this.set({ overlay: CLOSED_OVERLAY });
+	}
+	/** Patch the open `/model` overlay's sub-state; a no-op once it's closed. */
+	updateModelProfile(patch) {
+		if (this.state.overlay.kind !== "modelProfile") return;
+		this.set({ overlay: {
+			kind: "modelProfile",
+			modelProfile: {
+				...this.state.overlay.modelProfile,
+				...patch
+			}
+		} });
+	}
+	/** Patch the open `/presets` overlay's sub-state; a no-op once it's closed. */
+	updateAgentPresets(patch) {
+		if (this.state.overlay.kind !== "agentPresets") return;
+		this.set({ overlay: {
+			kind: "agentPresets",
+			agentPresets: {
+				...this.state.overlay.agentPresets,
+				...patch
+			}
+		} });
+	}
+	/** Move the `/presets` overlay's list cursor. */
+	selectAgentPresetRow(index) {
+		this.updateAgentPresets({ selected: index });
+	}
+	/** Mark the `@`-mention file index as loading; a no-op once candidates are already present. */
+	setFileIndexLoading() {
+		if (this.state.fileIndex.candidates !== void 0) return;
+		this.set({ fileIndex: {
+			candidates: void 0,
+			loading: true
+		} });
+	}
+	/** Settle the `@`-mention file index once `loadFileIndex` resolves. */
+	setFileIndex(candidates) {
+		this.set({ fileIndex: {
+			candidates,
+			loading: false
+		} });
+	}
+	/** Record a newer npm-published version found by the startup update check; persists for the session (not cleared by `/clear`'s notice reset) until dismissed by a fresh check finding none. */
+	setUpdateHint(version) {
+		this.set({ updateHint: version });
+	}
+	set(partial) {
+		this.state = {
+			...this.state,
+			...partial
+		};
+		for (const listener of this.listeners) listener();
+	}
+};
+//#endregion
+//#region src/tui/logoArt.generated.ts
+/**
+* Generated by `node scripts/generate-logo.mjs` from
+* `assets/deepseek-128px.png` via chafa (half-block, 16x16, rgb color
+* space). Do not hand-edit — re-run the script after the source image
+* changes; requires `chafa` installed locally (e.g. `brew install chafa`).
+* @module @tomowang/dsh-tui/tui/logoArt.generated
+*/
+/** One entry per output row; each line carries embedded 24-bit ANSI SGR color codes. */
+const LOGO_HALF_BLOCK = [
+	"\x1B[0m                \x1B[0m",
+	"  \x1B[38;2;60;84;201m▄\x1B[38;2;76;106;253m▄▄▄▄\x1B[38;2;75;105;251;48;2;49;69;164m▄\x1B[0m   \x1B[38;2;75;105;251m▄\x1B[38;2;44;61;147m▄\x1B[0m  \x1B[38;2;58;81;193m▄\x1B[0m",
+	"\x1B[38;2;46;64;153m▄\x1B[38;2;76;106;253;48;2;69;96;231m▄\x1B[48;2;76;106;253m▄▄▄▄▄▄\x1B[48;2;69;96;231m▄\x1B[0m\x1B[38;2;71;99;238m▄\x1B[0m \x1B[7m\x1B[38;2;73;103;246m▄\x1B[0m\x1B[38;2;76;106;253;48;2;76;106;253m▄\x1B[38;2;75;105;252;48;2;73;102;245m▄\x1B[38;2;55;77;185;48;2;76;106;253m▄\x1B[0m\x1B[7m\x1B[38;2;52;73;175m▄\x1B[0m",
+	"\x1B[38;2;67;93;224;48;2;76;106;253m▌\x1B[0m  \x1B[7m\x1B[38;2;39;55;132m▄\x1B[38;2;69;96;231m▄\x1B[0m\x1B[38;2;48;67;160;48;2;76;106;253m▄\x1B[38;2;76;106;253m▄▄\x1B[38;2;69;96;230;48;2;48;67;161m▌\x1B[0m\x1B[7m\x1B[38;2;68;95;228m▄\x1B[0m\x1B[38;2;67;94;224;48;2;73;102;245m▄\x1B[38;2;76;106;253;48;2;48;67;160m▄\x1B[48;2;76;106;253m▄\x1B[0m\x1B[38;2;53;74;177m▌\x1B[0m  \x1B[0m",
+	"\x1B[38;2;40;57;136;48;2;75;105;252m▌\x1B[0m\x1B[38;2;69;96;230m▌\x1B[0m    \x1B[7m\x1B[38;2;45;63;151m▄\x1B[0m\x1B[38;2;61;86;206;48;2;76;106;253m▄\x1B[38;2;76;106;253m▄\x1B[0m\x1B[38;2;76;106;253m▄\x1B[48;2;41;58;139m▄\x1B[48;2;76;106;253m▄\x1B[38;2;73;103;246;48;2;44;62;148m▌\x1B[0m   \x1B[0m",
+	" \x1B[7m\x1B[38;2;75;104;250m▄\x1B[0m\x1B[38;2;76;106;253;48;2;40;56;135m▄\x1B[0m\x1B[38;2;43;61;146m▄\x1B[0m \x1B[7m\x1B[38;2;50;70;167m▌\x1B[0m\x1B[38;2;64;90;215m▄\x1B[0m \x1B[7m\x1B[38;2;73;102;244m▄\x1B[0m\x1B[38;2;74;103;247;48;2;76;106;253m▄\x1B[38;2;76;106;253m▄\x1B[38;2;68;96;229;48;2;39;55;132m▌\x1B[0m    \x1B[0m",
+	"   \x1B[7m\x1B[38;2;73;102;245m▄\x1B[38;2;74;103;248m▄\x1B[0m\x1B[38;2;53;74;178;48;2;75;104;250m▄\x1B[38;2;57;79;189;48;2;76;106;253m▄\x1B[38;2;50;71;169;48;2;74;103;247m▄\x1B[0m\x1B[7m\x1B[38;2;50;71;169m▄\x1B[38;2;46;64;154m▄\x1B[38;2;52;72;173m▄\x1B[38;2;58;82;196m▄\x1B[0m    \x1B[0m",
+	"                \x1B[0m"
+];
+//#endregion
+//#region src/tui/bannerText.ts
+/**
+* Pure text builder for the startup banner: a bordered box with the brand
+* logo on the left and session info on the right. Kept dependency-free (no
+* Ink/React) so it's trivial to reason about and test in isolation,
+* mirroring `render.ts`'s hand-rolled ANSI-aware formatting.
+* @module @tomowang/dsh-tui/tui/bannerText
+*/
+const ESC = "\x1B[";
+const bold$10 = (s) => `${ESC}1m${s}${ESC}0m`;
+const dim$1 = fg(theme.muted);
+const primary = fg(theme.primary);
+const ANSI_RE = /\x1b\[[0-9;?]*[a-zA-Z]/g;
+const visibleWidth$1 = (s) => s.replace(ANSI_RE, "").length;
+const padVisible = (s, width) => s + " ".repeat(Math.max(0, width - visibleWidth$1(s)));
+const LOGO_WIDTH = 16;
+const LOGO_MARGIN = 2;
+const LEFT_WIDTH = 20;
+const MIN_WIDTH = 56;
+const MAX_WIDTH = 96;
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+/** Pads `rows` with blank lines, split evenly top/bottom, to reach `height`. */
+function centerRows(rows, height) {
+	const pad = Math.max(0, height - rows.length);
+	const top = Math.floor(pad / 2);
+	const bottom = pad - top;
+	return [
+		...Array(top).fill(""),
+		...rows,
+		...Array(bottom).fill("")
+	];
+}
+function topBorder(title, total) {
+	const inner = total - 2;
+	const label = ` ${title} `;
+	const leftDashes = 3;
+	const rightDashes = Math.max(1, inner - leftDashes - label.length);
+	return `╭${"─".repeat(leftDashes)}${primary(label)}${"─".repeat(rightDashes)}╮`;
+}
+function buildLeftColumn() {
+	const margin = " ".repeat(LOGO_MARGIN);
+	return LOGO_HALF_BLOCK.map((line) => margin + padVisible(line, LOGO_WIDTH) + margin);
+}
+function buildRightColumn(content, width) {
+	return [
+		bold$10(primary("DeepSeek Harness")),
+		"",
+		dim$1(`${content.provider}/${content.model}`),
+		dim$1(truncate(content.cwd, width))
+	];
+}
+/**
+* Builds the full multi-line banner text, sized to the given terminal
+* width: title bar, then a fixed-width logo column beside a session-info
+* column (vertically centered against each other), then the bottom border.
+*/
+function buildBannerText(content, columns) {
+	const total = clamp(columns, MIN_WIDTH, MAX_WIDTH);
+	const inner = total - 2;
+	const top = topBorder(`dsh-tui v${content.version}`, total);
+	const bottom = `╰${"─".repeat(inner)}╯`;
+	const rightWidth = inner - LEFT_WIDTH - 1;
+	const left = buildLeftColumn();
+	const right = buildRightColumn(content, rightWidth);
+	const height = Math.max(left.length, right.length);
+	const leftRows = centerRows(left, height);
+	const rightRows = centerRows(right, height);
+	return [
+		top,
+		...leftRows.map((line, i) => `│${padVisible(line, LEFT_WIDTH)}│${padVisible(rightRows[i] ?? "", rightWidth)}│`),
+		bottom
+	].join("\n");
+}
+//#endregion
+//#region src/tui/statsFormat.ts
+/**
+* Compact token count: 517 / 12.2K / 517K / 1.2M (one decimal under three digits).
+* @param n - token count.
+* @returns display string.
+*/
+function formatTokens(n) {
+	const scaled = (v) => v >= 100 ? String(Math.round(v)) : String(Math.round(v * 10) / 10);
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${scaled(n / 1e3)}K`;
+	return `${scaled(n / 1e6)}M`;
+}
+/**
+* Compact duration: 45.2s under a minute, 2m42s from there on.
+* @param ms - duration in milliseconds.
+* @returns display string.
+*/
+function formatDuration(ms) {
+	const s = ms / 1e3;
+	if (s < 60) return `${Math.round(s * 10) / 10}s`;
+	const whole = Math.round(s);
+	return `${Math.floor(whole / 60)}m${whole % 60}s`;
+}
+/**
+* Compact throughput: one decimal under 10 tok/s, whole above.
+* @param tps - tokens per second.
+* @returns display string.
+*/
+function formatTokensPerSecond(tps) {
+	const clamped = Math.max(0, tps);
+	return clamped >= 10 ? String(Math.round(clamped)) : String(Math.round(clamped * 10) / 10);
+}
+/**
+* Sum the three disjoint prompt-side billing buckets.
+* @param usage - the session's token-usage projection value.
+* @returns billed input tokens.
+*/
+function billedInputTokens(usage) {
+	return usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+}
+/**
+* Cache-hit share of prompt-side input over the whole durable log.
+* @param usage - the session's token-usage projection value.
+* @returns rounded integer percent, or null when no input was billed.
+*/
+function cacheHitPercent(usage) {
+	const denominator = billedInputTokens(usage);
+	return denominator === 0 ? null : Math.round(usage.cacheReadTokens / denominator * 100);
+}
+/**
+* Build the pipe-separated stats line for the status bar, e.g.
+* `1 turns · 1 steps| LLM 4.3s| TTFT avg 1.1s · 131 tok/s| Cache hit 80%| Input 9.1K tok · Output 412 tok`.
+* A group with no data drops out whole; an empty return means nothing to show yet.
+* @param stats - whole-log turn/step counts and wall times, or `undefined` without the projection unit mounted.
+* @param usage - whole-log provider token usage, or `undefined` without the projection unit mounted.
+* @returns the joined line, or `''` when there is nothing to display.
+*/
+function buildStatsLine(stats, usage) {
+	const groups = [];
+	if (stats !== void 0 && stats.steps > 0) {
+		groups.push(`${stats.turns} turns · ${stats.steps} steps`);
+		const durations = [];
+		if (stats.llmMs > 0) durations.push(`LLM ${formatDuration(stats.llmMs)}`);
+		if (stats.toolMs > 0) durations.push(`Tool call ${formatDuration(stats.toolMs)}`);
+		if (durations.length > 0) groups.push(durations.join(" · "));
+		const speeds = [];
+		if (stats.ttftSteps > 0) speeds.push(`TTFT avg ${formatDuration(stats.ttftMs / stats.ttftSteps)}`);
+		if (stats.decodeMs > 0) speeds.push(`${formatTokensPerSecond(stats.decodeTokens / (stats.decodeMs / 1e3))} tok/s`);
+		if (speeds.length > 0) groups.push(speeds.join(" · "));
+	}
+	if (usage !== void 0 && (billedInputTokens(usage) > 0 || usage.outputTokens > 0)) {
+		const cacheHit = cacheHitPercent(usage);
+		if (cacheHit !== null) groups.push(`Cache hit ${cacheHit}%`);
+		groups.push(`Input ${formatTokens(billedInputTokens(usage))} tok · Output ${formatTokens(usage.outputTokens)} tok`);
+	}
+	return groups.join("| ");
+}
+/**
+* Derive occupancy from the newest pressure sample, or `null` while either
+* side (a usage sample, a known route capacity) hasn't arrived yet.
+* @param pressure - the session's context-pressure projection value.
+* @returns occupancy figures, or `null` when there is nothing to show yet.
+*/
+function contextOccupancy(pressure) {
+	const usedTokens = pressure?.projectedTokens ?? pressure?.pressureTokens;
+	if (usedTokens === void 0 || pressure?.contextWindow === void 0) return null;
+	return {
+		percent: Math.min(100, Math.round(usedTokens / pressure.contextWindow * 100)),
+		usedTokens,
+		contextWindow: pressure.contextWindow
+	};
+}
+/**
+* Build the always-on compact context-usage line, e.g. `Context 1% · ~8.1K / 1M tok`.
+* @param pressure - the session's context-pressure projection value.
+* @returns the display line, or `''` when there is nothing to show yet.
+*/
+function buildContextLine(pressure) {
+	const occupancy = contextOccupancy(pressure);
+	if (occupancy === null) return "";
+	return `Context ${occupancy.percent}% · ~${formatTokens(occupancy.usedTokens)} / ${formatTokens(occupancy.contextWindow)} tok`;
+}
+/**
+* Proportional breakdown rows for the `/context` overlay's bar. The three
+* heuristic figures are composition only — they do not sum to
+* `occupancy.usedTokens` — so segment widths are scaled to `occupancy.percent`
+* rather than treated as an independent total; see `ContextBreakdownProjection`'s doc comment.
+* @param occupancy - this session's occupancy figures, or `null` without a usage sample yet.
+* @param breakdown - the session's context-breakdown projection value.
+* @returns the three rows in System/Tools/Messages order, or `[]` when there is nothing to show yet.
+*/
+function contextBreakdownRows(occupancy, breakdown) {
+	if (occupancy === null || breakdown === void 0) return [];
+	const total = breakdown.systemTokens + breakdown.toolsTokens + breakdown.messageTokens;
+	if (total === 0) return [];
+	const scale = (tokens) => occupancy.percent * tokens / total;
+	return [
+		{
+			label: "System prompt",
+			tokens: breakdown.systemTokens,
+			width: scale(breakdown.systemTokens)
+		},
+		{
+			label: "Tools",
+			tokens: breakdown.toolsTokens,
+			width: scale(breakdown.toolsTokens)
+		},
+		{
+			label: "Messages",
+			tokens: breakdown.messageTokens,
+			width: scale(breakdown.messageTokens)
+		}
+	];
+}
+//#endregion
+//#region src/sessionId.ts
+/**
+* Session id prefix helpers shared between id generation/resolution
+* (`src/index.ts`) and display (`src/tui/StatusBar.tsx`). `session-` is the
+* de facto convention for top-level interactive sessions across the harness
+* (web portal, headless bundle), so ids keep the prefix on disk; only
+* user-facing text strips it.
+* @module @tomowang/dsh-tui/sessionId
+*/
+const SESSION_ID_PREFIX = "session-";
+/** Strip the `session-` prefix for display, if present. */
+function stripSessionIdPrefix(id) {
+	return id.startsWith(SESSION_ID_PREFIX) ? id.slice(8) : id;
+}
+//#endregion
+//#region src/tui/liveText.ts
+const dim = fg(theme.muted);
+const accent = fg(theme.accent);
+const warning$1 = fg(theme.warning);
+function buildStatusBarText(params) {
+	const { sessionId, provider, model, status, queuedCount, presetLabel, eventCount, spinnerChar } = params;
+	const queuedSuffix = queuedCount > 0 ? ` · ${queuedCount} queued` : "";
+	const presetSegment = presetLabel === void 0 ? "" : ` · ${presetLabel}`;
+	const spinnerPart = status === "running" ? spinnerChar : "";
+	return dim(`session ${stripSessionIdPrefix(sessionId)} · `) + accent(`${provider}/${model}`) + dim(`${presetSegment} · ${spinnerPart} ${status}${queuedSuffix} · ${eventCount} events`);
+}
+function previewOf(message) {
+	return truncate(message.content.filter((block) => block.type === "text").map((block) => block.text).join(""), 80);
+}
+function buildQueuedText(queued) {
+	if (queued.length === 0) return "";
+	return queued.map((message) => dim(`↳ queued: ${previewOf(message)}`)).join("\n");
+}
+const PERMISSION_LABELS = {
+	"read-only": "Read Only",
+	"workspace-write": "Workspace Write",
+	"danger-full-access": "Full Access",
+	custom: "Custom"
+};
+const PERMISSION_ICONS = {
+	"read-only": "⊘",
+	"workspace-write": "✎",
+	"danger-full-access": "‼",
+	custom: "⊛"
+};
+const PERMISSION_COLORS = {
+	"read-only": theme.info,
+	"workspace-write": theme.success,
+	"danger-full-access": theme.error,
+	custom: theme.muted
+};
+/**
+* Persistent low-key dock row nudging the reader to upgrade once the
+* startup registry check (`src/updateCheck.ts`) finds a newer published
+* version; renders nothing while unchecked or already current. Unlike
+* `notice`, this isn't cleared on the next input — it's meant to stay
+* visible for the rest of the session, mirroring how `gh`/`npm` surface an
+* available-update line.
+*/
+function buildUpdateHintText(currentVersion, latestVersion) {
+	if (latestVersion === void 0) return "";
+	return warning$1(`⬆ dsh-tui update available: v${currentVersion} → v${latestVersion}`) + dim(" (run `dsh plugin --profile tui add @tomowang/dsh-tui` to upgrade)");
+}
+function buildPermissionText(permission) {
+	if (permission === void 0) return "";
+	const icon = PERMISSION_ICONS[permission.current] ?? "•";
+	const label = PERMISSION_LABELS[permission.current] ?? permission.current;
+	return `${fg(PERMISSION_COLORS[permission.current] ?? theme.muted)(`${icon} ${label}`)}${dim(" (shift+tab to cycle)")}`;
+}
+/** Human label for one durable goal phase — the single source of truth shared by the `/goal` notice (`index.ts`) and this strip. */
+function goalPhaseLabel(phase) {
+	switch (phase) {
+		case "active": return "active";
+		case "paused": return "paused";
+		case "blocked": return "blocked";
+		case "complete": return "complete";
+	}
+}
+/** Phase color for the goal glyph + label; active reads green, paused amber, blocked coral. */
+const GOAL_PHASE_COLORS = {
+	active: theme.success,
+	paused: theme.warning,
+	blocked: theme.error
+};
+/** Long-objective cap for the goal strip, matching the queued-preview cap. */
+const GOAL_OBJECTIVE_LIMIT = 80;
+/**
+* The goal strip docked above the composer — the terminal GoalBar. Mirrors
+* the web portal's rendering rule exactly: loading (`undefined` — projection
+* unit not composed), absent/cleared (`null`), and complete goals render
+* nothing; a present goal shows a goal glyph, its phase label, and the
+* truncated objective, with the blocker explanation appended for a blocked
+* goal (the portal shows it as a hover tooltip, which a terminal cannot).
+* Mutations live on the `/goal` command, not on the strip.
+*/
+/**
+* Terminal window/tab title: `<session title> — dsh-tui` once the optional
+* `dsh-session-title` service has accepted one for this session, or just
+* `dsh-tui` before that (loading) or without the service composed —
+* mirroring the harness's own `<session title> — <configured title>` OSC 0
+* convention. Plain text, never ANSI-colored: an OSC 0 title string is
+* displayed verbatim by the terminal chrome, not interpreted as SGR.
+*/
+function buildTerminalTitle(title) {
+	return title === null || title === void 0 ? "dsh-tui" : `${title} — dsh-tui`;
+}
+function buildGoalBarText(goal) {
+	if (goal === void 0 || goal === null || goal.goal.phase === "complete") return "";
+	const snapshot = goal.goal;
+	const color = fg(GOAL_PHASE_COLORS[snapshot.phase] ?? theme.muted);
+	const label = goalPhaseLabel(snapshot.phase);
+	const objective = truncate(snapshot.objective, GOAL_OBJECTIVE_LIMIT);
+	const blocker = snapshot.phase === "blocked" && snapshot.blockedReason !== void 0 ? dim(` · ${snapshot.blockedReason.code}: ${truncate(snapshot.blockedReason.message, GOAL_OBJECTIVE_LIMIT)}`) : "";
+	return `${color(`🎯 ${label}`)} · ${objective}${blocker}`;
+}
+//#endregion
+//#region src/tui/text.ts
+/**
+* Thin pi-tui `Component` wrappers around already-ANSI-styled strings.
+* `render.ts`/`markdown.ts`/`bannerText.ts` produce terminal-ready text
+* (colors, bold, links baked in via raw SGR/OSC sequences) — these wrappers
+* exist only to satisfy pi-tui's `Component` interface (`render(width)`,
+* `invalidate()`) without re-styling that text, mirroring how the old Ink
+* `<Text>` usage printed these strings unmodified.
+* @module @tomowang/dsh-tui/tui/text
+*/
+/** Left/right margin applied to main-panel message content, so it doesn't sit flush against either terminal edge. */
+const TRANSCRIPT_MARGIN = 2;
+const TRANSCRIPT_INDENT = " ".repeat(TRANSCRIPT_MARGIN);
+/** Word-wraps already-ANSI-styled text to fit within `width` minus the transcript's left/right margin, then indents every resulting line. Used by the live-region rows (streaming text, pending tool calls, live shell output), which rebuild their string from the store on every render — see `createTranscriptLine` for the settled, append-only transcript rows, which get the same margin from pi-tui's own `Text` instead so repeated renders can be cached. */
+function padTranscriptText(text, width) {
+	if (text === "") return [];
+	return wrapTextWithAnsi(text, Math.max(1, width - TRANSCRIPT_MARGIN * 2)).map((line) => `${TRANSCRIPT_INDENT}${line}`);
+}
+/** A settled transcript line: pi-tui's `Text` component wraps to width and applies the same left/right margin as `padTranscriptText`, but — unlike our own `Component`s here — caches its wrapped output keyed on `(text, width)`, so appended transcript history isn't re-wrapped on every unrelated store update (e.g. a streaming token delta) the way a hand-rolled render() would. Content is fixed at construction — transcript rows are append-only and never mutated after being added. */
+function createTranscriptLine(text) {
+	return new Text(text, TRANSCRIPT_MARGIN, 0);
+}
+/** A block of pre-styled text rebuilt from the current viewport width on every render — for content (the banner) whose own layout is width-responsive. */
+var DynamicText = class {
+	build;
+	constructor(build) {
+		this.build = build;
+	}
+	invalidate() {}
+	render(width) {
+		const text = this.build(width);
+		return text === "" ? [] : text.split("\n");
+	}
+};
+//#endregion
+//#region src/tui/commands.ts
+const SLASH_COMMANDS = [
+	{
+		command: "/help",
+		description: "Show help and available commands"
+	},
+	{
+		command: "/model",
+		description: "Manage LLM provider profiles"
+	},
+	{
+		command: "/trajectory",
+		description: "Browse the turn/step event ledger"
+	},
+	{
+		command: "/tools",
+		description: "Browse and expand tool cards"
+	},
+	{
+		command: "/context",
+		description: "Show context window usage"
+	},
+	{
+		command: "/plugins",
+		description: "Show the loaded plugin tree"
+	},
+	{
+		command: "/presets",
+		description: "Show and switch agent presets (only while the session is blank)"
+	},
+	{
+		command: "/goal",
+		description: "Set or view the long-running goal: /goal <objective> | clear | edit <objective> | pause | resume"
+	},
+	{
+		command: "/plan",
+		description: "Enter plan mode, optionally with a message; /plan off to leave"
+	},
+	{
+		command: "/compact",
+		description: "Summarize and compact session history"
+	},
+	{
+		command: "/clear",
+		description: "Clear the screen and start a new session"
+	},
+	{
+		command: "/exit",
+		description: "Exit dsh-tui"
+	},
+	{
+		command: "/quit",
+		description: "Exit dsh-tui"
+	}
+];
+Math.max(...SLASH_COMMANDS.map((c) => c.command.length));
+function matchSlashCommands(query) {
+	return SLASH_COMMANDS.filter((c) => c.command.startsWith(query));
+}
+function commandQuery(value) {
+	const query = value.trim();
+	const isCommandMode = value.startsWith("/") && !/\s/.test(query);
+	return {
+		isCommandMode,
+		matches: isCommandMode ? matchSlashCommands(query) : []
+	};
+}
+/** `/plan` on its own, or followed by whitespace — matches the harness's own `/plan [message]`/`/plan off` syntax. */
+const PLAN_COMMAND = /^\/plan(?:$|\s)/u;
+/**
+* `/plan`'s argument takes free text (a message, or the literal `off`), so unlike every other
+* command it can't route through {@link matchSlashCommands}'s whitespace-free matching.
+* @param text - Raw submitted line.
+* @returns The trimmed argument text, or `undefined` when `text` isn't a `/plan` invocation.
+*/
+function parsePlanCommand(text) {
+	const trimmed = text.trim();
+	if (!PLAN_COMMAND.test(trimmed)) return void 0;
+	return trimmed.slice(5).trim();
+}
+/** `/goal` on its own, or followed by whitespace — its objective is free text, so it shares `/plan`'s parse-ahead shape. */
+const GOAL_COMMAND = /^\/goal(?:$|\s)/u;
+/**
+* Parse a `/goal` invocation exactly the way `@deepseek-ai/dsh-command-goal`'s own
+* `parseGoalCommand` does — bare `/goal` shows the current goal, the control words
+* `clear`/`pause`/`resume` (case-insensitive) mutate it, `edit <objective>` replaces
+* the objective (bare `edit` is an error), and any other text is a create objective.
+* @param text - Raw submitted line.
+* @returns The parsed command, or `undefined` when `text` isn't a `/goal` invocation.
+*/
+function parseGoalCommand(text) {
+	const trimmed = text.trim();
+	if (!GOAL_COMMAND.test(trimmed)) return void 0;
+	const input = trimmed.slice(5).trim();
+	if (input.length === 0) return { kind: "show" };
+	const control = input.toLowerCase();
+	if (control === "clear") return { kind: "clear" };
+	if (control === "pause") return { kind: "pause" };
+	if (control === "resume") return { kind: "resume" };
+	if (control === "edit") return { kind: "invalid-edit" };
+	if (/^edit(?=\s)/iu.test(input)) return {
+		kind: "edit",
+		objective: input.slice(4).trim()
+	};
+	return {
+		kind: "create",
+		objective: input
+	};
+}
+function runSlashCommand(command, actions) {
+	switch (command) {
+		case "/help":
+			actions.help();
+			return;
+		case "/exit":
+		case "/quit":
+			actions.shutdown();
+			return;
+		case "/clear":
+			actions.clear();
+			return;
+		case "/model":
+			actions.openModelProfile();
+			return;
+		case "/trajectory":
+			actions.openTrajectory();
+			return;
+		case "/tools":
+			actions.openToolCards();
+			return;
+		case "/context":
+			actions.openContext();
+			return;
+		case "/plugins":
+			actions.openPlugins();
+			return;
+		case "/presets":
+			actions.openAgentPresets();
+			return;
+		case "/compact":
+			actions.compact();
+			return;
+	}
+}
+//#endregion
+//#region src/tui/piTheme.ts
+const bold$9 = (s) => `\x1b[1m${s}\x1b[0m`;
+const selectListTheme = {
+	selectedPrefix: fg(theme.primary),
+	selectedText: (s) => bold$9(fg(theme.primary)(s)),
+	description: fg(theme.muted),
+	scrollInfo: fg(theme.muted),
+	noMatch: fg(theme.muted)
+};
+const editorTheme = {
+	borderColor: fg(theme.primary),
+	selectList: selectListTheme
+};
+const shellModeEditorBorderColor = fg(theme.warning);
+const NOT_MENTION = {
+	isMentionMode: false,
+	query: "",
+	start: -1
+};
+/**
+* Find the `@`-mention token, if any, ending at `cursor`.
+* @param value - the full prompt buffer.
+* @param cursor - the buffer offset the reader is currently editing at.
+* @returns the open mention's query/span, or `isMentionMode: false` outside one.
+*/
+function mentionQuery(value, cursor) {
+	let i = cursor;
+	while (i > 0 && !/\s/.test(value[i - 1])) i--;
+	if (i === cursor || value[i] !== "@") return NOT_MENTION;
+	const before = value[i - 1];
+	if (before !== void 0 && !/\s/.test(before)) return NOT_MENTION;
+	return {
+		isMentionMode: true,
+		query: value.slice(i + 1, cursor),
+		start: i
+	};
+}
+/**
+* Filter and rank file candidates for a `@`-mention query.
+* @param candidates - the full file index, repo-relative paths.
+* @param query - text typed after `@` (case-insensitive substring match).
+* @param limit - max rows returned.
+* @returns matches ranked by path-prefix, then basename-prefix, then path length.
+*/
+function matchFileCandidates(candidates, query, limit = 10) {
+	const needle = query.toLowerCase();
+	const matches = candidates.filter((path) => path.toLowerCase().includes(needle));
+	matches.sort((a, b) => rank(a, needle) - rank(b, needle) || a.length - b.length);
+	return matches.slice(0, limit);
+}
+function rank(path, needle) {
+	const lower = path.toLowerCase();
+	if (lower.startsWith(needle)) return 0;
+	if (lower.slice(lower.lastIndexOf("/") + 1).startsWith(needle)) return 1;
+	return 2;
+}
+//#endregion
+//#region src/tui/promptAutocomplete.ts
+function offsetToLineCol(lines, offset) {
+	let remaining = offset;
+	for (let line = 0; line < lines.length; line++) {
+		const len = lines[line].length;
+		if (remaining <= len) return {
+			line,
+			col: remaining
+		};
+		remaining -= len + 1;
+	}
+	const lastLine = Math.max(0, lines.length - 1);
+	return {
+		line: lastLine,
+		col: lines[lastLine]?.length ?? 0
+	};
+}
+function lineColToOffset(lines, line, col) {
+	let offset = 0;
+	for (let i = 0; i < line; i++) offset += lines[i].length + 1;
+	return offset + col;
+}
+function splitWithCursor(text, offset) {
+	const lines = text.split("\n");
+	const { line, col } = offsetToLineCol(lines, offset);
+	return {
+		lines,
+		cursorLine: line,
+		cursorCol: col
+	};
+}
+var PromptAutocompleteProvider = class {
+	getFileCandidates;
+	triggerCharacters = ["/", "@"];
+	constructor(getFileCandidates) {
+		this.getFileCandidates = getFileCandidates;
+	}
+	async getSuggestions(lines, cursorLine, cursorCol, { signal }) {
+		const value = lines.join("\n");
+		const offset = lineColToOffset(lines, cursorLine, cursorCol);
+		const { isCommandMode, matches } = commandQuery(value);
+		if (isCommandMode) {
+			if (matches.length === 0) return null;
+			return {
+				items: matches.map((c) => ({
+					value: c.command,
+					label: c.command,
+					description: c.description
+				})),
+				prefix: value.trim()
+			};
+		}
+		const mention = mentionQuery(value, offset);
+		if (!mention.isMentionMode) return null;
+		const candidates = await this.getFileCandidates();
+		if (signal.aborted) return null;
+		const paths = matchFileCandidates(candidates, mention.query);
+		if (paths.length === 0) return null;
+		return {
+			items: paths.map((path) => ({
+				value: path,
+				label: path
+			})),
+			prefix: mention.query
+		};
+	}
+	applyCompletion(lines, cursorLine, cursorCol, item, _prefix) {
+		const value = lines.join("\n");
+		const offset = lineColToOffset(lines, cursorLine, cursorCol);
+		const { isCommandMode } = commandQuery(value);
+		if (isCommandMode) return splitWithCursor(item.value, item.value.length);
+		const mention = mentionQuery(value, offset);
+		if (mention.isMentionMode) {
+			const start = mention.start + 1;
+			const end = start + mention.query.length;
+			const inserted = `${item.value} `;
+			return splitWithCursor(value.slice(0, start) + inserted + value.slice(end), start + inserted.length);
+		}
+		return {
+			lines,
+			cursorLine,
+			cursorCol
+		};
+	}
+	shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+		return mentionQuery(lines.join("\n"), lineColToOffset(lines, cursorLine, cursorCol)).isMentionMode;
+	}
+};
+//#endregion
+//#region src/tui/CustomEditor.ts
+const EXIT_ARM_TIMEOUT_MS = 2e3;
+const armedHint = fg(theme.muted);
+const shellModeHint = fg(theme.warning);
+var CustomEditor = class extends Editor {
+	actions;
+	deps;
+	shellMode = false;
+	armedKey;
+	armTimer;
+	constructor(tui, actions, deps) {
+		super(tui, editorTheme, {
+			paddingX: 2,
+			autocompleteMaxVisible: 20
+		});
+		this.actions = actions;
+		this.deps = deps;
+		this.setAutocompleteProvider(new PromptAutocompleteProvider(deps.getFileCandidates));
+		this.onSubmit = (text) => this.handleSubmit(text);
+		for (const line of deps.history.slice(-100)) this.addToHistory(line);
+	}
+	armOrConfirmExit(key) {
+		if (this.armedKey === key) {
+			if (this.armTimer !== void 0) clearTimeout(this.armTimer);
+			this.armedKey = void 0;
+			this.actions.shutdown();
+			return;
+		}
+		if (this.armTimer !== void 0) clearTimeout(this.armTimer);
+		this.armedKey = key;
+		this.tui.requestRender();
+		this.armTimer = setTimeout(() => {
+			this.armTimer = void 0;
+			this.armedKey = void 0;
+			this.tui.requestRender();
+		}, EXIT_ARM_TIMEOUT_MS);
+	}
+	clearArm() {
+		if (this.armTimer !== void 0) clearTimeout(this.armTimer);
+		this.armTimer = void 0;
+		this.armedKey = void 0;
+	}
+	setShellMode(enabled) {
+		this.shellMode = enabled;
+		this.borderColor = enabled ? shellModeEditorBorderColor : editorTheme.borderColor;
+	}
+	handleSubmit(text) {
+		const trimmed = text.trim();
+		const shellMode = this.shellMode;
+		this.setShellMode(false);
+		if (trimmed === "") return;
+		if (this.deps.history.at(-1) !== trimmed) {
+			this.deps.history.push(trimmed);
+			this.actions.recordHistory(trimmed);
+		}
+		this.addToHistory(trimmed);
+		if (shellMode) {
+			this.actions.runShell(trimmed);
+			return;
+		}
+		const planArgs = parsePlanCommand(trimmed);
+		if (planArgs !== void 0) {
+			this.actions.plan(planArgs);
+			return;
+		}
+		const goalCommand = parseGoalCommand(trimmed);
+		if (goalCommand !== void 0) {
+			this.actions.goal(goalCommand);
+			return;
+		}
+		const matches = trimmed.startsWith("/") && !/\s/.test(trimmed) ? matchSlashCommands(trimmed) : [];
+		if (matches.length > 0) {
+			runSlashCommand(matches[0].command, this.actions);
+			return;
+		}
+		this.actions.send(trimmed);
+	}
+	handleInput(data) {
+		if (matchesKey(data, Key.ctrl("o"))) {
+			this.actions.openToolCards();
+			return;
+		}
+		if (!this.shellMode && data === "!" && this.getText() === "") {
+			this.setShellMode(true);
+			this.tui.requestRender();
+			return;
+		}
+		if (this.shellMode && (matchesKey(data, Key.escape) || matchesKey(data, Key.backspace) && this.getText() === "")) {
+			this.setShellMode(false);
+			this.tui.requestRender();
+			return;
+		}
+		if (matchesKey(data, "shift+tab")) {
+			this.actions.cyclePermission();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("c"))) {
+			if (this.deps.getStatus() === "running") {
+				this.actions.cancel();
+				return;
+			}
+			if (this.getText() !== "") {
+				this.setText("");
+				this.setShellMode(false);
+				this.clearArm();
+				this.tui.requestRender();
+				return;
+			}
+			this.armOrConfirmExit("c");
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("d"))) {
+			if (this.deps.getStatus() === "running") return;
+			if (this.getText() !== "") {
+				super.handleInput(data);
+				return;
+			}
+			this.armOrConfirmExit("d");
+			return;
+		}
+		super.handleInput(data);
+	}
+	render(width) {
+		const hints = [];
+		if (this.armedKey !== void 0) hints.push(armedHint(`Press Ctrl+${this.armedKey.toUpperCase()} again to exit`));
+		if (this.shellMode) hints.push(shellModeHint("! shell mode — Enter runs the command, Esc/Backspace exits"));
+		return [...hints, ...this.withPromptPrefix(super.render(width), width)];
+	}
+	/**
+	* Splices a `'› '`/`'! '` prompt marker into the editor box's first
+	* content row (index 1 — index 0 is always the top border), replacing
+	* that row's leading `paddingX` spaces. Skipped below `paddingX: 2`'s
+	* width-clamped floor (mirrors `Editor.render`'s own `maxPadding` clamp)
+	* rather than risk eating actual text in a pathologically narrow terminal.
+	*/
+	withPromptPrefix(lines, width) {
+		if (lines.length < 2) return lines;
+		if (Math.max(0, Math.floor((width - 1) / 2)) < 2) return lines;
+		const prefix = this.borderColor(this.shellMode ? "! " : "› ");
+		const next = [...lines];
+		next[1] = prefix + next[1].slice(2);
+		return next;
+	}
+};
+//#endregion
+//#region src/tui/Spinner.ts
+const FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const INTERVAL_MS = 80;
+var Spinner = class {
+	tui;
+	frame = 0;
+	timer;
+	constructor(tui) {
+		this.tui = tui;
+	}
+	current() {
+		return FRAMES[this.frame];
+	}
+	start() {
+		if (this.timer !== void 0) return;
+		this.timer = setInterval(() => {
+			this.frame = (this.frame + 1) % FRAMES.length;
+			this.tui.requestRender();
+		}, INTERVAL_MS);
+	}
+	stop() {
+		if (this.timer === void 0) return;
+		clearInterval(this.timer);
+		this.timer = void 0;
+	}
+};
+//#endregion
+//#region src/tui/miniTextField.ts
+/**
+* A tiny hand-rolled single-line text buffer (value + cursor, insert/
+* backspace/delete/left/right/home/end) shared by the handful of overlays
+* that need one embedded field inside otherwise-custom keyboard handling
+* (`QuestionOverlay`'s free-text answer, `TrajectoryOverlay`'s filter,
+* `ProviderForm`'s fields, `ModelListEditor`'s add-id field) — replacing
+* `ink-text-input` without wrestling with pi-tui's focus model, which only
+* tracks one focused `Component` at a time and has no built-in way to
+* delegate keystrokes to a field nested inside a larger custom overlay.
+* @module @tomowang/dsh-tui/tui/miniTextField
+*/
+function emptyMiniTextField(value = "") {
+	return {
+		value,
+		cursor: value.length
+	};
+}
+/** Apply one keystroke, or return `undefined` if this field doesn't handle it (so the caller can fall through to its own bindings, e.g. Enter/Escape/Tab). */
+function miniTextFieldInput(state, data) {
+	if (matchesKey(data, Key.left)) return {
+		...state,
+		cursor: Math.max(0, state.cursor - 1)
+	};
+	if (matchesKey(data, Key.right)) return {
+		...state,
+		cursor: Math.min(state.value.length, state.cursor + 1)
+	};
+	if (matchesKey(data, Key.home) || matchesKey(data, Key.ctrl("a"))) return {
+		...state,
+		cursor: 0
+	};
+	if (matchesKey(data, Key.end) || matchesKey(data, Key.ctrl("e"))) return {
+		...state,
+		cursor: state.value.length
+	};
+	if (matchesKey(data, Key.backspace)) {
+		if (state.cursor === 0) return state;
+		return {
+			value: state.value.slice(0, state.cursor - 1) + state.value.slice(state.cursor),
+			cursor: state.cursor - 1
+		};
+	}
+	if (matchesKey(data, Key.delete)) {
+		if (state.cursor >= state.value.length) return state;
+		return {
+			value: state.value.slice(0, state.cursor) + state.value.slice(state.cursor + 1),
+			cursor: state.cursor
+		};
+	}
+	if (data.length > 0 && !data.startsWith("\x1B") && data !== "\r" && data !== "\n" && data !== "	") return {
+		value: state.value.slice(0, state.cursor) + data + state.value.slice(state.cursor),
+		cursor: state.cursor + data.length
+	};
+}
+/** Render the field's text, optionally with an inverse-video cursor block at the cursor position. */
+function renderMiniTextField(state, cursorVisible, mask) {
+	const display = mask === void 0 ? state.value : mask.repeat(state.value.length);
+	if (!cursorVisible) return display;
+	return `${display.slice(0, state.cursor)}\x1b[7m${display[state.cursor] ?? " "}\x1b[0m${display.slice(state.cursor + 1)}`;
+}
+//#endregion
+//#region src/tui/modelProfile/ModelProfileOverlay.ts
+const bold$8 = (s) => `\x1b[1m${s}\x1b[0m`;
+const secondary$8 = fg(theme.secondary);
+const muted$9 = fg(theme.muted);
+const errorColor$4 = fg(theme.error);
+const invert$4 = (s) => `\x1b[7m${s}\x1b[0m`;
+var ModelProfileOverlay = class {
+	store;
+	actions;
+	confirmDelete;
+	formKeySeen = -1;
+	route = emptyMiniTextField();
+	displayName = emptyMiniTextField();
+	api = emptyMiniTextField();
+	baseURL = emptyMiniTextField();
+	apiKeyDraft = emptyMiniTextField();
+	models = [];
+	showModels = false;
+	focused = 0;
+	modelDraftId = emptyMiniTextField();
+	modelSelected = 0;
+	modelInputFocused = false;
+	constructor(store, actions) {
+		this.store = store;
+		this.actions = actions;
+	}
+	invalidate() {}
+	textFields(draft) {
+		return draft.isNew ? [
+			"route",
+			"displayName",
+			"api",
+			"baseURL",
+			"apiKey"
+		] : [
+			"displayName",
+			"api",
+			"baseURL",
+			"apiKey"
+		];
+	}
+	/** Reinitialize form-local state from the store's draft when `formKey` changes — the equivalent of the old `key={formKey}` remount. */
+	syncFormState(mp) {
+		if (mp.view !== "form" || mp.draft === void 0) return void 0;
+		const draft = mp.draft;
+		if (mp.formKey !== this.formKeySeen) {
+			this.formKeySeen = mp.formKey;
+			this.route = emptyMiniTextField(draft.route);
+			this.displayName = emptyMiniTextField(draft.displayName);
+			this.api = emptyMiniTextField(draft.api);
+			this.baseURL = emptyMiniTextField(draft.baseURL);
+			this.apiKeyDraft = emptyMiniTextField("");
+			this.models = [...draft.models];
+			this.showModels = false;
+			this.focused = 0;
+			this.modelDraftId = emptyMiniTextField();
+			this.modelSelected = 0;
+			this.modelInputFocused = false;
+		}
+		return draft;
+	}
+	buildDraft(draft) {
+		return {
+			...draft,
+			route: draft.isNew ? this.route.value.trim() : draft.route,
+			displayName: this.displayName.value,
+			api: this.api.value,
+			baseURL: this.baseURL.value,
+			apiKeyDraft: this.apiKeyDraft.value,
+			models: this.models
+		};
+	}
+	render(_width) {
+		const overlay = this.store.getSnapshot().overlay;
+		if (overlay.kind !== "modelProfile") return [];
+		const mp = overlay.modelProfile;
+		const draft = this.syncFormState(mp);
+		if (draft !== void 0) return this.showModels ? this.renderModelListEditor(mp) : this.renderForm(draft, mp);
+		return this.renderList(mp);
+	}
+	renderList(mp) {
+		const { providers, selected, busy, error } = mp;
+		const lines = [bold$8(secondary$8("Model providers"))];
+		if (error !== void 0) lines.push(errorColor$4(error));
+		if (busy && providers === void 0) lines.push(muted$9("Loading…"));
+		providers?.forEach((row, index) => {
+			const marker = row.configured ? "● " : "○ ";
+			const active = row.live ? " (active)" : "";
+			const noKey = row.apiKeyConfigured ? "" : " [no api key]";
+			const confirm = this.confirmDelete === index ? " — press d again to delete" : "";
+			const text = `${index === selected ? "› " : "  "}${marker}${row.displayName}${active}${noKey}${confirm}`;
+			lines.push(index === selected ? invert$4(text) : text);
+		});
+		if (providers?.length === 0) lines.push(muted$9("No providers configured yet — press a to add one."));
+		lines.push(muted$9("↑↓ select · enter edit · a add · d delete · s set active model · esc close"));
+		return lines;
+	}
+	handleListInput(data, mp) {
+		const { providers, selected } = mp;
+		if (matchesKey(data, Key.escape)) {
+			this.actions.closeModelProfile();
+			return;
+		}
+		if (providers === void 0 || providers.length === 0) {
+			if (data === "a") this.actions.createProvider();
+			return;
+		}
+		if (matchesKey(data, Key.up)) {
+			this.confirmDelete = void 0;
+			this.actions.selectProvider(Math.max(0, selected - 1));
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.confirmDelete = void 0;
+			this.actions.selectProvider(Math.min(providers.length - 1, selected + 1));
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			this.actions.editProvider(providers[selected].route);
+			return;
+		}
+		if (data === "a") {
+			this.actions.createProvider();
+			return;
+		}
+		if (data === "s") {
+			const row = providers[selected];
+			const model = row.models[0];
+			if (model !== void 0) this.actions.setActiveModel(row.route, model.id);
+			return;
+		}
+		if (data === "d") {
+			if (this.confirmDelete === selected) {
+				this.confirmDelete = void 0;
+				this.actions.deleteProvider(providers[selected]);
+			} else this.confirmDelete = selected;
+			return;
+		}
+		this.confirmDelete = void 0;
+	}
+	renderForm(draft, mp) {
+		const textFields = this.textFields(draft);
+		const modelsRow = textFields.length;
+		const saveRow = textFields.length + 1;
+		const fieldState = {
+			route: this.route,
+			displayName: this.displayName,
+			api: this.api,
+			baseURL: this.baseURL,
+			apiKey: this.apiKeyDraft
+		};
+		const labels = {
+			route: "Route",
+			displayName: "Name",
+			api: "Protocol",
+			baseURL: "Base URL",
+			apiKey: draft.apiKeyConfigured ? "API key (set — leave blank to keep)" : "API key"
+		};
+		const lines = [bold$8(secondary$8(draft.isNew ? "Add provider" : `Edit ${draft.displayName || draft.route}`))];
+		if (mp.error !== void 0) lines.push(errorColor$4(mp.error));
+		textFields.forEach((field, index) => {
+			const isFocused = this.focused === index;
+			const mask = field === "apiKey" ? "*" : void 0;
+			const prefix = `${isFocused ? "› " : "  "}${labels[field]}: `;
+			lines.push(`${prefix}${renderMiniTextField(fieldState[field], isFocused, mask)}`);
+		});
+		const modelsText = `${this.focused === modelsRow ? "› " : "  "}Models (${this.models.length}) — enter to edit`;
+		lines.push(this.focused === modelsRow ? invert$4(modelsText) : modelsText);
+		const saveText = `${this.focused === saveRow ? "› " : "  "}${mp.busy ? "Saving…" : "Save"}`;
+		lines.push(this.focused === saveRow ? invert$4(saveText) : saveText);
+		lines.push(muted$9("tab/shift+tab move · enter confirm field / activate row · esc cancel"));
+		return lines;
+	}
+	handleFormInput(data, draft) {
+		const textFields = this.textFields(draft);
+		const modelsRow = textFields.length;
+		const saveRow = textFields.length + 1;
+		const rowCount = textFields.length + 2;
+		if (matchesKey(data, Key.escape)) {
+			this.actions.backToProviderList();
+			return;
+		}
+		if (matchesKey(data, "shift+tab")) {
+			this.focused = (this.focused - 1 + rowCount) % rowCount;
+			return;
+		}
+		if (matchesKey(data, Key.tab)) {
+			this.focused = (this.focused + 1) % rowCount;
+			return;
+		}
+		if (matchesKey(data, Key.enter) && this.focused === modelsRow) {
+			this.showModels = true;
+			return;
+		}
+		if (matchesKey(data, Key.enter) && this.focused === saveRow) {
+			this.actions.saveProvider(this.buildDraft(draft));
+			return;
+		}
+		if (matchesKey(data, Key.enter) && this.focused < textFields.length) {
+			this.focused = (this.focused + 1) % rowCount;
+			return;
+		}
+		if (this.focused < textFields.length) {
+			const field = textFields[this.focused];
+			const next = miniTextFieldInput({
+				route: this.route,
+				displayName: this.displayName,
+				api: this.api,
+				baseURL: this.baseURL,
+				apiKey: this.apiKeyDraft
+			}[field], data);
+			if (next === void 0) return;
+			if (field === "route") this.route = next;
+			else if (field === "displayName") this.displayName = next;
+			else if (field === "api") this.api = next;
+			else if (field === "baseURL") this.baseURL = next;
+			else this.apiKeyDraft = next;
+		}
+	}
+	renderModelListEditor(mp) {
+		const lines = [bold$8(secondary$8("Models"))];
+		this.models.forEach((model, index) => {
+			const isSelected = !this.modelInputFocused && index === this.modelSelected;
+			const text = `${isSelected ? "› " : "  "}${model.id}${model.name === void 0 ? "" : ` — ${model.name}`}`;
+			lines.push(isSelected ? invert$4(text) : text);
+		});
+		if (this.models.length === 0) lines.push(muted$9("No models yet."));
+		lines.push(`${this.modelInputFocused ? "› " : "  "}Add id: ${renderMiniTextField(this.modelDraftId, this.modelInputFocused)}`);
+		if (mp.busy) lines.push(muted$9("Discovering…"));
+		if (mp.discovered !== void 0) if (mp.discovered.length === 0) lines.push(muted$9("No models discovered."));
+		else {
+			lines.push(muted$9("Discovered — tab to the id field and type one to adopt it:"));
+			for (const model of mp.discovered) lines.push(muted$9(`  ${model.id}${model.name === void 0 ? "" : ` — ${model.name}`}`));
+		}
+		lines.push(muted$9("tab toggle list/input · ↑↓ select · x remove · g discover · esc back"));
+		return lines;
+	}
+	addModel(id) {
+		const trimmed = id.trim();
+		if (trimmed === "" || this.models.some((model) => model.id === trimmed)) return;
+		const overlay = this.store.getSnapshot().overlay;
+		const found = (overlay.kind === "modelProfile" ? overlay.modelProfile.discovered : void 0)?.find((model) => model.id === trimmed);
+		this.models = [...this.models, found === void 0 ? { id: trimmed } : { ...found }];
+		this.modelDraftId = emptyMiniTextField();
+	}
+	handleModelListEditorInput(data, draft) {
+		if (matchesKey(data, Key.escape)) {
+			this.showModels = false;
+			return;
+		}
+		if (matchesKey(data, Key.tab)) {
+			this.modelInputFocused = !this.modelInputFocused;
+			return;
+		}
+		if (this.modelInputFocused) {
+			if (matchesKey(data, Key.enter)) {
+				this.addModel(this.modelDraftId.value);
+				return;
+			}
+			const next = miniTextFieldInput(this.modelDraftId, data);
+			if (next !== void 0) this.modelDraftId = next;
+			return;
+		}
+		if (data === "g") {
+			this.actions.discoverModelsForDraft(this.buildDraft(draft));
+			return;
+		}
+		if (this.models.length === 0) return;
+		if (matchesKey(data, Key.up)) {
+			this.modelSelected = Math.max(0, this.modelSelected - 1);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.modelSelected = Math.min(this.models.length - 1, this.modelSelected + 1);
+			return;
+		}
+		if (data === "x") {
+			this.models = this.models.filter((_, index) => index !== this.modelSelected);
+			this.modelSelected = Math.max(0, Math.min(this.modelSelected, this.models.length - 1));
+		}
+	}
+	handleInput(data) {
+		const overlay = this.store.getSnapshot().overlay;
+		if (overlay.kind !== "modelProfile") return;
+		const mp = overlay.modelProfile;
+		const draft = this.syncFormState(mp);
+		if (draft !== void 0) {
+			if (this.showModels) this.handleModelListEditorInput(data, draft);
+			else this.handleFormInput(data, draft);
+			return;
+		}
+		this.handleListInput(data, mp);
+	}
+};
+//#endregion
+//#region src/tui/trajectory/layout.ts
+const LABEL_LIMIT = 100;
+function prettyJson(raw) {
+	try {
+		return JSON.stringify(JSON.parse(raw), null, 2);
+	} catch {
+		return raw;
+	}
+}
+/** The row's kind tag (USER/CONTEXT) already names the source, so the label itself carries no redundant prefix. */
+function userLabel(data) {
+	const { source } = data;
+	if (source.kind === "user") return truncate(textOf(data.content), LABEL_LIMIT);
+	if (source.kind === "plugin") {
+		const summary = source.form === "notice" ? source.summary : void 0;
+		return `${source.plugin}${summary === void 0 ? "" : ` · ${summary}`}`;
+	}
+	if (source.kind === "goal") return `goal · round ${source.round}`;
+	return source.kind;
+}
+/**
+* Fold the session log into ledger rows, in seq order.
+* @param events - the session's durable event log (replay + live, already seq-deduped by `TuiStore`).
+* @param collapsedTurns - turns whose non-first content row should fold into one `'collapsed'` summary row.
+*/
+function buildTrajectoryRows(events, collapsedTurns) {
+	const rows = [];
+	const stepsByTurn = /* @__PURE__ */ new Map();
+	const pendingCalls = /* @__PURE__ */ new Map();
+	const openTurnRows = /* @__PURE__ */ new Map();
+	let currentTurn = 0;
+	let currentStep = 0;
+	for (const event of events) switch (event.type) {
+		case "turn/start": {
+			currentTurn = event.data.turn;
+			const draft = {
+				kind: "turn",
+				turn: currentTurn,
+				aborted: void 0
+			};
+			openTurnRows.set(currentTurn, draft);
+			rows.push(draft);
+			break;
+		}
+		case "turn/end": {
+			const draft = openTurnRows.get(event.data.turn);
+			const { reason } = event.data;
+			if (draft !== void 0 && reason.kind === "error") draft.aborted = `${reason.error.code}: ${reason.error.message}`;
+			else if (draft !== void 0 && reason.kind === "aborted") draft.aborted = "turn canceled";
+			break;
+		}
+		case "step/start": {
+			currentStep = event.data.step;
+			let steps = stepsByTurn.get(event.data.turn);
+			if (steps === void 0) {
+				steps = /* @__PURE__ */ new Set();
+				stepsByTurn.set(event.data.turn, steps);
+			}
+			steps.add(event.data.step);
+			rows.push({
+				kind: "step",
+				turn: event.data.turn,
+				step: event.data.step
+			});
+			break;
+		}
+		case "user/message": {
+			const label = userLabel(event.data);
+			const text = textOf(event.data.content);
+			const record = {
+				id: `${event.seq}`,
+				kind: event.data.source.kind === "user" ? "user" : "context",
+				turn: currentTurn,
+				step: currentStep,
+				seq: event.seq,
+				startedAt: event.time,
+				completedAt: void 0,
+				label,
+				isError: false,
+				summary: label,
+				payload: text === "" ? void 0 : text,
+				result: void 0,
+				reasoning: void 0,
+				source: event.data.source,
+				toolName: void 0
+			};
+			rows.push({
+				kind: "record",
+				record
+			});
+			break;
+		}
+		case "assistant/message": {
+			const content = event.data.message.content;
+			const text = textOf(content);
+			const reasoningText = reasoningOf(content);
+			const displaySource = text === "" ? reasoningText : text;
+			const label = displaySource === "" ? "(tool calls only)" : truncate(displaySource, LABEL_LIMIT);
+			const record = {
+				id: `${event.seq}`,
+				kind: "assistant",
+				turn: event.data.turn,
+				step: event.data.step,
+				seq: event.seq,
+				startedAt: event.time,
+				completedAt: void 0,
+				label,
+				isError: false,
+				summary: label,
+				payload: text === "" ? void 0 : text,
+				result: void 0,
+				reasoning: reasoningText === "" ? void 0 : reasoningText,
+				source: void 0,
+				toolName: void 0
+			};
+			rows.push({
+				kind: "record",
+				record
+			});
+			break;
+		}
+		case "tool/call": {
+			const label = `${event.data.name} ${truncate(event.data.arguments, LABEL_LIMIT)}`;
+			const record = {
+				id: event.data.callId,
+				kind: "tool",
+				turn: event.data.turn,
+				step: event.data.step,
+				seq: event.seq,
+				startedAt: event.time,
+				completedAt: void 0,
+				label,
+				isError: false,
+				summary: label,
+				payload: prettyJson(event.data.arguments),
+				result: void 0,
+				reasoning: void 0,
+				source: void 0,
+				toolName: event.data.name
+			};
+			pendingCalls.set(event.data.callId, record);
+			rows.push({
+				kind: "record",
+				record
+			});
+			break;
+		}
+		case "tool/result": {
+			const [block] = event.data.message.content;
+			const failed = event.data.error !== void 0 || block.isError === true;
+			const resultText = event.data.error !== void 0 ? `${event.data.error.code}: ${event.data.error.name}` : textOf(block.content);
+			const callId = event.data.message.source.callId;
+			const pending = pendingCalls.get(callId);
+			if (pending !== void 0) {
+				pending.completedAt = event.time;
+				pending.isError = failed;
+				pending.result = resultText;
+				pending.summary = `${pending.label} → ${failed ? "error" : "ok"}`;
+				pendingCalls.delete(callId);
+			} else {
+				const label = `(unmatched result) ${truncate(resultText, LABEL_LIMIT)}`;
+				const record = {
+					id: `${event.seq}`,
+					kind: "tool",
+					turn: event.data.turn,
+					step: event.data.step,
+					seq: event.seq,
+					startedAt: event.time,
+					completedAt: event.time,
+					label,
+					isError: failed,
+					summary: label,
+					payload: void 0,
+					result: resultText,
+					reasoning: void 0,
+					source: void 0,
+					toolName: void 0
+				};
+				rows.push({
+					kind: "record",
+					record
+				});
+			}
+			break;
+		}
+		case "request/header": {
+			if (event.data.reason === "initial") break;
+			const label = `config ${event.data.reason} updated`;
+			const record = {
+				id: `${event.seq}`,
+				kind: "header",
+				turn: currentTurn,
+				step: currentStep,
+				seq: event.seq,
+				startedAt: event.time,
+				completedAt: void 0,
+				label,
+				isError: false,
+				summary: label,
+				payload: JSON.stringify(event.data.header, null, 2),
+				result: void 0,
+				reasoning: void 0,
+				source: void 0,
+				toolName: void 0
+			};
+			rows.push({
+				kind: "record",
+				record
+			});
+			break;
+		}
+		default: break;
+	}
+	return collapseRows(rows.filter((row) => row.kind !== "step" || (stepsByTurn.get(row.turn)?.size ?? 0) > 1), collapsedTurns);
+}
+/** Fold every row of a collapsed turn after its first content row into one summary row. */
+function collapseRows(rows, collapsedTurns) {
+	if (collapsedTurns.size === 0) return rows;
+	const out = [];
+	let seenFirstInTurn = false;
+	let pendingCount = 0;
+	let pendingTurn = -1;
+	const flush = () => {
+		if (pendingCount > 0) {
+			out.push({
+				kind: "collapsed",
+				turn: pendingTurn,
+				count: pendingCount
+			});
+			pendingCount = 0;
+		}
+	};
+	for (const row of rows) {
+		if (row.kind === "turn") {
+			flush();
+			seenFirstInTurn = false;
+			pendingTurn = row.turn;
+			out.push(row);
+			continue;
+		}
+		const turn = row.kind === "step" ? row.turn : row.kind === "record" ? row.record.turn : pendingTurn;
+		if (!collapsedTurns.has(turn)) {
+			out.push(row);
+			continue;
+		}
+		if (!seenFirstInTurn) {
+			seenFirstInTurn = true;
+			out.push(row);
+			continue;
+		}
+		pendingCount += 1;
+	}
+	flush();
+	return out;
+}
+//#endregion
+//#region src/tui/trajectory/TrajectoryLedger.ts
+const bold$7 = (s) => `\x1b[1m${s}\x1b[0m`;
+const invert$3 = (s) => `\x1b[7m${s}\x1b[0m`;
+const secondary$7 = fg(theme.secondary);
+const muted$8 = fg(theme.muted);
+const errorColor$3 = fg(theme.error);
+function recordGlyph(record) {
+	if (record.kind === "tool") return record.isError ? "✖" : "⚙";
+	if (record.kind === "header") return "⊕";
+	return " ";
+}
+/** Kind tags, matching the web ledger's USER/CONTEXT/ASSISTANT/TOOL wording exactly (`header` has no web counterpart). */
+const KIND_TAG = {
+	user: "USER",
+	context: "CONTEXT",
+	assistant: "ASSISTANT",
+	tool: "TOOL",
+	header: "HEADER"
+};
+const KIND_TAG_WIDTH = Math.max(...Object.values(KIND_TAG).map((tag) => tag.length));
+/** Mirrors the web ledger's per-row kind tag coloring (assistant violet, tool amber, user brand blue, context mint, header neutral). */
+function kindColor(kind) {
+	switch (kind) {
+		case "user": return theme.primary;
+		case "context": return theme.success;
+		case "assistant": return theme.reasoning;
+		case "tool": return theme.warning;
+		case "header": return theme.muted;
+	}
+}
+function recordLine(record, selected) {
+	const tag = bold$7(fg(kindColor(record.kind))(KIND_TAG[record.kind].padEnd(KIND_TAG_WIDTH)));
+	const body = `${selected ? "› " : "  "}${tag} ${recordGlyph(record)} ${record.label}`;
+	const withColor = record.isError ? errorColor$3(body) : record.kind === "header" ? muted$8(body) : body;
+	return selected ? invert$3(withColor) : withColor;
+}
+function buildLedgerLines(rows, selectedId) {
+	return rows.map((row) => {
+		switch (row.kind) {
+			case "turn": return bold$7(secondary$7(`── Turn ${row.turn} ──${row.aborted === void 0 ? "" : ` ⚠ ${row.aborted}`}`));
+			case "step": return muted$8(`  Step ${row.step}`);
+			case "collapsed": return muted$8(`  … ${row.count} record${row.count === 1 ? "" : "s"} collapsed`);
+			case "record": return recordLine(row.record, row.record.id === selectedId);
+		}
+	});
+}
+//#endregion
+//#region src/tui/trajectory/detail.ts
+const violet = fg(theme.reasoning);
+function formatTime(ms) {
+	return new Date(ms).toLocaleTimeString();
+}
+function summaryText(record) {
+	const lines = [
+		`kind      ${record.kind}`,
+		`turn/step ${record.turn}/${record.step}`,
+		`started   ${formatTime(record.startedAt)}`
+	];
+	if (record.completedAt !== void 0) lines.push(`duration  ${record.completedAt - record.startedAt}ms`);
+	if (record.isError) lines.push("status    error");
+	return lines.join("\n");
+}
+function timingText(record) {
+	if (record.completedAt === void 0) return `started ${formatTime(record.startedAt)}\n(no completion recorded)`;
+	return [
+		`started   ${formatTime(record.startedAt)}`,
+		`completed ${formatTime(record.completedAt)}`,
+		`duration  ${record.completedAt - record.startedAt}ms`
+	].join("\n");
+}
+/** Rendered Preview tab: reasoning (if any) ahead of the visible text, mirroring the transcript's own reasoning-then-answer framing (`formatStreamingText` in `render.ts`). */
+function previewText(record) {
+	const parts = [];
+	if (record.reasoning !== void 0) parts.push(violet("✦ thinking"), violet(record.reasoning));
+	if (record.payload !== void 0) parts.push(renderMarkdown(record.payload));
+	return parts.length === 0 ? "(no content)" : parts.join("\n\n");
+}
+/** Raw tab: same content as `previewText`, unrendered — the markdown/plain source as the log carries it. */
+function rawText(record) {
+	const parts = [];
+	if (record.reasoning !== void 0) parts.push(`[thinking]\n${record.reasoning}`);
+	if (record.payload !== void 0) parts.push(record.payload);
+	return parts.length === 0 ? "(no content)" : parts.join("\n\n");
+}
+/** Source tab: the raw `user/message` event's `source` descriptor, pretty-printed. */
+function sourceText(record) {
+	if (record.source === void 0) return "(no source)";
+	try {
+		return JSON.stringify(record.source, null, 2);
+	} catch {
+		return "(unserializable source)";
+	}
+}
+/** Schema tab: the tool's own declared `{name, description, parameters}` (`ToolSchema`, via `getTool`) — the live registry's schema, not a per-request snapshot, so it can drift from what an older call actually saw if the tool changed mid-session. */
+function schemaText(record, getTool) {
+	const tool = record.toolName === void 0 ? void 0 : getTool?.(record.toolName);
+	if (tool === void 0) return "Schema unavailable";
+	return JSON.stringify({
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters
+	}, null, 2);
+}
+/** Render the content of one detail-pane tab for the selected record. */
+function buildDetail(record, tab, getTool) {
+	switch (tab) {
+		case "summary": return summaryText(record);
+		case "payload": return record.payload ?? "(no payload)";
+		case "result": return record.result ?? "—";
+		case "timing": return timingText(record);
+		case "preview": return previewText(record);
+		case "raw": return rawText(record);
+		case "source": return sourceText(record);
+		case "schema": return schemaText(record, getTool);
+	}
+}
+//#endregion
+//#region src/tui/trajectory/types.ts
+/**
+* Which detail tabs apply to a record, mirroring the web ledger's per-kind
+* split: a markdown record (user/context/assistant) gets Summary/Preview/Raw
+* plus Source only when the underlying event actually carried one (user and
+* context always do; assistant never does — see `layout.ts`). Everything
+* else (tool, header) gets Summary plus whichever of Payload/Result the
+* record actually has, and — tool records only — Schema, always followed by
+* Timing.
+*/
+function detailTabsFor(record) {
+	if (record.kind === "user" || record.kind === "context" || record.kind === "assistant") {
+		const tabs = [
+			"summary",
+			"preview",
+			"raw"
+		];
+		if (record.source !== void 0) tabs.push("source");
+		return tabs;
+	}
+	const tabs = ["summary"];
+	if (record.payload !== void 0) tabs.push("payload");
+	if (record.result !== void 0) tabs.push("result");
+	if (record.kind === "tool") tabs.push("schema");
+	tabs.push("timing");
+	return tabs;
+}
+//#endregion
+//#region src/tui/trajectory/TrajectoryDetail.ts
+/**
+* Pure line-builder for the `/trajectory` overlay's tabbed detail pane —
+* tabs vary by the selected record's kind (see `detailTabsFor`), content
+* word-wrapped to the pane's width and line-clamped to fit its height
+* budget. Wrapping matters here specifically because `buildDetail`'s
+* Preview/Raw/Payload/Schema content can be arbitrarily long prose or JSON
+* with no line breaks of its own — unlike a browser, the terminal won't wrap
+* it for us.
+* @module @tomowang/dsh-tui/tui/trajectory/TrajectoryDetail
+*/
+const muted$7 = fg(theme.muted);
+/** Left padding for the panel's body, under its flush-left tab-bar heading — mirrors the ledger's own "Turn" header / indented "Step" row convention (`TrajectoryLedger.ts`). */
+const DETAIL_INDENT = "  ";
+/** Right padding, matching `DETAIL_INDENT`'s width — reserved purely by wrapping short of the pane's edge, since there's no trailing character to place there. */
+const DETAIL_RIGHT_PADDING = 2;
+function buildDetailLines(record, tab, maxLines, getTool, width) {
+	const wrapWidth = Math.max(1, width - 2 - DETAIL_RIGHT_PADDING);
+	const lines = record === void 0 ? [] : wrapTextWithAnsi(buildDetail(record, tab, getTool), wrapWidth);
+	const shown = lines.slice(0, maxLines);
+	const hidden = lines.length - shown.length;
+	const out = [(record === void 0 ? [] : detailTabsFor(record)).map((candidate) => candidate === tab ? `[${candidate}]` : ` ${candidate} `).join(" ")];
+	if (record === void 0) out.push(`${DETAIL_INDENT}${muted$7("(no record selected)")}`);
+	else out.push(...shown.map((line) => `${DETAIL_INDENT}${line}`));
+	if (hidden > 0) out.push(`${DETAIL_INDENT}${muted$7(`… ${hidden} more line${hidden === 1 ? "" : "s"}`)}`);
+	return out;
+}
+//#endregion
+//#region src/tui/trajectory/TrajectoryOverlay.ts
+const bold$6 = (s) => `\x1b[1m${s}\x1b[0m`;
+const secondary$6 = fg(theme.secondary);
+const muted$6 = fg(theme.muted);
+var TrajectoryOverlay = class {
+	tui;
+	store;
+	actions;
+	getTool;
+	collapsedTurns = /* @__PURE__ */ new Set();
+	filter = emptyMiniTextField();
+	filterFocused = false;
+	detailTab = "summary";
+	selectedId;
+	scrollOffset = 0;
+	lastSelectedTurn;
+	constructor(tui, store, actions, getTool) {
+		this.tui = tui;
+		this.store = store;
+		this.actions = actions;
+		this.getTool = getTool;
+	}
+	invalidate() {}
+	heights() {
+		const availableRows = Math.max(10, this.tui.terminal.rows - 1);
+		const remaining = Math.max(6, availableRows - 4);
+		const detailContentHeight = Math.max(2, Math.floor(remaining / 2));
+		return {
+			ledgerHeight: Math.max(3, remaining - detailContentHeight - 1),
+			detailContentHeight
+		};
+	}
+	computeRows() {
+		const events = this.store.getSnapshot().events;
+		const rows = buildTrajectoryRows(events, this.collapsedTurns);
+		const query = this.filter.value.trim().toLowerCase();
+		const filteredRows = query === "" ? rows : rows.filter((row) => row.kind === "record" && (row.record.label.toLowerCase().includes(query) || row.record.summary.toLowerCase().includes(query)));
+		return {
+			filteredRows,
+			records: filteredRows.filter((row) => row.kind === "record")
+		};
+	}
+	render(width) {
+		const { filteredRows, records } = this.computeRows();
+		const selectedIndex = this.selectedId === void 0 ? -1 : records.findIndex((row) => row.record.id === this.selectedId);
+		const effectiveIndex = selectedIndex === -1 ? records.length - 1 : selectedIndex;
+		const selectedRecord = records[effectiveIndex]?.record;
+		if (selectedRecord !== void 0) this.lastSelectedTurn = selectedRecord.turn;
+		if (selectedRecord !== void 0 && !detailTabsFor(selectedRecord).includes(this.detailTab)) this.detailTab = "summary";
+		const selectedRowIndex = selectedRecord === void 0 ? -1 : filteredRows.findIndex((row) => row.kind === "record" && row.record.id === selectedRecord.id);
+		const { ledgerHeight, detailContentHeight } = this.heights();
+		const maxOffset = Math.max(0, filteredRows.length - ledgerHeight);
+		if (selectedRowIndex < this.scrollOffset) this.scrollOffset = selectedRowIndex;
+		else if (selectedRowIndex >= this.scrollOffset + ledgerHeight) this.scrollOffset = selectedRowIndex - ledgerHeight + 1;
+		this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+		const windowedRows = filteredRows.slice(this.scrollOffset, this.scrollOffset + ledgerHeight);
+		const lines = [
+			bold$6(secondary$6(`Trajectory${this.filter.value === "" ? "" : ` — filter: ${this.filter.value}`}${records.length === 0 ? "" : ` (${effectiveIndex + 1}/${records.length})`}`)),
+			...buildLedgerLines(windowedRows, selectedRecord?.id),
+			"",
+			...buildDetailLines(selectedRecord, this.detailTab, detailContentHeight, this.getTool, width),
+			""
+		];
+		if (this.filterFocused) lines.push(`/ ${renderMiniTextField(this.filter, true)}`);
+		else lines.push(muted$6("↑↓ select · tab detail · c collapse · / filter · esc close"));
+		return lines;
+	}
+	moveSelection(delta) {
+		const { records } = this.computeRows();
+		if (records.length === 0) return;
+		const selectedIndex = this.selectedId === void 0 ? -1 : records.findIndex((row) => row.record.id === this.selectedId);
+		const effectiveIndex = selectedIndex === -1 ? records.length - 1 : selectedIndex;
+		const next = Math.min(records.length - 1, Math.max(0, effectiveIndex + delta));
+		this.selectedId = records[next].record.id;
+	}
+	selectedRecord() {
+		const { records } = this.computeRows();
+		const selectedIndex = this.selectedId === void 0 ? -1 : records.findIndex((row) => row.record.id === this.selectedId);
+		return records[selectedIndex === -1 ? records.length - 1 : selectedIndex]?.record;
+	}
+	cycleTab(delta) {
+		const record = this.selectedRecord();
+		if (record === void 0) return;
+		const tabs = detailTabsFor(record);
+		const index = tabs.indexOf(this.detailTab);
+		const next = ((index === -1 ? 0 : index) + delta + tabs.length) % tabs.length;
+		this.detailTab = tabs[next];
+	}
+	toggleCollapse() {
+		const turn = this.selectedRecord()?.turn ?? this.lastSelectedTurn;
+		if (turn === void 0) return;
+		if (this.collapsedTurns.has(turn)) this.collapsedTurns.delete(turn);
+		else this.collapsedTurns.add(turn);
+	}
+	handleInput(data) {
+		if (this.filterFocused) {
+			if (matchesKey(data, Key.escape)) {
+				this.filterFocused = false;
+				return;
+			}
+			if (matchesKey(data, Key.enter)) {
+				this.filterFocused = false;
+				return;
+			}
+			const next = miniTextFieldInput(this.filter, data);
+			if (next !== void 0) this.filter = next;
+			return;
+		}
+		if (matchesKey(data, Key.escape)) {
+			this.actions.closeTrajectory();
+			return;
+		}
+		if (matchesKey(data, Key.up)) {
+			this.moveSelection(-1);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.moveSelection(1);
+			return;
+		}
+		if (matchesKey(data, "shift+tab")) {
+			this.cycleTab(-1);
+			return;
+		}
+		if (matchesKey(data, Key.tab)) {
+			this.cycleTab(1);
+			return;
+		}
+		if (data === "c") {
+			this.toggleCollapse();
+			return;
+		}
+		if (data === "/") this.filterFocused = true;
+	}
+};
+//#endregion
+//#region src/tui/toolCards/ToolCardsOverlay.ts
+const bold$5 = (s) => `\x1b[1m${s}\x1b[0m`;
+const secondary$5 = fg(theme.secondary);
+const muted$5 = fg(theme.muted);
+/** Stable identity for a row across its pending → resolved transition — the call's own `seq` when there is one, so `collapsed`/scroll state survives its result landing. */
+function rowKey(row) {
+	return (row.call ?? row.result).seq;
+}
+function summaryOf(row, options) {
+	if (row.result !== void 0) return formatToolCardSummary(row.result, options);
+	if (row.call !== void 0) return formatToolCardSummary(row.call, options);
+	return "";
+}
+/** Full detail for a row: the call's presentation, then the result's, blank-line separated when both are present. */
+function detailOf(row, options) {
+	const callLines = row.call === void 0 ? [] : formatToolCardDetail(row.call, options);
+	const resultLines = row.result === void 0 ? [] : formatToolCardDetail(row.result, options);
+	if (callLines.length === 0) return resultLines;
+	if (resultLines.length === 0) return callLines;
+	return [
+		...callLines,
+		"",
+		...resultLines
+	];
+}
+var ToolCardsOverlay = class {
+	tui;
+	store;
+	actions;
+	getTool;
+	getToolCall;
+	selected;
+	collapsed = /* @__PURE__ */ new Set();
+	scrollOffset = 0;
+	lastRowKey;
+	lastOpen = false;
+	constructor(tui, store, actions, getTool, getToolCall) {
+		this.tui = tui;
+		this.store = store;
+		this.actions = actions;
+		this.getTool = getTool;
+		this.getToolCall = getToolCall;
+	}
+	invalidate() {}
+	/** Pairs `tool/call`/`tool/result` events by `callId`, in call order; an orphaned result (no call in the log) gets its own trailing row. */
+	cards() {
+		const rows = [];
+		const indexByCallId = /* @__PURE__ */ new Map();
+		for (const event of this.store.getSnapshot().events) if (event.type === "tool/call") {
+			indexByCallId.set(event.data.callId, rows.length);
+			rows.push({
+				call: event,
+				result: void 0
+			});
+		} else if (event.type === "tool/result") {
+			const index = indexByCallId.get(event.data.message.source.callId);
+			if (index === void 0) rows.push({
+				call: void 0,
+				result: event
+			});
+			else rows[index] = {
+				...rows[index],
+				result: event
+			};
+		}
+		return rows;
+	}
+	contentRows() {
+		const availableRows = Math.max(6, this.tui.terminal.rows - 1);
+		return Math.max(1, availableRows - 4);
+	}
+	render(_width) {
+		const cards = this.cards();
+		const index = cards.length === 0 ? 0 : Math.min(this.selected ?? cards.length - 1, cards.length - 1);
+		const row = cards[index];
+		const key = row === void 0 ? void 0 : rowKey(row);
+		const open = key !== void 0 && !this.collapsed.has(key);
+		if (key !== this.lastRowKey || open !== this.lastOpen) {
+			this.scrollOffset = 0;
+			this.lastRowKey = key;
+			this.lastOpen = open;
+		}
+		const options = {
+			replay: false,
+			getTool: this.getTool,
+			getToolCall: this.getToolCall
+		};
+		const contentRows = this.contentRows();
+		const summary = row === void 0 ? void 0 : summaryOf(row, options);
+		const detailLines = row === void 0 || !open ? void 0 : detailOf(row, options);
+		const totalDetailLines = detailLines?.length ?? 0;
+		const maxScrollOffset = Math.max(0, totalDetailLines - contentRows);
+		const clampedOffset = Math.min(this.scrollOffset, maxScrollOffset);
+		const visibleDetailLines = detailLines?.slice(clampedOffset, clampedOffset + contentRows);
+		const scrollHint = totalDetailLines <= contentRows ? "" : ` · lines ${clampedOffset + 1}-${Math.min(totalDetailLines, clampedOffset + contentRows)} of ${totalDetailLines}`;
+		const lines = [bold$5(secondary$5(`Tool Cards${cards.length === 0 ? "" : ` (${index + 1}/${cards.length})`}${open ? scrollHint : ""}`))];
+		if (row === void 0) lines.push(muted$5("No tool cards in this session yet."));
+		else if (open) lines.push(...visibleDetailLines ?? []);
+		else lines.push(`▸ ${summary ?? ""}`);
+		lines.push("");
+		lines.push(muted$5(`↑↓ select · PgUp/PgDn/Home/End scroll · Enter/Space ${open ? "collapse" : "expand"} · Ctrl+O/Esc close`));
+		return lines;
+	}
+	move(delta) {
+		const cards = this.cards();
+		if (cards.length === 0) return;
+		const current = this.selected ?? cards.length - 1;
+		this.selected = Math.max(0, Math.min(cards.length - 1, current + delta));
+	}
+	scroll(delta, maxScrollOffset) {
+		this.scrollOffset = Math.max(0, Math.min(maxScrollOffset, this.scrollOffset + delta));
+	}
+	toggle() {
+		const cards = this.cards();
+		const row = cards[cards.length === 0 ? 0 : Math.min(this.selected ?? cards.length - 1, cards.length - 1)];
+		if (row === void 0) return;
+		const key = rowKey(row);
+		if (this.collapsed.has(key)) this.collapsed.delete(key);
+		else this.collapsed.add(key);
+	}
+	handleInput(data) {
+		if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("o")) || data === "q") {
+			this.actions.closeToolCards();
+			return;
+		}
+		const cards = this.cards();
+		const row = cards[cards.length === 0 ? 0 : Math.min(this.selected ?? cards.length - 1, cards.length - 1)];
+		const key = row === void 0 ? void 0 : rowKey(row);
+		const open = key !== void 0 && !this.collapsed.has(key);
+		const contentRows = this.contentRows();
+		const options = {
+			replay: false,
+			getTool: this.getTool,
+			getToolCall: this.getToolCall
+		};
+		const detailLines = row === void 0 || !open ? void 0 : detailOf(row, options);
+		const maxScrollOffset = Math.max(0, (detailLines?.length ?? 0) - contentRows);
+		if (matchesKey(data, Key.pageUp)) return this.scroll(-contentRows, maxScrollOffset);
+		if (matchesKey(data, Key.pageDown)) return this.scroll(contentRows, maxScrollOffset);
+		if (matchesKey(data, Key.home)) return this.scroll(-maxScrollOffset, maxScrollOffset);
+		if (matchesKey(data, Key.end)) return this.scroll(maxScrollOffset, maxScrollOffset);
+		if (matchesKey(data, Key.up) || matchesKey(data, Key.ctrl("p"))) {
+			this.move(-1);
+			return;
+		}
+		if (matchesKey(data, Key.down) || matchesKey(data, Key.ctrl("n"))) {
+			this.move(1);
+			return;
+		}
+		if (matchesKey(data, Key.enter) || data === " ") this.toggle();
+	}
+};
+//#endregion
+//#region src/tui/context/ContextOverlay.ts
+const bold$4 = (s) => `\x1b[1m${s}\x1b[0m`;
+const secondary$4 = fg(theme.secondary);
+const muted$4 = fg(theme.muted);
+const BAR_WIDTH = 30;
+function bar(widthPercent) {
+	const filled = Math.round(widthPercent / 100 * BAR_WIDTH);
+	return "█".repeat(Math.max(0, Math.min(BAR_WIDTH, filled))).padEnd(BAR_WIDTH, "░");
+}
+var ContextOverlay = class {
+	store;
+	actions;
+	constructor(store, actions) {
+		this.store = store;
+		this.actions = actions;
+	}
+	invalidate() {}
+	render(_width) {
+		const { contextPressure, contextBreakdown } = this.store.getSnapshot().stats;
+		const occupancy = contextOccupancy(contextPressure);
+		const rows = contextBreakdownRows(occupancy, contextBreakdown);
+		const lines = [bold$4(secondary$4("Context usage"))];
+		if (occupancy === null) lines.push(muted$4("No usage reported yet — send a message first."));
+		else {
+			lines.push(`${occupancy.percent}% of context used`);
+			lines.push(muted$4(`~${formatTokens(occupancy.usedTokens)} / ${formatTokens(occupancy.contextWindow)}`));
+			lines.push("");
+			if (rows.length === 0) lines.push(muted$4("No composition breakdown yet."));
+			else for (const row of rows) lines.push(`${row.label.padEnd(14)} ${secondary$4(bar(row.width))} ${formatTokens(row.tokens)}`);
+		}
+		lines.push("");
+		lines.push(muted$4("esc close"));
+		return lines;
+	}
+	handleInput(data) {
+		if (matchesKey(data, Key.escape) || data === "q") {
+			this.actions.closeContext();
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/tui/plugins/PluginsOverlay.ts
+const bold$3 = (s) => `\x1b[1m${s}\x1b[0m`;
+const secondary$3 = fg(theme.secondary);
+const muted$3 = fg(theme.muted);
+const errorColor$2 = fg(theme.error);
+const success$1 = fg(theme.success);
+const STATE_LABEL = {
+	pending: "pending",
+	loading: "loading",
+	active: "active",
+	failed: "failed",
+	disposed: "disposed",
+	unloading: "unloading"
+};
+function rowLabel(row) {
+	if (row.state !== void 0) return STATE_LABEL[row.state];
+	return row.disabled ? "off" : "···";
+}
+function rowColor(row) {
+	if (row.disabled) return muted$3;
+	if (row.state === "failed") return errorColor$2;
+	if (row.state === "active") return success$1;
+}
+var PluginsOverlay = class {
+	tui;
+	rows;
+	actions;
+	scrollOffset = 0;
+	constructor(tui, rows, actions) {
+		this.tui = tui;
+		this.rows = rows;
+		this.actions = actions;
+	}
+	invalidate() {}
+	listHeight() {
+		const availableRows = Math.max(10, this.tui.terminal.rows - 1);
+		return Math.max(3, availableRows - 2);
+	}
+	maxOffset() {
+		return Math.max(0, this.rows.length - this.listHeight());
+	}
+	render(_width) {
+		const listHeight = this.listHeight();
+		const offset = Math.min(this.scrollOffset, this.maxOffset());
+		const windowedRows = this.rows.slice(offset, offset + listHeight);
+		const activeCount = this.rows.filter((row) => row.state === "active").length;
+		const failedCount = this.rows.filter((row) => row.state === "failed").length;
+		const lines = [bold$3(secondary$3(`Plugins (${this.rows.length}) — ${activeCount} active${failedCount === 0 ? "" : `, ${failedCount} failed`}`))];
+		for (const row of windowedRows) {
+			const color = rowColor(row);
+			const label = color === void 0 ? rowLabel(row).padEnd(8) : color(rowLabel(row).padEnd(8));
+			const id = row.disabled ? muted$3(` ${row.id}`) : ` ${row.id}`;
+			lines.push(`${label}${id}${muted$3(` (${row.name})`)}`);
+		}
+		lines.push(muted$3("↑↓ scroll · esc close"));
+		return lines;
+	}
+	handleInput(data) {
+		if (matchesKey(data, Key.escape) || data === "q") {
+			this.actions.closePlugins();
+			return;
+		}
+		const listHeight = this.listHeight();
+		const maxOffset = this.maxOffset();
+		if (matchesKey(data, Key.up)) {
+			this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.scrollOffset = Math.min(maxOffset, this.scrollOffset + 1);
+			return;
+		}
+		if (matchesKey(data, Key.pageUp)) {
+			this.scrollOffset = Math.max(0, this.scrollOffset - listHeight);
+			return;
+		}
+		if (matchesKey(data, Key.pageDown)) this.scrollOffset = Math.min(maxOffset, this.scrollOffset + listHeight);
+	}
+};
+//#endregion
+//#region src/tui/agentPresets/AgentPresetsOverlay.ts
+const bold$2 = (s) => `\x1b[1m${s}\x1b[0m`;
+const secondary$2 = fg(theme.secondary);
+const muted$2 = fg(theme.muted);
+const errorColor$1 = fg(theme.error);
+const invert$2 = (s) => `\x1b[7m${s}\x1b[0m`;
+var AgentPresetsOverlay = class {
+	store;
+	actions;
+	constructor(store, actions) {
+		this.store = store;
+		this.actions = actions;
+	}
+	invalidate() {}
+	render(_width) {
+		const overlay = this.store.getSnapshot().overlay;
+		if (overlay.kind !== "agentPresets") return [];
+		const { rows, selected, current, blank, busy, error } = overlay.agentPresets;
+		const lines = [bold$2(secondary$2("Agent presets"))];
+		if (error !== void 0) lines.push(errorColor$1(error));
+		if (busy && rows.length === 0) lines.push(muted$2("Loading…"));
+		rows.forEach((row, index) => {
+			const marker = row.id === current ? "● " : "○ ";
+			const trust = row.trust === "user" ? " (custom)" : "";
+			const row0 = `${index === selected ? "› " : "  "}${marker}${row.label}${trust}`;
+			lines.push(index === selected ? invert$2(row0) : row0);
+			if (row.broken !== void 0) lines.push(errorColor$1(`    broken: ${row.broken}`));
+			else if (row.description !== void 0) lines.push(muted$2(`    ${row.description}`));
+		});
+		if (rows.length === 0 && !busy) lines.push(muted$2("No agent presets configured in this profile."));
+		lines.push(muted$2(blank ? "↑↓ select · enter apply · esc close" : "session already started — preset is fixed · esc close"));
+		return lines;
+	}
+	handleInput(data) {
+		const overlay = this.store.getSnapshot().overlay;
+		if (overlay.kind !== "agentPresets") return;
+		const { rows, selected, blank } = overlay.agentPresets;
+		if (matchesKey(data, Key.escape) || data === "q") {
+			this.actions.closeAgentPresets();
+			return;
+		}
+		if (rows.length === 0) return;
+		if (matchesKey(data, Key.up)) {
+			this.actions.selectAgentPresetRow(Math.max(0, selected - 1));
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.actions.selectAgentPresetRow(Math.min(rows.length - 1, selected + 1));
+			return;
+		}
+		if (matchesKey(data, Key.enter) && blank) {
+			const row = rows[selected];
+			if (row.broken === void 0) this.actions.applyAgentPreset(row.id);
+		}
+	}
+};
+//#endregion
+//#region src/tui/interaction/ApprovalOverlay.ts
+const bold$1 = (s) => `\x1b[1m${s}\x1b[0m`;
+const warning = fg(theme.warning);
+const muted$1 = fg(theme.muted);
+const success = fg(theme.success);
+const errorColor = fg(theme.error);
+const invert$1 = (s) => `\x1b[7m${s}\x1b[0m`;
+const CHOICES = [{
+	outcome: "allowed-once",
+	label: "Allow once"
+}, {
+	outcome: "rejected",
+	label: "Reject"
+}];
+var ApprovalOverlay = class {
+	approval;
+	actions;
+	selected = 0;
+	constructor(approval, actions) {
+		this.approval = approval;
+		this.actions = actions;
+	}
+	invalidate() {}
+	render(_width) {
+		const lines = [bold$1(warning("Approval requested"))];
+		const idSuffix = this.approval.callId === void 0 ? "" : muted$1(` (${this.approval.callId})`);
+		lines.push(`Tool: ${bold$1(this.approval.toolName)}${idSuffix}`);
+		if (this.approval.reason !== void 0) lines.push(muted$1(this.approval.reason));
+		CHOICES.forEach((choice, index) => {
+			const color = choice.outcome === "rejected" ? errorColor : success;
+			const text = `${index === this.selected ? "› " : "  "}${choice.label}`;
+			lines.push(color(index === this.selected ? invert$1(text) : text));
+		});
+		lines.push(muted$1("↑↓ select · enter confirm · y allow · n/esc reject"));
+		return lines;
+	}
+	handleInput(data) {
+		if (data === "y") {
+			this.actions.answerApproval("allowed-once");
+			return;
+		}
+		if (data === "n" || matchesKey(data, Key.escape)) {
+			this.actions.answerApproval("rejected");
+			return;
+		}
+		if (matchesKey(data, Key.up) || matchesKey(data, Key.left)) {
+			this.selected = (this.selected - 1 + CHOICES.length) % CHOICES.length;
+			return;
+		}
+		if (matchesKey(data, Key.down) || matchesKey(data, Key.right)) {
+			this.selected = (this.selected + 1) % CHOICES.length;
+			return;
+		}
+		if (matchesKey(data, Key.enter)) this.actions.answerApproval(CHOICES[this.selected].outcome);
+	}
+};
+//#endregion
+//#region src/tui/interaction/QuestionOverlay.ts
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const secondary$1 = fg(theme.secondary);
+const muted = fg(theme.muted);
+const invert = (s) => `\x1b[7m${s}\x1b[0m`;
+/** Detail (e.g. a plan-review's plan markdown) line cap. */
+const MAX_DETAIL_LINES = 60;
+function capDetailLines(detail) {
+	const lines = detail.split("\n");
+	if (lines.length <= MAX_DETAIL_LINES) return lines;
+	const omitted = lines.length - MAX_DETAIL_LINES;
+	return [...lines.slice(0, MAX_DETAIL_LINES), `… +${omitted} more line${omitted === 1 ? "" : "s"}`];
+}
+var QuestionOverlay = class {
+	question;
+	actions;
+	cursor = 0;
+	toggled = /* @__PURE__ */ new Set();
+	customMode;
+	customField = emptyMiniTextField();
+	constructor(question, actions) {
+		this.question = question;
+		this.actions = actions;
+		this.customMode = question.options.length === 0;
+	}
+	invalidate() {}
+	submit() {
+		const custom = this.customField.value.trim();
+		if (this.question.multiSelect) {
+			const selected = [...this.toggled].sort((a, b) => a - b).map((index) => this.question.options[index].label);
+			this.actions.answerQuestion({
+				selected,
+				custom: custom === "" ? void 0 : custom
+			});
+			return;
+		}
+		if (this.customMode) {
+			this.actions.answerQuestion({
+				selected: [],
+				custom
+			});
+			return;
+		}
+		this.actions.answerQuestion({
+			selected: [this.question.options[this.cursor].label],
+			custom: void 0
+		});
+	}
+	render(_width) {
+		const { header, question: text, detail, options, multiSelect, approveLabel, progress } = this.question;
+		const otherIndex = options.length;
+		const lines = [];
+		lines.push(bold(secondary$1(`${header ?? "Question"}${progress === void 0 ? "" : ` — ${progress}`}`)));
+		lines.push(text);
+		if (detail !== void 0) {
+			lines.push("");
+			for (const line of capDetailLines(detail)) lines.push(muted(line));
+			lines.push("");
+		}
+		options.forEach((option, index) => {
+			const isSelected = !this.customMode && this.cursor === index;
+			const box = multiSelect ? this.toggled.has(index) ? "[x] " : "[ ] " : "";
+			const approve = approveLabel === option.label ? " (approve)" : "";
+			const row = `${isSelected ? "› " : "  "}${box}${option.label}${approve}`;
+			lines.push(isSelected ? invert(row) : row);
+			if (option.description !== void 0) lines.push(muted(`    ${option.description}`));
+		});
+		if (options.length > 0) {
+			const isSelected = !this.customMode && this.cursor === otherIndex;
+			const row = `${isSelected ? "› " : "  "}Other…`;
+			lines.push(isSelected ? invert(row) : row);
+		}
+		if (this.customMode) lines.push(`> ${renderMiniTextField(this.customField, true)}`);
+		const hint = [
+			multiSelect ? "↑↓ move · space toggle · enter submit" : "↑↓ move · enter select",
+			options.length === 0 ? "" : "\"Other…\" for free text",
+			"esc skip"
+		].filter((s) => s !== "").join(" · ");
+		lines.push(muted(hint));
+		return lines;
+	}
+	handleInput(data) {
+		const { options, multiSelect } = this.question;
+		const otherIndex = options.length;
+		if (this.customMode) {
+			if (matchesKey(data, Key.escape)) {
+				if (options.length > 0) this.customMode = false;
+				else this.actions.answerQuestion({
+					selected: [],
+					custom: void 0
+				});
+				return;
+			}
+			if (matchesKey(data, Key.enter)) {
+				this.submit();
+				return;
+			}
+			const next = miniTextFieldInput(this.customField, data);
+			if (next !== void 0) this.customField = next;
+			return;
+		}
+		if (matchesKey(data, Key.escape)) {
+			this.actions.answerQuestion({
+				selected: [],
+				custom: void 0
+			});
+			return;
+		}
+		if (options.length === 0) return;
+		if (matchesKey(data, Key.up)) {
+			this.cursor = (this.cursor - 1 + options.length + 1) % (options.length + 1);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.cursor = (this.cursor + 1) % (options.length + 1);
+			return;
+		}
+		if (data === " " && multiSelect && this.cursor < options.length) {
+			if (this.toggled.has(this.cursor)) this.toggled.delete(this.cursor);
+			else this.toggled.add(this.cursor);
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			if (this.cursor === otherIndex) {
+				this.customMode = true;
+				return;
+			}
+			this.submit();
+		}
+	}
+};
+//#endregion
+//#region src/tui/TuiApp.ts
+/**
+* Root orchestrator: builds the pi-tui component tree once, then patches it
+* imperatively from `TuiStore` change notifications — the pi-tui equivalent
+* of `App.tsx` (root component) + `mount.tsx` (the `render()` call site)
+* combined, since pi-tui has no JSX/reconciler to split those across.
+*
+* Two different update strategies are used, deliberately:
+*
+* - The live region (notice, queued preview, streaming text, status bar,
+*   stats line, permission indicator, update hint) is a `DynamicText`/`Spinner` per row,
+*   each pulling straight from `store.getSnapshot()` at render time. There is
+*   no manual `setText` bookkeeping to keep in sync — every repaint just
+*   reflects whatever the store currently holds. The approve/reject panel
+*   (`ApprovalSlot`) is a live-region row too, but an interactive one: it
+*   delegates render/input to whichever `ApprovalOverlay` is currently
+*   active and takes focus while one is, rather than covering the screen.
+* - The transcript is append-only: `appendNewTranscriptItems` diffs the
+*   store's `events`/`shellHistory` arrays against how much has already been
+*   turned into a `createTranscriptLine` child of `documentContainer`,
+*   appending only the new tail. Re-formatting the whole transcript on every
+*   store change would be wasteful for a long session — `ScrollView`'s own
+*   viewport culling (confirmed in pi-tui's own test suite: painting a huge
+*   scroll child is O(viewport), not O(content)) is what makes this safe to
+*   grow without bound.
+*
+* Overlays (`/model`, `/trajectory`, Ctrl+O tool cards, `/context`,
+* `/plugins`, `/presets`, question) are `tui.showOverlay(...)` calls keyed
+* off `store.getSnapshot().overlay.kind` — see `updateOverlay`. Approval is
+* the one exception: it renders inline in the dock instead (see above).
+* @module @tomowang/dsh-tui/tui/TuiApp
+*/
+const secondary = fg(theme.secondary);
+/** Full-screen panel anchored at the top — every overlay's uniform placement. */
+const OVERLAY_OPTIONS = {
+	anchor: "top-left",
+	row: 0,
+	col: 0,
+	width: "100%",
+	maxHeight: "100%"
+};
+/**
+* Wraps an overlay `Component` so it always paints every cell of the
+* terminal, not just however many lines its own content happens to need.
+* `tui.showOverlay` composites exactly what `render()` returns onto the base
+* frame at the requested position/size — it does not clear or pad the rest
+* of that box — so a short overlay (e.g. a "No tool cards yet" one-liner)
+* otherwise leaves the transcript/dock's last-painted content visible
+* underneath it, which reads as a rendering bug (old messages "bleeding
+* through" around a top-anchored panel) rather than an intentional
+* takeover. Padding to the full terminal height/width here, once, means no
+* individual overlay has to reimplement this.
+*/
+var FullScreenOverlay = class {
+	inner;
+	tui;
+	constructor(inner, tui) {
+		this.inner = inner;
+		this.tui = tui;
+	}
+	get wantsKeyRelease() {
+		return this.inner.wantsKeyRelease ?? false;
+	}
+	invalidate() {
+		this.inner.invalidate();
+	}
+	handleInput(data) {
+		this.inner.handleInput?.(data);
+	}
+	render(width) {
+		const lines = this.inner.render(width);
+		const height = Math.max(lines.length, this.tui.terminal.rows);
+		const padded = [];
+		for (let i = 0; i < height; i++) {
+			const line = lines[i] ?? "";
+			const pad = width - visibleWidth(line);
+			padded.push(pad > 0 ? line + " ".repeat(pad) : line);
+		}
+		return padded;
+	}
+};
+/**
+* Dock row that delegates to whichever `ApprovalOverlay` is currently
+* active, or renders nothing between approvals. Unlike the other dock rows
+* (`DynamicText`, pulling read-only text from the store each render), this
+* one also takes focus and forwards keystrokes — it's how the approve/reject
+* panel gets shown inline, in the live region, instead of as a
+* full-screen `showOverlay` panel covering the transcript.
+*/
+var ApprovalSlot = class {
+	current;
+	set(component) {
+		this.current = component;
+	}
+	invalidate() {
+		this.current?.invalidate();
+	}
+	render(width) {
+		return this.current?.render(width) ?? [];
+	}
+	handleInput(data) {
+		this.current?.handleInput(data);
+	}
+};
+let activeTui;
+let keybindingsConfigured = false;
+/**
+* Emacs-style Ctrl+P/Ctrl+N aliases, and history recall on up/down —
+* matching the old hand-rolled `PromptInput` exactly. Also frees `Home`/`End`
+* from `TuiAltScreen`'s default viewport-jump-to-top/bottom bindings: the
+* alt-screen's own viewport navigation intercepts input *before* it reaches
+* the focused component (confirmed empirically — an unmodified `Home`
+* scrolled the transcript instead of moving the prompt's cursor to line
+* start), which would otherwise silently break `Editor`'s own
+* `cursorLineStart`/`cursorLineEnd` (`Home`/`End`/Ctrl+A/Ctrl+E) whenever the
+* prompt has focus, which is effectively always. `Ctrl+A`/`Ctrl+E` still
+* give line motion and `PageUp`/`PageDown`/mouse wheel still give transcript
+* scroll, so unbinding the dedicated top/bottom jump is a reasonable trade.
+* Configured once, globally (pi-tui's keybinding registry is module-global,
+* not per-instance).
+*/
+function ensureKeybindings() {
+	if (keybindingsConfigured) return;
+	keybindingsConfigured = true;
+	setKeybindings(new KeybindingsManager(TUI_KEYBINDINGS, {
+		"tui.editor.cursorUp": ["up", "ctrl+p"],
+		"tui.editor.cursorDown": ["down", "ctrl+n"],
+		"tui.editor.historyPrevious": ["up", "ctrl+p"],
+		"tui.editor.historyNext": ["down", "ctrl+n"],
+		"tui.altScreen.top": [],
+		"tui.altScreen.bottom": []
+	}));
+}
+var TuiApp = class {
+	options;
+	tui;
+	documentContainer = new Container();
+	editor;
+	spinner;
+	appendedEventsCount = 0;
+	appendedShellCount = 0;
+	currentOverlayKind = "none";
+	overlayHandle;
+	approvalSlot = new ApprovalSlot();
+	wasRunning = false;
+	stopped = false;
+	/** Last title string sent to the terminal, so an unrelated store change doesn't re-issue the same OSC 0 write every render. */
+	lastTerminalTitle;
+	constructor(options) {
+		this.options = options;
+		const { store, actions } = options;
+		const terminal = new ProcessTerminal();
+		this.tui = new TuiAltScreen(terminal, true, void 0, { mouse: true });
+		this.spinner = new Spinner(this.tui);
+		this.documentContainer.addChild(new DynamicText((width) => buildBannerText({
+			version: options.version,
+			provider: options.provider,
+			model: options.model,
+			cwd: options.cwd
+		}, width)));
+		const transcriptScrollView = new ScrollView(this.documentContainer, {
+			follow: "end",
+			primary: true,
+			overscroll: "chain"
+		});
+		this.editor = new CustomEditor(this.tui, actions, {
+			getStatus: () => store.getSnapshot().status,
+			history: options.promptHistory,
+			getFileCandidates: () => this.waitForFileIndex()
+		});
+		const noticeText = new DynamicText(() => {
+			const notice = store.getSnapshot().notice;
+			return notice === void 0 ? "" : secondary(notice);
+		});
+		const goalText = new DynamicText(() => buildGoalBarText(store.getSnapshot().goal));
+		const queuedText = new DynamicText(() => buildQueuedText(store.getSnapshot().queued));
+		const streamingText = new DynamicText((width) => {
+			const streaming = store.getSnapshot().streaming;
+			if (streaming === void 0) return "";
+			return padTranscriptText(formatStreamingText(streaming.text, streaming.reasoningText, this.spinner.current()) ?? "", width).join("\n");
+		});
+		const pendingToolCallsText = new DynamicText((width) => {
+			const { pendingToolCalls } = store.getSnapshot();
+			return padTranscriptText(formatPendingToolCalls(pendingToolCalls, this.spinner.current(), options.getTool), width).join("\n");
+		});
+		const shellRunLiveText = new DynamicText((width) => {
+			const run = store.getSnapshot().shellRun;
+			if (run === void 0) return "";
+			return padTranscriptText(formatShellRunLive(run.command, run.output), width).join("\n");
+		});
+		const statusBarText = new DynamicText(() => {
+			const state = store.getSnapshot();
+			return buildStatusBarText({
+				sessionId: options.sessionId,
+				provider: options.provider,
+				model: options.model,
+				status: state.status,
+				queuedCount: state.queued.length,
+				presetLabel: state.preset?.current,
+				eventCount: state.events.length,
+				spinnerChar: this.spinner.current()
+			});
+		});
+		const permissionText = new DynamicText(() => buildPermissionText(store.getSnapshot().permission));
+		const updateHintText = new DynamicText(() => buildUpdateHintText(options.version, store.getSnapshot().updateHint));
+		const statsLineText = new DynamicText(() => {
+			const stats = store.getSnapshot().stats;
+			return [buildStatsLine(stats.sessionStats, stats.tokenUsage), buildContextLine(stats.contextPressure)].filter((group) => group !== "").join("| ");
+		});
+		const dock = new VStack([
+			noticeText,
+			goalText,
+			queuedText,
+			streamingText,
+			pendingToolCallsText,
+			shellRunLiveText,
+			statusBarText,
+			this.approvalSlot,
+			this.editor,
+			permissionText,
+			updateHintText,
+			statsLineText
+		], { gap: 0 });
+		const layoutRoot = new VStack([{
+			component: transcriptScrollView,
+			basis: 0,
+			grow: 1,
+			minSize: 1
+		}, {
+			component: dock,
+			basis: "auto",
+			shrink: 1,
+			minSize: 1
+		}], { gap: 0 });
+		this.tui.setLayoutRoot(layoutRoot);
+		this.tui.setFocus(this.editor);
+		this.appendNewTranscriptItems(store.getSnapshot());
+		this.updateTerminalTitle(store.getSnapshot().title);
+		store.subscribe(() => {
+			const state = store.getSnapshot();
+			this.appendNewTranscriptItems(state);
+			this.updateOverlay(state.overlay);
+			this.updateTerminalTitle(state.title);
+			const running = state.status === "running";
+			if (running !== this.wasRunning) {
+				this.wasRunning = running;
+				if (running) this.spinner.start();
+				else this.spinner.stop();
+			}
+			this.tui.requestRender();
+		});
+	}
+	/** Push the terminal window/tab title (OSC 0) when the session's title projection changes; a no-op once already reflecting the current value. */
+	updateTerminalTitle(title) {
+		const text = buildTerminalTitle(title);
+		if (text === this.lastTerminalTitle) return;
+		this.lastTerminalTitle = text;
+		this.tui.terminal.setTitle(text);
+	}
+	start() {
+		activeTui = this.tui;
+		this.tui.start();
+	}
+	appendNewTranscriptItems(state) {
+		const { getTool, getToolCall } = this.options;
+		if (state.events.length > this.appendedEventsCount) {
+			for (let i = this.appendedEventsCount; i < state.events.length; i++) {
+				const event = state.events[i];
+				const formatted = formatEvent(event, {
+					replay: event.seq <= state.replayThrough,
+					getTool,
+					getToolCall
+				});
+				if (formatted !== void 0 && formatted !== "") this.documentContainer.addChild(createTranscriptLine(formatted));
+			}
+			this.appendedEventsCount = state.events.length;
+		}
+		if (state.shellHistory.length > this.appendedShellCount) {
+			for (let i = this.appendedShellCount; i < state.shellHistory.length; i++) {
+				const run = state.shellHistory[i];
+				this.documentContainer.addChild(createTranscriptLine(formatShellRun(run.command, run.output, run.exitCode)));
+			}
+			this.appendedShellCount = state.shellHistory.length;
+		}
+	}
+	/** Loads (once, cached in the store) and resolves with the `@`-mention file index, for `CustomEditor`'s autocomplete provider. */
+	waitForFileIndex() {
+		const { store, actions } = this.options;
+		actions.ensureFileIndex();
+		const snapshot = store.getSnapshot().fileIndex;
+		if (snapshot.candidates !== void 0) return Promise.resolve(snapshot.candidates);
+		return new Promise((resolve) => {
+			const unsubscribe = store.subscribe(() => {
+				const current = store.getSnapshot().fileIndex;
+				if (current.candidates !== void 0) {
+					unsubscribe();
+					resolve(current.candidates);
+				}
+			});
+		});
+	}
+	buildOverlayComponent(overlay) {
+		const { store, actions, getTool, getToolCall } = this.options;
+		switch (overlay.kind) {
+			case "none": return;
+			case "modelProfile": return new ModelProfileOverlay(store, actions);
+			case "trajectory": return new TrajectoryOverlay(this.tui, store, actions, getTool);
+			case "toolCards": return new ToolCardsOverlay(this.tui, store, actions, getTool, getToolCall);
+			case "context": return new ContextOverlay(store, actions);
+			case "plugins": return new PluginsOverlay(this.tui, overlay.rows, actions);
+			case "agentPresets": return new AgentPresetsOverlay(store, actions);
+			case "approval": return;
+			case "userQuestion": return new QuestionOverlay(overlay.userQuestion, actions);
+		}
+	}
+	updateOverlay(overlay) {
+		if (overlay.kind === this.currentOverlayKind) return;
+		const previousKind = this.currentOverlayKind;
+		this.currentOverlayKind = overlay.kind;
+		if ((overlay.kind === "approval" || overlay.kind === "userQuestion") && previousKind !== "approval" && previousKind !== "userQuestion") {
+			const message = overlay.kind === "approval" ? "dsh-tui is waiting for your approval" : "dsh-tui is waiting for your answer";
+			this.tui.terminal.write(`\x1b]9;${message}\x07`);
+		}
+		if (previousKind === "approval") this.approvalSlot.set(void 0);
+		if (this.overlayHandle !== void 0) {
+			this.overlayHandle.hide();
+			this.overlayHandle = void 0;
+		}
+		if (overlay.kind === "approval") {
+			this.approvalSlot.set(new ApprovalOverlay(overlay.approval, this.options.actions));
+			this.tui.setFocus(this.approvalSlot);
+			return;
+		}
+		this.tui.setFocus(this.editor);
+		const component = this.buildOverlayComponent(overlay);
+		if (component === void 0) return;
+		this.overlayHandle = this.tui.showOverlay(new FullScreenOverlay(component, this.tui), OVERLAY_OPTIONS);
+	}
+	unmount(options) {
+		if (this.stopped) return;
+		this.stopped = true;
+		this.spinner.stop();
+		this.tui.stop(options);
+		if (activeTui === this.tui) activeTui = void 0;
+	}
+	waitUntilExit() {
+		return new Promise((resolve) => setTimeout(resolve, 0));
+	}
+};
+/** Mount the interactive front door. */
+function mountTui(options) {
+	ensureKeybindings();
+	const app = new TuiApp(options);
+	app.start();
+	return app;
+}
+/** Directory names the fallback walk never descends into. */
+const WALK_EXCLUDES = /* @__PURE__ */ new Set([".git", "node_modules"]);
+/**
+* List candidate file paths under `cwd`, relative to `cwd`.
+* @param cwd - root to list from.
+* @returns tracked and untracked-but-not-gitignored paths via `git ls-files`
+* when `cwd` is inside a git repo; otherwise a bounded recursive walk.
+*/
+async function loadFileIndex(cwd) {
+	const fromGit = await listGitFiles(cwd);
+	if (fromGit !== void 0) return fromGit;
+	return walkDirectory(cwd);
+}
+function listGitFiles(cwd) {
+	return new Promise((resolve) => {
+		let out = "";
+		let child;
+		try {
+			child = spawn("git", [
+				"ls-files",
+				"--cached",
+				"--others",
+				"--exclude-standard"
+			], {
+				cwd,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			});
+		} catch {
+			resolve(void 0);
+			return;
+		}
+		child.stdout.on("data", (chunk) => {
+			out += chunk.toString();
+		});
+		child.on("error", () => resolve(void 0));
+		child.on("close", (code) => {
+			if (code !== 0) {
+				resolve(void 0);
+				return;
+			}
+			resolve(out.split("\n").filter((line) => line.length > 0));
+		});
+	});
+}
+async function walkDirectory(cwd) {
+	const results = [];
+	const queue = [cwd];
+	while (queue.length > 0 && results.length < 5e3) {
+		const dir = queue.shift();
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (results.length >= 5e3) break;
+			if (entry.isDirectory()) {
+				if (WALK_EXCLUDES.has(entry.name)) continue;
+				queue.push(join(dir, entry.name));
+				continue;
+			}
+			if (entry.isFile()) results.push(relative(cwd, join(dir, entry.name)));
+		}
+	}
+	return results;
+}
+//#endregion
+//#region src/tui-app/session.ts
+/**
+* ACRYL terminal host adapter: brings up one normal local runtime, opens or
+* resumes one native durable DSH session through the runtime-owned bridge,
+* projects the durable event log into `TuiStore`, and drives the pi-tui shell
+* (ported from `tomowang/dsh-tui`) through `TuiActions`. The adapter owns the
+* mount/dispose order only; it reuses ACRYL runtime ownership and never
+* constructs a Cordis tree or touches DSH agent internals directly.
+*
+* First slice scope: create/resume -> prompt -> stream -> tool state -> cancel
+* -> clean dispose. Overlay, approval/question, model/preset and shell-mode
+* surfaces are intentionally stubbed (later increments).
+*/
+const TUI_VERSION = "0.1.0-dev.0";
+const PROMPT_HISTORY_LIMIT = 200;
+const NOT_AVAILABLE = "not available in this build yet";
+function failUnknown(status) {
+	return status === "running" ? "running" : "idle";
+}
+function toolPreview(ctx) {
+	return (name) => ctx.get("tools")?.get(name);
+}
+/** Mount one interactive pi-tui session over the bridge. Resolves when the shell exits. */
+async function runAcrylTui(options) {
+	const host = await startDirectHost({ profile: options.profile });
+	let bridge;
+	let instance;
+	let settled = false;
+	try {
+		const created = createAcrylSessionBridge(host.ctx, {
+			profile: options.profile,
+			generationId: randomUUID(),
+			attachment: "owner",
+			cwd: process.cwd()
+		});
+		bridge = created;
+		const sessionId = await created.open(options.resumeSessionId);
+		const store = new TuiStore({ events: created.events(sessionId) });
+		const initial = await created.snapshot(sessionId);
+		store.setStatus(failUnknown(initial.agentStatus));
+		created.subscribeEvents(sessionId, (event) => {
+			store.appendEvent(event);
+			created.snapshot(sessionId).then((next) => store.setStatus(failUnknown(next.agentStatus)));
+		});
+		const history = [];
+		let exitResolve = () => {};
+		const exited = new Promise((resolve) => {
+			exitResolve = resolve;
+		});
+		const actions = {
+			send(text) {
+				store.setNotice(void 0);
+				created.submitPrompt({
+					sessionId,
+					text
+				}).catch((error) => {
+					store.setNotice(error instanceof Error ? error.message : String(error));
+				});
+			},
+			cancel() {
+				created.cancel(sessionId).catch(() => {});
+			},
+			shutdown() {
+				exitResolve();
+			},
+			help() {
+				store.setNotice("available: any text submits, Ctrl+C cancels, Ctrl+D exits, /help shows commands");
+			},
+			recordHistory(line) {
+				history.push(line);
+				if (history.length > PROMPT_HISTORY_LIMIT) history.shift();
+			},
+			clear() {
+				store.setNotice(`/clear ${NOT_AVAILABLE}`);
+			},
+			cyclePermission() {
+				store.setNotice(`permission cycling ${NOT_AVAILABLE}`);
+			},
+			compact() {
+				store.setNotice(`/compact ${NOT_AVAILABLE}`);
+			},
+			plan() {
+				store.setNotice(`plan mode ${NOT_AVAILABLE}`);
+			},
+			goal() {
+				store.setNotice(`goal mode ${NOT_AVAILABLE}`);
+			},
+			runShell() {
+				store.setNotice(`shell mode ${NOT_AVAILABLE}`);
+			},
+			ensureFileIndex() {
+				if (store.getSnapshot().fileIndex.candidates !== void 0) return;
+				loadFileIndex(process.cwd()).then((candidates) => store.setFileIndex(candidates));
+			},
+			openModelProfile() {
+				store.setNotice(`/model ${NOT_AVAILABLE}`);
+			},
+			openTrajectory() {
+				store.setNotice(`/trajectory ${NOT_AVAILABLE}`);
+			},
+			openToolCards() {
+				store.setNotice(`/tools ${NOT_AVAILABLE}`);
+			},
+			openContext() {
+				store.setNotice(`/context ${NOT_AVAILABLE}`);
+			},
+			openPlugins() {
+				store.setNotice(`/plugins ${NOT_AVAILABLE}`);
+			},
+			openAgentPresets() {
+				store.setNotice(`/presets ${NOT_AVAILABLE}`);
+			},
+			closeModelProfile() {},
+			backToProviderList() {},
+			selectProvider() {},
+			createProvider() {},
+			editProvider() {},
+			saveProvider() {},
+			deleteProvider() {},
+			discoverModelsForDraft() {},
+			setActiveModel() {},
+			closeTrajectory() {},
+			closeToolCards() {},
+			closeContext() {},
+			closePlugins() {},
+			closeAgentPresets() {},
+			selectAgentPresetRow() {},
+			applyAgentPreset() {},
+			answerApproval() {},
+			answerQuestion() {}
+		};
+		const selection = host.ctx.get("agentDefaultModel")?.currentSelection();
+		instance = mountTui({
+			store,
+			actions,
+			sessionId,
+			provider: selection?.provider ?? "",
+			model: selection?.model ?? "",
+			version: TUI_VERSION,
+			cwd: process.cwd(),
+			promptHistory: history,
+			getTool: toolPreview(host.ctx),
+			getToolCall: store.getToolCall
+		});
+		await exited;
+		instance.unmount();
+		await created.dispose();
+		await host.dispose();
+		const resumeHint = stripSessionIdPrefix(sessionId);
+		return Object.freeze({
+			sessionId,
+			resumeHint,
+			async dispose() {
+				if (settled) return;
+				settled = true;
+				instance?.unmount();
+				await bridge?.dispose();
+				await host.dispose();
+			}
+		});
+	} catch (error) {
+		instance?.unmount();
+		await bridge?.dispose().catch(() => {});
+		await host.dispose();
+		throw error;
+	}
+}
+//#endregion
+//#region src/version.ts
+/** Canonical ACRYL version string used by the CLI and the release smoke checks. */
+const ACRYL_VERSION = "0.1.0-dev.0";
+//#endregion
+//#region src/cli/grammar.ts
+const HOST_COMMANDS = /* @__PURE__ */ new Set([
+	"tui",
+	"gui",
+	"web"
+]);
+function hostCommand(value) {
+	return HOST_COMMANDS.has(value) ? value : void 0;
+}
+function parseAcrylArgs(args) {
+	let command;
+	let profile;
+	let resumeSessionId;
+	let json = false;
+	let version = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const argument = args[index];
+		if (argument === void 0) continue;
+		if (argument === "--version" || argument === "-v") {
+			if (version) throw new Error("--version may be provided only once");
+			version = true;
+			continue;
+		}
+		if (argument === "--profile") {
+			if (profile !== void 0) throw new Error("--profile may be provided only once");
+			const value = args[index + 1];
+			if (value === void 0 || value.startsWith("--") || value.trim() === "") throw new Error("--profile requires a value");
+			profile = value;
+			index += 1;
+			continue;
+		}
+		if (argument === "--resume") {
+			if (resumeSessionId !== void 0) throw new Error("--resume may be provided only once");
+			const value = args[index + 1];
+			if (value === void 0 || value.startsWith("--") || value.trim() === "") throw new Error("--resume requires a session id");
+			resumeSessionId = value;
+			index += 1;
+			continue;
+		}
+		if (argument === "--json") {
+			if (json) throw new Error("--json may be provided only once");
+			json = true;
+			continue;
+		}
+		if (argument.startsWith("-")) throw new Error(`unknown option: ${argument}`);
+		const parsed = hostCommand(argument);
+		if (command === void 0) {
+			if (parsed === void 0) throw new Error(`unknown command: ${argument}`);
+			command = parsed;
+			continue;
+		}
+		throw new Error(`unexpected argument for ${command}: ${argument}`);
+	}
+	const resolvedCommand = command ?? "tui";
+	if (!version && profile === void 0 && resumeSessionId === void 0) return {
+		command: resolvedCommand,
+		json,
+		version
+	};
+	return {
+		command: resolvedCommand,
+		json,
+		version,
+		...profile === void 0 ? {} : { profile },
+		...resumeSessionId === void 0 ? {} : { resumeSessionId }
+	};
+}
+//#endregion
+//#region src/cli/run.ts
+const defaults = {
+	startDirectHost,
+	runTui: runAcrylTui,
+	exit: (code) => {
+		process.exitCode = code;
+	},
+	write: (line) => {
+		process.stdout.write(`${line}\n`);
+	}
+};
+function statusLine(host) {
+	return JSON.stringify({
+		mode: "direct",
+		profile: host.profile,
+		generationId: host.generationId
+	});
+}
+/**
+* Run the direct ACRYL terminal host. `--json` is a short-lived, scriptable
+* headless readiness probe; interactive mode mounts the pi-tui session via the
+* runtime bridge until a normal exit, then prints a resumable session id.
+*/
+async function runAcryl(args, supplied = {}) {
+	const dependencies = {
+		...defaults,
+		...supplied
+	};
+	const invocation = parseAcrylArgs(args);
+	if (invocation.command !== "tui") throw new Error(`ACRYL ${invocation.command} host is not implemented; use "acryl tui"`);
+	if (invocation.version) {
+		dependencies.write(ACRYL_VERSION);
+		return;
+	}
+	if (invocation.json) {
+		const host = await dependencies.startDirectHost({ profile: invocation.profile ?? "acryl" });
+		try {
+			dependencies.write(statusLine(host));
+		} finally {
+			await host.dispose();
+		}
+		return;
+	}
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		dependencies.write("acryl-tui: stdin and stdout must both be TTYs; use `acryl tui --json` for a headless probe");
+		dependencies.exit(1);
+		return;
+	}
+	const result = await dependencies.runTui({
+		profile: invocation.profile ?? "acryl",
+		resumeSessionId: invocation.resumeSessionId
+	});
+	dependencies.write(`resume with: acryl tui --resume ${result.resumeHint}`);
+}
+//#endregion
+//#region src/bin.ts
+function isEntrypoint() {
+	const entrypoint = process.argv[1];
+	return entrypoint !== void 0 && resolve(entrypoint) === fileURLToPath(import.meta.url);
+}
+if (isEntrypoint()) (async () => {
+	const script = process.argv[1];
+	if (script === void 0) throw new Error("ACRYL Node entrypoint is unavailable");
+	if (await relaunchWithExposedInternals({
+		execArgv: process.execArgv,
+		script,
+		args: process.argv.slice(2)
+	})) return;
+	await runAcryl(process.argv.slice(2));
+})().catch((cause) => {
+	const message = cause instanceof Error ? cause.message : String(cause);
+	process.stderr.write(`acryl: ${message}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export { parseAcrylArgs, runAcryl };