@songtonyli/dsh-cli 0.1.10 → 0.1.11

package/node_modules/@deepseek-ai/dsh-tui-app/lib/index.js

@@ -1,11 +1,12 @@
 import { randomUUID } from "node:crypto";
-import { Container, Editor, Input, Loader, Markdown, ProcessTerminal, SelectList, Text, TuiMainScreen, matchesKey, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, Container, Editor, Input, Loader, Markdown, ProcessTerminal, SelectList, Text, TuiMainScreen, decodeKittyPrintable, fuzzyFilter, matchesKey, sliceByColumn, stripTerminalSequences, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import z from "@deepseek-ai/schemastery";
 import { brandString } from "@deepseek-ai/dsh-brand";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { launchEnvironmentOf, launchedThroughSsh } from "@deepseek-ai/dsh-launch-environment";
 import { canOpenNativePath, openNativeUrl } from "@deepseek-ai/dsh-native-command";
 import { SessionLogOffset } from "@deepseek-ai/dsh-session";
+import { homedir } from "node:os";
 import "@deepseek-ai/cordis";
 import { HarnessError, ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { activeAtToken, formatFileMention } from "@deepseek-ai/dsh-file-reference";
@@ -100,953 +101,2149 @@ async function attachLocalFile(store, cwd, path) {
 	};
 }
 //#endregion
-//#region lib/types/catalog.js
+//#region lib/types/diff.js
 /**
-* Terminal rows for the browser's settings, plugins, subagents, deliverables,
-* and turn-outline pages. Each reader resolves its service through `ctx.get`
-* and throws an `Error` naming the absent service; the app prints the message.
-* @module @deepseek-ai/dsh-tui-app/catalog
+* Line diff for tool cards: a longest-common-subsequence alignment of old and
+* new text, bounded so a huge file falls back to a plain replacement view.
+* @module @deepseek-ai/dsh-tui-app/diff
 */
-var __addDisposableResource$1 = function(env, value, async) {
-	if (value !== null && value !== void 0) {
-		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-		var dispose, inner;
-		if (async) {
-			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-			dispose = value[Symbol.asyncDispose];
-		}
-		if (dispose === void 0) {
-			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-			dispose = value[Symbol.dispose];
-			if (async) inner = dispose;
+/** Above this many old×new line pairs the quadratic alignment is skipped. */
+const MAX_ALIGNMENT_CELLS = 4e6;
+function splitLines(text) {
+	if (text === "") return [];
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	return lines;
+}
+/**
+* Align `oldText` against `newText` line by line.
+* @param oldText - the previous file content, or null when the file is new.
+* @param newText - the new file content.
+* @returns the rows in display order; a new file yields only added rows.
+*/
+function diffLines(oldText, newText) {
+	const next = splitLines(newText);
+	if (oldText === null) return next.map((text) => ({
+		kind: "added",
+		text
+	}));
+	const previous = splitLines(oldText);
+	if (previous.length * next.length > MAX_ALIGNMENT_CELLS) return [...previous.map((text) => ({
+		kind: "removed",
+		text
+	})), ...next.map((text) => ({
+		kind: "added",
+		text
+	}))];
+	const cols = next.length + 1;
+	const lcs = new Uint32Array((previous.length + 1) * cols);
+	for (let i = previous.length - 1; i >= 0; i--) for (let j = next.length - 1; j >= 0; j--) lcs[i * cols + j] = previous[i] === next[j] ? lcs[(i + 1) * cols + j + 1] + 1 : Math.max(lcs[(i + 1) * cols + j], lcs[i * cols + j + 1]);
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < previous.length && j < next.length) if (previous[i] === next[j]) {
+		out.push({
+			kind: "context",
+			text: previous[i]
+		});
+		i++;
+		j++;
+	} else if (lcs[(i + 1) * cols + j] >= lcs[i * cols + j + 1]) {
+		out.push({
+			kind: "removed",
+			text: previous[i]
+		});
+		i++;
+	} else {
+		out.push({
+			kind: "added",
+			text: next[j]
+		});
+		j++;
+	}
+	for (; i < previous.length; i++) out.push({
+		kind: "removed",
+		text: previous[i]
+	});
+	for (; j < next.length; j++) out.push({
+		kind: "added",
+		text: next[j]
+	});
+	return out;
+}
+/**
+* Keep changed rows plus `context` unchanged rows around each change, so a
+* card shows the hunks rather than the whole file.
+* @param lines - the aligned rows.
+* @param context - unchanged rows kept on each side of a change.
+* @returns the rows to display, with an `undefined` gap marker where rows were elided.
+*/
+function hunks(lines, context) {
+	const keep = new Array(lines.length).fill(false);
+	lines.forEach((line, index) => {
+		if (line.kind === "context") return;
+		for (let k = Math.max(0, index - context); k <= Math.min(lines.length - 1, index + context); k++) keep[k] = true;
+	});
+	const out = [];
+	let gap = false;
+	lines.forEach((line, index) => {
+		if (keep[index] === true) {
+			out.push(line);
+			gap = false;
+		} else if (!gap) {
+			out.push(void 0);
+			gap = true;
 		}
-		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-		if (inner) dispose = function() {
-			try {
-				inner.call(this);
-			} catch (e) {
-				return Promise.reject(e);
-			}
+	});
+	return out;
+}
+//#endregion
+//#region lib/types/transcript.js
+/**
+* Pure transcript formatting: durable session facts and tool presentation
+* views become plain text rows for the terminal components to draw. Nothing
+* here touches the terminal, the palette, or the agent.
+* @module @deepseek-ai/dsh-tui-app/transcript
+*/
+/** Unchanged rows shown around each diff hunk. */
+const DIFF_CONTEXT_LINES = 2;
+/**
+* Join the text of the text blocks in `blocks`; other block kinds are
+* summarized in brackets so a card never hides that they exist.
+* @param blocks - model or tool content.
+* @returns the readable text.
+*/
+function contentText(blocks) {
+	return blocks.map((block) => {
+		if (block.type === "text") return block.text;
+		if (block.type === "reasoning") return "";
+		return `[${block.type}]`;
+	}).filter((part) => part !== "").join("\n");
+}
+/**
+* Compact token count: `950`, `1.2k`, `3.4M`.
+* @param count - a non-negative token count.
+* @returns the formatted count.
+*/
+function formatTokens(count) {
+	if (count < 1e3) return String(count);
+	if (count < 1e6) return `${(count / 1e3).toFixed(count < 1e4 ? 1 : 0)}k`;
+	return `${(count / 1e6).toFixed(1)}M`;
+}
+/**
+* Compact elapsed time for the live counters: `0s`, `8s`, `1m12s`, `1h04m`,
+* `26h07m`. Seconds are truncated rather than rounded, so a counter never
+* reports a second that has not passed, and a negative input — a clock that
+* moved backwards between two samples — reads `0s`. A unit under a larger one
+* is padded to two digits so the text keeps its width while a counter runs,
+* and past an hour the seconds are dropped. `formatDuration` in `status.ts`
+* reports recorded model and tool times instead: tenths under a minute, and
+* no hour unit.
+* @param ms - elapsed milliseconds.
+* @returns the formatted duration.
+*/
+function formatElapsed(ms) {
+	const total = Math.max(0, Math.floor(ms / 1e3));
+	const hours = Math.floor(total / 3600);
+	const minutes = Math.floor(total / 60) % 60;
+	const seconds = total % 60;
+	if (hours > 0) return `${String(hours)}h${String(minutes).padStart(2, "0")}m`;
+	if (minutes > 0) return `${String(minutes)}m${String(seconds).padStart(2, "0")}s`;
+	return `${String(seconds)}s`;
+}
+/**
+* `YYYY-MM-DD HH:MM` in UTC: how this terminal dates a recorded moment, in
+* the session picker, the subagent details, and the status bar alike.
+* @param ms - a Unix timestamp in milliseconds.
+* @returns the formatted timestamp.
+*/
+function formatTimestamp(ms) {
+	return new Date(ms).toISOString().slice(0, 16).replace("T", " ");
+}
+/** The zero totals a fresh session starts from. */
+const EMPTY_USAGE = {
+	inputTokens: 0,
+	outputTokens: 0,
+	cacheReadTokens: 0,
+	lastInputTokens: 0
+};
+/**
+* Fold one committed usage record into the totals.
+* @param totals - the totals so far.
+* @param usage - the message's usage.
+* @returns the new totals.
+*/
+function addUsage(totals, usage) {
+	return {
+		inputTokens: totals.inputTokens + usage.inputTokens,
+		outputTokens: totals.outputTokens + usage.outputTokens,
+		cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0),
+		lastInputTokens: usage.inputTokens + (usage.cacheReadTokens ?? 0)
+	};
+}
+/**
+* The one-line usage summary drawn in the footer.
+* @param totals - the cumulative totals.
+* @returns the summary, or an empty string before the first committed message.
+*/
+function formatUsage(totals) {
+	if (totals.inputTokens === 0 && totals.outputTokens === 0) return "";
+	const parts = [`↑${formatTokens(totals.inputTokens)}`, `↓${formatTokens(totals.outputTokens)}`];
+	if (totals.cacheReadTokens > 0) parts.push(`cache ${formatTokens(totals.cacheReadTokens)}`);
+	parts.push(`ctx ${formatTokens(totals.lastInputTokens)}`);
+	return parts.join(" ");
+}
+/**
+* The notice a closed turn earns, or undefined for an ordinary completion.
+* @param reason - the durable turn-end reason.
+* @returns the notice text.
+*/
+function turnEndNotice(reason) {
+	switch (reason.kind) {
+		case "completed": return;
+		case "aborted": return "turn stopped";
+		case "blocked": return "turn blocked: the model produced nothing the loop could continue";
+		case "error": return `turn failed: ${reason.error.code}: ${reason.error.message}`;
+		case "max-tokens": return "turn reached the output token ceiling";
+		case "interrupted": return "turn was interrupted by an earlier process exit";
+		default: return assertNever(reason, "tui turn-end reason");
+	}
+}
+/**
+* One-line text for a failure value from a handler, a service, or the host.
+* @param error - the thrown or rejected value.
+* @returns the error message, or the value rendered as a string.
+*/
+function describeFailure(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Parse the model's raw argument JSON for presentation.
+* @param argumentsJson - the `tool/call` event's verbatim argument string.
+* @returns the parsed value, or undefined when it is not JSON.
+*/
+function parseArguments(argumentsJson) {
+	try {
+		return JSON.parse(argumentsJson);
+	} catch {
+		return;
+	}
+}
+/**
+* Render a diff for a card body.
+* @param diff - one file's old and new text.
+* @returns rows prefixed with `+`, `-`, or two spaces, plus `…` gap markers.
+*/
+function diffRows(diff) {
+	return hunks(diffLines(diff.oldText, diff.newText), DIFF_CONTEXT_LINES).map((row) => {
+		if (row === void 0) return "  …";
+		return (row.kind === "added" ? "+ " : row.kind === "removed" ? "- " : "  ") + row.text;
+	});
+}
+/**
+* Text for a tool call from its presentation view, falling back to the raw
+* arguments when the tool declares no presenter.
+* @param argumentsJson - the verbatim argument JSON.
+* @param view - the tool's `presentCall` view, when it has one.
+* @returns the card's call text.
+*/
+function toolCallText(argumentsJson, view) {
+	if (view === void 0) {
+		const parsed = parseArguments(argumentsJson);
+		const summary = parsed === void 0 ? argumentsJson : JSON.stringify(parsed);
+		return {
+			title: "",
+			lines: summary === "{}" || summary === "" ? [] : [summary]
 		};
-		env.stack.push({
-			value,
-			dispose,
-			async
-		});
+	}
+	switch (view.card) {
+		case "generic": {
+			const lines = [];
+			if (view.content !== void 0) lines.push(...contentText(view.content).split("\n"));
+			return {
+				title: view.title,
+				lines
+			};
+		}
+		case "terminal": {
+			const lines = [];
+			if (view.description !== void 0) lines.push(view.description);
+			if (view.cwd !== void 0) lines.push(`cwd: ${view.cwd}`);
+			return {
+				title: view.title,
+				lines
+			};
+		}
+		case "diff": return {
+			title: view.title,
+			lines: view.diffs.flatMap((diff) => [diff.path, ...diffRows(diff)])
+		};
+		default: return assertNever(view, "tui tool call view");
+	}
+}
+/**
+* Text rows for a completed tool call from its presentation view, falling
+* back to the model-facing result content.
+* @param view - the tool's `presentResult` view, when it has one.
+* @param content - the model-facing result content.
+* @returns the rows, before any preview truncation.
+*/
+function toolResultLines(view, content) {
+	if (view === void 0) return contentText(content).split("\n").filter((line) => line !== "");
+	switch (view.card) {
+		case "generic": return contentText(view.content ?? content).split("\n").filter((line) => line !== "");
+		case "terminal": {
+			const lines = (view.output ?? "").split("\n");
+			while (lines.length > 0 && lines.at(-1) === "") lines.pop();
+			if (view.exitCode !== void 0 && view.exitCode !== 0) lines.push(`exit ${String(view.exitCode)}`);
+			if (view.signal !== void 0) lines.push(`signal ${view.signal}`);
+			return lines;
+		}
+		case "diff": return view.diffs.flatMap((diff) => [diff.path, ...diffRows(diff)]);
+		case "search": {
+			const lines = view.shape === "matches" ? view.files.flatMap((file) => file.matches.map((match) => `${file.path}:${String(match.lineNumber)}: ${match.line}`)) : [...view.paths];
+			if (view.truncated) lines.push(`… ${String(view.total)} total`);
+			return lines;
+		}
+		case "read": return view.lines.map((line) => `${String(line.number).padStart(4)}│ ${line.text}`);
+		case "web": {
+			if (view.kind === "fetch") return [`${view.url} (${String(view.statusCode)})`];
+			const lines = view.sources.map((source) => source.title === void 0 ? source.url : `${source.title} — ${source.url}`);
+			if (view.answer !== void 0) lines.unshift(view.answer);
+			return lines;
+		}
+		default: return assertNever(view, "tui tool result view");
+	}
+}
+/**
+* Cut a card body to its collapsed preview.
+* @param lines - the full body rows.
+* @param previewLines - rows kept when collapsed.
+* @param expanded - whether the user expanded tool cards.
+* @returns the rows to draw, with a trailing count of hidden rows when cut.
+*/
+function previewLines(lines, previewLines, expanded) {
+	if (expanded || lines.length <= previewLines) return [...lines];
+	const hidden = lines.length - previewLines;
+	return [...lines.slice(0, previewLines), `… ${String(hidden)} more line${hidden === 1 ? "" : "s"} (Ctrl+O expands)`];
+}
+//#endregion
+//#region lib/types/catalog.js
+/**
+* Terminal rows for the browser's settings, plugins, subagents, deliverables,
+* and turn-outline pages. Each reader resolves its service through `ctx.get`
+* and throws an `Error` naming the absent service; the app prints the message.
+* `subagentDetail` is the exception: it returns that message as a row.
+* @module @deepseek-ai/dsh-tui-app/catalog
+*/
+var __addDisposableResource$1 = function(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
 	} else if (async) env.stack.push({ async: true });
 	return value;
 };
-var __disposeResources$1 = (function(SuppressedError) {
-	return function(env) {
-		function fail(e) {
-			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-			env.hasError = true;
-		}
-		var r, s = 0;
-		function next() {
-			while (r = env.stack.pop()) try {
-				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-				if (r.dispose) {
-					var result = r.dispose.call(r.value);
-					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-						fail(e);
-						return next();
-					});
-				} else s |= 1;
-			} catch (e) {
-				fail(e);
+var __disposeResources$1 = (function(SuppressedError) {
+	return function(env) {
+		function fail(e) {
+			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+			env.hasError = true;
+		}
+		var r, s = 0;
+		function next() {
+			while (r = env.stack.pop()) try {
+				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+				if (r.dispose) {
+					var result = r.dispose.call(r.value);
+					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+						fail(e);
+						return next();
+					});
+				} else s |= 1;
+			} catch (e) {
+				fail(e);
+			}
+			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+			if (env.hasError) throw env.error;
+		}
+		return next();
+	};
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+	var e = new Error(message);
+	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/**
+* Turns and presented files a subagent detail page lists in full; the rest of
+* each list folds into one `… <n> more …` row.
+*/
+const SUBAGENT_DETAIL_LIMIT = 8;
+/** Two-space indentation per nesting level. */
+function indent(depth) {
+	return "  ".repeat(depth);
+}
+/** The settings service, or a printable error naming its absence. */
+function requireSettings(ctx) {
+	const settings = ctx.get("settings");
+	if (settings === void 0) throw new Error("settings are not mounted in this profile");
+	return settings;
+}
+/** One namespace's redacted descriptor, or a printable error when it is not registered. */
+function requireDescriptor(settings, ns) {
+	const descriptor = settings.describe({ redactSecrets: true }).find((candidate) => candidate.ns === ns);
+	if (descriptor === void 0) throw new Error(`settings namespace "${ns}" is not registered`);
+	return descriptor;
+}
+/**
+* One row per registered settings namespace: the namespace, its revision,
+* whether the stored user section overrides anything, and when its owner
+* applies changes.
+* @param ctx - plugin context carrying the optional settings service.
+* @returns the rows in registration order.
+* @throws {Error} when no settings service is mounted.
+*/
+function listSettings(ctx) {
+	return requireSettings(ctx).describe({ redactSecrets: true }).map((descriptor) => {
+		const overridden = Object.keys(descriptor.user ?? {}).length > 0;
+		return `${descriptor.ns}  rev ${String(descriptor.revision)}  ${overridden ? "user-overridden" : "inherited"}  applies ${descriptor.applies}`;
+	});
+}
+/**
+* Pretty-printed JSON of one namespace's resolved value with every secret
+* field removed, followed by one row per secret slot stating whether it holds
+* a value.
+* @param ctx - plugin context carrying the optional settings service.
+* @param ns - the registered namespace to show.
+* @returns the JSON lines, then the secret-slot rows.
+* @throws {Error} when no settings service is mounted or `ns` is not registered.
+*/
+function showSetting(ctx, ns) {
+	const descriptor = requireDescriptor(requireSettings(ctx), ns);
+	const rows = JSON.stringify(descriptor.value, null, 2).split("\n");
+	for (const secret of descriptor.secrets ?? []) rows.push(`secret ${secret.path.join(".")}: ${secret.set ? "set" : "unset"}`);
+	return rows;
+}
+/**
+* Write one field of a namespace's user section through a path-addressed
+* `set` against the revision read at call time. `rawValue` is parsed as JSON
+* when it is valid JSON and stored as a string otherwise; an empty `path`
+* addresses the section root, which then requires a JSON object.
+* @param ctx - plugin context carrying the optional settings service.
+* @param ns - the registered namespace to edit.
+* @param path - dot-separated field path (`api.timeoutMs`), or `''` for the root.
+* @param rawValue - the typed value, JSON or plain text.
+* @returns a confirmation row naming the namespace, path, and stored value.
+* @throws {Error} when no settings service is mounted or `ns` is not registered.
+*/
+async function setSetting(ctx, ns, path, rawValue) {
+	const settings = requireSettings(ctx);
+	const { revision } = requireDescriptor(settings, ns);
+	const value = parseSettingValue(rawValue);
+	const parts = path === "" ? [] : path.split(".");
+	await settings.mutate(ns, [{
+		op: "set",
+		path: parts,
+		value
+	}], revision);
+	return `settings ${ns}: set ${path === "" ? "(root)" : path} = ${JSON.stringify(value)}`;
+}
+/** JSON when the text parses, otherwise the text itself. */
+function parseSettingValue(rawValue) {
+	try {
+		return JSON.parse(rawValue);
+	} catch {
+		return rawValue;
+	}
+}
+/**
+* Empty one namespace's user section so every field re-inherits its
+* composition base and schema default.
+* @param ctx - plugin context carrying the optional settings service.
+* @param ns - the registered namespace to reset.
+* @returns a confirmation row.
+* @throws {Error} when no settings service is mounted or `ns` is not registered.
+*/
+async function resetSetting(ctx, ns) {
+	const settings = requireSettings(ctx);
+	const { revision } = requireDescriptor(settings, ns);
+	await settings.replace(ns, {}, revision);
+	return `settings ${ns}: reset to defaults`;
+}
+/**
+* One row per non-group Loader entry: entry id, module name, effective
+* enablement, and the root Fiber phase (`none` without a live root Fiber).
+* @param ctx - plugin context carrying the optional Cordis Loader.
+* @returns the rows in Loader order.
+* @throws {Error} when no Loader is mounted.
+*/
+function listPlugins(ctx) {
+	const loader = ctx.get("loader");
+	if (loader === void 0) throw new Error("the plugin loader is not mounted in this profile");
+	const rows = [];
+	for (const entry of loader.entries()) {
+		if (entry.options.group) continue;
+		const phase = pluginFiberPhase(entry.fiber?.state);
+		rows.push(`${entry.id}  ${entry.options.name}  ${entry.disabled ? "disabled" : "enabled"}  ${phase ?? "none"}`);
+	}
+	return rows;
+}
+/**
+* One descendant listing entry as a picker row: the child session id (usable
+* with `/sessions` and `--resume`), its activity, mode, and label, or a
+* diagnostic candidate's reason. The live panel enters the same row.
+* @param entry - the listing entry.
+* @returns the row; `enterable` is false exactly for a diagnostic entry.
+*/
+function subagentChoice(entry) {
+	const prefix = indent(entry.depth - 1);
+	switch (entry.kind) {
+		case "child": {
+			const parts = [entry.activity, entry.mode];
+			if (entry.label !== void 0) parts.push(entry.id);
+			return {
+				id: entry.id,
+				depth: entry.depth,
+				label: `${prefix}${entry.label ?? entry.id}`,
+				description: parts.join(" · "),
+				enterable: true
+			};
+		}
+		case "diagnostic": return {
+			id: entry.id,
+			depth: entry.depth,
+			label: `${prefix}${entry.id}`,
+			description: entry.reason,
+			enterable: false
+		};
+		default: return assertNever(entry, "tui subagent list entry");
+	}
+}
+/**
+* Every session-backed subagent below one session in pre-order as picker rows.
+* @param ctx - plugin context carrying the optional subagent runtime.
+* @param sessionId - the root session whose descendants are listed.
+* @param signal - cancels the listing.
+* @returns one choice per descendant in listing order, empty when the session has no subagents.
+* @throws {Error} when no subagent runtime is mounted.
+*/
+async function listSubagentChoices(ctx, sessionId, signal) {
+	const subagents = ctx.get("subagents");
+	if (subagents === void 0) throw new Error("subagents are not mounted in this profile");
+	return (await subagents.listDescendants(sessionId, signal)).map(subagentChoice);
+}
+/**
+* The rows shown when the user enters one subagent picker row: the row's own
+* label and description, the session's creation time and workspace, its
+* title, its turn outline, and the files it presented. Turns and presented
+* files each stop at {@link SUBAGENT_DETAIL_LIMIT} entries and fold the rest
+* into one counting row; a fact this profile keeps no projection or header
+* field for is skipped.
+*
+* Reading the session never throws here: a row that is not `enterable`, an
+* absent session query engine, and a failed read each return explanatory
+* rows instead.
+* @param ctx - plugin context carrying the optional session query engine.
+* @param choice - the entered picker row.
+* @param signal - cancels a cold log read.
+* @returns the detail rows; never empty.
+*/
+async function subagentDetail(ctx, choice, signal) {
+	if (!choice.enterable) return [choice.id, `unreadable subagent session: ${choice.description}`];
+	const query = ctx.get("sessionQuery");
+	if (query === void 0) return [`cannot read ${choice.id}: the session query engine is not mounted in this profile`];
+	try {
+		const env_1 = {
+			stack: [],
+			error: void 0,
+			hasError: false
+		};
+		try {
+			const observation = __addDisposableResource$1(env_1, await query.observeSession(choice.id, {
+				signal,
+				projectionMode: "all"
+			}), false);
+			const rows = [choice.label.slice(indent(choice.depth - 1).length), choice.description];
+			rows.push(`created: ${formatTimestamp(observation.header.createdAt)}`);
+			const { cwd } = observation.header;
+			if (cwd !== void 0) rows.push(`workspace: ${cwd}`);
+			const values = observation.projections?.values;
+			const title = values?.title;
+			if (title !== void 0 && title !== null) rows.push(`title: ${title}`);
+			rows.push(...foldDetailRows(values?.turnOutline ?? [], outlineRows, "turn"));
+			rows.push(...foldDetailRows(presentedPaths(observation.events), (path) => [`presented: ${path}`], "file"));
+			return rows;
+		} catch (e_1) {
+			env_1.error = e_1;
+			env_1.hasError = true;
+		} finally {
+			__disposeResources$1(env_1);
+		}
+	} catch (error) {
+		return [`cannot read ${choice.id}: ${describeFailure(error)}`];
+	}
+}
+/** Every presented path in log order, one entry per file of every `deliverables/presented` event. */
+function presentedPaths(events) {
+	const paths = [];
+	for (const event of events) {
+		if (event.type !== "deliverables/presented") continue;
+		for (const file of event.data.files) paths.push(file.path);
+	}
+	return paths;
+}
+/** The leading entries rendered in full, then one row counting the entries left out. */
+function foldDetailRows(entries, render, noun) {
+	const rows = entries.slice(0, SUBAGENT_DETAIL_LIMIT).flatMap(render);
+	const hidden = Math.max(0, entries.length - SUBAGENT_DETAIL_LIMIT);
+	if (hidden > 0) rows.push(`… ${String(hidden)} more ${noun}${hidden === 1 ? "" : "s"}`);
+	return rows;
+}
+/** One outline entry: the numbered prompt, then the indented response once the turn ended with text. */
+function outlineRows(entry) {
+	const rows = [`${String(entry.turn)}. ${entry.prompt === "" ? "(no prompt)" : entry.prompt}`];
+	if (entry.response !== "") rows.push(`${indent(1)}→ ${entry.response}`);
+	return rows;
+}
+/**
+* Files the model declared through the present tool, folded from the
+* session's `deliverables/presented` events and grouped under one `turn N`
+* heading per turn in log order.
+* @param ctx - plugin context carrying the optional session query engine.
+* @param sessionId - the session whose log is read.
+* @param signal - cancels a cold log read.
+* @returns the heading and file rows, empty when nothing was presented.
+* @throws {Error} when no session query engine is mounted.
+*/
+async function listDeliverables(ctx, sessionId, signal) {
+	const env_2 = {
+		stack: [],
+		error: void 0,
+		hasError: false
+	};
+	try {
+		const query = ctx.get("sessionQuery");
+		if (query === void 0) throw new Error("the session query engine is not mounted in this profile");
+		const observation = __addDisposableResource$1(env_2, await query.observeSession(sessionId, {
+			signal,
+			projectionMode: "none"
+		}), false);
+		const turns = /* @__PURE__ */ new Map();
+		for (const event of observation.events) {
+			if (event.type !== "deliverables/presented") continue;
+			const files = turns.get(event.data.turn) ?? [];
+			files.push(...event.data.files);
+			turns.set(event.data.turn, files);
+		}
+		const rows = [];
+		for (const [turn, files] of turns) {
+			rows.push(`turn ${String(turn)}`);
+			for (const file of files) rows.push(`${indent(1)}${file.path}${file.description === void 0 ? "" : `  ${file.description}`}`);
+		}
+		return rows;
+	} catch (e_2) {
+		env_2.error = e_2;
+		env_2.hasError = true;
+	} finally {
+		__disposeResources$1(env_2);
+	}
+}
+/**
+* The session's turn outline: one numbered row per started turn with its
+* prompt preview, followed by an indented response preview once the turn
+* ended with assistant text.
+* @param ctx - plugin context carrying the optional projection registry.
+* @param session - the live session whose outline is read.
+* @returns the rows, empty before the first turn starts.
+* @throws {Error} when no projection registry is mounted or the `turnOutline` unit is not registered.
+*/
+function sessionOutline(ctx, session) {
+	const projections = ctx.get("sessionProjections");
+	if (projections === void 0) throw new Error("session projections are not mounted in this profile");
+	const outline = projections.snapshot(session, ["turnOutline"]).values.turnOutline;
+	if (outline === void 0) throw new Error("the turnOutline projection is not registered in this profile");
+	return outline.flatMap(outlineRows);
+}
+/** Control Sequence Introducer. */
+const CSI = "\x1B[";
+/**
+* Ends the foreground color a recolored run set. SGR 39 restores the default
+* foreground only: bold, italic, underline, inverse, and the background set by
+* enclosing markdown styling stay in force.
+*/
+const RESET_FOREGROUND = `${CSI}39m`;
+/** Faint intensity: the only ramp level the two-level mode draws. */
+const DIM = `${CSI}2m`;
+/** Ends faint intensity. SGR 22 also ends bold, which shares the code. */
+const RESET_INTENSITY = `${CSI}22m`;
+/** Ages the two-level mode draws faint; later ages draw as rendered. */
+const DIM_AGES = 2;
+/** First xterm 256-color grayscale index. */
+const GRAY_FIRST_INDEX = 232;
+/** Grayscale levels the indices 232..255 carry. */
+const GRAY_LEVELS = 24;
+/** Gray value index 232 carries. */
+const GRAY_FIRST_VALUE = 8;
+/** Gray value step between consecutive grayscale indices. */
+const GRAY_VALUE_STEP = 10;
+/** Relative-luminance weights used to pick the nearest gray. */
+const LUMINANCE = {
+	r: .2126,
+	g: .7152,
+	b: .0722
+};
+/** Largest value one color channel encodes. */
+const CHANNEL_MAX = 255;
+/**
+* Grapheme segmenter for the reverse column walk. pi-tui keeps its own
+* segmenter private, so this module holds one; grapheme segmentation does not
+* vary by locale.
+*/
+const GRAPHEMES = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/**
+* Decide how far the terminal can draw the ramp.
+*
+* Reduced motion, a disabled palette, a non-empty `NO_COLOR`, and `TERM=dumb`
+* each yield `none`, which draws every chunk at the foreground with no ramp.
+* Otherwise `COLORTERM` of `truecolor` or `24bit` yields `truecolor`, a `TERM`
+* naming `256color` yields `ansi256`, and every other terminal falls back to
+* the two-level `dim` mode.
+* @param input - the palette flag, the environment, and the reduced-motion preference.
+* @returns the capability {@link fadeSgr} and {@link recolorTail} encode under.
+*/
+function resolveFadeCapability(input) {
+	const { env } = input;
+	if (input.reducedMotion || !input.paletteEnabled) return "none";
+	if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return "none";
+	const term = env.TERM ?? "";
+	if (term === "dumb") return "none";
+	const colorterm = (env.COLORTERM ?? "").toLowerCase();
+	if (colorterm === "truecolor" || colorterm === "24bit") return "truecolor";
+	return term.includes("256color") ? "ansi256" : "dim";
+}
+/**
+* Build the brightness ramp a chunk climbs, `ramp[k] = lerp(bg, fg, (k + 1) /
+* steps)` in sRGB with each channel rounded to a byte. The last level is a
+* copy of `fg` rather than a computed value, so settled text and the last
+* faded frame carry identical color.
+* @param bg - the terminal background color.
+* @param fg - the normal foreground color.
+* @param steps - brightness levels; defaults to {@link FADE_STEPS}.
+* @returns `steps` levels, darkest first.
+*/
+function buildFadeRamp(bg, fg, steps = 5) {
+	return Array.from({ length: steps }, (_unused, level) => {
+		if (level === steps - 1) return {
+			r: fg.r,
+			g: fg.g,
+			b: fg.b
+		};
+		const ratio = (level + 1) / steps;
+		return {
+			r: mix(bg.r, fg.r, ratio),
+			g: mix(bg.g, fg.g, ratio),
+			b: mix(bg.b, fg.b, ratio)
+		};
+	});
+}
+/**
+* Interpolate one channel.
+* @param from - the background channel.
+* @param to - the foreground channel.
+* @param ratio - position between them, 0 at `from` and 1 at `to`.
+* @returns the channel value rounded to a byte.
+*/
+function mix(from, to, ratio) {
+	return Math.round(from + (to - from) * ratio);
+}
+/**
+* The SGR sequence one age draws under.
+* @param style - the capability and the ramp.
+* @param age - ticks since the chunk arrived; ages past the ramp draw its last level.
+* @returns the sequence to open the run with, or the empty string when the
+* chunk draws as the component rendered it, which is also what an empty ramp
+* yields under a color capability.
+*/
+function fadeSgr(style, age) {
+	if (style.capability === "none") return "";
+	if (style.capability === "dim") return age < DIM_AGES ? DIM : "";
+	const level = style.ramp[Math.max(0, Math.min(age, style.ramp.length - 1))];
+	if (level === void 0) return "";
+	return style.capability === "truecolor" ? truecolorSgr(level) : grayscaleSgr(level);
+}
+/**
+* Encode one level as a 24-bit foreground.
+* @param color - the ramp level.
+* @returns `ESC[38;2;R;G;Bm` with each channel clamped to a byte.
+*/
+function truecolorSgr(color) {
+	return `${CSI}38;2;${channel(color.r)};${channel(color.g)};${channel(color.b)}m`;
+}
+/**
+* Encode one level as the nearest xterm grayscale index.
+* @param color - the ramp level.
+* @returns `ESC[38;5;Nm` with N in 232..255.
+*/
+function grayscaleSgr(color) {
+	const luminance = LUMINANCE.r * color.r + LUMINANCE.g * color.g + LUMINANCE.b * color.b;
+	const step = Math.round((luminance - GRAY_FIRST_VALUE) / GRAY_VALUE_STEP);
+	return `${CSI}38;5;${GRAY_FIRST_INDEX + Math.max(0, Math.min(GRAY_LEVELS - 1, step))}m`;
+}
+/**
+* Clamp one channel to what an SGR byte carries.
+* @param value - the channel value.
+* @returns an integer in 0..255.
+*/
+function channel(value) {
+	return Math.max(0, Math.min(CHANNEL_MAX, Math.round(value)));
+}
+/**
+* The sequence that ends a recolored line.
+* @param capability - the encoding the runs were opened with.
+* @returns `ESC[22m` for the two-level mode, which set intensity, and
+* `ESC[39m` for the color modes, which set a foreground.
+*/
+function restoreFor(capability) {
+	return capability === "dim" ? RESET_INTENSITY : RESET_FOREGROUND;
+}
+/**
+* The tail of one streaming assistant message: the chunks young enough to be
+* recolored, advanced one tick at a time.
+*
+* Deltas are split at word boundaries, which reads more smoothly than raw
+* token edges. A delta that ends mid-word leaves that word open, and the next
+* delta extends it rather than starting a second chunk, so the word keeps the
+* tick it first became visible on.
+*
+* Fast streams. While each of the last {@link FADE_FAST_WINDOW_TICKS}
+* completed ticks received at least one chunk, the stream outruns the ramp and
+* the effect turns off: the arriving chunk is not tracked and the whole tail is
+* flushed, so nothing already on screen darkens. The decision is recoverable:
+* one tick without an arrival ends it, and chunks appended afterwards fade
+* again. Recovery only affects new chunks, so it never re-darkens settled text.
+*/
+var FadeTracker = class {
+	steps;
+	fastWindowTicks;
+	now = 0;
+	chunks = [];
+	openChunk = void 0;
+	arrivals = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.steps = options?.steps ?? 5;
+		this.fastWindowTicks = options?.fastWindowTicks ?? 10;
+	}
+	/**
+	* Take one stream event.
+	* @param delta - the text delta; the empty string is not a stream event and is ignored.
+	*/
+	append(delta) {
+		if (delta === "") return;
+		this.arrivals.add(this.now);
+		if (this.isFastStream()) {
+			this.flush();
+			return;
+		}
+		const open = this.openChunk;
+		const text = open === void 0 ? delta : open.text + delta;
+		const born = open === void 0 ? this.now : open.born;
+		if (open !== void 0) this.chunks.pop();
+		this.openChunk = void 0;
+		const words = text.match(/\s*\S+\s*/g);
+		if (words === null) {
+			this.openChunk = {
+				text,
+				born
+			};
+			this.chunks.push(this.openChunk);
+			return;
+		}
+		for (const [index, word] of words.entries()) this.chunks.push({
+			text: word,
+			born: index === 0 ? born : this.now
+		});
+		if (!/\s$/.test(text)) this.openChunk = this.chunks.at(-1);
+	}
+	/**
+	* Advance one tick and drop the chunks that reached `steps`.
+	* @returns whether this tick changed a chunk's color, and so needs a repaint.
+	*/
+	tick() {
+		const changing = this.needsRepaint();
+		this.now += 1;
+		this.chunks = this.chunks.filter((chunk) => this.now - chunk.born < this.steps);
+		if (this.openChunk !== void 0 && !this.chunks.includes(this.openChunk)) this.openChunk = void 0;
+		for (const arrival of this.arrivals) if (arrival < this.now - this.fastWindowTicks) this.arrivals.delete(arrival);
+		return changing;
+	}
+	/**
+	* Whether the current frame still differs from the settled rendering.
+	* @returns true while a tracked chunk draws below the last ramp level, which
+	* is the only reason to keep ticking.
+	*/
+	needsRepaint() {
+		return this.chunks.some((chunk) => this.now - chunk.born < this.steps - 1);
+	}
+	/**
+	* The tail {@link recolorTail} recolors.
+	* @returns one span per tracked chunk, oldest first, each with its current age.
+	*/
+	spans() {
+		return this.chunks.map((chunk) => ({
+			text: chunk.text,
+			age: this.now - chunk.born
+		}));
+	}
+	/**
+	* Drop the whole tail so every chunk drawn so far renders at the foreground,
+	* and start tracking again from the next delta. The application calls this on
+	* a terminal width change and at stream end. The fast-stream window is kept:
+	* a resize says nothing about the arrival rate.
+	*/
+	flush() {
+		this.chunks = [];
+		this.openChunk = void 0;
+	}
+	/**
+	* The fast-stream test.
+	* @returns true while every completed tick of the window received at least one chunk.
+	*/
+	isFastStream() {
+		let covered = 0;
+		for (let tick = this.now - this.fastWindowTicks; tick < this.now; tick += 1) if (this.arrivals.has(tick)) covered += 1;
+		return covered >= this.fastWindowTicks;
+	}
+};
+/**
+* Recolor the tail inside lines a component already rendered.
+*
+* The walk runs backwards over visible columns only: escape sequences, wide
+* characters, and grapheme clusters are stepped over as units, never split.
+* Whitespace is skipped on both sides while matching, so a chunk still matches
+* after the renderer turned its space into a line break or trimmed it.
+*
+* Markdown rewrites text, so a chunk may not appear in the rendered output at
+* all. Matching then stops: that chunk and every older chunk of the tail draw
+* at the foreground, unchanged. Because older chunks are already the brightest
+* levels, the degradation is the least visible one available.
+*
+* Styling inside a recolored run survives. The run reasserts the sequences in
+* force at its start, so an enclosing bold or italic continues across it; an
+* enclosing foreground color reasserted there wins over the ramp, and that run
+* simply does not fade. Each recolored line ends with `ESC[39m` (or `ESC[22m`
+* in the two-level mode, which also ends bold) after the line's own closing
+* sequences, so the recolor never leaks past the line it was applied to.
+* @param lines - the rendered lines of the streaming block, newest text last.
+* @param spans - the tail from {@link FadeTracker.spans}, oldest first.
+* @param style - the capability and the ramp.
+* @returns the lines with the tail recolored; lines the tail does not cover
+* are returned byte-identical, so the renderer leaves them alone.
+*/
+function recolorTail(lines, spans, style) {
+	if (style.capability === "none" || spans.length === 0 || lines.length === 0) return [...lines];
+	const cells = cellsFromEnd(lines);
+	const runs = [];
+	for (const span of [...spans].reverse()) {
+		const covered = consumeSpan(cells, span.text);
+		if (covered === void 0) break;
+		const sgr = fadeSgr(style, span.age);
+		if (sgr !== "") collectRuns(runs, covered, sgr);
+	}
+	const byLine = /* @__PURE__ */ new Map();
+	for (const run of runs) {
+		const known = byLine.get(run.line);
+		if (known === void 0) byLine.set(run.line, [run]);
+		else known.unshift(run);
+	}
+	const restore = restoreFor(style.capability);
+	return lines.map((text, index) => {
+		const lineRuns = byLine.get(index);
+		return lineRuns === void 0 ? text : paintLine(text, lineRuns, restore);
+	});
+}
+/**
+* Walk the rendered lines backwards, one visible grapheme at a time. Lazy: a
+* line is stripped and segmented only once the walk reaches it, so a long
+* settled message costs nothing beyond the lines the tail touches.
+* @param lines - the rendered lines.
+* @returns cells from the last column of the last line towards the first.
+*/
+function* cellsFromEnd(lines) {
+	for (const [line, text] of [...lines.entries()].reverse()) {
+		const cells = [];
+		let column = 0;
+		for (const part of GRAPHEMES.segment(stripTerminalSequences(text))) {
+			const width = visibleWidth(part.segment);
+			cells.push({
+				line,
+				column,
+				width,
+				grapheme: part.segment
+			});
+			column += width;
+		}
+		yield* cells.reverse();
+	}
+}
+/**
+* Take the cells one chunk covers off the walk.
+* @param cells - the backwards walk, positioned at the end of the region still unclaimed.
+* @param text - the chunk's text as it was appended.
+* @returns the cells the chunk covers, whitespace included, or undefined when
+* the chunk's visible characters are not there.
+*/
+function consumeSpan(cells, text) {
+	const wanted = Array.from(GRAPHEMES.segment(text), (part) => part.segment).filter((part) => !isBlank(part)).reverse();
+	const covered = [];
+	for (const want of wanted) {
+		let step = cells.next();
+		while (!step.done && isBlank(step.value.grapheme)) {
+			covered.push(step.value);
+			step = cells.next();
+		}
+		if (step.done || step.value.grapheme !== want) return void 0;
+		covered.push(step.value);
+	}
+	return covered;
+}
+/**
+* Whether a grapheme draws nothing.
+* @param grapheme - one grapheme cluster.
+* @returns true for whitespace.
+*/
+function isBlank(grapheme) {
+	return grapheme.trim() === "";
+}
+/**
+* Turn covered cells into runs, merging each cell into the run to its right
+* when they touch on the same line under the same sequence.
+* @param runs - runs collected so far, in the walk's right-to-left order.
+* @param covered - the cells one chunk covers.
+* @param sgr - the sequence the chunk draws under.
+*/
+function collectRuns(runs, covered, sgr) {
+	for (const cell of covered) {
+		const previous = runs.at(-1);
+		if (previous !== void 0 && previous.line === cell.line && previous.sgr === sgr && previous.start === cell.column + cell.width) previous.start = cell.column;
+		else runs.push({
+			line: cell.line,
+			start: cell.column,
+			end: cell.column + cell.width,
+			sgr
+		});
+	}
+}
+/**
+* Rebuild one line with its runs recolored.
+* @param text - the rendered line.
+* @param runs - the line's runs, in column order.
+* @param restore - the sequence that ends the last run.
+* @returns the line with each run opened by its sequence, the text between
+* runs untouched, and the line's own trailing sequences kept ahead of `restore`.
+*/
+function paintLine(text, runs, restore) {
+	let out = "";
+	let cursor = 0;
+	for (const run of runs) {
+		out += sliceByColumn(text, cursor, run.start - cursor);
+		out += run.sgr + sliceByColumn(text, run.start, run.end - run.start);
+		cursor = run.end;
+	}
+	return `${out}${sliceByColumn(text, cursor, text.length + 1)}${restore}`;
+}
+//#endregion
+//#region lib/types/style.js
+/**
+* The terminal palette: one table of SGR open/close pairs behind named roles,
+* so components never emit raw escape codes. A disabled palette returns text
+* unchanged for dumb terminals and captured output.
+* @module @deepseek-ai/dsh-tui-app/style
+*/
+const ESC = "\x1B[";
+/** SGR open/close code pairs by role. */
+const SGR = {
+	dim: ["2", "22"],
+	bold: ["1", "22"],
+	italic: ["3", "23"],
+	underline: ["4", "24"],
+	accent: ["36", "39"],
+	success: ["32", "39"],
+	warning: ["33", "39"],
+	error: ["31", "39"],
+	inverse: ["7", "27"]
+};
+/**
+* Build the palette.
+* @param enabled - whether escape sequences are emitted; false makes every role the identity.
+* @returns the palette.
+*/
+function createPalette(enabled) {
+	const role = (name) => {
+		const [open, close] = SGR[name];
+		return enabled ? (text) => `${ESC}${open}m${text}${ESC}${close}m` : (text) => text;
+	};
+	return {
+		dim: role("dim"),
+		bold: role("bold"),
+		italic: role("italic"),
+		underline: role("underline"),
+		accent: role("accent"),
+		success: role("success"),
+		warning: role("warning"),
+		error: role("error"),
+		inverse: role("inverse"),
+		enabled
+	};
+}
+/**
+* Decide whether the terminal gets color: `NO_COLOR` (any non-empty value)
+* wins, then a non-empty non-zero `FORCE_COLOR`, then whether stdout is a TTY.
+* @param env - the process environment.
+* @param isTty - whether stdout is a terminal.
+* @returns true when SGR styling should be emitted.
+*/
+function colorEnabled(env, isTty) {
+	if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+	if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
+	return isTty;
+}
+/**
+* The Markdown theme derived from the palette.
+* @param palette - the active palette.
+* @returns a complete pi-tui Markdown theme.
+*/
+function markdownTheme(palette) {
+	return {
+		heading: (text) => palette.bold(palette.accent(text)),
+		link: palette.accent,
+		linkUrl: palette.dim,
+		code: palette.warning,
+		codeBlock: (text) => text,
+		codeBlockBorder: palette.dim,
+		quote: palette.italic,
+		quoteBorder: palette.dim,
+		hr: palette.dim,
+		listBullet: palette.accent,
+		bold: palette.bold,
+		italic: palette.italic,
+		strikethrough: palette.dim,
+		underline: palette.underline
+	};
+}
+/**
+* The select-list theme derived from the palette.
+* @param palette - the active palette.
+* @returns a complete pi-tui select-list theme.
+*/
+function selectListTheme(palette) {
+	return {
+		selectedPrefix: palette.accent,
+		selectedText: (text) => palette.bold(palette.accent(text)),
+		description: palette.dim,
+		scrollInfo: palette.dim,
+		noMatch: palette.dim
+	};
+}
+/**
+* The editor theme derived from the palette.
+* @param palette - the active palette.
+* @returns a complete pi-tui editor theme.
+*/
+function editorTheme(palette) {
+	return {
+		borderColor: palette.dim,
+		selectList: selectListTheme(palette)
+	};
+}
+//#endregion
+//#region lib/types/blocks.js
+/**
+* Transcript components: one pi-tui component per rendered fact (a user
+* prompt, an assistant reply, a tool card, a notice). Each owns its display
+* state and re-renders from it at any width.
+* @module @deepseek-ai/dsh-tui-app/blocks
+*/
+/** A prompt the user submitted, drawn with a leading `›`. */
+var UserBlock = class {
+	theme;
+	text;
+	constructor(theme, text) {
+		this.theme = theme;
+		this.text = text;
+	}
+	invalidate() {}
+	render(width) {
+		const palette = this.theme.palette;
+		return ["", ...wrapTextWithAnsi(this.text, Math.max(1, width - 2)).map((line, index) => `${palette.accent(index === 0 ? "›" : " ")} ${palette.bold(line)}`)];
+	}
+};
+/** A dim one-line notice about the session (a stopped turn, a command result, a model switch). */
+var NoticeBlock = class {
+	text;
+	constructor(theme, text, tone = "dim") {
+		const palette = theme.palette;
+		this.text = new Text(palette[tone](`· ${text}`), 0, 0);
+	}
+	invalidate() {
+		this.text.invalidate();
+	}
+	render(width) {
+		return this.text.render(width);
+	}
+};
+/**
+* An assistant reply: streamed reasoning above streamed Markdown text. The
+* durable `assistant/message` replaces both with the committed content.
+*
+* A block that is streaming right now can carry a {@link FadeRender}, which
+* draws its newest text dimmed and brightening. A block rebuilt from history
+* carries none, and {@link AssistantBlock.commit} drops the one a streaming
+* block had, so settled text is never recolored.
+*/
+var AssistantBlock = class {
+	theme;
+	reasoning = "";
+	text = "";
+	interrupted = false;
+	markdown;
+	reasoningText;
+	fade;
+	/** Width of the last render that drew a tail; absent before the first one. */
+	fadeWidth;
+	constructor(theme) {
+		this.theme = theme;
+		const palette = theme.palette;
+		this.markdown = new Markdown("", 0, 0, markdownTheme(palette));
+		this.reasoningText = new Text("", 0, 0);
+	}
+	/**
+	* Draw this block's newest text through `fade` until it commits.
+	* @param fade - the tail and drawing settings of the running stream.
+	*/
+	setFade(fade) {
+		this.fade = fade;
+	}
+	/**
+	* Append streamed visible text.
+	* @param delta - the text delta.
+	*/
+	appendText(delta) {
+		this.text += delta;
+		this.markdown.setText(this.text);
+	}
+	/**
+	* Append streamed reasoning text.
+	* @param delta - the reasoning delta.
+	*/
+	appendReasoning(delta) {
+		this.reasoning += delta;
+		this.reasoningText.setText(this.theme.palette.dim(this.theme.palette.italic(this.reasoning.trimEnd())));
+	}
+	/**
+	* Replace the streamed content with the committed message.
+	* @param text - the committed visible text.
+	* @param reasoning - the committed reasoning text.
+	* @param interrupted - whether the message was cut short.
+	*/
+	commit(text, reasoning, interrupted) {
+		this.text = text;
+		this.reasoning = reasoning;
+		this.interrupted = interrupted;
+		this.fade = void 0;
+		this.markdown.setText(text);
+		this.reasoningText.setText(this.theme.palette.dim(this.theme.palette.italic(reasoning.trimEnd())));
+	}
+	invalidate() {
+		this.markdown.invalidate();
+		this.reasoningText.invalidate();
+	}
+	render(width) {
+		const lines = [""];
+		if (this.reasoning.trim() !== "") lines.push(...this.reasoningText.render(width), "");
+		if (this.text !== "") lines.push(...this.renderText(width));
+		if (this.interrupted) lines.push(this.theme.palette.dim("[interrupted]"));
+		return lines;
+	}
+	/**
+	* The Markdown lines, with the streaming tail recolored.
+	*
+	* `recolorTail` matches the tail backwards from the end of what it is
+	* given, so it gets the Markdown lines alone: the reasoning above them and
+	* any marker below them would put the newest chunk somewhere other than the
+	* end and drop the whole tail to the plain foreground.
+	*
+	* Only chunks younger than `steps - 1` are handed over. The last ramp level
+	* is an assumed foreground - pi-tui reports the terminal background but not
+	* its foreground - so the oldest visible level is left to draw in the
+	* terminal's own foreground, which is also what the chunk draws in once it
+	* settles. No chunk can therefore jump color as it leaves the tail.
+	* @param width - the width the Markdown lays out in.
+	* @returns the lines to draw.
+	*/
+	renderText(width) {
+		const fade = this.fade;
+		const lines = this.markdown.render(width);
+		if (fade === void 0) return lines;
+		if (this.fadeWidth !== void 0 && this.fadeWidth !== width) fade.flush();
+		this.fadeWidth = width;
+		return recolorTail(lines, fade.spans().filter((span) => span.age < fade.steps - 1), fade.style());
+	}
+};
+/** A tool call card: status glyph, tool name, headline, then a foldable body. */
+var ToolBlock = class {
+	theme;
+	name;
+	call;
+	status = "running";
+	resultLines = [];
+	expanded = false;
+	constructor(theme, name, call) {
+		this.theme = theme;
+		this.name = name;
+		this.call = call;
+	}
+	/**
+	* Attach the result rows and settle the status.
+	* @param lines - the result rows before preview truncation.
+	* @param isError - whether the tool reported failure.
+	*/
+	setResult(lines, isError) {
+		this.resultLines = lines;
+		this.status = isError ? "error" : "done";
+	}
+	/**
+	* Fold or unfold the body.
+	* @param expanded - whether the full body is shown.
+	*/
+	setExpanded(expanded) {
+		this.expanded = expanded;
+	}
+	invalidate() {}
+	render(width) {
+		const palette = this.theme.palette;
+		const header = `${this.status === "running" ? palette.warning("●") : this.status === "done" ? palette.success("●") : palette.error("●")} ${palette.bold(this.name)}${this.call.title === "" ? "" : ` ${palette.dim(this.call.title)}`}`;
+		const shown = previewLines([...this.call.lines, ...this.resultLines], this.theme.toolPreviewLines, this.expanded);
+		const inner = Math.max(1, width - 4);
+		const rows = shown.flatMap((line) => wrapTextWithAnsi(line, inner).map((part) => `  ${palette.dim("│")} ${part}`));
+		return [
+			"",
+			...wrapTextWithAnsi(header, width),
+			...rows
+		];
+	}
+};
+//#endregion
+//#region lib/types/completion.js
+/**
+* Editor completion: `/` at the start of the message opens the command list,
+* and `@` anywhere offers workspace paths and other sessions as references,
+* inserted in the same mention grammar the browser composer uses.
+* @module @deepseek-ai/dsh-tui-app/completion
+*/
+/**
+* Build the provider over live sources, so commands and references registered
+* after startup appear without re-creating the editor.
+* @param sources - the command and reference sources.
+* @returns the editor's autocomplete provider.
+*/
+function editorCompletion(sources) {
+	return {
+		triggerCharacters: ["/", "@"],
+		async getSuggestions(lines, cursorLine, cursorCol, options) {
+			const line = lines[cursorLine] ?? "";
+			const before = line.slice(0, cursorCol);
+			const at = activeAtToken(line, cursorCol);
+			if (at !== void 0) {
+				const items = (await sources.references(at.query, at.quoted, options.signal)).map((reference) => ({
+					value: reference.mention,
+					label: reference.label,
+					...reference.description === void 0 ? {} : { description: reference.description }
+				}));
+				return items.length === 0 ? null : {
+					items,
+					prefix: at.prefix
+				};
 			}
-			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-			if (env.hasError) throw env.error;
+			if (cursorLine !== 0 || !before.startsWith("/") || /\s/u.test(before)) return null;
+			const prefix = before;
+			const items = sources.commands().filter((command) => `/${command.name}`.startsWith(prefix)).map((command) => ({
+				value: `/${command.name}`,
+				label: `/${command.name}`,
+				description: command.hint === void 0 ? command.description : `${command.description} · ${command.hint}`
+			}));
+			return items.length === 0 ? null : {
+				items,
+				prefix
+			};
+		},
+		applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+			const line = lines[cursorLine] ?? "";
+			const start = cursorCol - prefix.length;
+			const replaced = `${line.slice(0, start)}${item.value} ${line.slice(cursorCol)}`;
+			const next = [...lines];
+			next[cursorLine] = replaced;
+			return {
+				lines: next,
+				cursorLine,
+				cursorCol: start + item.value.length + 1
+			};
 		}
-		return next();
 	};
-})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
-	var e = new Error(message);
-	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-/** Two-space indentation per nesting level. */
-function indent(depth) {
-	return "  ".repeat(depth);
-}
-/** The settings service, or a printable error naming its absence. */
-function requireSettings(ctx) {
-	const settings = ctx.get("settings");
-	if (settings === void 0) throw new Error("settings are not mounted in this profile");
-	return settings;
-}
-/** One namespace's redacted descriptor, or a printable error when it is not registered. */
-function requireDescriptor(settings, ns) {
-	const descriptor = settings.describe({ redactSecrets: true }).find((candidate) => candidate.ns === ns);
-	if (descriptor === void 0) throw new Error(`settings namespace "${ns}" is not registered`);
-	return descriptor;
 }
+//#endregion
+//#region lib/types/editor.js
 /**
-* One row per registered settings namespace: the namespace, its revision,
-* whether the stored user section overrides anything, and when its owner
-* applies changes.
-* @param ctx - plugin context carrying the optional settings service.
-* @returns the rows in registration order.
-* @throws {Error} when no settings service is mounted.
+* The prompt editor's caret. pi-tui draws the caret cell itself in reverse
+* video; this module takes that block off the rendered lines and names the
+* DECSCUSR sequences the application writes so the terminal draws the caret
+* instead, as a blinking bar.
+* @module @deepseek-ai/dsh-tui-app/editor
 */
-function listSettings(ctx) {
-	return requireSettings(ctx).describe({ redactSecrets: true }).map((descriptor) => {
-		const overridden = Object.keys(descriptor.user ?? {}).length > 0;
-		return `${descriptor.ns}  rev ${String(descriptor.revision)}  ${overridden ? "user-overridden" : "inherited"}  applies ${descriptor.applies}`;
-	});
+/**
+* DECSCUSR `CSI 5 SP q` (`\x1b[5 q`): tell the terminal to draw its text
+* cursor as a blinking vertical bar.
+*/
+const SET_BLINKING_BAR_CURSOR = "\x1B[5 q";
+/**
+* DECSCUSR `CSI 0 SP q` (`\x1b[0 q`): tell the terminal to draw its text
+* cursor in the shape it is configured with, for the application to write
+* before it releases the terminal.
+*/
+const SET_TERMINAL_DEFAULT_CURSOR = "\x1B[0 q";
+/** SGR reverse video on, which pi-tui opens its drawn block cursor with. */
+const REVERSE_VIDEO_ON = "\x1B[7m";
+/** SGR reset, which pi-tui closes its drawn block cursor with. */
+const REVERSE_VIDEO_OFF = "\x1B[0m";
+/**
+* Take pi-tui's drawn block cursor off one rendered editor line.
+*
+* The removal is anchored at `CURSOR_MARKER`, which pi-tui emits immediately
+* before the cell it draws: only the `\x1b[7m` / `\x1b[0m` pair that follows
+* the marker is deleted, so reverse video inside the text the user typed or
+* pasted is never touched. The cell's own character stays - or, past the last
+* character of the line, the space pi-tui drew instead - so the line keeps its
+* visible width and the marker keeps its column. A line with no marker, or a
+* marker the pair does not follow, comes back unchanged.
+* @param line - one line of `Editor.render` output.
+* @returns the line with the marker still in place and the block gone.
+*/
+function stripBlockCursor(line) {
+	const marker = line.indexOf(CURSOR_MARKER);
+	if (marker === -1) return line;
+	const block = marker + CURSOR_MARKER.length;
+	if (!line.startsWith(REVERSE_VIDEO_ON, block)) return line;
+	const cell = block + 4;
+	const close = line.indexOf(REVERSE_VIDEO_OFF, cell);
+	if (close === -1) return line;
+	return line.slice(0, block) + line.slice(cell, close) + line.slice(close + 4);
 }
 /**
-* Pretty-printed JSON of one namespace's resolved value with every secret
-* field removed, followed by one row per secret slot stating whether it holds
-* a value.
-* @param ctx - plugin context carrying the optional settings service.
-* @param ns - the registered namespace to show.
-* @returns the JSON lines, then the secret-slot rows.
-* @throws {Error} when no settings service is mounted or `ns` is not registered.
+* The prompt editor drawn without pi-tui's block cursor.
+*
+* pi-tui's `Editor` always draws the caret cell in reverse video and
+* `EditorOptions` carries no switch for it, while the real terminal cursor is
+* placed from the `CURSOR_MARKER` the editor emits at the same position. This
+* subclass removes that block from the lines `render` returns so the
+* terminal's own cursor - which the application shapes with
+* `SET_BLINKING_BAR_CURSOR` - is the only caret on screen. Everything else is
+* pi-tui's: text, autocomplete, padding, borders, scrolling, submission, and
+* history are untouched, and the component writes to no terminal itself.
+*
+* pi-tui emits the marker only while the editor is focused, yet it draws the
+* block either way, so an unfocused editor would keep a caret while another
+* region holds the keyboard. `render` therefore turns the marker on for the
+* `super.render` call to anchor the removal, then drops the marker again when
+* the editor is not focused: the unfocused editor shows no caret, and the
+* terminal cursor stays with the region that owns the keyboard.
 */
-function showSetting(ctx, ns) {
-	const descriptor = requireDescriptor(requireSettings(ctx), ns);
-	const rows = JSON.stringify(descriptor.value, null, 2).split("\n");
-	for (const secret of descriptor.secrets ?? []) rows.push(`secret ${secret.path.join(".")}: ${secret.set ? "set" : "unset"}`);
-	return rows;
+var BarCursorEditor = class extends Editor {
+	/**
+	* Render the editor without pi-tui's drawn block cursor.
+	* @param width - the total width to lay the editor out in.
+	* @returns the rendered lines, carrying `CURSOR_MARKER` only while focused.
+	*/
+	render(width) {
+		const focused = this.focused;
+		this.focused = true;
+		let lines;
+		try {
+			lines = super.render(width);
+		} finally {
+			this.focused = focused;
+		}
+		return lines.map((line) => {
+			const stripped = stripBlockCursor(line);
+			return focused ? stripped : stripped.replaceAll(CURSOR_MARKER, "");
+		});
+	}
+};
+/** What the provider-default row is called. */
+const PROVIDER_DEFAULT_LABEL = "Provider default";
+/** The `/effort` argument that restores the provider default. */
+const DEFAULT_ARGUMENT = "default";
+/**
+* The display name of one effort.
+* @param reasoning - what the model declares.
+* @param effort - the selected effort, or undefined for the provider default.
+* @returns the declared name, the raw id when the model no longer declares it, or the provider-default label.
+*/
+function effortName(reasoning, effort) {
+	if (effort === void 0) return PROVIDER_DEFAULT_LABEL;
+	return reasoning.efforts.find((candidate) => candidate.id === effort)?.name ?? effort;
 }
 /**
-* Write one field of a namespace's user section through a path-addressed
-* `set` against the revision read at call time. `rawValue` is parsed as JSON
-* when it is valid JSON and stored as a string otherwise; an empty `path`
-* addresses the section root, which then requires a JSON object.
-* @param ctx - plugin context carrying the optional settings service.
-* @param ns - the registered namespace to edit.
-* @param path - dot-separated field path (`api.timeoutMs`), or `''` for the root.
-* @param rawValue - the typed value, JSON or plain text.
-* @returns a confirmation row naming the namespace, path, and stored value.
-* @throws {Error} when no settings service is mounted or `ns` is not registered.
+* Picker rows for one model: the provider default above the adapter's own order.
+* @param reasoning - what the model declares.
+* @returns the rows, provider default first.
 */
-async function setSetting(ctx, ns, path, rawValue) {
-	const settings = requireSettings(ctx);
-	const { revision } = requireDescriptor(settings, ns);
-	const value = parseSettingValue(rawValue);
-	const parts = path === "" ? [] : path.split(".");
-	await settings.mutate(ns, [{
-		op: "set",
-		path: parts,
-		value
-	}], revision);
-	return `settings ${ns}: set ${path === "" ? "(root)" : path} = ${JSON.stringify(value)}`;
+function effortItems(reasoning) {
+	const resolved = reasoning.defaultEffort === void 0 ? void 0 : `resolves to ${effortName(reasoning, reasoning.defaultEffort)}`;
+	return [{
+		value: "",
+		label: PROVIDER_DEFAULT_LABEL,
+		...resolved === void 0 ? {} : { description: resolved }
+	}, ...reasoning.efforts.map((effort) => ({
+		value: effort.id,
+		label: effort.name,
+		...effort.description === void 0 ? {} : { description: effort.description }
+	}))];
 }
-/** JSON when the text parses, otherwise the text itself. */
-function parseSettingValue(rawValue) {
-	try {
-		return JSON.parse(rawValue);
-	} catch {
-		return rawValue;
-	}
+/**
+* The dim row under the picker heading.
+* @param reasoning - what the model declares.
+* @param effort - the effort in force, or undefined for the provider default.
+* @returns one row naming the effort in force and the keys that change it.
+*/
+function effortHint(reasoning, effort) {
+	return `current: ${effortName(reasoning, effort)} · Esc keeps it · Shift+Tab cycles`;
 }
 /**
-* Empty one namespace's user section so every field re-inherits its
-* composition base and schema default.
-* @param ctx - plugin context carrying the optional settings service.
-* @param ns - the registered namespace to reset.
-* @returns a confirmation row.
-* @throws {Error} when no settings service is mounted or `ns` is not registered.
+* The effort a typed `/effort` argument names. A declared id wins over the
+* `default` keyword, so an adapter may own that id.
+* @param reasoning - what the model declares.
+* @param typed - the argument, matched against declared ids without case.
+* @returns the declared effort, undefined for the provider default, or null when the model declares no such effort.
 */
-async function resetSetting(ctx, ns) {
-	const settings = requireSettings(ctx);
-	const { revision } = requireDescriptor(settings, ns);
-	await settings.replace(ns, {}, revision);
-	return `settings ${ns}: reset to defaults`;
+function matchEffort(reasoning, typed) {
+	const wanted = typed.toLowerCase();
+	const declared = reasoning.efforts.find((effort) => effort.id.toLowerCase() === wanted);
+	if (declared !== void 0) return declared.id;
+	return wanted === DEFAULT_ARGUMENT ? void 0 : null;
 }
+//#endregion
+//#region lib/types/export.js
 /**
-* One row per non-group Loader entry: entry id, module name, effective
-* enablement, and the root Fiber phase (`none` without a live root Fiber).
-* @param ctx - plugin context carrying the optional Cordis Loader.
-* @returns the rows in Loader order.
-* @throws {Error} when no Loader is mounted.
+* `/export`: the same session-log ZIP the browser downloads, written to a
+* local directory through the export package's archive helpers.
+* @module @deepseek-ai/dsh-tui-app/export
 */
-function listPlugins(ctx) {
-	const loader = ctx.get("loader");
-	if (loader === void 0) throw new Error("the plugin loader is not mounted in this profile");
-	const rows = [];
-	for (const entry of loader.entries()) {
-		if (entry.options.group) continue;
-		const phase = pluginFiberPhase(entry.fiber?.state);
-		rows.push(`${entry.id}  ${entry.options.name}  ${entry.disabled ? "disabled" : "enabled"}  ${phase ?? "none"}`);
-	}
-	return rows;
+/**
+* Write the session tree (the session, its sub-sessions, and attachments) as
+* a ZIP archive into `directory`.
+* @param ctx - plugin context carrying the query, persistence, and attachment services.
+* @param sessionId - the session to export.
+* @param directory - the directory the archive is written into.
+* @param signal - cancels the export.
+* @returns the archive's absolute path.
+* @throws when a required service is not composed or the session has no persisted log.
+*/
+async function exportSessionZip(ctx, sessionId, directory, signal) {
+	const deps = sessionLogExportDeps(ctx);
+	if (deps.sessionQuery === void 0 || deps.sessionPersistence === void 0 || deps.attachments === void 0) throw new Error("export needs the session query, persistence, and attachment services");
+	const ready = {
+		...deps,
+		sessionQuery: deps.sessionQuery,
+		sessionPersistence: deps.sessionPersistence,
+		attachments: deps.attachments
+	};
+	await flushLiveSessionLog(deps, sessionId, signal);
+	const root = await readSessionLogText(deps.sessionPersistence, sessionId, signal);
+	if (root === void 0) throw new Error(`session ${sessionId} has no persisted log to export`);
+	const path = join(directory, sessionLogZipFilename(sessionId));
+	const archive = streamSessionLogZip(ready, root, sessionId, true, DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, signal);
+	await pipeline(Readable.fromWeb(archive), createWriteStream(path), { signal });
+	return path;
 }
+//#endregion
+//#region lib/types/todos.js
 /**
-* Every session-backed subagent below one session in pre-order, one row each,
-* indented by tree depth: the child session id (usable with `/sessions` and
-* `--resume`), its activity, mode, and label; a diagnostic candidate shows its
-* reason instead.
-* @param ctx - plugin context carrying the optional subagent runtime.
-* @param sessionId - the root session whose descendants are listed.
-* @param signal - cancels the listing.
-* @returns the rows, empty when the session has no subagents.
-* @throws {Error} when no subagent runtime is mounted.
+* The agent's todo list as terminal rows: the status glyphs every todo surface
+* of this terminal draws, the picker choices the list offers, and the detail
+* rows one entered item prints. Everything here is pure text work over plain
+* values; the single service touch is one optional read of the `todos` session
+* projection.
+* @module @deepseek-ai/dsh-tui-app/todos
 */
-async function listSubagents(ctx, sessionId, signal) {
-	const subagents = ctx.get("subagents");
-	if (subagents === void 0) throw new Error("subagents are not mounted in this profile");
-	return (await subagents.listDescendants(sessionId, signal)).map((entry) => {
-		const prefix = `${indent(entry.depth - 1)}${entry.id}`;
-		if (entry.kind === "diagnostic") return `${prefix}  ${entry.reason}`;
-		const label = entry.label === void 0 ? "" : `  ${entry.label}`;
-		return `${prefix}  ${entry.activity}  ${entry.mode}${label}`;
-	});
-}
 /**
-* Files the model declared through the present tool, folded from the
-* session's `deliverables/presented` events and grouped under one `turn N`
-* heading per turn in log order.
-* @param ctx - plugin context carrying the optional session query engine.
-* @param sessionId - the session whose log is read.
-* @param signal - cancels a cold log read.
-* @returns the heading and file rows, empty when nothing was presented.
-* @throws {Error} when no session query engine is mounted.
+* Terminal columns a picker row spends on content. The list draws one row per
+* todo, so content past this cap ends in `…` instead of wrapping onto a second
+* row; 64 columns plus the status glyph and the list's own row marker fit an
+* 80-column terminal. Columns, not characters: one wide character fills two of
+* them. A presentation choice of this terminal surface, not a deployment
+* setting.
 */
-async function listDeliverables(ctx, sessionId, signal) {
-	const env_1 = {
-		stack: [],
-		error: void 0,
-		hasError: false
-	};
-	try {
-		const query = ctx.get("sessionQuery");
-		if (query === void 0) throw new Error("the session query engine is not mounted in this profile");
-		const observation = __addDisposableResource$1(env_1, await query.observeSession(sessionId, {
-			signal,
-			projectionMode: "none"
-		}), false);
-		const turns = /* @__PURE__ */ new Map();
-		for (const event of observation.events) {
-			if (event.type !== "deliverables/presented") continue;
-			const files = turns.get(event.data.turn) ?? [];
-			files.push(...event.data.files);
-			turns.set(event.data.turn, files);
-		}
-		const rows = [];
-		for (const [turn, files] of turns) {
-			rows.push(`turn ${String(turn)}`);
-			for (const file of files) rows.push(`${indent(1)}${file.path}${file.description === void 0 ? "" : `  ${file.description}`}`);
-		}
-		return rows;
-	} catch (e_1) {
-		env_1.error = e_1;
-		env_1.hasError = true;
-	} finally {
-		__disposeResources$1(env_1);
-	}
-}
+const TODO_LABEL_COLUMNS = 64;
 /**
-* The session's turn outline: one numbered row per started turn with its
-* prompt preview, followed by an indented response preview once the turn
-* ended with assistant text.
-* @param ctx - plugin context carrying the optional projection registry.
-* @param session - the live session whose outline is read.
-* @returns the rows, empty before the first turn starts.
-* @throws {Error} when no projection registry is mounted or the `turnOutline` unit is not registered.
+* Columns the detail rows wrap one item's full content to. Fixed rather than
+* read from the terminal so these rows stay plain values; 72 columns fit an
+* 80-column terminal, and a narrower terminal wraps them again when it draws
+* them. A presentation choice of this terminal surface, not a deployment
+* setting.
 */
-function sessionOutline(ctx, session) {
-	const projections = ctx.get("sessionProjections");
-	if (projections === void 0) throw new Error("session projections are not mounted in this profile");
-	const outline = projections.snapshot(session, ["turnOutline"]).values.turnOutline;
-	if (outline === void 0) throw new Error("the turnOutline projection is not registered in this profile");
-	const rows = [];
-	for (const entry of outline) {
-		rows.push(`${String(entry.turn)}. ${entry.prompt === "" ? "(no prompt)" : entry.prompt}`);
-		if (entry.response !== "") rows.push(`${indent(1)}→ ${entry.response}`);
-	}
-	return rows;
-}
-//#endregion
-//#region lib/types/style.js
+const TODO_DETAIL_COLUMNS = 72;
 /**
-* The terminal palette: one table of SGR open/close pairs behind named roles,
-* so components never emit raw escape codes. A disabled palette returns text
-* unchanged for dumb terminals and captured output.
-* @module @deepseek-ai/dsh-tui-app/style
+* Glyph per todo status: the marker a todo row leads with. This module is the
+* one home of the markers — every module of this terminal surface that prints
+* a todo row imports them from here rather than keeping its own table.
 */
-const ESC = "\x1B[";
-/** SGR open/close code pairs by role. */
-const SGR = {
-	dim: ["2", "22"],
-	bold: ["1", "22"],
-	italic: ["3", "23"],
-	underline: ["4", "24"],
-	accent: ["36", "39"],
-	success: ["32", "39"],
-	warning: ["33", "39"],
-	error: ["31", "39"],
-	inverse: ["7", "27"]
+const TODO_GLYPH = {
+	completed: "✓",
+	in_progress: "▸",
+	pending: "○"
 };
+/** The word each status is spelled out as. */
+const TODO_WORD = {
+	completed: "completed",
+	in_progress: "in progress",
+	pending: "pending"
+};
+/** Every status, in the order a counts row lists them. */
+const TODO_STATUSES = [
+	"completed",
+	"in_progress",
+	"pending"
+];
 /**
-* Build the palette.
-* @param enabled - whether escape sequences are emitted; false makes every role the identity.
-* @returns the palette.
+* The agent's current todo list as picker rows, in write order.
+* @param ctx - plugin context carrying the optional session-projection registry.
+* @param session - the session whose todo list is read.
+* @returns one choice per item. Empty in three cases: no projection registry
+* is composed in this profile, the registry has no `todos` unit registered, or
+* the value is `null` — which it is before the first `todo_write` of the
+* current turn, since every `turn/start` clears the list.
 */
-function createPalette(enabled) {
-	const role = (name) => {
-		const [open, close] = SGR[name];
-		return enabled ? (text) => `${ESC}${open}m${text}${ESC}${close}m` : (text) => text;
-	};
-	return {
-		dim: role("dim"),
-		bold: role("bold"),
-		italic: role("italic"),
-		underline: role("underline"),
-		accent: role("accent"),
-		success: role("success"),
-		warning: role("warning"),
-		error: role("error"),
-		inverse: role("inverse"),
-		enabled
-	};
+function listTodoChoices(ctx, session) {
+	const projections = ctx.get("sessionProjections");
+	if (projections === void 0) return [];
+	const items = projections.snapshot(session, ["todos"]).values.todos;
+	if (items === void 0 || items === null) return [];
+	return items.map((item, index) => ({
+		index,
+		label: `${TODO_GLYPH[item.status]} ${labelContent(item.content)}`,
+		description: describeStatus(item.status),
+		status: item.status
+	}));
 }
 /**
-* Decide whether the terminal gets color: `NO_COLOR` (any non-empty value)
-* wins, then a non-empty non-zero `FORCE_COLOR`, then whether stdout is a TTY.
-* @param env - the process environment.
-* @param isTty - whether stdout is a terminal.
-* @returns true when SGR styling should be emitted.
+* One content line cut to a single picker row.
+* @param content - the item's content.
+* @returns the content unchanged, or its leading columns followed by `…`,
+* together never wider than {@link TODO_LABEL_COLUMNS}. A wide character that
+* would straddle the cut is dropped rather than halved.
 */
-function colorEnabled(env, isTty) {
-	if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
-	if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
-	return isTty;
+function labelContent(content) {
+	if (visibleWidth(content) <= TODO_LABEL_COLUMNS) return content;
+	return `${sliceByColumn(content, 0, TODO_LABEL_COLUMNS - 1, true)}…`;
 }
 /**
-* The Markdown theme derived from the palette.
-* @param palette - the active palette.
-* @returns a complete pi-tui Markdown theme.
+* The picker description for one status.
+* @param status - the item's status.
+* @returns the status word, and for `in_progress` that the item is being worked on now.
 */
-function markdownTheme(palette) {
-	return {
-		heading: (text) => palette.bold(palette.accent(text)),
-		link: palette.accent,
-		linkUrl: palette.dim,
-		code: palette.warning,
-		codeBlock: (text) => text,
-		codeBlockBorder: palette.dim,
-		quote: palette.italic,
-		quoteBorder: palette.dim,
-		hr: palette.dim,
-		listBullet: palette.accent,
-		bold: palette.bold,
-		italic: palette.italic,
-		strikethrough: palette.dim,
-		underline: palette.underline
-	};
+function describeStatus(status) {
+	return status === "in_progress" ? `${TODO_WORD[status]} · being worked on now` : TODO_WORD[status];
 }
 /**
-* The select-list theme derived from the palette.
-* @param palette - the active palette.
-* @returns a complete pi-tui select-list theme.
+* The rows one entered todo prints: its full content wrapped to
+* {@link TODO_DETAIL_COLUMNS}, its status, its position in the list, the
+* list's counts by status, and — when the caller tracked them — the turn the
+* item first appeared in and the turn its status last changed in. Equal turns
+* print the appearance row alone: an item still holding the status it was
+* written with has no later change to report.
+* @param items - the list the entered row was drawn from.
+* @param index - zero-based position of the entered row.
+* @param transition - the turn facts the caller tracked for this item, when it has them.
+* @returns the detail rows; one row naming the missing item when `index` is
+* outside the list, which it is once a later `todo/write` shortened it.
 */
-function selectListTheme(palette) {
-	return {
-		selectedPrefix: palette.accent,
-		selectedText: (text) => palette.bold(palette.accent(text)),
-		description: palette.dim,
-		scrollInfo: palette.dim,
-		noMatch: palette.dim
-	};
+function todoDetail(items, index, transition) {
+	const item = items[index];
+	if (item === void 0) return [`no todo item ${String(index + 1)} of ${String(items.length)}`];
+	const rows = [
+		...wrapTextWithAnsi(item.content, TODO_DETAIL_COLUMNS),
+		`status: ${TODO_WORD[item.status]}`,
+		`item ${String(index + 1)} of ${String(items.length)}`,
+		countsRow(items)
+	];
+	if (transition !== void 0) {
+		rows.push(`first written in turn ${String(transition.firstTurn)}`);
+		if (transition.statusTurn !== transition.firstTurn) rows.push(`status last changed in turn ${String(transition.statusTurn)}`);
+	}
+	return rows;
 }
 /**
-* The editor theme derived from the palette.
-* @param palette - the active palette.
-* @returns a complete pi-tui editor theme.
+* The whole list counted by status.
+* @param items - the current list.
+* @returns one count per status in {@link TODO_STATUSES} order, including the
+* zeroes, e.g. `2 completed · 1 in progress · 4 pending`.
 */
-function editorTheme(palette) {
-	return {
-		borderColor: palette.dim,
-		selectList: selectListTheme(palette)
-	};
+function countsRow(items) {
+	return TODO_STATUSES.map((status) => `${String(items.filter((item) => item.status === status).length)} ${TODO_WORD[status]}`).join(" · ");
 }
 //#endregion
-//#region lib/types/diff.js
+//#region lib/types/status.js
 /**
-* Line diff for tool cards: a longest-common-subsequence alignment of old and
-* new text, bounded so a huge file falls back to a plain replacement view.
-* @module @deepseek-ai/dsh-tui-app/diff
+* Persistent session status for the terminal: one read of the session
+* projections becomes plain facts, and pure formatters turn those facts into
+* footer parts, the report sections `/status` and the status bar's segment
+* details share, and the one-line notices for compaction and model-request
+* retries. Nothing here touches the terminal, the palette, or the agent.
+* @module @deepseek-ai/dsh-tui-app/status
 */
-/** Above this many old×new line pairs the quadratic alignment is skipped. */
-const MAX_ALIGNMENT_CELLS = 4e6;
-function splitLines(text) {
-	if (text === "") return [];
-	const lines = text.split("\n");
-	if (lines.at(-1) === "") lines.pop();
-	return lines;
-}
+/** The client-visible keys one status read selects. */
+const STATUS_KEYS = [
+	"contextPressure",
+	"contextBreakdown",
+	"tokenUsage",
+	"sessionStats",
+	"todos",
+	"goal",
+	"plan",
+	"permissions"
+];
 /**
-* Align `oldText` against `newText` line by line.
-* @param oldText - the previous file content, or null when the file is new.
-* @param newText - the new file content.
-* @returns the rows in display order; a new file yields only added rows.
+* Read one consistent cut of the status projections for `session`.
+* @param projections - the session-projection registry (`ctx.get('sessionProjections')`).
+* @param session - the session whose status is read.
+* @returns the facts every registered key yields; unregistered keys leave their fact absent.
 */
-function diffLines(oldText, newText) {
-	const next = splitLines(newText);
-	if (oldText === null) return next.map((text) => ({
-		kind: "added",
-		text
-	}));
-	const previous = splitLines(oldText);
-	if (previous.length * next.length > MAX_ALIGNMENT_CELLS) return [...previous.map((text) => ({
-		kind: "removed",
-		text
-	})), ...next.map((text) => ({
-		kind: "added",
-		text
-	}))];
-	const cols = next.length + 1;
-	const lcs = new Uint32Array((previous.length + 1) * cols);
-	for (let i = previous.length - 1; i >= 0; i--) for (let j = next.length - 1; j >= 0; j--) lcs[i * cols + j] = previous[i] === next[j] ? lcs[(i + 1) * cols + j + 1] + 1 : Math.max(lcs[(i + 1) * cols + j], lcs[i * cols + j + 1]);
-	const out = [];
-	let i = 0;
-	let j = 0;
-	while (i < previous.length && j < next.length) if (previous[i] === next[j]) {
-		out.push({
-			kind: "context",
-			text: previous[i]
-		});
-		i++;
-		j++;
-	} else if (lcs[(i + 1) * cols + j] >= lcs[i * cols + j + 1]) {
-		out.push({
-			kind: "removed",
-			text: previous[i]
-		});
-		i++;
-	} else {
-		out.push({
-			kind: "added",
-			text: next[j]
-		});
-		j++;
+function readStatusFacts(projections, session) {
+	const { values } = projections.snapshot(session, STATUS_KEYS);
+	const facts = {};
+	const pressure = values.contextPressure;
+	const used = pressure?.projectedTokens ?? pressure?.pressureTokens;
+	if (used !== void 0 && pressure?.contextWindow !== void 0) facts.context = {
+		used,
+		window: pressure.contextWindow,
+		percent: Math.min(100, Math.round(used / pressure.contextWindow * 100))
+	};
+	if (values.contextBreakdown !== void 0) facts.breakdown = values.contextBreakdown;
+	if (values.tokenUsage !== void 0) facts.tokenUsage = values.tokenUsage;
+	if (values.sessionStats !== void 0) facts.stats = values.sessionStats;
+	if (values.todos !== void 0 && values.todos !== null) {
+		const items = values.todos;
+		facts.todos = {
+			items,
+			done: items.filter((item) => item.status === "completed").length,
+			active: items.filter((item) => item.status === "in_progress").length,
+			pending: items.filter((item) => item.status === "pending").length
+		};
 	}
-	for (; i < previous.length; i++) out.push({
-		kind: "removed",
-		text: previous[i]
-	});
-	for (; j < next.length; j++) out.push({
-		kind: "added",
-		text: next[j]
-	});
-	return out;
+	if (values.goal !== void 0 && values.goal !== null) {
+		const { goal, roundsStarted } = values.goal;
+		facts.goal = {
+			phase: goal.phase,
+			objective: goal.objective,
+			round: roundsStarted,
+			maxRounds: goal.maxGoalRounds,
+			...goal.blockedReason === void 0 ? {} : { blockedReason: goal.blockedReason.message }
+		};
+	}
+	if (values.plan !== void 0) facts.plan = values.plan;
+	if (values.permissions !== void 0) facts.permissions = values.permissions;
+	return facts;
 }
 /**
-* Keep changed rows plus `context` unchanged rows around each change, so a
-* card shows the hunks rather than the whole file.
-* @param lines - the aligned rows.
-* @param context - unchanged rows kept on each side of a change.
-* @returns the rows to display, with an `undefined` gap marker where rows were elided.
+* The short footer parts: `ctx 42%`, `todo 2/5` (done over total),
+* `goal active`, and `plan` (`plan…` while a mode switch is pending).
+* @param facts - the facts one status read produced.
+* @returns one part per present fact, in footer order; empty when nothing is known.
 */
-function hunks(lines, context) {
-	const keep = new Array(lines.length).fill(false);
-	lines.forEach((line, index) => {
-		if (line.kind === "context") return;
-		for (let k = Math.max(0, index - context); k <= Math.min(lines.length - 1, index + context); k++) keep[k] = true;
+function footerStatus(facts) {
+	const parts = [];
+	if (facts.context !== void 0) parts.push({
+		id: "context",
+		label: `ctx ${String(facts.context.percent)}%`
 	});
-	const out = [];
-	let gap = false;
-	lines.forEach((line, index) => {
-		if (keep[index] === true) {
-			out.push(line);
-			gap = false;
-		} else if (!gap) {
-			out.push(void 0);
-			gap = true;
-		}
+	if (facts.todos !== void 0) parts.push({
+		id: "todo",
+		label: `todo ${String(facts.todos.done)}/${String(facts.todos.items.length)}`
 	});
-	return out;
+	if (facts.goal !== void 0) parts.push({
+		id: "goal",
+		label: `goal ${facts.goal.phase}`
+	});
+	if (facts.plan?.pending === true) parts.push({
+		id: "plan",
+		label: "plan…"
+	});
+	else if (facts.plan?.active === true) parts.push({
+		id: "plan",
+		label: "plan"
+	});
+	return parts;
 }
-//#endregion
-//#region lib/types/transcript.js
 /**
-* Pure transcript formatting: durable session facts and tool presentation
-* views become plain text rows for the terminal components to draw. Nothing
-* here touches the terminal, the palette, or the agent.
-* @module @deepseek-ai/dsh-tui-app/transcript
-*/
-/** Unchanged rows shown around each diff hunk. */
-const DIFF_CONTEXT_LINES = 2;
-/**
-* Join the text of the text blocks in `blocks`; other block kinds are
-* summarized in brackets so a card never hides that they exist.
-* @param blocks - model or tool content.
-* @returns the readable text.
+* The context section: occupancy of the next request and, when the breakdown
+* is registered, its system/tools/messages composition.
+* @param facts - the facts one status read produced.
+* @returns the section lines; empty when neither fact is known.
 */
-function contentText(blocks) {
-	return blocks.map((block) => {
-		if (block.type === "text") return block.text;
-		if (block.type === "reasoning") return "";
-		return `[${block.type}]`;
-	}).filter((part) => part !== "").join("\n");
+function contextLines(facts) {
+	const lines = [];
+	if (facts.context !== void 0) {
+		const { used, window, percent } = facts.context;
+		lines.push(`context: ~${formatTokens(used)} / ${formatTokens(window)} (${String(percent)}%)`);
+	}
+	if (facts.breakdown !== void 0) {
+		const { systemTokens, toolsTokens, messageTokens } = facts.breakdown;
+		lines.push(`  system ~${formatTokens(systemTokens)} · tools ~${formatTokens(toolsTokens)} · messages ~${formatTokens(messageTokens)}`);
+	}
+	return lines;
 }
 /**
-* Compact token count: `950`, `1.2k`, `3.4M`.
-* @param count - a non-negative token count.
-* @returns the formatted count.
+* The usage section: cumulative provider-reported tokens with the cache-hit
+* share, and the whole-log turn/step counts and wall times.
+* @param facts - the facts one status read produced.
+* @returns the section lines; empty when neither fact is known.
 */
-function formatTokens(count) {
-	if (count < 1e3) return String(count);
-	if (count < 1e6) return `${(count / 1e3).toFixed(count < 1e4 ? 1 : 0)}k`;
-	return `${(count / 1e6).toFixed(1)}M`;
+function usageLines(facts) {
+	const lines = [];
+	if (facts.tokenUsage !== void 0) {
+		const usage = facts.tokenUsage;
+		const parts = [
+			`↑${formatTokens(usage.uncachedInputTokens)} uncached`,
+			`cache read ${formatTokens(usage.cacheReadTokens)}`,
+			`cache write ${formatTokens(usage.cacheWriteTokens)}`,
+			`↓${formatTokens(usage.outputTokens)}`
+		];
+		const hit = cacheHitPercent(usage);
+		if (hit !== null) parts.push(`cache hit ${hit}%`);
+		lines.push(`tokens: ${parts.join(" · ")}`);
+	}
+	if (facts.stats !== void 0) {
+		const stats = facts.stats;
+		const parts = [
+			`${String(stats.turns)} ${plural(stats.turns, "turn")}`,
+			`${String(stats.steps)} ${plural(stats.steps, "step")}`,
+			`model ${formatDuration(stats.llmMs)}`,
+			`tools ${formatDuration(stats.toolMs)}`
+		];
+		if (stats.ttftSteps > 0) parts.push(`first token ${formatDuration(stats.ttftMs / stats.ttftSteps)} avg`);
+		if (stats.decodeMs > 0) parts.push(`${String(Math.round(stats.decodeTokens / stats.decodeMs * 1e3))} tok/s`);
+		lines.push(`session: ${parts.join(" · ")}`);
+	}
+	return lines;
 }
-/** The zero totals a fresh session starts from. */
-const EMPTY_USAGE = {
-	inputTokens: 0,
-	outputTokens: 0,
-	cacheReadTokens: 0,
-	lastInputTokens: 0
-};
 /**
-* Fold one committed usage record into the totals.
-* @param totals - the totals so far.
-* @param usage - the message's usage.
-* @returns the new totals.
+* The todo section: the counts by status and the list itself.
+* @param facts - the facts one status read produced.
+* @returns the section lines; empty when no todo list is known.
 */
-function addUsage(totals, usage) {
-	return {
-		inputTokens: totals.inputTokens + usage.inputTokens,
-		outputTokens: totals.outputTokens + usage.outputTokens,
-		cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0),
-		lastInputTokens: usage.inputTokens + (usage.cacheReadTokens ?? 0)
-	};
+function todoLines(facts) {
+	if (facts.todos === void 0) return [];
+	const { items, done, active, pending } = facts.todos;
+	return [`todos: ${String(done)} done · ${String(active)} active · ${String(pending)} pending`, ...items.map((item) => `  ${TODO_GLYPH[item.status]} ${item.content}`)];
 }
 /**
-* The one-line usage summary drawn in the footer.
-* @param totals - the cumulative totals.
-* @returns the summary, or an empty string before the first committed message.
+* The goal section: phase, admitted rounds, objective, and the blocking
+* condition while the goal is blocked.
+* @param facts - the facts one status read produced.
+* @returns the section lines; empty when the session carries no goal.
 */
-function formatUsage(totals) {
-	if (totals.inputTokens === 0 && totals.outputTokens === 0) return "";
-	const parts = [`↑${formatTokens(totals.inputTokens)}`, `↓${formatTokens(totals.outputTokens)}`];
-	if (totals.cacheReadTokens > 0) parts.push(`cache ${formatTokens(totals.cacheReadTokens)}`);
-	parts.push(`ctx ${formatTokens(totals.lastInputTokens)}`);
-	return parts.join(" ");
+function goalLines(facts) {
+	if (facts.goal === void 0) return [];
+	const goal = facts.goal;
+	const lines = [`goal: ${goal.phase} · round ${String(goal.round)}/${String(goal.maxRounds)} · ${goal.objective}`];
+	if (goal.blockedReason !== void 0) lines.push(`  blocked: ${goal.blockedReason}`);
+	return lines;
 }
 /**
-* The notice a closed turn earns, or undefined for an ordinary completion.
-* @param reason - the durable turn-end reason.
-* @returns the notice text.
+* The plan-mode section.
+* @param facts - the facts one status read produced.
+* @returns the one section line; empty when no plan-mode projection is registered.
 */
-function turnEndNotice(reason) {
-	switch (reason.kind) {
-		case "completed": return;
-		case "aborted": return "turn stopped";
-		case "blocked": return "turn blocked: the model produced nothing the loop could continue";
-		case "error": return `turn failed: ${reason.error.code}: ${reason.error.message}`;
-		case "max-tokens": return "turn reached the output token ceiling";
-		case "interrupted": return "turn was interrupted by an earlier process exit";
-		default: return assertNever(reason, "tui turn-end reason");
-	}
+function planLines(facts) {
+	if (facts.plan === void 0) return [];
+	return [`plan: ${facts.plan.active ? "on" : "off"}${facts.plan.pending ? " (switching)" : ""}`];
 }
 /**
-* One-line text for a failure value from a handler, a service, or the host.
-* @param error - the thrown or rejected value.
-* @returns the error message, or the value rendered as a string.
+* The permission section. The projection carries the current value only; the
+* selectable options moved to the process-level catalog Remote.
+* @param facts - the facts one status read produced.
+* @returns the one section line; empty when no permission service is composed.
 */
-function describeFailure(error) {
-	return error instanceof Error ? error.message : String(error);
+function permissionLines(facts) {
+	if (facts.permissions === void 0) return [];
+	return [`permission: ${facts.permissions.currentValue}`];
 }
 /**
-* Parse the model's raw argument JSON for presentation.
-* @param argumentsJson - the `tool/call` event's verbatim argument string.
-* @returns the parsed value, or undefined when it is not JSON.
+* The multi-line `/status` report: context occupancy and composition, token
+* usage with the cache-hit share, session stats, the todo list, the goal,
+* plan mode, and the permission preset — one section per present fact. The
+* status bar prints the same sections as one segment's details.
+* @param facts - the facts one status read produced.
+* @returns the report lines; a single explanatory line when nothing is known.
 */
-function parseArguments(argumentsJson) {
-	try {
-		return JSON.parse(argumentsJson);
-	} catch {
-		return;
-	}
+function statusReport(facts) {
+	const lines = [
+		...contextLines(facts),
+		...usageLines(facts),
+		...todoLines(facts),
+		...goalLines(facts),
+		...planLines(facts),
+		...permissionLines(facts)
+	];
+	return lines.length === 0 ? ["no session status yet"] : lines;
 }
 /**
-* Render a diff for a card body.
-* @param diff - one file's old and new text.
-* @returns rows prefixed with `+`, `-`, or two spaces, plus `…` gap markers.
+* The share of prompt-side input served from cache over the complete log.
+* @param usage - cumulative provider-reported usage.
+* @returns the percentage text; a partial hit never rounds up to `100`, and
+* no billed input returns null.
 */
-function diffRows(diff) {
-	return hunks(diffLines(diff.oldText, diff.newText), DIFF_CONTEXT_LINES).map((row) => {
-		if (row === void 0) return "  …";
-		return (row.kind === "added" ? "+ " : row.kind === "removed" ? "- " : "  ") + row.text;
-	});
+function cacheHitPercent(usage) {
+	const promptTokens = usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+	if (promptTokens === 0) return null;
+	if (promptTokens === usage.cacheReadTokens) return "100";
+	const percent = usage.cacheReadTokens / promptTokens * 100;
+	const rounded = Math.round(percent);
+	return rounded < 100 ? String(rounded) : String(Math.floor(percent * 10) / 10);
 }
 /**
-* Text for a tool call from its presentation view, falling back to the raw
-* arguments when the tool declares no presenter.
-* @param argumentsJson - the verbatim argument JSON.
-* @param view - the tool's `presentCall` view, when it has one.
-* @returns the card's call text.
+* Compact duration: `45.2s` under a minute, `2m42s` from there on.
+* @param ms - duration in milliseconds.
+* @returns the formatted duration.
 */
-function toolCallText(argumentsJson, view) {
-	if (view === void 0) {
-		const parsed = parseArguments(argumentsJson);
-		const summary = parsed === void 0 ? argumentsJson : JSON.stringify(parsed);
-		return {
-			title: "",
-			lines: summary === "{}" || summary === "" ? [] : [summary]
-		};
-	}
-	switch (view.card) {
-		case "generic": {
-			const lines = [];
-			if (view.content !== void 0) lines.push(...contentText(view.content).split("\n"));
-			return {
-				title: view.title,
-				lines
-			};
-		}
-		case "terminal": {
-			const lines = [];
-			if (view.description !== void 0) lines.push(view.description);
-			if (view.cwd !== void 0) lines.push(`cwd: ${view.cwd}`);
-			return {
-				title: view.title,
-				lines
-			};
-		}
-		case "diff": return {
-			title: view.title,
-			lines: view.diffs.flatMap((diff) => [diff.path, ...diffRows(diff)])
-		};
-		default: return assertNever(view, "tui tool call view");
-	}
+function formatDuration(ms) {
+	const seconds = ms / 1e3;
+	if (seconds < 60) return `${String(Math.round(seconds * 10) / 10)}s`;
+	const whole = Math.round(seconds);
+	return `${String(Math.floor(whole / 60))}m${String(whole % 60)}s`;
 }
 /**
-* Text rows for a completed tool call from its presentation view, falling
-* back to the model-facing result content.
-* @param view - the tool's `presentResult` view, when it has one.
-* @param content - the model-facing result content.
-* @returns the rows, before any preview truncation.
+* The notice a completed compaction earns.
+* @param data - the `compaction/summary` event data.
+* @returns e.g. `compacted 12 items (~3.4k tokens)`.
 */
-function toolResultLines(view, content) {
-	if (view === void 0) return contentText(content).split("\n").filter((line) => line !== "");
-	switch (view.card) {
-		case "generic": return contentText(view.content ?? content).split("\n").filter((line) => line !== "");
-		case "terminal": {
-			const lines = (view.output ?? "").split("\n");
-			while (lines.length > 0 && lines.at(-1) === "") lines.pop();
-			if (view.exitCode !== void 0 && view.exitCode !== 0) lines.push(`exit ${String(view.exitCode)}`);
-			if (view.signal !== void 0) lines.push(`signal ${view.signal}`);
-			return lines;
-		}
-		case "diff": return view.diffs.flatMap((diff) => [diff.path, ...diffRows(diff)]);
-		case "search": {
-			const lines = view.shape === "matches" ? view.files.flatMap((file) => file.matches.map((match) => `${file.path}:${String(match.lineNumber)}: ${match.line}`)) : [...view.paths];
-			if (view.truncated) lines.push(`… ${String(view.total)} total`);
-			return lines;
-		}
-		case "read": return view.lines.map((line) => `${String(line.number).padStart(4)}│ ${line.text}`);
-		case "web": {
-			if (view.kind === "fetch") return [`${view.url} (${String(view.statusCode)})`];
-			const lines = view.sources.map((source) => source.title === void 0 ? source.url : `${source.title} — ${source.url}`);
-			if (view.answer !== void 0) lines.unshift(view.answer);
-			return lines;
-		}
-		default: return assertNever(view, "tui tool result view");
-	}
+function compactionNotice(data) {
+	const count = data.shadowedSeqs.length;
+	return `compacted ${String(count)} ${plural(count, "item")} (~${formatTokens(data.shadowedTokenCount)} tokens)`;
 }
 /**
-* Cut a card body to its collapsed preview.
-* @param lines - the full body rows.
-* @param previewLines - rows kept when collapsed.
-* @param expanded - whether the user expanded tool cards.
-* @returns the rows to draw, with a trailing count of hidden rows when cut.
+* The notice a scheduled model-request retry earns.
+* @param data - the `llm/retry` event data.
+* @returns e.g. `retrying (2/5) in 4s · RATE_LIMIT: provider busy`; an
+* `always` policy has no cap, so its attempt reads `(2)`.
 */
-function previewLines(lines, previewLines, expanded) {
-	if (expanded || lines.length <= previewLines) return [...lines];
-	const hidden = lines.length - previewLines;
-	return [...lines.slice(0, previewLines), `… ${String(hidden)} more line${hidden === 1 ? "" : "s"} (Ctrl+O expands)`];
+function retryMessage(data) {
+	return `retrying (${data.mode === "normal" ? `${String(data.retry)}/${String(data.maxRetries)}` : String(data.retry)}) in ${formatDuration(data.delayMs)} · ${data.failure.code}: ${data.failure.message}`;
+}
+function plural(count, noun) {
+	return count === 1 ? noun : `${noun}s`;
 }
 //#endregion
-//#region lib/types/blocks.js
+//#region lib/types/footer.js
 /**
-* Transcript components: one pi-tui component per rendered fact (a user
-* prompt, an assistant reply, a tool card, a notice). Each owns its display
-* state and re-renders from it at any width.
-* @module @deepseek-ai/dsh-tui-app/blocks
+* The status bar under the editor: plain session facts become an ordered list
+* of segments, each with a stable id, the short label the bar draws, and what
+* `Enter` on it does — the rows the app prints, or the app's own navigable
+* page; a second function renders the segments as the footer's two lines, dim
+* while the editor holds focus and with the selected segment accented while
+* the bar does. Everything here is pure — no Context, no services, no
+* terminal, and no clock: elapsed values arrive already formatted.
+* @module @deepseek-ai/dsh-tui-app/footer
 */
-/** A prompt the user submitted, drawn with a leading `›`. */
-var UserBlock = class {
-	theme;
-	text;
-	constructor(theme, text) {
-		this.theme = theme;
-		this.text = text;
-	}
-	invalidate() {}
-	render(width) {
-		const palette = this.theme.palette;
-		return ["", ...wrapTextWithAnsi(this.text, Math.max(1, width - 2)).map((line, index) => `${palette.accent(index === 0 ? "›" : " ")} ${palette.bold(line)}`)];
-	}
-};
-/** A dim one-line notice about the session (a stopped turn, a command result, a model switch). */
-var NoticeBlock = class {
-	text;
-	constructor(theme, text, tone = "dim") {
-		const palette = theme.palette;
-		this.text = new Text(palette[tone](`· ${text}`), 0, 0);
-	}
-	invalidate() {
-		this.text.invalidate();
-	}
-	render(width) {
-		return this.text.render(width);
-	}
-};
+/** The segment focus enters the bar on; `buildFooterSegments` always emits it first. */
+const FIRST_FOOTER_SEGMENT = "model";
+/** What separates two segments, and two parts inside a hint line. */
+const SEPARATOR$1 = " · ";
 /**
-* An assistant reply: streamed reasoning above streamed Markdown text. The
-* durable `assistant/message` replaces both with the committed content.
+* Longest workspace label the bar draws in full. A wider path keeps its last
+* two segments behind `…/` so one long project path cannot crowd out the
+* facts beside it. This is a presentation choice of this terminal surface,
+* not a deployment setting.
 */
-var AssistantBlock = class {
-	theme;
-	reasoning = "";
-	text = "";
-	interrupted = false;
-	markdown;
-	reasoningText;
-	constructor(theme) {
-		this.theme = theme;
-		const palette = theme.palette;
-		this.markdown = new Markdown("", 0, 0, markdownTheme(palette));
-		this.reasoningText = new Text("", 0, 0);
-	}
-	/**
-	* Append streamed visible text.
-	* @param delta - the text delta.
-	*/
-	appendText(delta) {
-		this.text += delta;
-		this.markdown.setText(this.text);
-	}
-	/**
-	* Append streamed reasoning text.
-	* @param delta - the reasoning delta.
-	*/
-	appendReasoning(delta) {
-		this.reasoning += delta;
-		this.reasoningText.setText(this.theme.palette.dim(this.theme.palette.italic(this.reasoning.trimEnd())));
-	}
-	/**
-	* Replace the streamed content with the committed message.
-	* @param text - the committed visible text.
-	* @param reasoning - the committed reasoning text.
-	* @param interrupted - whether the message was cut short.
-	*/
-	commit(text, reasoning, interrupted) {
-		this.text = text;
-		this.reasoning = reasoning;
-		this.interrupted = interrupted;
-		this.markdown.setText(text);
-		this.reasoningText.setText(this.theme.palette.dim(this.theme.palette.italic(reasoning.trimEnd())));
-	}
-	invalidate() {
-		this.markdown.invalidate();
-		this.reasoningText.invalidate();
-	}
-	render(width) {
-		const lines = [""];
-		if (this.reasoning.trim() !== "") lines.push(...this.reasoningText.render(width), "");
-		if (this.text !== "") lines.push(...this.markdown.render(width));
-		if (this.interrupted) lines.push(this.theme.palette.dim("[interrupted]"));
-		return lines;
-	}
-};
-/** A tool call card: status glyph, tool name, headline, then a foldable body. */
-var ToolBlock = class {
-	theme;
-	name;
-	call;
-	status = "running";
-	resultLines = [];
-	expanded = false;
-	constructor(theme, name, call) {
-		this.theme = theme;
-		this.name = name;
-		this.call = call;
-	}
-	/**
-	* Attach the result rows and settle the status.
-	* @param lines - the result rows before preview truncation.
-	* @param isError - whether the tool reported failure.
-	*/
-	setResult(lines, isError) {
-		this.resultLines = lines;
-		this.status = isError ? "error" : "done";
-	}
-	/**
-	* Fold or unfold the body.
-	* @param expanded - whether the full body is shown.
-	*/
-	setExpanded(expanded) {
-		this.expanded = expanded;
-	}
-	invalidate() {}
-	render(width) {
-		const palette = this.theme.palette;
-		const header = `${this.status === "running" ? palette.warning("●") : this.status === "done" ? palette.success("●") : palette.error("●")} ${palette.bold(this.name)}${this.call.title === "" ? "" : ` ${palette.dim(this.call.title)}`}`;
-		const shown = previewLines([...this.call.lines, ...this.resultLines], this.theme.toolPreviewLines, this.expanded);
-		const inner = Math.max(1, width - 4);
-		const rows = shown.flatMap((line) => wrapTextWithAnsi(line, inner).map((part) => `  ${palette.dim("│")} ${part}`));
-		return [
-			"",
-			...wrapTextWithAnsi(header, width),
-			...rows
-		];
-	}
-};
-//#endregion
-//#region lib/types/completion.js
+const WORKSPACE_LABEL_WIDTH = 24;
+/** The last two segments of a path, with the separators that precede them. */
+const PATH_TAIL = /[/\\][^/\\]+[/\\][^/\\]+$/u;
+/** The keys the focused bar answers, replacing the usual hints. */
+const FOCUS_HINTS$1 = `← → select${SEPARATOR$1}Enter details${SEPARATOR$1}Esc back`;
+/** What the unfocused hints advertise as the way into the bar. */
+const ENTRY_HINT = "Shift+↑ status bar";
+/** The command that prints every projection section at once. */
+const STATUS_COMMAND_ROW = "/status prints all of these sections";
 /**
-* Editor completion: `/` at the start of the message opens the command list,
-* and `@` anywhere offers workspace paths and other sessions as references,
-* inserted in the same mention grammar the browser composer uses.
-* @module @deepseek-ai/dsh-tui-app/completion
+* What opening each projection-fact segment does: a section builder produces
+* the rows the app prints, and `OPENED_PAGE` names a fact the app has its own
+* navigable page for. The printed `/status` report still carries a todo
+* section; the bar hands the todo list to the app instead.
 */
+const STATUS_SECTIONS = {
+	context: contextLines,
+	todo: { kind: "page" },
+	goal: goalLines,
+	plan: planLines
+};
 /**
-* Build the provider over live sources, so commands and references registered
-* after startup appear without re-creating the editor.
-* @param sources - the command and reference sources.
-* @returns the editor's autocomplete provider.
+* Detail rows as the segment carries them.
+* @param rows - the rows the app prints; never empty.
+* @returns the detail.
 */
-function editorCompletion(sources) {
+function printed(rows) {
 	return {
-		triggerCharacters: ["/", "@"],
-		async getSuggestions(lines, cursorLine, cursorCol, options) {
-			const line = lines[cursorLine] ?? "";
-			const before = line.slice(0, cursorCol);
-			const at = activeAtToken(line, cursorCol);
-			if (at !== void 0) {
-				const items = (await sources.references(at.query, at.quoted, options.signal)).map((reference) => ({
-					value: reference.mention,
-					label: reference.label,
-					...reference.description === void 0 ? {} : { description: reference.description }
-				}));
-				return items.length === 0 ? null : {
-					items,
-					prefix: at.prefix
-				};
-			}
-			if (cursorLine !== 0 || !before.startsWith("/") || /\s/u.test(before)) return null;
-			const prefix = before;
-			const items = sources.commands().filter((command) => `/${command.name}`.startsWith(prefix)).map((command) => ({
-				value: `/${command.name}`,
-				label: `/${command.name}`,
-				description: command.hint === void 0 ? command.description : `${command.description} · ${command.hint}`
-			}));
-			return items.length === 0 ? null : {
-				items,
-				prefix
-			};
-		},
-		applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-			const line = lines[cursorLine] ?? "";
-			const start = cursorCol - prefix.length;
-			const replaced = `${line.slice(0, start)}${item.value} ${line.slice(cursorCol)}`;
-			const next = [...lines];
-			next[cursorLine] = replaced;
-			return {
-				lines: next,
-				cursorLine,
-				cursorCol: start + item.value.length + 1
-			};
-		}
+		kind: "rows",
+		rows
 	};
 }
-/** What the provider-default row is called. */
-const PROVIDER_DEFAULT_LABEL = "Provider default";
-/** The `/effort` argument that restores the provider default. */
-const DEFAULT_ARGUMENT = "default";
-/**
-* The display name of one effort.
-* @param reasoning - what the model declares.
-* @param effort - the selected effort, or undefined for the provider default.
-* @returns the declared name, the raw id when the model no longer declares it, or the provider-default label.
-*/
-function effortName(reasoning, effort) {
-	if (effort === void 0) return PROVIDER_DEFAULT_LABEL;
-	return reasoning.efforts.find((candidate) => candidate.id === effort)?.name ?? effort;
-}
 /**
-* Picker rows for one model: the provider default above the adapter's own order.
-* @param reasoning - what the model declares.
-* @returns the rows, provider default first.
+* The workspace label: a home-directory prefix becomes `~`, and a path still
+* wider than the bar allows keeps only its last two segments.
+* @param cwd - the workspace root.
+* @param home - the home directory to fold into `~`; absent leaves `cwd` alone.
+* @returns the label the bar draws.
 */
-function effortItems(reasoning) {
-	const resolved = reasoning.defaultEffort === void 0 ? void 0 : `resolves to ${effortName(reasoning, reasoning.defaultEffort)}`;
-	return [{
-		value: "",
-		label: PROVIDER_DEFAULT_LABEL,
-		...resolved === void 0 ? {} : { description: resolved }
-	}, ...reasoning.efforts.map((effort) => ({
-		value: effort.id,
-		label: effort.name,
-		...effort.description === void 0 ? {} : { description: effort.description }
-	}))];
+function workspaceLabel(cwd, home) {
+	const folded = home !== void 0 && home !== "" && startsWithDirectory(cwd, home) ? `~${cwd.slice(home.length)}` : cwd;
+	if (folded.length <= WORKSPACE_LABEL_WIDTH) return folded;
+	const tail = PATH_TAIL.exec(folded);
+	return tail === null ? folded : `…${tail[0]}`;
 }
 /**
-* The dim row under the picker heading.
-* @param reasoning - what the model declares.
-* @param effort - the effort in force, or undefined for the provider default.
-* @returns one row naming the effort in force and the keys that change it.
+* Whether `path` is `directory` itself or lies under it.
+* @param path - the path to test.
+* @param directory - the candidate prefix, without a trailing separator.
+* @returns true when `path` starts at `directory`.
 */
-function effortHint(reasoning, effort) {
-	return `current: ${effortName(reasoning, effort)} · Esc keeps it · Shift+Tab cycles`;
+function startsWithDirectory(path, directory) {
+	if (!path.startsWith(directory)) return false;
+	const next = path.charAt(directory.length);
+	return next === "" || next === "/" || next === "\\";
 }
 /**
-* The effort a typed `/effort` argument names. A declared id wins over the
-* `default` keyword, so an adapter may own that id.
-* @param reasoning - what the model declares.
-* @param typed - the argument, matched against declared ids without case.
-* @returns the declared effort, undefined for the provider default, or null when the model declares no such effort.
+* Build the status bar's segments in the order it draws them: model, effort,
+* permission, turn, usage, the projection facts, workspace, attachments. Only
+* the model and workspace segments are always present; every other segment
+* needs its fact.
+* @param inputs - the facts the app read for the bound session.
+* @returns the segments, the model segment first.
 */
-function matchEffort(reasoning, typed) {
-	const wanted = typed.toLowerCase();
-	const declared = reasoning.efforts.find((effort) => effort.id.toLowerCase() === wanted);
-	if (declared !== void 0) return declared.id;
-	return wanted === DEFAULT_ARGUMENT ? void 0 : null;
+function buildFooterSegments(inputs) {
+	const { selection, facts, turn } = inputs;
+	const effort = selection.reasoningEffort;
+	const segments = [{
+		id: "model",
+		label: `${selection.provider}/${selection.model}`,
+		detail: printed([
+			`provider: ${selection.provider}`,
+			`model: ${selection.model}`,
+			effort === void 0 ? "reasoning effort: the model's own default" : `reasoning effort: ${effort}`,
+			"/model picks the provider and model for the next request"
+		])
+	}];
+	if (effort !== void 0) segments.push({
+		id: "effort",
+		label: `effort ${effort}`,
+		detail: printed([`reasoning effort: ${effort}`, `Shift+Tab cycles it${SEPARATOR$1}/effort picks one`])
+	});
+	if (inputs.permission !== void 0) {
+		const projected = permissionLines(facts);
+		segments.push({
+			id: "permission",
+			label: `permission ${inputs.permission}`,
+			detail: printed([...projected.length === 0 ? [`permission: ${inputs.permission}`] : projected, "/permission <preset> changes the sandbox mode and the approval policy"])
+		});
+	}
+	if (turn !== void 0) segments.push({
+		id: "turn",
+		label: `turn ${turn.elapsed}`,
+		detail: printed([
+			`turn ${String(turn.number)}`,
+			`started: ${formatTimestamp(turn.startedAt)}`,
+			`elapsed: ${turn.elapsed}`,
+			`queued: ${String(turn.queuedNextTurn)} for the next turn${SEPARATOR$1}${String(turn.queuedNextStep)} for the next step`
+		])
+	});
+	if (inputs.usage !== "") segments.push({
+		id: "usage",
+		label: inputs.usage,
+		detail: printed([
+			`this terminal: ${inputs.usage}`,
+			...usageLines(facts),
+			STATUS_COMMAND_ROW
+		])
+	});
+	for (const part of footerStatus(facts)) {
+		const section = STATUS_SECTIONS[part.id];
+		segments.push({
+			id: part.id,
+			label: part.label,
+			detail: typeof section === "function" ? printed([...section(facts), STATUS_COMMAND_ROW]) : section
+		});
+	}
+	segments.push({
+		id: "workspace",
+		label: workspaceLabel(inputs.cwd, inputs.home),
+		detail: printed([`workspace: ${inputs.cwd}`])
+	});
+	if (inputs.attachments.length > 0) segments.push({
+		id: "attachments",
+		label: `${String(inputs.attachments.length)} attached`,
+		detail: printed([...inputs.attachments.map((attachment) => `${attachment.kind}: ${attachment.name}`), `/attach <path> adds one${SEPARATOR$1}/attach clear drops them all`])
+	});
+	return segments;
 }
-//#endregion
-//#region lib/types/export.js
 /**
-* `/export`: the same session-log ZIP the browser downloads, written to a
-* local directory through the export package's archive helpers.
-* @module @deepseek-ai/dsh-tui-app/export
+* Where the bar draws its selection.
+* @param segments - the segments in bar order.
+* @param selected - the segment id the bar holds.
+* @returns that segment's index, or 0 once the fact behind it is gone.
 */
+function footerSelectionIndex(segments, selected) {
+	const index = segments.findIndex((segment) => segment.id === selected);
+	return index === -1 ? 0 : index;
+}
 /**
-* Write the session tree (the session, its sub-sessions, and attachments) as
-* a ZIP archive into `directory`.
-* @param ctx - plugin context carrying the query, persistence, and attachment services.
-* @param sessionId - the session to export.
-* @param directory - the directory the archive is written into.
-* @param signal - cancels the export.
-* @returns the archive's absolute path.
-* @throws when a required service is not composed or the session has no persisted log.
+* Render the footer's two lines: the segment labels, then the key hints.
+* Unfocused the whole bar is dim and the hints advertise the entry key;
+* focused the selected segment is accented and the hints name the navigation
+* keys instead.
+* @param segments - the segments in bar order.
+* @param render - the palette, the selected index, and the unfocused hints.
+* @returns the footer text, two lines separated by a newline.
 */
-async function exportSessionZip(ctx, sessionId, directory, signal) {
-	const deps = sessionLogExportDeps(ctx);
-	if (deps.sessionQuery === void 0 || deps.sessionPersistence === void 0 || deps.attachments === void 0) throw new Error("export needs the session query, persistence, and attachment services");
-	const ready = {
-		...deps,
-		sessionQuery: deps.sessionQuery,
-		sessionPersistence: deps.sessionPersistence,
-		attachments: deps.attachments
-	};
-	await flushLiveSessionLog(deps, sessionId, signal);
-	const root = await readSessionLogText(deps.sessionPersistence, sessionId, signal);
-	if (root === void 0) throw new Error(`session ${sessionId} has no persisted log to export`);
-	const path = join(directory, sessionLogZipFilename(sessionId));
-	const archive = streamSessionLogZip(ready, root, sessionId, true, DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, signal);
-	await pipeline(Readable.fromWeb(archive), createWriteStream(path), { signal });
-	return path;
+function renderFooter(segments, render) {
+	const { palette, selected, hints } = render;
+	const labels = segments.map((segment) => segment.label);
+	if (selected === void 0) return `${palette.dim(labels.join(SEPARATOR$1))}\n${palette.dim(`${hints}${SEPARATOR$1}${ENTRY_HINT}`)}`;
+	return `${labels.map((label, index) => index === selected ? palette.bold(palette.accent(label)) : palette.dim(label)).join(palette.dim(SEPARATOR$1))}\n${palette.dim(FOCUS_HINTS$1)}`;
 }
 //#endregion
 //#region lib/types/prompts.js
 /**
-* Modal prompts the agent raises through the approval and user-questions
-* seams, and the queue that shows them one at a time above the editor.
+* Modal prompts the terminal shows above the editor — the approval and
+* user-questions seams, list pickers, and read-only detail pages — and the
+* queue that shows them one at a time.
 * @module @deepseek-ai/dsh-tui-app/prompts
 */
 /** Rows a select list shows before scrolling. */
@@ -1091,22 +2288,46 @@ var Settlement = class {
 var ListPrompt = class {
 	palette;
 	body;
+	choose;
+	cancel;
+	layout;
 	settled;
 	settlement = new Settlement();
 	heading;
 	list;
-	constructor(palette, heading, body, items, choose, cancel) {
+	constructor(palette, heading, body, items, choose, cancel, layout) {
 		this.palette = palette;
 		this.body = body;
+		this.choose = choose;
+		this.cancel = cancel;
+		this.layout = layout;
 		this.settled = this.settlement.settled;
 		this.heading = new Text(heading, 0, 0);
-		this.list = new SelectList(items, SELECT_MAX_VISIBLE, selectListTheme(palette));
-		this.list.onSelect = (item) => {
-			this.settlement.settle(choose(item));
+		this.list = this.listOver(items);
+	}
+	/**
+	* A select list over `items` wired to this prompt's settlement. `SelectList`
+	* takes its rows at construction and exposes no way to replace them, so a
+	* different row set means a different list.
+	* @param items - the rows to show.
+	* @returns the list, highlighting its first row.
+	*/
+	listOver(items) {
+		const list = new SelectList(items, SELECT_MAX_VISIBLE, selectListTheme(this.palette), this.layout);
+		list.onSelect = (item) => {
+			this.settlement.settle(this.choose(item));
 		};
-		this.list.onCancel = () => {
-			this.settlement.settle(cancel());
+		list.onCancel = () => {
+			this.settlement.settle(this.cancel());
 		};
+		return list;
+	}
+	/**
+	* Show `items` instead of the current rows, highlighting the first one.
+	* @param items - the rows to show.
+	*/
+	setRows(items) {
+		this.list = this.listOver(items);
 	}
 	/**
 	* Settle from outside the list, for withdrawal.
@@ -1136,9 +2357,18 @@ var ListPrompt = class {
 			"",
 			...this.heading.render(width),
 			...body,
-			...this.list.render(width)
+			...this.listLines(width)
 		];
 	}
+	/**
+	* The lines under the body rows: the select list, which a subclass may
+	* precede or replace.
+	* @param width - the terminal width.
+	* @returns the rendered lines.
+	*/
+	listLines(width) {
+		return this.list.render(width);
+	}
 };
 /**
 * Approval question: allow this one tool call or reject it; Escape rejects.
@@ -1164,19 +2394,168 @@ var ApprovalPrompt = class extends ListPrompt {
 };
 /** Marks the row a picker opened on, so it stays visible after the highlight moves. */
 const CURRENT_MARK = " ✓";
-/** A generic list picker (models, sessions); Escape settles undefined. */
+/** What the filter line says while the query is empty. */
+const FILTER_HINT = "type to filter · Enter selects · Esc cancels";
+/** Characters a typed query never carries: C0 controls, DEL, and C1 controls. */
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/u;
+/**
+* The text one key press types.
+* @param data - the bytes the terminal sent.
+* @returns the characters to append to a query, or undefined for control keys and escape sequences.
+*/
+function typedText(data) {
+	const kitty = decodeKittyPrintable(data);
+	if (kitty !== void 0) return kitty;
+	return CONTROL_CHARACTERS.test(data) ? void 0 : data;
+}
+/**
+* The text a picker row is matched against.
+* @param row - the row.
+* @returns the label and description joined, so one query can span both.
+*/
+function rowText(row) {
+	return row.description === void 0 ? row.label : `${row.label} ${row.description}`;
+}
+/**
+* A generic list picker (models, sessions) with a type-to-filter query.
+* Printable keys extend the query, Backspace drops its last character, and
+* Ctrl+U clears it; Escape clears a non-empty query and settles undefined
+* once the query is empty. The visible rows are the query's fuzzy matches
+* against each row's label and description, best match first; the row in
+* force keeps its mark and stays highlighted only while the query is empty.
+*/
 var PickPrompt = class extends ListPrompt {
+	/** Every row in declared order, without the mark, as matched against. */
+	rows;
+	/** The same rows with the in-force one marked, shown while the query is empty. */
+	markedRows;
+	/** Index of the row in force, or -1 when no row is. */
+	inForce;
+	/** What the user has typed, empty until the first printable key. */
+	query = "";
+	/** The rows the list shows: all of them, or the query's matches. */
+	visible;
 	constructor(palette, title, items, options = {}) {
+		const rows = items.map((item) => ({ ...item }));
 		const inForce = items.findIndex((item) => item.value === options.current);
-		super(palette, `${palette.accent("?")} ${palette.bold(title)}`, options.body ?? [], items.map((item, index) => index === inForce ? {
-			...item,
-			label: `${item.label}${CURRENT_MARK}`
-		} : { ...item }), (row) => items.find((item) => item.value === row.value), () => void 0);
+		const markedRows = rows.map((row, index) => index === inForce ? {
+			...row,
+			label: `${row.label}${CURRENT_MARK}`
+		} : row);
+		super(palette, `${palette.accent("?")} ${palette.bold(title)}`, options.body ?? [], [...markedRows], (row) => items.find((item) => item.value === row.value), () => void 0, options.layout);
+		this.rows = rows;
+		this.markedRows = markedRows;
+		this.inForce = inForce;
+		this.visible = markedRows;
 		if (inForce > 0) this.highlight(inForce);
 	}
+	/**
+	* Apply `query` and rebuild the visible rows from it.
+	* @param query - the new query; an empty one restores the declared order, the mark, and the row in force.
+	*/
+	setQuery(query) {
+		if (query === this.query) return;
+		this.query = query;
+		this.visible = query === "" ? this.markedRows : fuzzyFilter([...this.rows], query, rowText);
+		this.setRows([...this.visible]);
+		if (query === "" && this.inForce > 0) this.highlight(this.inForce);
+	}
 	withdraw() {
 		this.settle(void 0);
 	}
+	handleInput(data) {
+		if (matchesKey(data, "escape") && this.query !== "") {
+			this.setQuery("");
+			return;
+		}
+		if (matchesKey(data, "backspace")) {
+			this.setQuery(this.query.slice(0, -1));
+			return;
+		}
+		if (matchesKey(data, "ctrl+u")) {
+			this.setQuery("");
+			return;
+		}
+		const typed = typedText(data);
+		if (typed === void 0) {
+			super.handleInput(data);
+			return;
+		}
+		this.setQuery(this.query + typed);
+	}
+	listLines(width) {
+		const filter = this.query === "" ? FILTER_HINT : `filter: ${this.query} · ${String(this.visible.length)}/${String(this.rows.length)}`;
+		const shown = this.query !== "" && this.visible.length === 0 ? [this.palette.dim(`  no row matches "${this.query}"`)] : super.listLines(width);
+		return [this.palette.dim(filter), ...shown];
+	}
+};
+/** Detail rows a read-only page draws at once; the rest wait behind a scroll. */
+const DETAIL_MAX_VISIBLE = 16;
+/** The keys a read-only detail page answers, drawn dim under its rows. */
+const DETAIL_HINT = "↑ ↓ scroll · Enter, Esc, or ← returns";
+/**
+* A read-only page over rows the caller already rendered: an accented
+* heading, the rows wrapped to the terminal width, and the hint line. `Up`
+* and `Down` move one row, `PageUp` and `PageDown` a full page, and the hint
+* line carries the first visible row and the total once the rows pass
+* {@link DETAIL_MAX_VISIBLE}. `Enter`, `Escape`, and `Left` settle it; every
+* other key is ignored.
+*/
+var DetailPrompt = class {
+	palette;
+	rows;
+	settled;
+	settlement = new Settlement();
+	heading;
+	/** Index of the first visible wrapped row. */
+	offset = 0;
+	/** Wrapped rows the last render produced, which bounds scrolling; 0 before the first render. */
+	total = 0;
+	constructor(palette, heading, rows) {
+		this.palette = palette;
+		this.rows = rows;
+		this.settled = this.settlement.settled;
+		this.heading = new Text(palette.bold(palette.accent(heading)), 0, 0);
+	}
+	/**
+	* The largest first-visible row index; 0 while every row fits at once.
+	* @returns the index scrolling stops at.
+	*/
+	maxOffset() {
+		return Math.max(0, this.total - DETAIL_MAX_VISIBLE);
+	}
+	/**
+	* Move the visible window, stopping at both ends.
+	* @param step - rows to move by; negative scrolls toward the first row.
+	*/
+	scroll(step) {
+		this.offset = Math.max(0, Math.min(this.offset + step, this.maxOffset()));
+	}
+	withdraw() {
+		this.settlement.settle();
+	}
+	handleInput(data) {
+		if (matchesKey(data, "up")) this.scroll(-1);
+		else if (matchesKey(data, "down")) this.scroll(1);
+		else if (matchesKey(data, "pageUp")) this.scroll(-16);
+		else if (matchesKey(data, "pageDown")) this.scroll(DETAIL_MAX_VISIBLE);
+		else if (matchesKey(data, "enter") || matchesKey(data, "escape") || matchesKey(data, "left")) this.settlement.settle();
+	}
+	invalidate() {
+		this.heading.invalidate();
+	}
+	render(width) {
+		const wrapped = this.rows.flatMap((row) => wrapTextWithAnsi(row, Math.max(1, width)));
+		this.total = wrapped.length;
+		this.offset = Math.min(this.offset, this.maxOffset());
+		const position = this.maxOffset() === 0 ? "" : ` · (${String(this.offset + 1)}/${String(this.total)})`;
+		return [
+			"",
+			...this.heading.render(width),
+			...wrapped.slice(this.offset, this.offset + DETAIL_MAX_VISIBLE),
+			this.palette.dim(`${DETAIL_HINT}${position}`)
+		];
+	}
 };
 /** Marker value of the free-text row. */
 const CUSTOM_VALUE = "\0custom";
@@ -1428,200 +2807,96 @@ async function listSessionChoices(ctx, currentId, signal) {
 * The picker row for one session: title or id, then the workspace and date.
 * @param choice - the session.
 * @returns the label and description.
-*/
-function describeSession(choice) {
-	const parts = [new Date(choice.createdAt).toISOString().slice(0, 16).replace("T", " ")];
-	if (choice.cwd !== void 0) parts.push(choice.cwd);
-	if (choice.current) parts.push("current");
-	return {
-		label: choice.title ?? choice.id,
-		description: parts.join(" · ")
-	};
-}
-//#endregion
-//#region lib/types/status.js
-/**
-* Persistent session status for the terminal: one read of the session
-* projections becomes plain facts, and pure formatters turn those facts into
-* footer parts, the `/status` report, and the one-line notices for
-* compaction and model-request retries. Nothing here touches the terminal,
-* the palette, or the agent.
-* @module @deepseek-ai/dsh-tui-app/status
-*/
-/** The client-visible keys one status read selects. */
-const STATUS_KEYS = [
-	"contextPressure",
-	"contextBreakdown",
-	"tokenUsage",
-	"sessionStats",
-	"todos",
-	"goal",
-	"plan",
-	"permissions"
-];
-/**
-* Read one consistent cut of the status projections for `session`.
-* @param projections - the session-projection registry (`ctx.get('sessionProjections')`).
-* @param session - the session whose status is read.
-* @returns the facts every registered key yields; unregistered keys leave their fact absent.
-*/
-function readStatusFacts(projections, session) {
-	const { values } = projections.snapshot(session, STATUS_KEYS);
-	const facts = {};
-	const pressure = values.contextPressure;
-	const used = pressure?.projectedTokens ?? pressure?.pressureTokens;
-	if (used !== void 0 && pressure?.contextWindow !== void 0) facts.context = {
-		used,
-		window: pressure.contextWindow,
-		percent: Math.min(100, Math.round(used / pressure.contextWindow * 100))
-	};
-	if (values.contextBreakdown !== void 0) facts.breakdown = values.contextBreakdown;
-	if (values.tokenUsage !== void 0) facts.tokenUsage = values.tokenUsage;
-	if (values.sessionStats !== void 0) facts.stats = values.sessionStats;
-	if (values.todos !== void 0 && values.todos !== null) {
-		const items = values.todos;
-		facts.todos = {
-			items,
-			done: items.filter((item) => item.status === "completed").length,
-			active: items.filter((item) => item.status === "in_progress").length,
-			pending: items.filter((item) => item.status === "pending").length
-		};
-	}
-	if (values.goal !== void 0 && values.goal !== null) {
-		const { goal, roundsStarted } = values.goal;
-		facts.goal = {
-			phase: goal.phase,
-			objective: goal.objective,
-			round: roundsStarted,
-			maxRounds: goal.maxGoalRounds,
-			...goal.blockedReason === void 0 ? {} : { blockedReason: goal.blockedReason.message }
-		};
-	}
-	if (values.plan !== void 0) facts.plan = values.plan;
-	if (values.permissions !== void 0) facts.permissions = values.permissions;
-	return facts;
-}
-/**
-* The short footer parts: `ctx 42%`, `todo 2/5` (done over total),
-* `goal active`, and `plan` (`plan…` while a mode switch is pending).
-* @param facts - the facts one status read produced.
-* @returns one part per present fact, in footer order; empty when nothing is known.
-*/
-function footerStatus(facts) {
-	const parts = [];
-	if (facts.context !== void 0) parts.push(`ctx ${String(facts.context.percent)}%`);
-	if (facts.todos !== void 0) parts.push(`todo ${String(facts.todos.done)}/${String(facts.todos.items.length)}`);
-	if (facts.goal !== void 0) parts.push(`goal ${facts.goal.phase}`);
-	if (facts.plan?.pending === true) parts.push("plan…");
-	else if (facts.plan?.active === true) parts.push("plan");
-	return parts;
-}
-/** Glyph per todo status, matching the browser's list markers. */
-const TODO_GLYPH = {
-	completed: "✓",
-	in_progress: "▸",
-	pending: "○"
-};
-/**
-* The multi-line `/status` report: context occupancy and composition, token
-* usage with the cache-hit share, session stats, the todo list, the goal,
-* plan mode, and the permission preset — one section per present fact.
-* @param facts - the facts one status read produced.
-* @returns the report lines; a single explanatory line when nothing is known.
-*/
-function statusReport(facts) {
-	const lines = [];
-	if (facts.context !== void 0) {
-		const { used, window, percent } = facts.context;
-		lines.push(`context: ~${formatTokens(used)} / ${formatTokens(window)} (${String(percent)}%)`);
-	}
-	if (facts.breakdown !== void 0) {
-		const { systemTokens, toolsTokens, messageTokens } = facts.breakdown;
-		lines.push(`  system ~${formatTokens(systemTokens)} · tools ~${formatTokens(toolsTokens)} · messages ~${formatTokens(messageTokens)}`);
-	}
-	if (facts.tokenUsage !== void 0) {
-		const usage = facts.tokenUsage;
-		const parts = [
-			`↑${formatTokens(usage.uncachedInputTokens)} uncached`,
-			`cache read ${formatTokens(usage.cacheReadTokens)}`,
-			`cache write ${formatTokens(usage.cacheWriteTokens)}`,
-			`↓${formatTokens(usage.outputTokens)}`
-		];
-		const hit = cacheHitPercent(usage);
-		if (hit !== null) parts.push(`cache hit ${hit}%`);
-		lines.push(`tokens: ${parts.join(" · ")}`);
-	}
-	if (facts.stats !== void 0) {
-		const stats = facts.stats;
-		const parts = [
-			`${String(stats.turns)} ${plural(stats.turns, "turn")}`,
-			`${String(stats.steps)} ${plural(stats.steps, "step")}`,
-			`model ${formatDuration(stats.llmMs)}`,
-			`tools ${formatDuration(stats.toolMs)}`
-		];
-		if (stats.ttftSteps > 0) parts.push(`first token ${formatDuration(stats.ttftMs / stats.ttftSteps)} avg`);
-		if (stats.decodeMs > 0) parts.push(`${String(Math.round(stats.decodeTokens / stats.decodeMs * 1e3))} tok/s`);
-		lines.push(`session: ${parts.join(" · ")}`);
-	}
-	if (facts.todos !== void 0) {
-		const { items, done, active, pending } = facts.todos;
-		lines.push(`todos: ${String(done)} done · ${String(active)} active · ${String(pending)} pending`);
-		for (const item of items) lines.push(`  ${TODO_GLYPH[item.status]} ${item.content}`);
-	}
-	if (facts.goal !== void 0) {
-		const goal = facts.goal;
-		lines.push(`goal: ${goal.phase} · round ${String(goal.round)}/${String(goal.maxRounds)} · ${goal.objective}`);
-		if (goal.blockedReason !== void 0) lines.push(`  blocked: ${goal.blockedReason}`);
-	}
-	if (facts.plan !== void 0) lines.push(`plan: ${facts.plan.active ? "on" : "off"}${facts.plan.pending ? " (switching)" : ""}`);
-	if (facts.permissions !== void 0) lines.push(`permission: ${facts.permissions.currentValue}`);
-	return lines.length === 0 ? ["no session status yet"] : lines;
+*/
+function describeSession(choice) {
+	const parts = [formatTimestamp(choice.createdAt)];
+	if (choice.cwd !== void 0) parts.push(choice.cwd);
+	if (choice.current) parts.push("current");
+	return {
+		label: choice.title ?? choice.id,
+		description: parts.join(" · ")
+	};
 }
+/** Two-space indentation per nesting level, as the `/subagents` rows indent. */
+const DEPTH_INDENT = "  ";
+/** What separates two facts inside one row, and two parts of the heading. */
+const SEPARATOR = " · ";
+/** The keys the focused panel answers, appended to its heading. */
+const FOCUS_HINTS = `↑ ↓ select${SEPARATOR}Enter details${SEPARATOR}Esc back`;
 /**
-* The share of prompt-side input served from cache over the complete log.
-* @param usage - cumulative provider-reported usage.
-* @returns the percentage text; a partial hit never rounds up to `100`, and
-* no billed input returns null.
+* The elapsed part of a row: the open turn's running time, else the total the
+* child's settled turns took. Absent when no timing projection is registered.
+* @param facts - the live facts sampled for the child, when it has any.
+* @param now - the wall clock the running time is measured against.
+* @returns the formatted elapsed time, or undefined when the child has none.
 */
-function cacheHitPercent(usage) {
-	const promptTokens = usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
-	if (promptTokens === 0) return null;
-	if (promptTokens === usage.cacheReadTokens) return "100";
-	const percent = usage.cacheReadTokens / promptTokens * 100;
-	const rounded = Math.round(percent);
-	return rounded < 100 ? String(rounded) : String(Math.floor(percent * 10) / 10);
+function elapsedOf(facts, now) {
+	if (facts?.activeSince !== void 0) return formatElapsed(now - facts.activeSince);
+	if (facts?.settledMs !== void 0) return formatElapsed(facts.settledMs);
 }
 /**
-* Compact duration: `45.2s` under a minute, `2m42s` from there on.
-* @param ms - duration in milliseconds.
-* @returns the formatted duration.
+* One listing entry as a row.
+* @param entry - the listing entry.
+* @param facts - the live facts sampled for it, when it has any.
+* @param now - the wall clock the running time is measured against.
+* @returns the row.
 */
-function formatDuration(ms) {
-	const seconds = ms / 1e3;
-	if (seconds < 60) return `${String(Math.round(seconds * 10) / 10)}s`;
-	const whole = Math.round(seconds);
-	return `${String(Math.floor(whole / 60))}m${String(whole % 60)}s`;
+function rowOf(entry, facts, now) {
+	const indent = DEPTH_INDENT.repeat(entry.depth - 1);
+	if (entry.kind === "diagnostic") return {
+		id: entry.id,
+		enterable: false,
+		ticking: false,
+		text: `${indent}${entry.id}${SEPARATOR}unreadable: ${entry.reason}`
+	};
+	const parts = [
+		entry.mode,
+		"resident",
+		facts?.running === true ? "running" : "idle"
+	];
+	const elapsed = elapsedOf(facts, now);
+	if (elapsed !== void 0) parts.push(elapsed);
+	if (facts?.usage !== void 0) parts.push(`↑${formatTokens(facts.usage.inputTokens)} ↓${formatTokens(facts.usage.outputTokens)}`);
+	return {
+		id: entry.id,
+		enterable: true,
+		ticking: facts?.activeSince !== void 0,
+		text: `${indent}${entry.label ?? entry.id}${SEPARATOR}${parts.join(SEPARATOR)}`
+	};
 }
 /**
-* The notice a completed compaction earns.
-* @param data - the `compaction/summary` event data.
-* @returns e.g. `compacted 12 items (~3.4k tokens)`.
+* Build one panel draw: every resident child and every diagnostic candidate
+* of the listing, in listing order, cut to {@link SUBAGENT_PANEL_MAX_ROWS}.
+* @param inputs - the listing, the live facts, and the current time.
+* @returns the drawn rows, the count they left out, and whether any of them advances with the clock.
 */
-function compactionNotice(data) {
-	const count = data.shadowedSeqs.length;
-	return `compacted ${String(count)} ${plural(count, "item")} (~${formatTokens(data.shadowedTokenCount)} tokens)`;
+function subagentPanelView(inputs) {
+	const listed = inputs.entries.filter((entry) => entry.kind === "diagnostic" || entry.activity === "running");
+	const rows = listed.slice(0, 6).map((entry) => rowOf(entry, inputs.facts.get(entry.id), inputs.now));
+	return {
+		rows,
+		hidden: listed.length - rows.length,
+		ticking: rows.some((row) => row.ticking)
+	};
 }
 /**
-* The notice a scheduled model-request retry earns.
-* @param data - the `llm/retry` event data.
-* @returns e.g. `retrying (2/5) in 4s · RATE_LIMIT: provider busy`; an
-* `always` policy has no cap, so its attempt reads `(2)`.
+* Render the panel: a heading counting the listed children, one line per
+* drawn row, the overflow count, and the last listing failure. The whole
+* panel is dim while the keyboard is elsewhere; the selected row is accented
+* while the panel holds it.
+* @param view - the rows one draw produced.
+* @param render - the palette, the selected row, and the listing failure.
+* @returns the panel text, one line per row.
 */
-function retryMessage(data) {
-	return `retrying (${data.mode === "normal" ? `${String(data.retry)}/${String(data.maxRetries)}` : String(data.retry)}) in ${formatDuration(data.delayMs)} · ${data.failure.code}: ${data.failure.message}`;
-}
-function plural(count, noun) {
-	return count === 1 ? noun : `${noun}s`;
+function renderSubagentPanel(view, render) {
+	const { palette, selected } = render;
+	const total = view.rows.length + view.hidden;
+	const heading = `subagents${SEPARATOR}${String(total)} listed${selected === void 0 ? "" : `${SEPARATOR}${FOCUS_HINTS}`}`;
+	const lines = [palette.dim(heading)];
+	for (const [index, row] of view.rows.entries()) lines.push(index === selected ? palette.bold(palette.accent(row.text)) : palette.dim(row.text));
+	if (view.hidden > 0) lines.push(palette.dim(`+${String(view.hidden)} more${SEPARATOR}/subagents lists them all`));
+	if (render.failure !== void 0) lines.push(palette.dim(`listing failed: ${render.failure}`));
+	return lines.join("\n");
 }
 //#endregion
 //#region lib/types/app.js
@@ -1629,11 +2904,76 @@ function plural(count, noun) {
 * The interactive terminal application: it renders the durable session log
 * and the live assistant stream of one Agent at a time into a pi-tui tree,
 * turns keystrokes into agent input, answers the approval and user-questions
-* seams for that Agent, and switches between sessions through its host.
+* seams for that Agent, and switches between sessions through its host. Under
+* the editor it keeps two docked regions the keyboard can take over — the
+* subagent panel and the status bar — and one repeating tick advances their
+* elapsed counters and re-reads a stale subagent listing. A second tick, at
+* its own period, brightens the text of the message streaming right now.
 * @module @deepseek-ai/dsh-tui-app/app
 */
 /** A second Ctrl+C inside this window quits. */
 const QUIT_DOUBLE_PRESS_MS = 600;
+/**
+* Row layout of the todo picker: the label column grows with the widest todo
+* line instead of stopping at the list's 32-column default, which would cut a
+* todo well inside the width its rows are built for. 68 columns hold the
+* status glyph, the row's own content cap, and the gap before the status
+* column. A presentation choice of this terminal surface, not a deployment
+* setting.
+*/
+const TODO_ROW_LAYOUT = {
+	minPrimaryColumnWidth: 1,
+	maxPrimaryColumnWidth: 68
+};
+/** The panel draw of a session with no subagent rows. */
+const EMPTY_PANEL_VIEW = {
+	rows: [],
+	hidden: 0,
+	ticking: false
+};
+/**
+* How long the application waits for the terminal to answer the OSC 11
+* background-color query it sends once at start. The query is a round trip to
+* the attached terminal, so this bounds one local handshake, not a deployment
+* choice; a terminal that stays silent leaves the fade in its two-level mode.
+*/
+const BACKGROUND_QUERY_TIMEOUT_MS = 200;
+/** Drawing settings before the background query settles, and whenever the terminal draws no ramp. */
+const NO_FADE = {
+	capability: "none",
+	ramp: []
+};
+/**
+* Relative luminance of the terminal background at which the foreground is
+* taken to be dark rather than light, as a fraction of a full channel.
+*/
+const DARK_BACKGROUND_LUMINANCE = .5;
+/** The foreground assumed over a dark background. */
+const LIGHT_FOREGROUND = {
+	r: 255,
+	g: 255,
+	b: 255
+};
+/** The foreground assumed over a light background. */
+const DARK_FOREGROUND = {
+	r: 0,
+	g: 0,
+	b: 0
+};
+/**
+* The foreground the ramp climbs towards.
+*
+* pi-tui reports the terminal background but never its foreground, so this is
+* an assumption: a light foreground over a dark background and the reverse.
+* It is never drawn - the streaming block withholds the oldest visible level,
+* which is the only level this color reaches - and only sets the direction
+* and spacing of the levels below it.
+* @param background - the background the terminal reported.
+* @returns the assumed foreground.
+*/
+function assumedForeground(background) {
+	return (.2126 * background.r + .7152 * background.g + .0722 * background.b) / 255 < DARK_BACKGROUND_LUMINANCE ? LIGHT_FOREGROUND : DARK_FOREGROUND;
+}
 /** The terminal's own commands, handled before the shared command registry. */
 const LOCAL_COMMANDS = [
 	{
@@ -1692,6 +3032,10 @@ const LOCAL_COMMANDS = [
 		name: "status",
 		description: "Show context usage, token totals, session stats, todos, goal, plan, and permission"
 	},
+	{
+		name: "todos",
+		description: "Browse the agent's todo list (Enter shows one item in full)"
+	},
 	{
 		name: "outline",
 		description: "List the turns of this session with their prompts and replies"
@@ -1702,7 +3046,7 @@ const LOCAL_COMMANDS = [
 	},
 	{
 		name: "subagents",
-		description: "List the subagent sessions under this session"
+		description: "Browse the subagent sessions under this session (Enter shows one session's details)"
 	},
 	{
 		name: "settings",
@@ -1743,6 +3087,9 @@ var TuiApp = class {
 	loader;
 	modalSlot = new Container();
 	editor;
+	/** Holds {@link panel} exactly while the bound session has subagent rows. */
+	panelSlot = new Container();
+	panel;
 	footer;
 	modals;
 	theme;
@@ -1750,7 +3097,43 @@ var TuiApp = class {
 	toolArguments = /* @__PURE__ */ new Map();
 	submittedIds = /* @__PURE__ */ new Set();
 	disposers = [];
+	/** Turn facts of the bound session's todo lines, keyed by content. */
+	todoTurns = /* @__PURE__ */ new Map();
+	/** The turn the last logged `turn/start` opened; 0 before the first one. */
+	turn = 0;
+	/** When the running turn started, from its `turn/start` envelope; absent between turns. */
+	turnStartedAt;
 	pending = [];
+	/** The home directory the footer shortens the workspace path against. */
+	home = homedir();
+	/** The segments of the last footer draw, in bar order. */
+	segments = [];
+	/** Which docked region owns the keyboard. */
+	focus = "editor";
+	/** The segment the status bar holds; read only while the bar has focus. */
+	barSelection = FIRST_FOOTER_SEGMENT;
+	/** The descendant listing the last reconcile produced, in pre-order. */
+	subagentEntries = [];
+	/** The rows of the last panel draw. */
+	panelView = EMPTY_PANEL_VIEW;
+	/** The panel row the selection sits on; absent before the first row is drawn. */
+	panelSelection;
+	/** Whether a live signal invalidated the listing since the last reconcile. */
+	subagentsStale = false;
+	/** Set while a listing is in flight, so two reconciles never overlap. */
+	listing = false;
+	/** Why the last listing failed; cleared by the next one that succeeds. */
+	listingFailure;
+	/** Disposer of the live-refresh tick while it is armed. */
+	ticker;
+	/** Disposer of the fade tick while it is armed. */
+	fadeTicker;
+	/** The tail of the message streaming right now; absent between messages. */
+	fadeTail;
+	/** Whether this terminal draws a ramp at all, decided once at start. */
+	fading = false;
+	/** How streamed text is drawn; `none` until the background query settles. */
+	fadeStyle = NO_FADE;
 	bound;
 	streaming;
 	toolsExpanded = false;
@@ -1758,6 +3141,8 @@ var TuiApp = class {
 	switching = false;
 	/** Serializes Shift+Tab effort cycles so rapid presses apply in order. */
 	effortCycle = Promise.resolve();
+	/** Serializes `/attach` reads so pending attachments keep the typed order. */
+	attaching = Promise.resolve();
 	usage = EMPTY_USAGE;
 	lastCtrlC = 0;
 	stopped = false;
@@ -1769,11 +3154,11 @@ var TuiApp = class {
 			palette,
 			toolPreviewLines: deps.toolPreviewLines
 		};
-		this.tui = new TuiMainScreen(deps.terminal);
+		this.tui = new TuiMainScreen(deps.terminal, true);
 		this.header = new Text("", 0, 0);
 		this.loader = new Loader(this.tui, palette.accent, palette.dim, "thinking");
 		this.loader.stop();
-		this.editor = new Editor(this.tui, editorTheme(palette), { paddingX: 1 });
+		this.editor = new BarCursorEditor(this.tui, editorTheme(palette), { paddingX: 1 });
 		this.editor.setAutocompleteProvider(editorCompletion({
 			commands: () => this.completableCommands(),
 			references: (query, quoted, signal) => this.references(query, quoted, signal)
@@ -1781,6 +3166,7 @@ var TuiApp = class {
 		this.editor.onSubmit = (text) => {
 			this.onSubmit(text);
 		};
+		this.panel = new Text("", 0, 0);
 		this.footer = new Text("", 0, 0);
 		this.modals = new ModalQueue({
 			tui: this.tui,
@@ -1793,6 +3179,7 @@ var TuiApp = class {
 			this.statusSlot,
 			this.modalSlot,
 			this.editor,
+			this.panelSlot,
 			this.footer
 		]) this.tui.addChild(child);
 	}
@@ -1812,8 +3199,15 @@ var TuiApp = class {
 			if (subject !== this.agent) return;
 			this.onStreamFrame(frame);
 		}), ctx.on("agent/status", ({ agent: subject, status }) => {
-			if (subject !== this.agent) return;
+			if (subject !== this.agent) {
+				this.markSubagentsStale();
+				return;
+			}
 			this.setWorking(status === "running");
+		}), ctx.on("subagent/start", () => {
+			this.markSubagentsStale();
+		}), ctx.on("subagent/end", () => {
+			this.markSubagentsStale();
 		}), ctx.on("approval/request", (request, next) => {
 			if (request.agent !== this.agent) return next();
 			return this.askApproval(request.toolName, request.reason, request.callId, request.signal);
@@ -1824,20 +3218,61 @@ var TuiApp = class {
 		const projections = ctx.get("sessionProjections");
 		if (projections !== void 0) this.disposers.push(projections.onChanged((session) => {
 			if (session === this.agent.session) this.refreshFooter();
+			else this.markSubagentsStale();
 		}));
 		this.deps.terminal.setTitle(`dsh · ${this.deps.cwd}`);
 		this.tui.setFocus(this.editor);
 		this.tui.start();
+		this.deps.terminal.write(SET_BLINKING_BAR_CURSOR);
+		this.startFade();
 		this.bind(this.bound);
 		if (initialPrompt !== void 0) this.submit(initialPrompt);
 	}
+	/**
+	* Decide whether streamed text fades at all, once per run, from the
+	* palette, the environment, and the reduced-motion preference. A terminal
+	* that draws no ramp tracks no tail and arms no fade tick, so streaming
+	* costs there exactly what it did before the effect existed.
+	*/
+	startFade() {
+		const capability = resolveFadeCapability({
+			paletteEnabled: this.deps.palette.enabled,
+			env: this.deps.env,
+			reducedMotion: this.deps.reducedMotion
+		});
+		if (capability === "none") return;
+		this.fading = true;
+		this.resolveFadeRamp(capability);
+	}
+	/**
+	* Ask the terminal for its background color, the only color a ramp can be
+	* built from, and settle the drawing settings on the answer. A terminal
+	* that answers nothing usable - the query timed out, or its reply did not
+	* parse - leaves the two-level mode, which needs no colors. Text streamed
+	* before the answer arrives draws as the Markdown component rendered it.
+	* @param capability - how far this terminal encodes one ramp level.
+	*/
+	async resolveFadeRamp(capability) {
+		const background = await this.tui.queryTerminalBackgroundColor({ timeoutMs: BACKGROUND_QUERY_TIMEOUT_MS });
+		if (this.stopped) return;
+		this.fadeStyle = background === void 0 ? {
+			capability: "dim",
+			ramp: []
+		} : {
+			capability,
+			ramp: buildFadeRamp(background, assumedForeground(background), this.deps.fadeSteps)
+		};
+	}
 	/** Release the terminal and tell the host to exit; later calls are no-ops. */
 	stop() {
 		if (this.stopped) return;
 		this.stopped = true;
+		this.updateTicker();
+		this.updateFadeTicker();
 		for (const dispose of this.disposers.splice(0)) dispose();
 		this.modals.withdrawActive();
 		this.loader.stop();
+		this.deps.terminal.write(SET_TERMINAL_DEFAULT_CURSOR);
 		this.tui.stop();
 		this.deps.releaseInput();
 		this.deps.onQuit(this.bound);
@@ -1849,13 +3284,23 @@ var TuiApp = class {
 		this.toolBlocks.clear();
 		this.toolArguments.clear();
 		this.submittedIds.clear();
+		this.todoTurns.clear();
+		this.turn = 0;
+		this.turnStartedAt = void 0;
 		this.streaming = void 0;
+		this.endFade();
 		this.usage = EMPTY_USAGE;
 		this.pending = [];
+		this.subagentEntries = [];
+		this.panelSelection = void 0;
+		this.listingFailure = void 0;
+		this.subagentsStale = false;
 		this.setWorking(next.agent.status === "running");
 		for (const event of next.history) this.onSessionEvent(next.agent.session, event);
 		this.refreshHeader();
 		this.refreshFooter();
+		this.refreshSubagentPanel();
+		this.reconcileSubagents();
 	}
 	/**
 	* Move the terminal to the session `open` resolves, releasing the current one.
@@ -1959,20 +3404,185 @@ var TuiApp = class {
 	}
 	refreshFooter() {
 		const palette = this.deps.palette;
-		const selection = this.currentSelection();
-		const parts = [`${selection.provider}/${selection.model}`];
-		if (selection.reasoningEffort !== void 0) parts.push(`effort ${selection.reasoningEffort}`);
 		const permission = this.deps.ctx.get("permissionPresets")?.current(this.agent.session);
-		if (permission !== void 0) parts.push(`permission ${permission}`);
-		const usage = formatUsage(this.usage);
-		if (usage !== "") parts.push(usage);
-		parts.push(...footerStatus(this.statusFacts()));
-		parts.push(this.deps.cwd);
-		if (this.pending.length > 0) parts.push(`${String(this.pending.length)} attached`);
+		const started = this.turnStartedAt;
+		const inbox = this.agent.inbox;
+		this.segments = buildFooterSegments({
+			selection: this.currentSelection(),
+			...permission === void 0 ? {} : { permission },
+			...started === void 0 ? {} : { turn: {
+				number: this.turn,
+				startedAt: started,
+				elapsed: formatElapsed(this.deps.now() - started),
+				queuedNextTurn: inbox.nextTurn.length,
+				queuedNextStep: inbox.nextStep.length
+			} },
+			usage: formatUsage(this.usage),
+			facts: this.statusFacts(),
+			cwd: this.deps.cwd,
+			home: this.home,
+			attachments: this.pending.map((attachment) => ({
+				name: attachment.name,
+				kind: attachment.block.type
+			}))
+		});
 		const hints = this.agent.status === "running" ? "Enter queues for the next turn · Ctrl+S steers this turn · Esc stops it · Ctrl+O tool output · Ctrl+C twice quits" : "Enter sends · Esc stops the turn · Ctrl+O tool output · Ctrl+C twice quits";
-		this.footer.setText(`${palette.dim(parts.join(" · "))}\n${palette.dim(hints)}`);
+		this.footer.setText(renderFooter(this.segments, {
+			palette,
+			...this.focus === "bar" ? { selected: footerSelectionIndex(this.segments, this.barSelection) } : {},
+			hints
+		}));
+		this.tui.requestRender();
+	}
+	/**
+	* Redraw the panel from the last listing and a fresh sample of the live
+	* facts. The panel is mounted exactly while it has a row, so the last
+	* resident child leaving takes the panel with it — and the keyboard back to
+	* the editor when the panel held it.
+	*/
+	refreshSubagentPanel() {
+		const view = subagentPanelView({
+			entries: this.subagentEntries,
+			facts: this.subagentFacts(),
+			now: this.deps.now()
+		});
+		this.panelView = view;
+		const mounted = this.panelSlot.children.length > 0;
+		if (view.rows.length === 0) {
+			this.panelSelection = void 0;
+			if (this.focus === "panel") this.setFocus("editor");
+			if (mounted) this.panelSlot.removeChild(this.panel);
+		} else {
+			if (!mounted) this.panelSlot.addChild(this.panel);
+			const selected = this.panelSelectionIndex(view.rows);
+			this.panelSelection = view.rows[selected]?.id;
+			this.panel.setText(renderSubagentPanel(view, {
+				palette: this.deps.palette,
+				...this.focus === "panel" ? { selected } : {},
+				...this.listingFailure === void 0 ? {} : { failure: this.listingFailure }
+			}));
+		}
+		this.updateTicker();
 		this.tui.requestRender();
 	}
+	/**
+	* Sample what this process knows about each listed child right now: whether
+	* its Agent is running a turn, and one projection read for its timing and
+	* token totals. Both reads are synchronous and touch no session log; a
+	* child with no live Agent here contributes no facts.
+	* @returns the facts by child session id.
+	*/
+	subagentFacts() {
+		const facts = /* @__PURE__ */ new Map();
+		const { ctx } = this.deps;
+		const agents = ctx.get("agents");
+		const projections = ctx.get("sessionProjections");
+		for (const entry of this.subagentEntries) {
+			const child = agents?.get(entry.id);
+			if (child === void 0) continue;
+			const live = { running: child.status === "running" };
+			if (projections !== void 0) {
+				const { values } = projections.snapshot(child.session, ["subagentTiming", "tokenUsage"]);
+				const timing = values.subagentTiming;
+				if (timing !== void 0) {
+					live.settledMs = timing.settledMs;
+					if (timing.active !== void 0) live.activeSince = timing.active.since;
+				}
+				const usage = values.tokenUsage;
+				if (usage !== void 0) live.usage = {
+					inputTokens: usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens,
+					outputTokens: usage.outputTokens
+				};
+			}
+			facts.set(entry.id, live);
+		}
+		return facts;
+	}
+	/**
+	* Where the panel draws its selection.
+	* @param rows - the rows of the current draw.
+	* @returns the selected row's index, or 0 once the child behind it is gone.
+	*/
+	panelSelectionIndex(rows) {
+		const index = rows.findIndex((row) => row.id === this.panelSelection);
+		return index === -1 ? 0 : index;
+	}
+	/**
+	* Mark the descendant listing out of date. The listing is never read from
+	* the handler that noticed: the shared tick performs at most one read per
+	* period, which bounds a burst of child events to one listing.
+	*/
+	markSubagentsStale() {
+		if (this.deps.ctx.get("subagents") === void 0) return;
+		this.subagentsStale = true;
+		this.updateTicker();
+	}
+	/**
+	* Re-read the descendant listing once. Two listings never overlap and a
+	* result the terminal moved away from is discarded — both leave the listing
+	* stale, so the next tick reads again. A rejection keeps the rows the last
+	* good listing produced and records the reason without a fresh stale mark,
+	* so a failing service is retried on the next live signal rather than once
+	* per tick.
+	*/
+	async reconcileSubagents() {
+		const subagents = this.deps.ctx.get("subagents");
+		if (subagents === void 0) return;
+		if (this.listing) {
+			this.markSubagentsStale();
+			return;
+		}
+		this.listing = true;
+		this.subagentsStale = false;
+		const session = this.agent.session;
+		try {
+			const entries = await subagents.listDescendants(session.id, new AbortController().signal);
+			if (this.agent.session === session) {
+				this.subagentEntries = entries;
+				this.listingFailure = void 0;
+			} else this.markSubagentsStale();
+		} catch (error) {
+			this.reportListingFailure(describeFailure(error));
+		} finally {
+			this.listing = false;
+			if (!this.stopped) this.refreshSubagentPanel();
+		}
+	}
+	/**
+	* Record why the listing failed. The panel carries the reason as one line
+	* under its rows; the transcript hears only about a reason that changed, so
+	* a service that keeps failing cannot fill the conversation with notices.
+	* @param message - the failure text.
+	*/
+	reportListingFailure(message) {
+		if (this.listingFailure === message) return;
+		this.listingFailure = message;
+		this.notice(`subagent listing failed: ${message}`, "error");
+	}
+	/**
+	* Arm the live-refresh tick while something needs it and disarm it
+	* otherwise: a running turn and a drawn row timing an open turn each need
+	* one redraw per period, and a stale listing needs one reconcile. Exactly
+	* one runs at a time, and a stopped app runs none.
+	*/
+	updateTicker() {
+		if (!this.stopped && (this.turnStartedAt !== void 0 || this.subagentsStale || this.panelView.ticking)) {
+			this.ticker ??= this.deps.tick(() => {
+				this.onTick();
+			}, this.deps.liveRefreshMs);
+			return;
+		}
+		const ticker = this.ticker;
+		if (ticker === void 0) return;
+		this.ticker = void 0;
+		ticker();
+	}
+	/** One live-refresh period: reconcile a stale listing, then redraw what the clock moved. */
+	onTick() {
+		if (this.subagentsStale) this.reconcileSubagents();
+		this.refreshSubagentPanel();
+		if (this.turnStartedAt !== void 0) this.refreshFooter();
+	}
 	statusFacts() {
 		const projections = this.deps.ctx.get("sessionProjections");
 		return projections === void 0 ? {} : readStatusFacts(projections, this.agent.session);
@@ -1983,9 +3593,129 @@ var TuiApp = class {
 			this.notice(empty);
 			return;
 		}
+		this.showBlock(rows);
+	}
+	/** Print `rows` into the transcript as one block. */
+	showBlock(rows) {
 		this.chat.addChild(new Text(rows.join("\n"), 0, 1));
 		this.tui.requestRender();
 	}
+	/**
+	* Show one prompt through the modal queue. Whichever docked region holds
+	* the keyboard gives it up first: the queue hands focus to the editor once
+	* the prompt settles, and a bar or panel that still held it would swallow
+	* every key typed after that.
+	* @param prompt - the prompt to show.
+	* @param signal - withdraws the prompt when aborted.
+	* @returns the prompt's settled value.
+	*/
+	showModal(prompt, signal) {
+		this.focusEditor();
+		return this.modals.run(prompt, signal);
+	}
+	/**
+	* Walk a list one entry at a time: the picker opens on `rows`, `Enter`
+	* shows the picked entry's details, leaving the details returns to the
+	* picker on the entry just read, and `Esc` at the picker returns to the
+	* editor. An entry whose details cannot be read shows the failure in their
+	* place, so the list stays open.
+	* @param title - the picker heading.
+	* @param rows - the entries to walk, in list order.
+	* @param layout - how each row splits its width between label and description; the picker's default when omitted.
+	*/
+	async browse(title, rows, layout) {
+		let visited;
+		for (;;) {
+			const picked = await this.showModal(new PickPrompt(this.deps.palette, title, rows.map((row) => row.item), {
+				...visited === void 0 ? {} : { current: visited },
+				...layout === void 0 ? {} : { layout }
+			}));
+			if (picked === void 0) return;
+			const row = rows.find((candidate) => candidate.item.value === picked.value);
+			/* v8 ignore next -- the picker settles with one of the rows it was handed */
+			if (row === void 0) return;
+			visited = picked.value;
+			await this.showDetail(row);
+		}
+	}
+	/**
+	* Show one entry's detail page, with a failed read printed in place of its
+	* rows. Both the picker loop and the subagent panel enter a page this way.
+	* @param row - the entry the user opened.
+	*/
+	async showDetail(row) {
+		await this.showModal(new DetailPrompt(this.deps.palette, row.heading, await this.detailRows(row)));
+	}
+	/**
+	* The rows one list entry's detail page shows.
+	* @param row - the entry the user opened.
+	* @returns its detail rows, or the failure text when the read fails.
+	*/
+	async detailRows(row) {
+		try {
+			return await row.detail();
+		} catch (error) {
+			/* v8 ignore next -- subagentDetail, the only resolver today, reports its own read failures as rows */
+			return [describeFailure(error)];
+		}
+	}
+	/**
+	* Walk the agent's todo list: one row per item, and entering a row shows
+	* that item in full with its position, the list's counts by status, and the
+	* turns it was first written in and last changed status in.
+	*/
+	async browseTodos() {
+		const items = this.statusFacts().todos?.items ?? [];
+		const choices = listTodoChoices(this.deps.ctx, this.agent.session);
+		if (choices.length === 0) {
+			this.notice("no todos yet");
+			return;
+		}
+		const tracked = items.map((item) => this.todoTurns.get(item.content));
+		await this.browse("Todos", choices.map((choice) => ({
+			item: {
+				value: String(choice.index),
+				label: choice.label,
+				description: choice.description
+			},
+			heading: `Todo ${String(choice.index + 1)}`,
+			detail: () => Promise.resolve(todoDetail(items, choice.index, tracked[choice.index]))
+		})), TODO_ROW_LAYOUT);
+	}
+	/**
+	* The browsable entry behind one subagent row: the same detail page the
+	* `/subagents` list and the live panel open.
+	* @param choice - the listing row.
+	* @returns the entry.
+	*/
+	subagentBrowseRow(choice) {
+		return {
+			item: {
+				value: choice.id,
+				label: choice.label,
+				description: choice.description
+			},
+			heading: choice.id,
+			detail: () => subagentDetail(this.deps.ctx, choice, new AbortController().signal)
+		};
+	}
+	/**
+	* Open the selected panel row's session details, then give the keyboard
+	* back to the panel unless its last row left while the page was open. A
+	* diagnostic row explains itself in the panel and opens nothing.
+	*/
+	async openPanelRow() {
+		const rows = this.panelView.rows;
+		const row = rows[this.panelSelectionIndex(rows)];
+		/* v8 ignore next -- the panel answers keys only while it has rows to select from */
+		if (row === void 0) return;
+		if (!row.enterable) return;
+		const entry = this.subagentEntries.find((candidate) => candidate.id === row.id);
+		/* v8 ignore next -- every drawn row comes from the entries of the last listing */
+		if (entry === void 0) return;
+		await this.showDetail(this.subagentBrowseRow(subagentChoice(entry)));
+		if (this.panelView.rows.length > 0) this.focusRegion("panel");
+	}
 	async settings(argument) {
 		const [first, second, ...rest] = argument === "" ? [] : argument.split(/\s+/u);
 		if (first === void 0) {
@@ -2012,8 +3742,7 @@ var TuiApp = class {
 		this.notice(await setSetting(this.deps.ctx, first, second, value), "success");
 	}
 	showStatus() {
-		this.chat.addChild(new Text(statusReport(this.statusFacts()).join("\n"), 0, 1));
-		this.tui.requestRender();
+		this.showBlock(statusReport(this.statusFacts()));
 	}
 	currentSelection() {
 		const { selection, agent } = this.bound;
@@ -2031,6 +3760,7 @@ var TuiApp = class {
 			return { consume: true };
 		}
 		if (matchesKey(data, "ctrl+c")) {
+			this.focusEditor();
 			const now = Date.now();
 			if (now - this.lastCtrlC < QUIT_DOUBLE_PRESS_MS) {
 				this.stop();
@@ -2042,9 +3772,20 @@ var TuiApp = class {
 			return { consume: true };
 		}
 		if (matchesKey(data, "ctrl+d")) {
+			this.focusEditor();
 			if (this.editor.getText() === "") this.stop();
 			return { consume: true };
 		}
+		if (this.focus === "bar") return this.onStatusBarKey(data);
+		if (this.focus === "panel") return this.onPanelKey(data);
+		if (matchesKey(data, "shift+up")) {
+			this.focusBar();
+			return { consume: true };
+		}
+		if (matchesKey(data, "shift+down") && this.panelView.rows.length > 0) {
+			this.focusRegion("panel");
+			return { consume: true };
+		}
 		if (matchesKey(data, "escape") && !this.editor.isShowingAutocomplete()) {
 			if (this.agent.status === "running") {
 				this.agent.cancel({ kind: "user" }, { keepInbox: true });
@@ -2070,6 +3811,140 @@ var TuiApp = class {
 			return { consume: true };
 		}
 	}
+	/**
+	* Answer one key while the status bar holds focus. Every key is consumed
+	* here, so nothing typed at the bar reaches the editor.
+	* @param data - the raw key bytes.
+	* @returns the consume marker the input listener returns.
+	*/
+	onStatusBarKey(data) {
+		if (matchesKey(data, "escape") || matchesKey(data, "shift+down")) {
+			this.focusEditor();
+			return { consume: true };
+		}
+		if (matchesKey(data, "shift+up")) {
+			this.focusRegion(this.panelView.rows.length > 0 ? "panel" : "editor");
+			return { consume: true };
+		}
+		if (matchesKey(data, "left") || matchesKey(data, "shift+tab")) {
+			this.moveStatusBar(-1);
+			return { consume: true };
+		}
+		if (matchesKey(data, "right") || matchesKey(data, "tab")) {
+			this.moveStatusBar(1);
+			return { consume: true };
+		}
+		if (matchesKey(data, "enter")) this.openSegment(this.barSelection);
+		return { consume: true };
+	}
+	/**
+	* Answer one key while the subagent panel holds focus. Every key is
+	* consumed here; `Ctrl+C` and `Ctrl+D` never reach this far, keeping their
+	* global meaning.
+	* @param data - the raw key bytes.
+	* @returns the consume marker the input listener returns.
+	*/
+	onPanelKey(data) {
+		if (matchesKey(data, "escape") || matchesKey(data, "shift+up")) {
+			this.focusEditor();
+			return { consume: true };
+		}
+		if (matchesKey(data, "shift+down")) {
+			this.focusBar();
+			return { consume: true };
+		}
+		if (matchesKey(data, "up")) {
+			this.movePanel(-1);
+			return { consume: true };
+		}
+		if (matchesKey(data, "down")) {
+			this.movePanel(1);
+			return { consume: true };
+		}
+		if (matchesKey(data, "enter")) this.navigate("subagent details", () => this.openPanelRow());
+		return { consume: true };
+	}
+	/**
+	* Open one page a docked region's `Enter` leads to, reporting a failure as
+	* a notice instead of an unhandled rejection.
+	* @param label - what the notice calls the page.
+	* @param open - shows the page and settles when the user leaves it.
+	*/
+	navigate(label, open) {
+		open().catch((error) => {
+			this.notice(`${label} failed: ${describeFailure(error)}`, "error");
+		});
+	}
+	/**
+	* Answer `Enter` on the held segment: a segment whose fact the app has a
+	* navigable page for opens that page, and every other segment prints its
+	* detail rows into the transcript.
+	* @param selected - the segment the bar holds.
+	*/
+	openSegment(selected) {
+		const segment = this.segments[footerSelectionIndex(this.segments, selected)];
+		/* v8 ignore next -- the bar draws at least the model segment, and an absent id falls back to it */
+		if (segment === void 0) return;
+		if (segment.detail.kind === "rows") {
+			this.showBlock(segment.detail.rows);
+			return;
+		}
+		this.navigate("/todos", () => this.browseTodos());
+	}
+	/**
+	* Move the bar's selection, wrapping at both ends.
+	* @param step - 1 for the next segment, -1 for the previous one.
+	*/
+	moveStatusBar(step) {
+		const count = this.segments.length;
+		const next = this.segments[(footerSelectionIndex(this.segments, this.barSelection) + step + count) % count];
+		/* v8 ignore next -- the wrapped index stays inside the bar's own segments */
+		if (next !== void 0) this.barSelection = next.id;
+		this.refreshFooter();
+	}
+	/**
+	* Move the panel's selection, wrapping at both ends of the drawn rows. The
+	* rows behind a `+<n> more` row are not selectable; `/subagents` walks the
+	* complete tree.
+	* @param step - 1 for the next row, -1 for the previous one.
+	*/
+	movePanel(step) {
+		const rows = this.panelView.rows;
+		const count = rows.length;
+		const next = rows[(this.panelSelectionIndex(rows) + step + count) % count];
+		/* v8 ignore next -- the wrapped index stays inside the panel's own rows */
+		if (next !== void 0) this.panelSelection = next.id;
+		this.refreshSubagentPanel();
+	}
+	/** Give the keyboard to the status bar, starting at its first segment. */
+	focusBar() {
+		this.barSelection = FIRST_FOOTER_SEGMENT;
+		this.focusRegion("bar");
+	}
+	/** Hand the keyboard back to the editor; a no-op while the editor already has it. */
+	focusEditor() {
+		this.focusRegion("editor");
+	}
+	/**
+	* Move the keyboard between the docked regions and redraw both of them, so
+	* the region losing focus stops drawing its selection.
+	* @param region - the region that takes the keyboard.
+	*/
+	focusRegion(region) {
+		if (this.focus === region) return;
+		this.setFocus(region);
+		this.refreshSubagentPanel();
+	}
+	/**
+	* Give the keyboard to `region` and redraw the bar. The caller redraws the
+	* panel; the panel's own refresh calls this when its last row leaves.
+	* @param region - the region that takes the keyboard.
+	*/
+	setFocus(region) {
+		this.focus = region;
+		this.tui.setFocus(region === "editor" ? this.editor : null);
+		this.refreshFooter();
+	}
 	toggleTools() {
 		this.toolsExpanded = !this.toolsExpanded;
 		for (const block of this.toolBlocks.values()) block.setExpanded(this.toolsExpanded);
@@ -2182,15 +4057,24 @@ var TuiApp = class {
 			case "status":
 				this.showStatus();
 				return;
+			case "todos":
+				await this.browseTodos();
+				return;
 			case "outline":
 				this.showRows(sessionOutline(this.deps.ctx, this.agent.session), "no completed turn yet");
 				return;
 			case "deliverables":
 				this.showRows(await listDeliverables(this.deps.ctx, this.agent.session.id, new AbortController().signal), "nothing presented yet");
 				return;
-			case "subagents":
-				this.showRows(await listSubagents(this.deps.ctx, this.agent.session.id, new AbortController().signal), "no subagent sessions");
+			case "subagents": {
+				const choices = await listSubagentChoices(this.deps.ctx, this.agent.session.id, new AbortController().signal);
+				if (choices.length === 0) {
+					this.notice("no subagent sessions");
+					return;
+				}
+				await this.browse("Subagent sessions", choices.map((choice) => this.subagentBrowseRow(choice)));
 				return;
+			}
 			case "settings":
 				await this.settings(argument);
 				return;
@@ -2209,6 +4093,8 @@ var TuiApp = class {
 			"@ completes paths and sessions (workspace, ../, ~/, absolute) · / completes commands",
 			"Esc stops the running turn · Ctrl+O expands or collapses tool output",
 			"Shift+Tab cycles the current model's reasoning effort for the next request",
+			"Shift+Up focuses the status bar: ← → select a fact, Enter shows its details, Esc returns to the input",
+			"Shift+Up again focuses the subagent panel while it is drawn: ↑ ↓ select a child, Enter shows its session",
 			"Ctrl+C clears the input (twice quits) · Ctrl+D on an empty input quits"
 		];
 		this.chat.addChild(new Text([
@@ -2270,7 +4156,7 @@ var TuiApp = class {
 				return;
 			}
 			const current = this.currentSelection();
-			const picked = await this.modals.run(new PickPrompt(this.deps.palette, "Model for the next request", items, { current: `${current.provider}/${current.model}` }));
+			const picked = await this.showModal(new PickPrompt(this.deps.palette, "Model for the next request", items, { current: `${current.provider}/${current.model}` }));
 			if (picked === void 0) return;
 			const slash = picked.value.indexOf("/");
 			next = {
@@ -2303,7 +4189,7 @@ var TuiApp = class {
 		if (lookup.kind !== "ready") return void 0;
 		const current = this.currentSelection();
 		const sameModel = current.provider === model.provider && current.model === model.model;
-		const picked = await this.modals.run(new PickPrompt(this.deps.palette, `Reasoning effort · ${model.provider}/${model.model}`, effortItems(lookup.reasoning), {
+		const picked = await this.showModal(new PickPrompt(this.deps.palette, `Reasoning effort · ${model.provider}/${model.model}`, effortItems(lookup.reasoning), {
 			body: ["Esc cancels the model change"],
 			current: (sameModel ? current.reasoningEffort : void 0) ?? ""
 		}));
@@ -2335,7 +4221,7 @@ var TuiApp = class {
 			this.applyEffort(current, matched);
 			return;
 		}
-		const picked = await this.modals.run(new PickPrompt(this.deps.palette, `Reasoning effort · ${current.provider}/${current.model}`, effortItems(reasoning), {
+		const picked = await this.showModal(new PickPrompt(this.deps.palette, `Reasoning effort · ${current.provider}/${current.model}`, effortItems(reasoning), {
 			body: [effortHint(reasoning, current.reasoningEffort)],
 			current: current.reasoningEffort ?? ""
 		}));
@@ -2450,7 +4336,7 @@ var TuiApp = class {
 			value: choice.id,
 			...describeSession(choice)
 		}));
-		const picked = await this.modals.run(new PickPrompt(this.deps.palette, "Switch to a session", items));
+		const picked = await this.showModal(new PickPrompt(this.deps.palette, "Switch to a session", items));
 		const target = choices.find((choice) => choice.id === picked?.value);
 		if (target === void 0 || target.current) return;
 		await this.switchSession(() => this.deps.host.resume(target.id), "resumed");
@@ -2472,7 +4358,21 @@ var TuiApp = class {
 			this.notice(`rename failed: ${describeFailure(error)}`, "error");
 		}
 	}
-	async attach(argument) {
+	/**
+	* Run one `/attach` after every `/attach` typed before it. Each command
+	* reaches this from its own unawaited dispatch, so two of them read their
+	* files at the same time and the slower read would otherwise land second
+	* whichever file the user named first. Queueing them keeps `pending`, the
+	* footer count, and the notices in the order the user typed.
+	* @param argument - the command argument: a path, `clear`, or nothing.
+	* @returns when this attachment has settled.
+	*/
+	attach(argument) {
+		const settled = this.attaching.then(() => this.attachNow(argument));
+		this.attaching = settled;
+		return settled;
+	}
+	async attachNow(argument) {
 		if (argument === "") {
 			this.notice(this.pending.length === 0 ? "nothing attached; /attach <path> attaches a file or image to the next prompt" : `attached: ${this.pending.map((attachment) => attachment.name).join(", ")}`);
 			return;
@@ -2545,7 +4445,7 @@ var TuiApp = class {
 		}
 		let key = argument;
 		if (key === "") {
-			const picked = await this.modals.run(new PickPrompt(this.deps.palette, subscriptionOnly ? "Log in with" : "Sign in to", entries.map((entry) => ({
+			const picked = await this.showModal(new PickPrompt(this.deps.palette, subscriptionOnly ? "Log in with" : "Sign in to", entries.map((entry) => ({
 				value: entry.key,
 				label: entry.label,
 				description: entry.methods.map((method) => method.label).join(", ")
@@ -2560,7 +4460,7 @@ var TuiApp = class {
 		}
 		let method = entry.methods[0]?.id;
 		if (entry.methods.length > 1) {
-			const picked = await this.modals.run(new PickPrompt(this.deps.palette, `Sign-in method for ${entry.label}`, entry.methods.map((candidate) => ({
+			const picked = await this.showModal(new PickPrompt(this.deps.palette, `Sign-in method for ${entry.label}`, entry.methods.map((candidate) => ({
 				value: candidate.id,
 				label: candidate.label
 			}))));
@@ -2591,7 +4491,7 @@ var TuiApp = class {
 	}
 	async answerAuthorizationPrompt(prompt) {
 		if (prompt.kind === "select") {
-			const picked = await this.modals.run(new PickPrompt(this.deps.palette, prompt.message, prompt.options.map((option) => ({
+			const picked = await this.showModal(new PickPrompt(this.deps.palette, prompt.message, prompt.options.map((option) => ({
 				value: option.id,
 				label: option.label,
 				...option.description === void 0 ? {} : { description: option.description }
@@ -2599,7 +4499,7 @@ var TuiApp = class {
 			if (picked === void 0) throw new AuthorizationDeclinedError("the sign-in prompt was dismissed");
 			return picked.value;
 		}
-		const answer = await this.modals.run(new QuestionPrompt(this.deps.palette, {
+		const answer = await this.showModal(new QuestionPrompt(this.deps.palette, {
 			id: "authorization",
 			question: prompt.message,
 			...prompt.placeholder === void 0 ? {} : { detail: prompt.placeholder }
@@ -2619,7 +4519,7 @@ var TuiApp = class {
 	async askApproval(toolName, reason, callId, signal) {
 		const args = callId === void 0 ? void 0 : this.toolArguments.get(callId);
 		const detail = args === void 0 ? [] : toolCallText(JSON.stringify(args), this.presentCall(toolName, args)).lines;
-		const outcome = await this.modals.run(new ApprovalPrompt(this.deps.palette, toolName, reason, detail), signal);
+		const outcome = await this.showModal(new ApprovalPrompt(this.deps.palette, toolName, reason, detail), signal);
 		const tone = outcome === "allowed-once" ? "success" : "dim";
 		this.notice(`${toolName}: ${outcome === "allowed-once" ? "allowed once" : outcome}`, tone);
 		return outcome;
@@ -2627,7 +4527,7 @@ var TuiApp = class {
 	async askQuestions(questions, signal) {
 		const answers = [];
 		for (const question of questions) {
-			const answer = await this.modals.run(new QuestionPrompt(this.deps.palette, question), signal);
+			const answer = await this.showModal(new QuestionPrompt(this.deps.palette, question), signal);
 			if (answer === null) throw new Error("the question was dismissed");
 			answers.push(answer);
 		}
@@ -2640,16 +4540,89 @@ var TuiApp = class {
 		}
 		return this.streaming;
 	}
+	/**
+	* Take one visible text delta: the block draws it and the tail of that same
+	* block ages it. The tail is created with the first delta of a message, so
+	* a block rebuilt from history or committed from the log never carries one.
+	* @param delta - the streamed text delta.
+	*/
+	appendStreamedText(delta) {
+		const block = this.streamingBlock();
+		block.appendText(delta);
+		if (!this.fading) return;
+		if (this.fadeTail === void 0) {
+			this.fadeTail = new FadeTracker({ steps: this.deps.fadeSteps });
+			block.setFade({
+				spans: () => this.fadeTail?.spans() ?? [],
+				style: () => this.fadeStyle,
+				steps: this.deps.fadeSteps,
+				flush: () => {
+					this.flushFade();
+				}
+			});
+		}
+		this.fadeTail.append(delta);
+		this.updateFadeTicker();
+	}
+	/**
+	* Settle what the current block has drawn and stop tracking it: the tail
+	* goes, so its text renders at the terminal's foreground from the next
+	* render on, and no fade tick stays armed between messages.
+	*/
+	endFade() {
+		this.fadeTail = void 0;
+		this.updateFadeTicker();
+	}
+	/**
+	* Settle what is drawn while the message keeps streaming, which the block
+	* asks for after a width change. The tracker stays, so what it knows about
+	* the arrival rate survives a resize and only the tail is dropped.
+	*/
+	flushFade() {
+		this.fadeTail?.flush();
+		this.updateFadeTicker();
+	}
+	/**
+	* Arm the fade tick while a chunk is still below the last brightness level
+	* and disarm it otherwise, so a session that is not streaming runs no fade
+	* timer. Exactly one runs at a time, and a stopped app runs none.
+	*/
+	updateFadeTicker() {
+		const tail = this.fadeTail;
+		if (!this.stopped && tail !== void 0 && tail.needsRepaint()) {
+			this.fadeTicker ??= this.deps.tick(() => {
+				this.onFadeTick(tail);
+			}, this.deps.fadeStepMs);
+			return;
+		}
+		const ticker = this.fadeTicker;
+		if (ticker === void 0) return;
+		this.fadeTicker = void 0;
+		ticker();
+	}
+	/**
+	* One fade period over the tail the tick was armed for. Every change to the
+	* tail runs {@link TuiApp.updateFadeTicker} again, so an armed period always
+	* holds that same tail and always moves a chunk's color; the render request
+	* redraws the lines it moved, and the disarm check follows the ageing.
+	* @param tail - the tail this tick was armed for.
+	*/
+	onFadeTick(tail) {
+		tail.tick();
+		this.tui.requestRender();
+		this.updateFadeTicker();
+	}
 	onStreamFrame(frame) {
 		switch (frame.type) {
 			case "start":
 				this.streaming = void 0;
+				this.endFade();
 				return;
 			case "chunk": {
 				const chunk = frame.chunk;
 				switch (chunk.type) {
 					case "text-delta":
-						if (chunk.text !== "") this.streamingBlock().appendText(chunk.text);
+						if (chunk.text !== "") this.appendStreamedText(chunk.text);
 						break;
 					case "reasoning-delta":
 						if (chunk.text !== "") this.streamingBlock().appendReasoning(chunk.text);
@@ -2669,6 +4642,7 @@ var TuiApp = class {
 			}
 			case "end":
 				this.streaming = void 0;
+				this.endFade();
 				this.tui.requestRender();
 				return;
 			/* v8 ignore next -- closed-union exhaustiveness guard */
@@ -2676,8 +4650,20 @@ var TuiApp = class {
 		}
 	}
 	onSessionEvent(session, event) {
-		if (session !== this.agent.session) return;
+		if (session !== this.agent.session) {
+			this.markSubagentsStale();
+			return;
+		}
 		switch (event.type) {
+			case "turn/start":
+				this.turn = event.data.turn;
+				this.turnStartedAt = event.time;
+				this.updateTicker();
+				this.refreshFooter();
+				break;
+			case "todo/write":
+				this.trackTodoTurns(event.data.todos);
+				break;
 			case "user/message":
 				this.onUserMessage(event.data);
 				break;
@@ -2687,6 +4673,7 @@ var TuiApp = class {
 				const reasoning = message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
 				this.streamingBlock().commit(text, reasoning, interrupted === true);
 				this.streaming = void 0;
+				this.endFade();
 				if (usage !== void 0) {
 					this.usage = addUsage(this.usage, usage);
 					this.refreshFooter();
@@ -2714,6 +4701,10 @@ var TuiApp = class {
 				break;
 			}
 			case "turn/end": {
+				this.turnStartedAt = void 0;
+				this.updateTicker();
+				this.endFade();
+				this.refreshFooter();
 				const notice = turnEndNotice(event.data.reason);
 				if (notice !== void 0) this.notice(notice, event.data.reason.kind === "error" ? "error" : "dim");
 				break;
@@ -2734,6 +4725,31 @@ var TuiApp = class {
 		}
 		this.tui.requestRender();
 	}
+	/**
+	* Fold one whole-list todo write into the turn facts: a content this
+	* session has not carried before starts at the current turn, a known
+	* content whose status moved records that turn, and a content the write
+	* dropped is forgotten.
+	* @param todos - the list the write replaced the previous one with.
+	*/
+	trackTodoTurns(todos) {
+		const tracked = /* @__PURE__ */ new Map();
+		for (const item of todos) {
+			const known = this.todoTurns.get(item.content);
+			if (known === void 0) tracked.set(item.content, {
+				firstTurn: this.turn,
+				statusTurn: this.turn,
+				status: item.status
+			});
+			else if (known.status === item.status) tracked.set(item.content, known);
+			else tracked.set(item.content, {
+				firstTurn: known.firstTurn,
+				statusTurn: this.turn,
+				status: item.status
+			});
+		}
+		this.todoTurns = tracked;
+	}
 	onUserMessage(message) {
 		const source = message.source;
 		if (source.kind === "user") {
@@ -2848,6 +4864,10 @@ const Config = z.object({
 	prompt: z.string(),
 	resume: z.string(),
 	toolPreviewLines: z.natural().min(1).default(8),
+	liveRefreshMs: z.natural().min(100).default(1e3),
+	streamFadeSteps: z.natural().min(2).default(5),
+	streamFadeStepMs: z.natural().min(16).default(40),
+	reducedMotion: z.boolean().default(false),
 	openBrowser: z.boolean().default(true)
 });
 /** The process-bound pieces of the host; tests substitute a fake terminal and captured streams. */
@@ -3019,6 +5039,22 @@ async function run(ctx, config, host) {
 		terminal: host.createTerminal(),
 		palette: createPalette(host.color),
 		toolPreviewLines: config.toolPreviewLines,
+		liveRefreshMs: config.liveRefreshMs,
+		fadeSteps: config.streamFadeSteps,
+		fadeStepMs: config.streamFadeStepMs,
+		reducedMotion: config.reducedMotion,
+		env: process.env,
+		now: () => Date.now(),
+		tick: (callback, delayMs) => {
+			const dispose = ctx.effect(() => {
+				const timer = setInterval(callback, delayMs);
+				timer.unref();
+				return () => {
+					clearInterval(timer);
+				};
+			}, "tui-app: repeating redraw");
+			return () => void dispose();
+		},
 		cwd,
 		...openUrl === void 0 ? {} : { openUrl },
 		releaseInput: () => {