@xmoon76/dsh-pi-tui 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -2,9 +2,9 @@ import { TUI_STARTUP_SERVICE } from "./startup.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
 import { StringDecoder } from "node:string_decoder";
-import { execSync, spawn } from "node:child_process";
+import { execFileSync, execSync, spawn } from "node:child_process";
 import * as fs from "node:fs";
-import { accessSync, closeSync, constants, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { accessSync, appendFileSync, closeSync, constants, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import * as os from "node:os";
 import { homedir, tmpdir } from "node:os";
 import * as path from "node:path";
@@ -29,6 +29,7 @@ import { eastAsianWidth } from "get-east-asian-width";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
 import { EventEmitter } from "events";
+import { isUserInvocable } from "@deepseek-ai/dsh-skill";
 //#region src/present.ts
 /** Figma row titles per variant (design literals, not translatable copy). */
 const VARIANT_TITLES = {
@@ -147,6 +148,37 @@ function deriveSummary(variant, argsRaw) {
 	for (const value of Object.values(args)) if (typeof value === "string" && value !== "") return firstLine(value);
 	return firstLine(argsRaw);
 }
+/**
+* Tool-specific args summaries for tools whose natural one-line identity is
+* not a raw arg value (Web TodoRow/AskQuestionRow parity): `todo_write`
+* reads `done/total done` plus the first active item, `ask_user_question`
+* reads the first question text. Returns undefined for every other tool,
+* letting the generic derivation own the summary.
+* @param name - the tool name.
+* @param argsRaw - the raw arguments JSON.
+* @returns the tool-specific summary, or undefined when none applies.
+*/
+function summarizeToolArgs(name, argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const args = parsed;
+	if (name === "ask_user_question") {
+		const questions = args.questions;
+		if (!Array.isArray(questions) || questions.length === 0) return void 0;
+		const first = questions[0];
+		if (typeof first !== "object" || first === null) return void 0;
+		const question = first.question;
+		if (typeof question !== "string" || question === "") return void 0;
+		return firstLine(question);
+	}
+	if (name !== "todo_write") return void 0;
+	const todos = args.todos;
+	if (!Array.isArray(todos)) return void 0;
+	const done = todos.filter((todo) => typeof todo === "object" && todo !== null && todo.status === "completed").length;
+	const active = todos.find((todo) => typeof todo === "object" && todo !== null && todo.status !== "completed");
+	const content = active === void 0 ? "" : String(active.content ?? "");
+	return `${done}/${todos.length} done${content === "" ? "" : ` · ${firstLine(content)}`}`;
+}
 /** Classify a tool name into its row variant; unknown names are `others`. */
 function classifyTool(name) {
 	return TOOL_VARIANTS[name] ?? "others";
@@ -294,7 +326,8 @@ function readFoldedPreview(result) {
 function toolCardHeader(name, argsRaw, cwd) {
 	const variant = classifyTool(name);
 	const toolTitle = TOOL_TITLES[name] ?? TUI_TOOL_TITLES[name];
-	const base = argsRaw === "" ? "" : relativizeToCwd(deriveSummary(variant, argsRaw), cwd);
+	const toolSummary = summarizeToolArgs(name, argsRaw);
+	const base = argsRaw === "" ? "" : toolSummary ?? relativizeToCwd(deriveSummary(variant, argsRaw), cwd);
 	const summary = variant === "others" && toolTitle === void 0 ? base === "" ? "" : name + " · " + base : base;
 	return {
 		title: toolTitle ?? (name.startsWith("/") ? name.slice(1) : VARIANT_TITLES[variant]),
@@ -302,6 +335,123 @@ function toolCardHeader(name, argsRaw, cwd) {
 	};
 }
 /**
+* Render a completed web retrieval as display lines (Web WebBlock parity):
+* a `search` shows the provider answer and the source list (title — url,
+* snippet under each), a `fetch` shows the URL and HTTP status. Truncation
+* is marked in the same place the Web marks it: under the list/status.
+* Colors are the caller's (the render layer owns the palette).
+* @param view - the web result view from presentResult.
+* @returns the display lines; empty when the view carries nothing to show.
+*/
+function webCardLines(view) {
+	if (view.kind === "search") {
+		const lines = [];
+		if (view.answer !== void 0 && view.answer !== "") lines.push(view.answer);
+		for (const source of view.sources) {
+			const head = source.title === void 0 || source.title === "" ? source.url : `${source.title} — ${source.url}`;
+			lines.push(`• ${head}`);
+			if (source.snippet !== void 0 && source.snippet !== "") lines.push(`  ${source.snippet}`);
+		}
+		if (view.truncated) lines.push("… truncated — more sources omitted");
+		return lines;
+	}
+	const lines = [`${view.url} — HTTP ${view.statusCode}`];
+	if (view.truncated) lines.push("… truncated — content capped");
+	return lines;
+}
+/**
+* Render a generic card's rawInput as display lines, structured per tool
+* where the payload has a natural one-line shape (web TodoRow parity for
+* `todo_write`, a session/terminal target line for the rest). Unknown
+* object payloads fall back to pretty JSON — the same fallback the Web's
+* generic body uses. A string rawInput renders verbatim.
+* @param name - the tool name.
+* @param rawInput - the presenter's salient raw input.
+* @returns the display lines.
+*/
+/** Checklist display lines for a todo list: `●` in progress, `○` pending,
+* `✓` completed (Web TodoRow parity). Malformed items are skipped. */
+function todoChecklistLines(todos) {
+	const lines = [];
+	for (const todo of todos) {
+		if (typeof todo !== "object" || todo === null) continue;
+		const item = todo;
+		const content = typeof item.content === "string" ? item.content : String(item.content ?? "");
+		const mark = item.status === "completed" ? "✓" : item.status === "in_progress" ? "●" : "○";
+		lines.push(`${mark} ${content}`);
+	}
+	return lines;
+}
+function genericRawInputLines(name, rawInput) {
+	if (typeof rawInput === "string") return rawInput === "" ? [] : [rawInput];
+	if (typeof rawInput !== "object" || rawInput === null) return rawInput === void 0 ? [] : [String(rawInput)];
+	if (name === "todo_write" && Array.isArray(rawInput)) return todoChecklistLines(rawInput);
+	const args = rawInput;
+	if (name === "todo_write") {
+		const todos = args.todos;
+		if (Array.isArray(todos)) return todoChecklistLines(todos);
+	}
+	if ((name === "terminal_read" || name === "terminal_signal" || name === "terminal_send") && typeof args.sessionId === "string") {
+		const line = `session ${args.sessionId}`;
+		return name === "terminal_send" && typeof args.text === "string" ? [`${line}: ${args.text}`] : [line];
+	}
+	if ((name === "session_event_trace" || name === "session_event_read" || name === "session_trace") && (args.seq !== void 0 || args.session_id !== void 0)) {
+		const parts = [];
+		if (args.session_id !== void 0) parts.push(String(args.session_id));
+		if (args.seq !== void 0) parts.push(`seq ${String(args.seq)}`);
+		return [parts.join(" · ")];
+	}
+	return JSON.stringify(rawInput, null, 2).split("\n");
+}
+/**
+* Flatten a settled result's content blocks to display lines, with the Web's
+* `resultText` semantics: text blocks verbatim, other block shapes as pretty
+* JSON. Empty content on a failed call falls back to the structured error's
+* `name: code` line (the Web's error summary).
+* @param blocks - the result content blocks.
+* @param error - the structured error, when the call failed.
+* @returns the display lines (may be empty).
+*/
+function resultTextLines(blocks, error) {
+	const lines = [];
+	for (const block of blocks) if (block.type === "text") lines.push(...block.text.split("\n"));
+	else lines.push(JSON.stringify(block, null, 2));
+	if (lines.length === 0 && error !== void 0) lines.push(`${error.name}: ${error.code}`);
+	return lines;
+}
+/**
+* The folded-card call preview for tools whose args carry a one-line
+* identity (Web TodoRow/WebRow folded parity): `todo_write` summarizes
+* `done/total` plus the first active item, `web_search`/`web_fetch` show
+* the query/URL. Empty for every other tool (their folded row keeps the
+* header + result preview).
+* @param name - the tool name.
+* @param argsRaw - the raw arguments JSON.
+* @returns the preview line, or '' when the tool has none.
+*/
+function foldedCallPreview(name, argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null) return "";
+	const args = parsed;
+	if (name === "todo_write") {
+		const summary = summarizeToolArgs(name, argsRaw);
+		return summary === void 0 ? "" : ` — ${summary}`;
+	}
+	if (name === "web_search") {
+		const query = args.query;
+		return typeof query === "string" && query !== "" ? ` — ${firstLine(query)}` : "";
+	}
+	if (name === "web_fetch") {
+		const url = args.url;
+		return typeof url === "string" && url !== "" ? ` — ${firstLine(url)}` : "";
+	}
+	if (name === "skill") {
+		const skill = args.name;
+		return typeof skill === "string" && skill !== "" ? ` — ${firstLine(skill)}` : "";
+	}
+	return "";
+}
+/**
 * Build the presentation bridge over a tool-definition lookup (the runner
 * passes a scoped registry read, e.g. `ctx.get('tools')?.get(name, scope)`).
 * Mirrors the host apiproxy's presenter invocations: args are JSON-parsed and
@@ -1530,6 +1680,24 @@ const selectListTheme = {
 	groupHeader: (text) => chalk.bold.hex(currentPalette.textMuted)(text)
 };
 /**
+* Status-dot colour for a background-job status (dsh-web StateDot parity:
+* running = ongoing/primary, stopping = warning, completed = done/dim,
+* failed/killed/timed-out/lost = error). Unknown statuses fall back to the
+* muted token so a future wire status never crashes the renderer.
+*/
+function taskStatusColor(status) {
+	switch (status) {
+		case "running": return color.primary;
+		case "stopping": return color.warning;
+		case "completed": return color.textDim;
+		case "failed":
+		case "killed":
+		case "timed_out":
+		case "lost": return color.error;
+		default: return color.textMuted;
+	}
+}
+/**
 * SettingsList palette from the semantic tokens. A FUNCTION, not a
 * module-level constant: `cursor` is a pre-rendered ANSI string, so a
 * constant would freeze the cursor colour at module load and never follow
@@ -6078,6 +6246,7 @@ var Editor = class {
 	isInPaste = false;
 	pasteBurst = new PasteBurst();
 	disablePasteBurst = false;
+	inlineSlashTrigger = false;
 	history = [];
 	historyIndex = -1;
 	historyDraft = null;
@@ -6117,6 +6286,7 @@ var Editor = class {
 		const maxVisible = options.autocompleteMaxVisible ?? 5;
 		this.autocompleteMaxVisible = Number.isFinite(maxVisible) ? Math.max(3, Math.min(20, Math.floor(maxVisible))) : 5;
 		this.disablePasteBurst = options.disablePasteBurst ?? false;
+		this.inlineSlashTrigger = options.inlineSlashTrigger ?? false;
 	}
 	/** Set of currently valid paste IDs, for marker-aware segmentation. */
 	validPasteIds() {
@@ -6404,7 +6574,7 @@ var Editor = class {
 					this.state.lines = result.lines;
 					this.state.cursorLine = result.cursorLine;
 					this.setCursorCol(result.cursorCol);
-					if (this.autocompletePrefix.startsWith("/")) this.cancelAutocomplete();
+					if (this.autocompletePrefix.startsWith("/") && selected.data?.["inlineSkill"] !== true) this.cancelAutocomplete();
 					else {
 						this.cancelAutocomplete();
 						if (this.onChange) this.onChange(this.getText());
@@ -6710,15 +6880,16 @@ var Editor = class {
 		this.setCursorCol(this.state.cursorCol + char.length);
 		if (this.onChange) this.onChange(this.getText());
 		if (!this.autocompleteState) {
-			if (char === "/" && this.isAtStartOfMessage()) this.tryTriggerAutocomplete();
+			if (char === "/" && (this.isAtStartOfMessage() || this.inlineSlashTrigger && this.isAtInlineSlashTrigger())) this.tryTriggerAutocomplete();
 			else if (this.autocompleteTriggerCharacters.includes(char)) {
 				const textBeforeCursor = (this.state.lines[this.state.cursorLine] || "").slice(0, this.state.cursorCol);
 				const charBeforeSymbol = textBeforeCursor[textBeforeCursor.length - 2];
 				if (textBeforeCursor.length === 1 || charBeforeSymbol === " " || charBeforeSymbol === "	") this.tryTriggerAutocomplete();
-			} else if (/[a-zA-Z0-9.\-_]/.test(char)) {
+			} else if (/[a-zA-Z0-9.:\-_]/.test(char)) {
 				const textBeforeCursor = (this.state.lines[this.state.cursorLine] || "").slice(0, this.state.cursorCol);
 				if (this.isInSlashCommandContext(textBeforeCursor)) this.tryTriggerAutocomplete();
 				else if (this.autocompleteTriggerPattern.test(textBeforeCursor)) this.tryTriggerAutocomplete();
+				else if (this.isInInlineSlashContext(textBeforeCursor)) this.tryTriggerAutocomplete();
 			}
 		} else this.updateAutocomplete();
 	}
@@ -7342,6 +7513,20 @@ var Editor = class {
 		const beforeCursor = (this.state.lines[this.state.cursorLine] || "").slice(0, this.state.cursorCol);
 		return beforeCursor.trim() === "" || beforeCursor.trim() === "/";
 	}
+	isAtInlineSlashTrigger() {
+		if (this.isAtStartOfMessage()) return false;
+		const beforeCursor = (this.state.lines[this.state.cursorLine] || "").slice(0, this.state.cursorCol);
+		if (!beforeCursor.endsWith("/")) return false;
+		if (this.state.cursorLine > 0 && beforeCursor.trim() === "/") return true;
+		const charBeforeSlash = beforeCursor[beforeCursor.length - 2];
+		return charBeforeSlash === " " || charBeforeSlash === "	";
+	}
+	isInInlineSlashContext(textBeforeCursor) {
+		if (!this.inlineSlashTrigger) return false;
+		if (this.isInSlashCommandContext(textBeforeCursor)) return false;
+		if (/[ \t]\/[a-zA-Z0-9.:\-_]*$/.test(textBeforeCursor)) return true;
+		return this.state.cursorLine > 0 && /^\/[a-zA-Z0-9.:\-_]*$/.test(textBeforeCursor);
+	}
 	isInSlashCommandContext(textBeforeCursor) {
 		return this.isSlashMenuAllowed() && textBeforeCursor.trimStart().startsWith("/");
 	}
@@ -12554,6 +12739,249 @@ function renderDiffView(diffs, cwd, options = {}) {
 	return out;
 }
 //#endregion
+//#region src/task-panel.ts
+/**
+* TaskBrowserPanel — the visual layer over the task-browser row model
+* (tasks-browser.ts). Rendered as an overlay inside a Frame (the ↓ / Ctrl+J
+* trigger with an empty editor, and /tasks), it replaces the generic
+* SelectList with a dsh-web JobListAction-style list: status dots, aligned
+* kind · label / status · elapsed columns, group headers, live 1s elapsed
+* ticking, and type-to-filter search.
+*
+* The row MODEL stays in tasks-browser.ts (buildTaskRows / taskRowLabel /
+* describeTaskRow / rowGroup) — this component only presents it.
+* @module @xmoon76/dsh-pi-tui/task-panel
+*/
+/**
+* Render the `status · elapsed` tail: elapsed is humanized as `2s` / `1m5s` /
+* `1h2m` (dsh-web duration parity), omitted when absent.
+*/
+function formatElapsed(elapsed) {
+	if (elapsed === void 0 || !Number.isFinite(elapsed)) return "";
+	const total = Math.max(0, Math.floor(elapsed));
+	const seconds = total % 60;
+	const minutes = Math.floor(total / 60) % 60;
+	const hours = Math.floor(total / 3600);
+	if (hours > 0) return `${hours}h${minutes}m`;
+	if (minutes > 0) return `${minutes}m${seconds}s`;
+	return `${seconds}s`;
+}
+const POINTER = "→";
+const DOT = "●";
+/**
+* The task browser surface: a searchable, live-updating list of task rows
+* with status dots and aligned columns. Owns its own scroll window so the
+* list can grow beyond the overlay height.
+*/
+var TaskBrowserPanel = class {
+	items = [];
+	/** The filtered view (search query applied). */
+	filtered = [];
+	selected = 0;
+	/** Scroll offset into the filtered list. */
+	scroll = 0;
+	maxVisible;
+	options;
+	searchInput = new Input();
+	searchEnabled;
+	onSelect;
+	onCancel;
+	/** Live tick: bumped every second while a running row is visible. */
+	now = Date.now();
+	tickTimer;
+	/** Latched by dispose(): an in-flight tick callback must not render. */
+	disposed = false;
+	requestRender;
+	_focused = false;
+	constructor(items, maxVisible, options, onSelect, onCancel, requestRender) {
+		this.items = [...items];
+		this.filtered = [...items];
+		this.maxVisible = Math.max(1, maxVisible);
+		this.options = options;
+		this.onSelect = onSelect;
+		this.onCancel = onCancel;
+		this.requestRender = requestRender;
+		this.searchEnabled = options.enableSearch ?? false;
+		this.searchInput.onEscape = () => this.onCancel();
+		this.searchInput.onSubmit = (value) => {
+			const item = this.filtered[this.selected];
+			if (item !== void 0) this.onSelect(item.value);
+		};
+		const initial = options.initialQuery ?? "";
+		if (initial !== "") {
+			this.searchInput.setValue(initial);
+			this.applyFilter(initial);
+		}
+		this.startTick();
+	}
+	/** Replace the row list; the active search query re-applies and the
+	* selection survives when its value is still present. */
+	setItems(items) {
+		const previousValue = this.filtered[this.selected]?.value;
+		this.items = [...items];
+		this.applyFilter(this.searchInput.getValue() ?? "");
+		if (previousValue !== void 0) {
+			const index = this.filtered.findIndex((item) => item.value === previousValue);
+			if (index !== -1) this.selected = index;
+		}
+	}
+	/** The current search query. */
+	getFilter() {
+		return this.searchInput.getValue() ?? "";
+	}
+	/** The number of rows currently visible (after filtering). */
+	get filteredCount() {
+		return this.filtered.length;
+	}
+	startTick() {
+		this.tickTimer = setInterval(() => {
+			if (this.disposed) return;
+			if (!this.items.some((item) => item.startedAt !== void 0 && (item.status === "running" || item.status === "stopping"))) return;
+			this.now = Date.now();
+			this.requestRender();
+		}, 1e3);
+		this.tickTimer.unref();
+	}
+	/** Stop the tick (the overlay is closing). */
+	dispose() {
+		this.disposed = true;
+		if (this.tickTimer !== void 0) clearInterval(this.tickTimer);
+		this.tickTimer = void 0;
+	}
+	get focused() {
+		return this._focused;
+	}
+	set focused(value) {
+		this._focused = value;
+		this.searchInput.focused = value;
+	}
+	invalidate() {
+		this.searchInput.invalidate();
+	}
+	handleInput(data) {
+		const isNavUp = data === "\x1B[A" || !this.searchEnabled && data === "k";
+		const isNavDown = data === "\x1B[B" || !this.searchEnabled && data === "j";
+		const isPage = data === "\x1B[5~" || data === "\x1B[6~";
+		if (!isNavUp && !isNavDown && !isPage && data !== "\r" && data !== "\n" && data !== "\x1B" && this.searchEnabled) {
+			this.searchInput.handleInput(data);
+			this.applyFilter(this.searchInput.getValue() ?? "");
+			return;
+		}
+		if (isNavUp) {
+			if (this.filtered.length === 0) return;
+			this.selected = Math.max(0, this.selected - 1);
+			this.ensureVisible();
+			return;
+		}
+		if (isNavDown) {
+			if (this.filtered.length === 0) return;
+			this.selected = Math.min(this.filtered.length - 1, this.selected + 1);
+			this.ensureVisible();
+			return;
+		}
+		if (isPage) {
+			if (this.filtered.length === 0) return;
+			if (data === "\x1B[5~") this.selected = Math.max(0, this.selected - this.maxVisible);
+			else this.selected = Math.min(this.filtered.length - 1, this.selected + this.maxVisible);
+			this.ensureVisible();
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			const item = this.filtered[this.selected];
+			if (item !== void 0) this.onSelect(item.value);
+			return;
+		}
+		if (data === "\x1B") this.onCancel();
+	}
+	ensureVisible() {
+		if (this.selected < this.scroll) this.scroll = this.selected;
+		else if (this.selected >= this.scroll + this.maxVisible) this.scroll = this.selected - this.maxVisible + 1;
+		this.scroll = Math.max(0, Math.min(this.scroll, Math.max(0, this.filtered.length - this.maxVisible)));
+	}
+	applyFilter(query) {
+		if (query === "") this.filtered = this.items;
+		else {
+			const needle = query.toLowerCase();
+			this.filtered = this.items.filter((item) => `${item.value}\n${item.label}\n${item.status}\n${item.detail ?? ""}`.toLowerCase().includes(needle));
+		}
+		this.selected = 0;
+		this.scroll = 0;
+	}
+	render(width) {
+		const safeWidth = Math.max(1, width);
+		const lines = [];
+		if (this.options.header !== void 0) {
+			const counts = this.counts();
+			const headerText = counts === "" ? this.options.header : `${this.options.header}  ${counts}`;
+			lines.push(color.textStrong(truncateToWidth(headerText, safeWidth, "…")));
+			lines.push("");
+		}
+		if (this.searchEnabled) {
+			const searchLine = this.searchInput.render(Math.max(1, safeWidth - 2))[0] ?? "";
+			const stripped = searchLine.startsWith("> ") ? searchLine.slice(2) : searchLine;
+			lines.push(this.searchInput.getValue() === "" ? color.textDim(" search…") : ` ${stripped}`);
+			lines.push("");
+		}
+		if (this.filtered.length === 0) {
+			lines.push(color.textDim(this.options.noMatchText ?? "no active tasks"));
+			lines.push("");
+			lines.push(color.textMuted(`  ${this.hint()}`));
+			return lines;
+		}
+		this.ensureVisible();
+		const start = this.scroll;
+		const end = Math.min(this.filtered.length, start + this.maxVisible);
+		let lastGroup;
+		for (let i = start; i < end; i++) {
+			const item = this.filtered[i];
+			if (item === void 0) continue;
+			if (item.group !== lastGroup) {
+				if (item.group !== void 0) lines.push(color.textMuted(`── ${item.group} ──`));
+				lastGroup = item.group;
+			}
+			lines.push(...this.renderRow(item, i === this.selected, safeWidth));
+		}
+		if (this.filtered.length > this.maxVisible) lines.push(color.textMuted(`  ${this.selected + 1}/${this.filtered.length}`));
+		lines.push("");
+		lines.push(color.textMuted(`  ${this.hint()}`));
+		return lines;
+	}
+	counts() {
+		const running = this.items.filter((item) => item.status === "running" || item.status === "stopping").length;
+		const done = this.items.filter((item) => item.status === "completed").length;
+		const failed = this.items.filter((item) => item.status === "failed" || item.status === "killed" || item.status === "timed_out" || item.status === "lost").length;
+		const parts = [];
+		if (running > 0) parts.push(color.primary(`${running} running`));
+		if (done > 0) parts.push(color.textDim(`${done} done`));
+		if (failed > 0) parts.push(color.error(`${failed} failed`));
+		if (parts.length === 0) parts.push(color.textDim(`${this.items.length} total`));
+		return parts.join(" · ");
+	}
+	renderRow(item, selected, width) {
+		const dot = taskStatusColor(item.status)(DOT);
+		const leftPrefix = `${selected ? color.primary(POINTER) : " "} ${dot} `;
+		const leftWidth = visibleWidth(leftPrefix);
+		const label = selected ? color.textStrong(item.label) : color.text(item.label);
+		const statusText = taskStatusColor(item.status)(item.status);
+		const elapsedSeconds = item.startedAt === void 0 ? void 0 : Math.max(0, Math.floor((this.now - item.startedAt) / 1e3));
+		const tail = [statusText, elapsedSeconds === void 0 ? "" : color.textMuted(formatElapsed(elapsedSeconds))].filter((part) => part !== "").join(" ");
+		const tailWidth = visibleWidth(tail);
+		const available = width - leftWidth;
+		const leftFinal = leftPrefix + truncateToWidth(label, Math.max(1, available - tailWidth - 2), "…");
+		const pad = Math.max(1, available - visibleWidth(leftFinal) - tailWidth);
+		const out = [truncateToWidth(leftFinal + " ".repeat(pad) + tail, width, "…")];
+		if (item.detail !== void 0 && item.detail !== "") {
+			const indent = " ".repeat(leftWidth);
+			const detailLines = wrapTextWithAnsi(color.textDim(item.detail), Math.max(1, width - leftWidth));
+			for (const wrapped of detailLines.slice(0, 2)) out.push(truncateToWidth(indent + wrapped, width, "…"));
+		}
+		return out;
+	}
+	hint() {
+		return `${this.searchEnabled ? "type to filter · " : ""}↑↓ navigate · enter open · esc close`;
+	}
+};
+//#endregion
 //#region src/search.ts
 /**
 * The transcript-search overlay component: a one-line query input with a
@@ -12623,8 +13051,9 @@ const OTHER_ROW = "\0other";
 /**
 * Default total physical-row budget of the question flow itself. The
 * QuestionFrame in tui-app.ts re-derives the budget from the terminal height
-* on every render (60% cap, 8..24 content rows) and pushes it through
-* {@link QuestionFlow.setMaxRows}; 24 is the fallback for direct renders.
+* on every render (60% cap COLLAPSED, 8..24 content rows; up to 38 when
+* expanded) and pushes it through {@link QuestionFlow.setMaxRows}; 24 is the
+* fallback for direct renders.
 * The Frame wrapper adds its two border rows, and NOTHING clips the flow's
 * output in the editor-seat layout — so EVERYTHING (tabs, question, detail,
 * options with their descriptions, scroll marker, skipped note, hint) must
@@ -12638,13 +13067,24 @@ const DEFAULT_BUDGET = 24;
 */
 const MIN_SUPPORTED_BUDGET = 8;
 /**
-* Total physical-row budget for the question body (question text + detail),
-* shared so a single unbroken long line cannot push the options and hints
-* out of the dialog's maxHeight (kimi MAX_BODY_LINES scale).
+* Largest supported content-row budget: the EXPANDED frame cap (80% of the
+* terminal, at most 40 frame rows) minus the two frame borders. An explicit
+* body expand ('e' / marker click) grows the panel beyond the default 60%
+* cap — the user asked for the room; the budget math is linear and holds
+* for every budget >= MIN_SUPPORTED_BUDGET.
+*/
+const MAX_BUDGET = 38;
+/**
+* Cap for the WRAPPED page scrollport content (question + detail + options
+* with their descriptions). Beyond it the content ends in a `... more
+* content hidden` note — wrapping an unbounded 100KB detail every frame
+* would be wasteful. 256 rows keeps realistic questions AND all their
+* answerable options reachable (7 options × ~19 wrapped description rows
+* at 50 columns fits); the cap is a hard wall, so a page whose content
+* alone exceeds 256 rows ends in the note — that page is unreachable in
+* practice, and the note makes the cut non-silent.
 */
-const MAX_BODY_LINES = 12;
-/** Max visible option rows before the list windows around the cursor. */
-const MAX_VISIBLE_OPTIONS = 7;
+const MAX_CONTENT_ROWS = 256;
 /**
 * Budgeted push of `content` to `lines`, wrapping it to `width`: pushes at
 * most `budget` PHYSICAL (wrapped) rows, appends a `... N more` marker when
@@ -12736,13 +13176,46 @@ var QuestionFlow = class {
 	/** Review-page action highlight (0 = Submit, 1 = Cancel). */
 	submitIdx = 0;
 	/**
-	* Current content-row budget (8..24). The editor-seat QuestionFrame in
+	* Current content-row budget (8..38). The editor-seat QuestionFrame in
 	* tui-app.ts re-derives it from the terminal height on every render and
 	* pushes it through {@link setMaxRows}; nothing clips the flow's output
 	* in that layout, so every render must fit the budget exactly.
 	*/
 	budget = DEFAULT_BUDGET;
 	_focused = false;
+	/**
+	* Scroll offset (content rows) into the UNIFIED page scrollport (question,
+	* detail, then every option with its description, then the free-text row).
+	* PageUp/PageDown move it; ↑↓/digits/click move the cursor and the render
+	* follows it into view (pendingCursorScroll).
+	*/
+	bodyScroll = 0;
+	/**
+	* Expanded mode ('e' / marker click): the FRAME grows toward 80% (the
+	* QuestionFrame reads isBodyExpanded each render), so the scrollport is
+	* taller and more of the page — including option descriptions — is visible
+	* at once. Everything stays reachable by scrolling either way.
+	*/
+	bodyExpanded = false;
+	/** Cursor moved since the last render: the next render must scroll the
+	* cursor's rows into view. */
+	pendingCursorScroll = false;
+	/** Hit map from the last render: content row -> option row key. Built each
+	* render; drives fullscreen click-to-select. */
+	hitMap = /* @__PURE__ */ new Map();
+	/** Content row of the scroll marker in the last render (-1 = none);
+	* clicking it toggles the expanded panel. */
+	lastMarkerRow = -1;
+	/** Scrollport height from the last render (scroll page math). */
+	lastRegionHeight = 0;
+	/** Wrapped page content length from the last render. */
+	lastContentRows = 0;
+	/** Content rows visible in the region from the last render (region minus
+	* the marker row when overflowing). */
+	lastVisibleRows = 0;
+	/** Whether the page content overflows the scrollport on the last render —
+	* 'e' (and the scroll verbs) are available when true. */
+	lastExpandable = false;
 	constructor(questions, onDone, onCancel) {
 		this.questions = questions;
 		this.onDone = onDone;
@@ -12773,10 +13246,144 @@ var QuestionFlow = class {
 	* Replace the content-row budget (the Frame wrapper adds its two border
 	* rows on top). Called by QuestionFrame on every render immediately
 	* before the flow renders, so no invalidation is needed; values outside
-	* [MIN_SUPPORTED_BUDGET, DEFAULT_BUDGET] are clamped.
+	* [MIN_SUPPORTED_BUDGET, MAX_BUDGET] are clamped.
 	*/
 	setMaxRows(rows) {
-		this.budget = Math.max(MIN_SUPPORTED_BUDGET, Math.min(DEFAULT_BUDGET, Math.floor(rows)));
+		this.budget = Math.max(MIN_SUPPORTED_BUDGET, Math.min(MAX_BUDGET, Math.floor(rows)));
+	}
+	/** Whether the panel is expanded (the frame grows toward 80% of the
+	* terminal — QuestionFrame reads this every render). */
+	isBodyExpanded() {
+		return this.bodyExpanded;
+	}
+	/**
+	* Reset the view (scroll + expanded + pending cursor follow) — called on
+	* every tab change so each question starts at its top, collapsed.
+	*/
+	resetBodyView() {
+		this.bodyScroll = 0;
+		this.bodyExpanded = false;
+		this.pendingCursorScroll = false;
+	}
+	/**
+	* Page the unified scrollport. One page = the visible content rows. No-op
+	* when the content fits the region.
+	*/
+	scrollBody(direction) {
+		const visible = this.lastVisibleRows;
+		if (visible <= 0 || this.lastContentRows <= visible) return;
+		const maxScroll = this.lastContentRows - visible;
+		this.bodyScroll = Math.max(0, Math.min(this.bodyScroll + direction * visible, maxScroll));
+	}
+	/** Toggle the expanded panel ('e' or a click on the scroll marker).
+	* Expanding is only meaningful when the page content overflows the
+	* scrollport (everything fits -> a taller panel shows nothing new). The
+	* SCROLL POSITION is kept: the taller region reveals MORE rows where the
+	* user is looking (e.g. the option descriptions they scrolled to), instead
+	* of jumping back to the top — the render clamps the offset to the new
+	* maxScroll. */
+	toggleExpanded() {
+		if (!this.bodyExpanded && !this.lastExpandable) return;
+		this.bodyExpanded = !this.bodyExpanded;
+	}
+	/**
+	* Primary-click routing (fullscreen): an option row selects it (single-
+	* select advances, multi-select toggles, the "Type something." row enters
+	* free-text), and the scroll marker toggles the expanded panel. The hit
+	* map reflects the LAST rendered frame, which is what the user sees.
+	*/
+	clickRow(row) {
+		if (row < 0 || this.tab >= this.questions.length) return;
+		const key = this.hitMap.get(row);
+		if (key === OTHER_ROW) {
+			if (this.editingOther) return;
+			const index = this.rows().findIndex((candidate) => candidate.key === OTHER_ROW);
+			if (index >= 0) {
+				this.cursor = index;
+				this.pendingCursorScroll = true;
+				this.enterOther();
+			}
+			return;
+		}
+		if (key !== void 0) {
+			this.cursor = Number(key);
+			this.pendingCursorScroll = true;
+			this.confirm();
+			return;
+		}
+		if (row === this.lastMarkerRow) this.toggleExpanded();
+	}
+	/**
+	* Build the UNIFIED page scrollport content: the question + detail first
+	* (required-first — row 0 is always the question's first physical row),
+	* a separator, then every option row (label + description), then the
+	* free-text row. Each option row maps to its key for click hit-testing.
+	* Capped at MAX_CONTENT_ROWS with a trailing `... more content hidden`
+	* note, so wrapping an unbounded detail/description stays cheap.
+	*/
+	buildPageContent(question, rows, draft, multi, width) {
+		const lines = [];
+		const hits = [];
+		let left = MAX_CONTENT_ROWS;
+		left = appendContentFirst(lines, `${color.primary("?")}  `, "    ", color.textStrong(question.question), width, left);
+		hits.push(...new Array(lines.length).fill(void 0));
+		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) {
+			if (left <= 1) {
+				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), width, left);
+				break;
+			}
+			left = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), width, left);
+		}
+		hits.push(...new Array(lines.length - hits.length).fill(void 0));
+		lines.push("");
+		hits.push(void 0);
+		for (const row of rows) {
+			const isCursor = rows[this.cursor] === row;
+			const selected = row.key === OTHER_ROW ? draft.custom !== "" : draft.selected.has(question.options?.[Number(row.key)]?.label ?? "");
+			const marker = multi || row.key === OTHER_ROW ? selected ? color.success("[✓]") : color.textDim("[ ]") : selected ? color.success(`[${Number(row.key) + 1}]`) : color.textDim(`[${Number(row.key) + 1}]`);
+			const prefix = `${isCursor ? color.primary("→") : " "} ${marker} `;
+			const indent = " ".repeat(visibleWidth(prefix));
+			const badge = row.recommended ? ` ${color.primary("[recommended]")}` : "";
+			const label = isCursor ? color.textStrong(row.label) : row.label;
+			if (row.key === OTHER_ROW && this.editingOther) {
+				const inputLine = this.otherInput.render(Math.max(1, width - visibleWidth(prefix)))[0] ?? "";
+				const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
+				lines.push(prefix + (this.otherInput.getValue() === "" ? color.textDim(row.label) : stripped));
+				hits.push(OTHER_ROW);
+				continue;
+			}
+			const labelWidth = Math.max(1, width - visibleWidth(prefix));
+			for (const wrapped of wrapTextWithAnsi(`${label}${badge}`, labelWidth)) if (!this.pushPageRow(lines, hits, prefix + wrapped, row.key)) return {
+				lines,
+				hits
+			};
+			if (row.description !== void 0 && row.description !== "" && !(row.key === OTHER_ROW && this.editingOther)) {
+				const descWidth = Math.max(1, width - visibleWidth(indent));
+				for (const wrapped of wrapTextWithAnsi(color.textDim(row.description), descWidth)) if (!this.pushPageRow(lines, hits, indent + wrapped, row.key)) return {
+					lines,
+					hits
+				};
+			}
+		}
+		return {
+			lines,
+			hits
+		};
+	}
+	/** Push one page-content row, capping at MAX_CONTENT_ROWS with a single
+	* `... more content hidden` note (never a second one after the detail's).
+	* @returns false when the cap was hit (callers stop building). */
+	pushPageRow(lines, hits, line, key) {
+		if (lines.length >= MAX_CONTENT_ROWS) {
+			if (lines[lines.length - 1]?.includes("more content hidden") !== true) {
+				lines.push(color.textDim("... more content hidden"));
+				hits.push(void 0);
+			}
+			return false;
+		}
+		lines.push(line);
+		hits.push(key);
+		return true;
 	}
 	/** The rows of the current question (options plus the free-text row). */
 	rows() {
@@ -12846,6 +13453,7 @@ var QuestionFlow = class {
 	}
 	/** Optionless questions edit text directly; options start in list mode. */
 	syncEditMode() {
+		this.resetBodyView();
 		const question = this.questions[this.tab];
 		const optionless = question !== void 0 && (question.options?.length ?? 0) === 0;
 		this.editingOther = optionless;
@@ -12920,6 +13528,7 @@ var QuestionFlow = class {
 		if (this.editingOther) {
 			if (data === "\r" || data === "\n") this.commitOther(this.otherInput.getValue());
 			else if (data === "\x1B") this.exitOther();
+			else if (data === "\x1B[5~" || data === "\x1B[6~") this.scrollBody(data === "\x1B[5~" ? -1 : 1);
 			else if (data === "\x1B[D") {
 				if (this.tab > 0) {
 					this.tab -= 1;
@@ -12962,16 +13571,39 @@ var QuestionFlow = class {
 			const row = rows[Number(digit[0]) - 1];
 			if (row !== void 0) {
 				this.cursor = rows.indexOf(row);
+				this.pendingCursorScroll = true;
 				this.confirm();
 			}
 			return;
 		}
 		if (data === "\x1B[A" || data === "k") {
-			if (rows.length > 0) this.cursor = (this.cursor - 1 + rows.length) % rows.length;
+			if (rows.length === 0) return;
+			if (this.cursor === 0 && this.bodyScroll > 0) {
+				this.scrollBody(-1);
+				return;
+			}
+			this.cursor = (this.cursor - 1 + rows.length) % rows.length;
+			this.pendingCursorScroll = true;
 			return;
 		}
 		if (data === "\x1B[B" || data === "j") {
-			if (rows.length > 0) this.cursor = (this.cursor + 1) % rows.length;
+			if (rows.length === 0) return;
+			const atLastRow = this.cursor === rows.length - 1;
+			const scrolled = this.lastExpandable && this.lastContentRows > this.bodyScroll + this.lastVisibleRows;
+			if (atLastRow && scrolled) {
+				this.scrollBody(1);
+				return;
+			}
+			this.cursor = (this.cursor + 1) % rows.length;
+			this.pendingCursorScroll = true;
+			return;
+		}
+		if (data === "\x1B[5~" || data === "\x1B[6~") {
+			this.scrollBody(data === "\x1B[5~" ? -1 : 1);
+			return;
+		}
+		if (data === "e") {
+			this.toggleExpanded();
 			return;
 		}
 		if (data === "\r" || data === "\n") {
@@ -12992,6 +13624,7 @@ var QuestionFlow = class {
 				this.tab += 1;
 				this.cursor = 0;
 				this.submitIdx = 0;
+				this.syncEditMode();
 			} else {
 				this.tab = this.questions.length;
 				this.cursor = 0;
@@ -13012,6 +13645,8 @@ var QuestionFlow = class {
 	render(width) {
 		const safeWidth = Math.max(1, width);
 		const lines = [];
+		this.hitMap.clear();
+		this.lastMarkerRow = -1;
 		const tabs = this.questions.map((_, index) => {
 			const draft = this.drafts[index];
 			const answered = draft !== void 0 && (draft.selected.size > 0 || draft.custom !== "" || draft.skipped);
@@ -13053,102 +13688,73 @@ var QuestionFlow = class {
 		if (question === void 0 || draft === void 0) return lines;
 		const rows = this.rows();
 		const multi = question.multiSelect === true;
-		this.editingOther && rows.some((row) => row.key === OTHER_ROW);
 		const skippedRow = draft.skipped ? 1 : 0;
 		const optionless = rows.length === 0 || rows.length === 1 && rows[0]?.key === OTHER_ROW;
-		const tail = optionless ? 3 + skippedRow : 4 + skippedRow;
-		let bodyAllowance = this.budget - lines.length - tail;
+		const tail = optionless ? 3 + skippedRow : 2 + skippedRow;
 		const header = question.header;
-		if (header !== void 0 && header !== "" && bodyAllowance >= 2) {
-			lines.push(color.textDim(header));
-			bodyAllowance -= 1;
-		}
-		const bodyBudget = Math.min(MAX_BODY_LINES, Math.max(1, bodyAllowance));
-		let bodyLeft = appendContentFirst(lines, `${color.primary("?")}  `, "    ", color.textStrong(question.question), safeWidth, bodyBudget);
-		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) {
-			if (bodyLeft <= 1) {
-				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), safeWidth, bodyLeft);
-				break;
-			}
-			bodyLeft = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), safeWidth, bodyLeft);
-		}
-		if (!optionless) {
-			lines.push("");
-			const optionBudget = this.budget - lines.length - skippedRow - 2;
-			const maxWindow = Math.max(1, Math.min(MAX_VISIBLE_OPTIONS, optionBudget));
-			const visibleCount = Math.min(rows.length, maxWindow);
-			const half = Math.floor(maxWindow / 2);
-			const maxStart = Math.max(0, rows.length - visibleCount);
-			const start = Math.max(0, Math.min(this.cursor - half, maxStart));
-			const end = Math.min(rows.length, start + visibleCount);
-			{
-				const cursorRow = rows[this.cursor];
-				let reserved = 1;
-				if (cursorRow !== void 0 && cursorRow.key !== OTHER_ROW) {
-					const prefix = `→ ${multi || cursorRow.key === OTHER_ROW ? draft.selected.has(question.options?.[Number(cursorRow.key)]?.label ?? "") ? "[✓]" : "[ ]" : draft.selected.has(question.options?.[Number(cursorRow.key)]?.label ?? "") ? `[${Number(cursorRow.key) + 1}]` : `[${Number(cursorRow.key) + 1}]`} `;
-					const badge = cursorRow.recommended ? ` ${color.primary("[recommended]")}` : "";
-					reserved = Math.min(Math.max(1, wrapTextWithAnsi(`${color.textStrong(cursorRow.label)}${badge}`, Math.max(1, safeWidth - visibleWidth(prefix))).length), maxWindow);
-				}
-				let left = optionBudget;
-				let cursorRendered = false;
-				for (let index = start; index < end; index++) {
-					const row = rows[index];
-					if (row === void 0) continue;
-					const isCursor = index === this.cursor;
-					if (!isCursor && (cursorRendered ? left <= 0 : left <= reserved)) continue;
-					if (row.key === OTHER_ROW && this.editingOther) {
-						const prefix = `${color.primary("→")} ${color.textDim(`[${index + 1}]`)} `;
-						const inputLine = this.otherInput.render(Math.max(1, safeWidth - visibleWidth(prefix)))[0] ?? "";
-						const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
-						left -= 1;
-						lines.push(prefix + stripped);
-						if (isCursor) cursorRendered = true;
-						continue;
-					}
-					const selected = row.key === OTHER_ROW ? draft.custom !== "" : draft.selected.has(question.options?.[Number(row.key)]?.label ?? "");
-					const marker = multi || row.key === OTHER_ROW ? selected ? color.success("[✓]") : color.textDim("[ ]") : selected ? color.success(`[${Number(row.key) + 1}]`) : color.textDim(`[${Number(row.key) + 1}]`);
-					const prefix = `${isCursor ? color.primary("→") : " "} ${marker} `;
-					const badge = row.recommended ? ` ${color.primary("[recommended]")}` : "";
-					const label = isCursor ? color.textStrong(row.label) : row.label;
-					const indent = " ".repeat(visibleWidth(prefix));
-					const available = isCursor || cursorRendered ? left : left - reserved;
-					const beforeLabel = lines.length;
-					if (isCursor) appendContentFirst(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
-					else appendWrappedBudgeted(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
-					left -= lines.length - beforeLabel;
-					if (row.description !== void 0 && row.description !== "" && left > 0) {
-						const descCap = isCursor || cursorRendered ? left : left - reserved;
-						const beforeDescription = lines.length;
-						appendWrappedBudgeted(lines, indent, indent, color.textDim(row.description), safeWidth, descCap);
-						left -= lines.length - beforeDescription;
-					}
-					if (isCursor) cursorRendered = true;
+		if (header !== void 0 && header !== "" && this.budget - lines.length - tail >= 2) lines.push(color.textDim(header));
+		const content = this.buildPageContent(question, rows, draft, multi, safeWidth);
+		const regionHeight = Math.max(1, this.budget - lines.length - tail);
+		const overflow = content.lines.length > regionHeight;
+		const visible = overflow && regionHeight >= 2 ? regionHeight - 1 : regionHeight;
+		this.lastRegionHeight = regionHeight;
+		this.lastContentRows = content.lines.length;
+		this.lastVisibleRows = visible;
+		this.lastExpandable = overflow && regionHeight >= 2;
+		const maxScroll = Math.max(0, content.lines.length - visible);
+		this.bodyScroll = Math.min(this.bodyScroll, maxScroll);
+		if (this.pendingCursorScroll) {
+			this.pendingCursorScroll = false;
+			const cursorKey = rows[this.cursor]?.key;
+			if (cursorKey !== void 0) {
+				const first = content.hits.indexOf(cursorKey);
+				if (first >= 0) {
+					if (first < this.bodyScroll) this.bodyScroll = first;
+					else if (first >= this.bodyScroll + visible) this.bodyScroll = first - visible + 1;
+					this.bodyScroll = Math.max(0, Math.min(this.bodyScroll, maxScroll));
 				}
-				if (rows.length > MAX_VISIBLE_OPTIONS && left > 0) left = appendWrappedBudgeted(lines, "   ", "   ", `showing ${start + 1}-${end} of ${rows.length}`, safeWidth, left);
 			}
-		} else {
+		}
+		for (let index = this.bodyScroll; index < this.bodyScroll + visible && index < content.lines.length; index++) {
+			const hit = content.hits[index];
+			if (hit !== void 0) this.hitMap.set(lines.length, hit);
+			lines.push(content.lines[index]);
+		}
+		if (overflow && regionHeight >= 2) {
+			const above = this.bodyScroll;
+			const below = content.lines.length - (this.bodyScroll + visible);
+			const marker = above > 0 && below > 0 ? `↑ ${above} up · ↓ ${below} more lines` : above > 0 ? `↑ ${above} up` : `↓ ${below} more lines`;
+			this.lastMarkerRow = lines.length;
+			lines.push(color.textDim(marker));
+		} else this.lastMarkerRow = -1;
+		if (optionless) {
 			const inputLine = this.otherInput.render(Math.max(1, safeWidth - 2))[0] ?? "";
 			const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
-			lines.push(` ${stripped}`);
+			lines.push(this.otherInput.getValue() === "" ? color.textDim(" Type your answer…") : ` ${stripped}`);
 		}
 		if (draft.skipped) lines.push(color.textDim("(skipped)"));
 		lines.push("");
 		const optionCount = Math.min(rows.length, 9);
+		const scrollable = this.lastExpandable;
 		const hintParts = [
 			"↑↓ select",
 			optionCount > 0 ? `1-${optionCount} choose` : "",
 			multi ? "↵ toggle" : "↵ confirm",
+			scrollable ? "pgup/pgdn scroll" : "",
+			!this.editingOther ? this.bodyExpanded ? "e collapse" : scrollable ? "e expand" : "" : "",
 			this.questions.length > 1 ? "←→ switch" : "",
 			"s skip",
 			"esc cancel"
 		].filter((part) => part !== "");
+		const cancel = "esc cancel";
+		const verbs = hintParts.filter((part) => part !== cancel);
 		let hint = "";
-		for (const part of hintParts) {
+		for (const part of verbs) {
 			const next = hint === "" ? part : `${hint} · ${part}`;
-			if (visibleWidth(next) > safeWidth) break;
+			if (visibleWidth(`${next} · ${cancel}`) > safeWidth) break;
 			hint = next;
 		}
-		lines.push(color.textDim(hint === "" ? "esc cancel" : hint));
+		lines.push(color.textDim(hint === "" ? cancel : `${hint} · ${cancel}`));
 		return lines;
 	}
 };
@@ -13705,6 +14311,10 @@ var Frame = class {
 var QuestionFrame = class extends Frame {
 	flow;
 	heightOf;
+	/** Rendered height of the last frame (fullscreen click hit-testing). */
+	lastRows = 0;
+	/** Terminal height the last render used (click staleness guard). */
+	lastTermRows = 0;
 	constructor(flow, heightOf) {
 		super(flow, true);
 		this.flow = flow;
@@ -13712,9 +14322,20 @@ var QuestionFrame = class extends Frame {
 	}
 	render(width) {
 		const rows = Math.max(1, this.heightOf());
-		const frameRows = Math.max(10, Math.min(26, Math.floor(rows * .6)));
+		this.lastTermRows = rows;
+		const frameRows = this.flow.isBodyExpanded() ? Math.max(10, Math.min(40, Math.floor(rows * .8))) : Math.max(10, Math.min(26, Math.floor(rows * .6)));
 		this.flow.setMaxRows(frameRows - 2);
-		return super.render(width);
+		const out = super.render(width);
+		this.lastRows = out.length;
+		return out;
+	}
+	/** The frame's height from the last render (0 before the first one). */
+	get rows() {
+		return this.lastRows;
+	}
+	/** The terminal height the last render used. */
+	get termRows() {
+		return this.lastTermRows;
 	}
 	get focused() {
 		return this.flow.focused;
@@ -13997,19 +14618,23 @@ var TuiApp = class TuiApp {
 	/** The todo panel Text; empty when hidden. */
 	todoPanel;
 	/**
-	* The persistent dock strip directly above the todo panel: one line each
-	* for the current permission, the live goal, the todo summary, and running
-	* background tasks (kimi chrome parity). Empty lines drop out entirely.
+	* The persistent dock strip directly above the todo panel: the todo
+	* summary. Empty lines drop out entirely.
 	*/
 	dock;
-	/** Active background tasks for the dock/footer lines (label + status). */
+	/**
+	* The goal line between the todo panel and the queue pane: `goal ● …`
+	* rendered only while a goal is set (display-only).
+	*/
+	goalLine;
+	/** Active background tasks for the footer badge (label + status). */
 	dockTasks = [];
-	/** Live child subagents (continuable or running one-shot) for the dock/footer lines (never jobs records). */
+	/** Live child subagents (continuable or running one-shot) for the footer badge (never jobs records). */
 	dockAgents = [];
 	/**
-	* The queued-input pane below the todo panel (kimi QueuePane parity):
-	* a border rule plus one `❯ text` row per pending message and a dim hint.
-	* Renders nothing while the queue is empty.
+	* The queued-input pane below the todo panel: a border rule plus one
+	* `❯ text` row per pending message and a dim hint. Renders nothing while
+	* the queue is empty.
 	*/
 	queuePane;
 	/** The pending inbox messages (next-turn followups and next-step steers). */
@@ -14062,8 +14687,6 @@ var TuiApp = class TuiApp {
 	planMode = false;
 	/** The editor's normal border style, restored when plan mode ends. */
 	editorBorder;
-	/** Todo summary segment of the header (without the base or badges). */
-	todoText = "";
 	/** Welcome card shown above the transcript; renders nothing without facts. */
 	welcomeCard = new WelcomeCard();
 	/** Transient error line shown under the transcript; cleared by the next
@@ -14133,6 +14756,7 @@ var TuiApp = class TuiApp {
 		this.messagesView = new Container();
 		this.dock = new Text("", 0, 0);
 		this.todoPanel = new Text("", 0, 0);
+		this.goalLine = new Text("", 0, 0);
 		this.queuePane = new Text("", 0, 0);
 		this.working = new WorkingIndicator(() => this.requestRender(), options.workingIntervalMs === void 0 ? {} : { intervalMs: options.workingIntervalMs });
 		this.footer = new Text("", 0, 0);
@@ -14142,6 +14766,7 @@ var TuiApp = class TuiApp {
 		this.tui.addChild(this.messagesView);
 		this.tui.addChild(this.dock);
 		this.tui.addChild(this.todoPanel);
+		this.tui.addChild(this.goalLine);
 		this.tui.addChild(this.queuePane);
 		this.tui.addChild(this.working);
 		this.tui.addChild(this.editorSeat);
@@ -14551,6 +15176,10 @@ var TuiApp = class TuiApp {
 					component: this.todoPanel,
 					shrink: 0
 				},
+				{
+					component: this.goalLine,
+					shrink: 0
+				},
 				{
 					component: this.queuePane,
 					shrink: 0
@@ -14714,6 +15343,23 @@ var TuiApp = class TuiApp {
 	* The global Ctrl+O fold still wins, so keyboard behavior is unchanged.
 	*/
 	handleFullscreenClick(x, y) {
+		const question = this.activeQuestions;
+		if (question?.frame !== void 0) {
+			if (this.terminal.rows !== question.frame.termRows) return;
+			const width = this.terminal.columns;
+			const height = this.terminal.rows;
+			const footerHeight = this.footer.render(width).length;
+			const seatHeight = question.frame.rows;
+			const seatBottom = height - footerHeight;
+			const seatTop = seatBottom - seatHeight;
+			if (y >= seatTop && y < seatBottom) {
+				if (x >= 2 && x <= width - 3) {
+					question.flow.clickRow(y - seatTop - 1);
+					this.requestRender();
+				}
+				return;
+			}
+		}
 		const width = this.terminal.columns;
 		const rowInScroll = y - this.header.render(width).length;
 		if (rowInScroll < 0) return;
@@ -14972,9 +15618,12 @@ var TuiApp = class TuiApp {
 		} else {
 			const rows = [];
 			const callPreview = parseCallPreview(message.name, message.args);
+			const foldedCall = header.summary === "" ? foldedCallPreview(message.name, message.args) : "";
 			const resultPreview = message.name === "read" ? readFoldedPreview(message.result) : message.result === "" ? "" : ` — ${preview(message.result, 3)}`;
+			const callHead = foldedCall === "" ? "" : foldedCall;
+			const headWithPreview = `${head}${callHead}${resultPreview}`;
 			if (callPreview?.kind === "bash" && callPreview.command !== "") {
-				rows.push(truncateToWidth(head, this.terminal.columns, "…"));
+				rows.push(truncateToWidth(`${head}${callHead}`, this.terminal.columns, "…"));
 				const commandLines = callPreview.command.split("\n");
 				const shown = commandLines.slice(0, 3);
 				const prompt = color.shellMode("$ ");
@@ -14985,12 +15634,12 @@ var TuiApp = class TuiApp {
 				if (commandLines.length > 3) rows.push(color.textDim(`${indent}… ${commandLines.length - 3} more command lines (ctrl+o to expand)`));
 				if (resultPreview !== "") rows.push(color.textDim(`  ${resultPreview}`));
 			} else if (callPreview?.kind === "diff" && callPreview.diffs.length > 0) {
-				rows.push(truncateToWidth(`${head}${resultPreview}`, this.terminal.columns, "…"));
+				rows.push(truncateToWidth(`${headWithPreview}`, this.terminal.columns, "…"));
 				for (const line of renderDiffView(callPreview.diffs, this.workspaceRoot, {
 					maxLines: 4,
 					expandHint: "ctrl+o to expand"
 				})) rows.push(`  ${line}`);
-			} else rows.push(truncateToWidth(`${head}${resultPreview}`, this.terminal.columns, "…"));
+			} else rows.push(truncateToWidth(headWithPreview, this.terminal.columns, "…"));
 			card.addChild(new Text(rows.join("\n"), 0, 0));
 		}
 		return card;
@@ -15068,10 +15717,11 @@ var TuiApp = class TuiApp {
 					this.addTerminalCommandRow(card, callView.title, this.shellPrompt(message.name));
 					return;
 				}
-				if (callView.card === "generic" && callView.rawInput !== void 0) {
+				if (callView.card === "generic" && (callView.rawInput !== void 0 || (callView.content?.length ?? 0) > 0)) {
 					this.addTerminalCommandRow(card, this.terminalCommand(message.name, message.args), this.shellPrompt(message.name));
-					const raw = typeof callView.rawInput === "string" ? callView.rawInput : JSON.stringify(callView.rawInput, null, 2);
-					card.addChild(new Text(color.textDim(raw), 0, 0));
+					if (callView.rawInput !== void 0) for (const line of genericRawInputLines(message.name, callView.rawInput)) card.addChild(new Text(color.textDim(line), 0, 0));
+					for (const block of callView.content ?? []) if (block.type === "text") card.addChild(new Text(color.textDim(block.text), 0, 0));
+					else card.addChild(new Text(color.textDim(JSON.stringify(block, null, 2)), 0, 0));
 					return;
 				}
 			}
@@ -15112,6 +15762,18 @@ var TuiApp = class TuiApp {
 			case "diff":
 				this.renderDiffBody(card, resultView.diffs, explicitlyExpanded);
 				return;
+			case "web":
+				for (const line of webCardLines(resultView)) card.addChild(new Text(color.textDim(line), 0, 0));
+				return;
+			case "generic": {
+				const content = resultView.content ?? [];
+				if (content.length > 0) {
+					for (const block of content) if (block.type === "text") card.addChild(new Text(color.textDim(block.text), 0, 0));
+					else card.addChild(new Text(color.textDim(JSON.stringify(block, null, 2)), 0, 0));
+					return;
+				}
+				break;
+			}
 		}
 		if (resultView === void 0) {
 			const callView = this.present?.call(message.name, message.args);
@@ -15139,7 +15801,12 @@ var TuiApp = class TuiApp {
 		if (isDiffResult(message.name, message.result)) for (const line of renderDiffLines(message.result)) card.addChild(new Text(line, 0, 0));
 		else {
 			this.addTerminalCommandRow(card, this.terminalCommand(message.name, message.args), this.shellPrompt(message.name));
-			card.addChild(new Text(color.textDim(message.result), 0, 0));
+			const blocks = message.resultBlocks ?? [];
+			const lines = blocks.length > 0 ? resultTextLines(blocks, message.status === "error" ? {
+				name: "error",
+				code: "tool"
+			} : void 0) : [message.result];
+			for (const line of lines) card.addChild(new Text(color.textDim(line), 0, 0));
 		}
 	}
 	/**
@@ -15161,21 +15828,12 @@ var TuiApp = class TuiApp {
 		(this.fullscreen ?? this.tui).requestRender(force);
 	}
 	/**
-	* Reflect the todo list in the header line: active (non-completed) count
-	* and, when the list is non-empty, the first active item's text.
+	* Reflect the todo list in the dock summary line: active (non-completed)
+	* count and, when the list is non-empty, the first active item's text.
 	* @param todos - the latest todo/write snapshot.
 	*/
 	setTodoSummary(todos) {
 		this.todoItems = todos;
-		const active = todos.filter((todo) => todo.status !== "completed");
-		const done = todos.length - active.length;
-		if (active.length === 0) this.todoText = done > 0 ? ` · ${done} todo done` : "";
-		else {
-			const first = active[0];
-			const label = first === void 0 ? "" : first.content.length > 30 ? `${first.content.slice(0, 30)}…` : first.content;
-			this.todoText = ` · ${active.length} active · ${label}`;
-		}
-		this.renderHeader();
 		this.renderDock();
 		if (this.todoPanelVisible) this.renderTodoPanel();
 	}
@@ -15183,6 +15841,7 @@ var TuiApp = class TuiApp {
 	toggleTodoPanel() {
 		this.todoPanelVisible = !this.todoPanelVisible;
 		this.renderTodoPanel();
+		this.renderDock();
 		this.requestRender();
 		return this.todoPanelVisible;
 	}
@@ -15191,8 +15850,9 @@ var TuiApp = class TuiApp {
 		return this.todoPanelVisible;
 	}
 	/**
-	* Rebuild the todo panel text: a header line plus up to five rows,
-	* in_progress first, then pending, then completed (strikethrough).
+	* Rebuild the todo panel text: a border rule + `Todo` title (both indented
+	* one cell) plus up to five rows, in_progress first, then pending, then
+	* completed (strikethrough).
 	*/
 	renderTodoPanel() {
 		if (!this.todoPanelVisible) {
@@ -15205,15 +15865,22 @@ var TuiApp = class TuiApp {
 			...this.todoItems.filter((todo) => todo.status === "pending"),
 			...this.todoItems.filter((todo) => todo.status === "completed")
 		].slice(0, 5);
+		const width = Math.max(1, this.terminal.columns);
+		const border = color.border(` ${"─".repeat(Math.max(0, width - 2))} `);
+		const title = color.textStrong("  Todo");
 		if (ordered.length === 0) {
-			this.todoPanel.setText(color.border("─ todo ─"));
+			this.todoPanel.setText([border, title].join("\n"));
 			return;
 		}
 		const lines = ordered.map((todo) => {
 			const body = todo.status === "completed" ? `\x1b[9m${todo.content}\x1b[29m` : todo.content;
 			return `${mark(todo)} ${body}`;
 		});
-		this.todoPanel.setText([color.border("─ todo ─"), ...lines].join("\n"));
+		this.todoPanel.setText([
+			border,
+			title,
+			...lines
+		].join("\n"));
 	}
 	/** Hide/show thinking entries; the fold state is untouched. */
 	toggleThinkingHidden() {
@@ -15225,15 +15892,15 @@ var TuiApp = class TuiApp {
 	isThinkingHidden() {
 		return this.hideThinking;
 	}
-	/** Rebuild the header from base + session title + todo summary + plan badge.
+	/** Rebuild the header from base + session title + plan badge.
 	* Colours are applied AT RENDER TIME from the live palette — the semantic
-	* state (plan mode, title, todo text) is stored separately, so a theme
-	* switch only has to re-run this. */
+	* state (plan mode, title) is stored separately, so a theme switch only
+	* has to re-run this. */
 	renderHeader() {
 		const badge = this.planMode ? ` ${color.warning("[plan]")}` : "";
 		const viewerBadge = this.viewerMode === void 0 ? "" : ` ${color.accent("[viewing subagent]")}`;
 		const title = this.viewerMode !== void 0 ? ` · ${color.textMuted(this.viewerMode.label)}` : this.sessionTitleText === "" ? "" : ` · ${color.textMuted(this.sessionTitleText)}`;
-		this.header.setText(`🐋  dsh-pi-tui${title}${this.todoText}${badge}${viewerBadge}`);
+		this.header.setText(`🐋  dsh-pi-tui${title}${badge}${viewerBadge}`);
 		this.requestRender();
 	}
 	/**
@@ -15249,29 +15916,27 @@ var TuiApp = class TuiApp {
 		};
 		this.renderFooter();
 		this.renderDock();
+		this.renderGoalLine();
 	}
 	/**
-	* Replace the active background-task list for the dock lines and the
-	* footer badge. Non-empty sets arm the ↓/Ctrl+J task-browser trigger.
+	* Replace the active background-task list for the footer badge. Non-empty
+	* sets arm the ↓/Ctrl+J task-browser trigger.
 	* @param tasks - active jobs (id + label + lifecycle status), empty to hide.
 	*/
 	setTasks(tasks) {
 		this.dockTasks = tasks;
 		this.tasksActive = tasks.length > 0 || this.dockAgents.length > 0;
-		this.renderDock();
 		this.renderFooter();
 	}
 	/**
-	* Replace the live child-subagent list for the dock lines and the
-	* footer badge. Continuable children and foreground one-shot children
-	* never register jobs records (AGENTS.md), so they arm the ↓/Ctrl+J
-	* trigger through this channel.
+	* Replace the live child-subagent list for the footer badge. Continuable
+	* children and foreground one-shot children never register jobs records
+	* (AGENTS.md), so they arm the ↓/Ctrl+J trigger through this channel.
 	* @param agents - live children (id + label + activity), empty to hide.
 	*/
 	setAgents(agents) {
 		this.dockAgents = agents;
 		this.tasksActive = this.dockTasks.length > 0 || agents.length > 0;
-		this.renderDock();
 		this.renderFooter();
 	}
 	/** Whether background tasks are active (drives the ↓/Ctrl+J trigger). */
@@ -15279,9 +15944,9 @@ var TuiApp = class TuiApp {
 		return this.tasksActive;
 	}
 	/**
-	* Replace the pending inbox rows for the queue pane (kimi QueuePane
-	* parity): a border rule, one `❯ text` row per message, and a dim hint.
-	* An empty queue renders nothing at all.
+	* Replace the pending inbox rows for the queue pane: a border rule, one
+	* `❯ text` row per message, and a dim hint. An empty queue renders
+	* nothing at all.
 	* @param items - pending followups/steers, in delivery order.
 	*/
 	setQueueItems(items) {
@@ -15297,7 +15962,7 @@ var TuiApp = class TuiApp {
 			return;
 		}
 		const width = Math.max(1, this.terminal.columns);
-		const lines = [color.border("─".repeat(width))];
+		const lines = [color.border(` ${"─".repeat(Math.max(0, width - 2))} `)];
 		for (const item of items) {
 			const prefix = item.notice === true ? `${color.textDim("⏳")} ` : `${color.accent("❯")} `;
 			const truncated = truncateToWidth(item.text.replace(/\s+/g, " ").trim(), Math.max(1, width - visibleWidth(prefix)), "…");
@@ -15341,45 +16006,37 @@ var TuiApp = class TuiApp {
 		};
 	}
 	/**
-	* Rebuild the persistent dock strip above the todo panel: todo summary and
-	* background tasks — one truncated line each, only while non-empty (kimi
-	* chrome parity). The dock is the "at a glance" surface under the
-	* transcript; the full todo list stays on Ctrl+T. The goal badge lives in
-	* the FOOTER ONLY (its one home — the dock previously duplicated it above
-	* the editor), and the permission preset badges in the footer only too, so
-	* every fact has exactly one home.
+	* Rebuild the persistent dock strip above the todo panel: the todo summary
+	* as a single dim info line, only while non-empty. No border rule — a full
+	* ─ line here visually collides with the editor's own full-width border
+	* (user feedback); the summary reads as an info line, and only the
+	* EXPANDED todo panel (Ctrl+T) carries a panel border. Background-task and
+	* subagent details live in the footer badge and the ↓/Ctrl+J browser ONLY
+	* — every fact has exactly one home.
 	*/
 	renderDock() {
-		const lines = [];
-		if (this.todoItems.length > 0) {
-			const active = this.todoItems.filter((todo) => todo.status !== "completed");
-			const done = this.todoItems.length - active.length;
-			const first = active[0];
-			const label = first === void 0 ? "" : first.content.length > 40 ? `${first.content.slice(0, 40)}…` : first.content;
-			const summary = [
-				done > 0 ? `${done} done` : "",
-				active.length > 0 ? `${active.length} active` : "",
-				label
-			].filter((part) => part !== "").join(" · ");
-			lines.push(color.textDim(`☑  ${summary}`));
-		}
-		if (this.dockTasks.length > 0) {
-			const shown = this.dockTasks.slice(0, 3);
-			for (const task of shown) {
-				const label = task.label.length > 40 ? `${task.label.slice(0, 40)}…` : task.label;
-				lines.push(color.textDim(`⏳  ${task.id} · ${label}`));
-			}
-			if (this.dockTasks.length > 3) lines.push(color.textDim(`   … ${this.dockTasks.length - 3} more`));
-		}
-		if (this.dockAgents.length > 0) {
-			const shown = this.dockAgents.slice(0, 3);
-			for (const agent of shown) {
-				const label = agent.label.length > 40 ? `${agent.label.slice(0, 40)}…` : agent.label;
-				lines.push(color.textDim(`🤖  ${agent.id} · ${label}`));
-			}
-			if (this.dockAgents.length > 3) lines.push(color.textDim(`   … ${this.dockAgents.length - 3} more`));
-		}
-		this.dock.setText(lines.join("\n"));
+		if (this.todoPanelVisible || this.todoItems.length === 0) {
+			this.dock.setText("");
+			this.requestRender();
+			return;
+		}
+		const active = this.todoItems.filter((todo) => todo.status !== "completed");
+		const done = this.todoItems.length - active.length;
+		const first = active[0];
+		const label = first === void 0 ? "" : first.content.length > 40 ? `${first.content.slice(0, 40)}…` : first.content;
+		const summary = [
+			done > 0 ? `${done} todo done` : "",
+			active.length > 0 ? `${active.length} active` : "",
+			label
+		].filter((part) => part !== "").join(" · ");
+		this.dock.setText(color.textDim(`☑  ${summary}`));
+		this.requestRender();
+	}
+	/** Rebuild the goal line: `goal ● <objective>` while a goal is set, hidden
+	* otherwise (display-only — no verbs yet). */
+	renderGoalLine() {
+		const goal = this.status.goal;
+		this.goalLine.setText(goal === void 0 || goal === "" ? "" : color.primary(goal));
 		this.requestRender();
 	}
 	/** Footer density presets: full keeps the stats line, compact drops it. */
@@ -15404,7 +16061,6 @@ var TuiApp = class TuiApp {
 		const line1 = [
 			permissionBadge,
 			this.planMode ? color.warning("[plan]") : "",
-			this.status.goal === void 0 || this.status.goal === "" ? "" : color.primary(this.status.goal),
 			this.status.model === "" ? "" : `[${this.status.model}]`,
 			taskBadge,
 			this.status.cwd,
@@ -15463,23 +16119,67 @@ var TuiApp = class TuiApp {
 		};
 	}
 	/**
-	* Open the settings overlay as a SettingsList. The runner supplies the
-	* items and reacts to changes/cancellation. Returns a CLOSER so an
-	* action-style list (e.g. /subagents' View transcript / Interrupt) can
-	* dismiss itself after the action — without it the list stays mounted as
-	* a ghost overlay that eats every later key (the /subagents trap).
-	* @param items - setting rows.
-	* @param onChange - called with (id, newValue) on confirm.
-	* @param onCancel - called when the user closes without applying.
-	* @returns a function that closes the overlay.
+	* Open the task browser overlay (the ↓ / Ctrl+J trigger with an empty
+	* editor, and /tasks). Unlike the generic {@link openPicker}, rows carry a
+	* status word + start timestamp so the panel can render status dots,
+	* right-aligned status/elapsed columns, live counts, and a 1s elapsed
+	* tick. Selection calls `onSelect` with the row value and closes; Esc
+	* calls `onCancel`.
+	* @param items - task rows (see TaskPanelItem).
+	* @param onSelect - confirmed row value.
+	* @param onCancel - dismissed without a choice.
+	* @param options - header/search/sizing configuration.
+	* @returns a handle to close the browser or replace its rows (e.g. when
+	* jobs change while it is open).
 	*/
-	openSettings(items, onChange, onCancel) {
-		let handle;
-		const settings = new SettingsList(items, 6, settingsListTheme(), onChange, () => {
-			handle?.hide();
-			onCancel();
-		}, { enableSearch: true });
-		handle = this.showOverlayOnHost(new Frame(settings), {
+	openTaskBrowser(items, onSelect, onCancel, options = {}) {
+		const panel = new TaskBrowserPanel(items.map((item) => ({ ...item })), options.maxVisible ?? 10, {
+			header: options.header,
+			noMatchText: options.noMatchText,
+			enableSearch: options.enableSearch,
+			initialQuery: options.initialQuery
+		}, (value) => {
+			close();
+			onSelect(value);
+		}, () => {
+			close();
+			onCancel();
+		}, () => this.requestRender());
+		const handle = this.showOverlayOnHost(new Frame(panel), {
+			width: options.width ?? 72,
+			maxHeight: options.maxHeight ?? 24
+		});
+		let close = () => {};
+		close = () => {
+			panel.dispose();
+			handle.hide();
+		};
+		return {
+			close,
+			setItems: (next) => {
+				panel.setItems(next.map((item) => ({ ...item })));
+				this.requestRender();
+			}
+		};
+	}
+	/**
+	* Open the settings overlay as a SettingsList. The runner supplies the
+	* items and reacts to changes/cancellation. Returns a CLOSER so an
+	* action-style list (e.g. /subagents' View transcript / Interrupt) can
+	* dismiss itself after the action — without it the list stays mounted as
+	* a ghost overlay that eats every later key (the /subagents trap).
+	* @param items - setting rows.
+	* @param onChange - called with (id, newValue) on confirm.
+	* @param onCancel - called when the user closes without applying.
+	* @returns a function that closes the overlay.
+	*/
+	openSettings(items, onChange, onCancel) {
+		let handle;
+		const settings = new SettingsList(items, 6, settingsListTheme(), onChange, () => {
+			handle?.hide();
+			onCancel();
+		}, { enableSearch: true });
+		handle = this.showOverlayOnHost(new Frame(settings), {
 			width: 72,
 			maxHeight: 28
 		});
@@ -15542,6 +16242,7 @@ var TuiApp = class TuiApp {
 		this.renderFooter();
 		this.renderDock();
 		this.renderTodoPanel();
+		this.renderGoalLine();
 		this.renderQueuePane();
 		this.working.refresh();
 		this.editor.invalidate();
@@ -15951,14 +16652,6 @@ function taskRowLabel(row) {
 function rowGroup(row) {
 	return row.kind === "job" ? JOB_GROUP : SUBAGENT_GROUP;
 }
-/** The picker description line for a row. */
-function describeTaskRow(row, now) {
-	if (row.kind === "job") {
-		const elapsed = Math.max(0, Math.floor((now - row.startedAt) / 1e3));
-		return `${row.status}${row.detail === void 0 ? "" : ` — ${row.detail}`} · ${elapsed}s`;
-	}
-	return `${row.activity}${row.hasChildren ? " · has children" : ""}`;
-}
 //#endregion
 //#region src/model-menu.ts
 /**
@@ -16240,6 +16933,262 @@ async function loadSessionTitles(query, persistence, ids, signal) {
 	return titles;
 }
 //#endregion
+//#region src/skill-catalog.ts
+/**
+* The standing-scope skill catalog adapter: the SINGLE narrow seam between
+* the TUI and the dsh skill services (the non-public-API isolation
+* contract, plan appendix B).
+*
+* Everything the TUI knows about dsh-skill and agent-presets lives here:
+* - structural service types (never upstream classes) with OPTIONAL
+*   capability members — `snapshot` and `standingKeyFor` are detected at
+*   call time, so an upstream change degrades instead of breaking;
+* - `readHumanSkillCatalog()`: snapshot-first collector (list() fallback),
+*   official `isUserInvocable` filter, field validation, stable sort,
+*   deep freeze, distinct abort propagation;
+* - `resolveColdSkillTarget()`: capability-gated cold target selection
+*   (standing scope → rosterless global → degraded global with a notice);
+* - `resolveLiveSkillTarget()`: the agent's own registry + agent scope.
+*
+* Failure contract: ordinary provider/composition failures surface as
+* degraded targets or rethrown errors for the coordinator to classify;
+* aborts ALWAYS propagate as aborts. No failure may hang or crash the TUI —
+* the worst outcome is "the corresponding commands are missing".
+* @module @xmoon76/dsh-pi-tui/skill-catalog
+*/
+/**
+* Subscribe to the dsh-skill invalidation notification. The event carries
+* no scope or cwd — consumers refetch for their own cwd and scope — and the
+* subscription itself is optional: an unavailable `on` or a throwing
+* subscribe degrades to NO subscription (owner switches and `/reload` still
+* refresh). The CALLER owns the listener's failure totality (route the
+* refresh through `runOwned`).
+* @param ctx - the context surface exposing the event bus.
+* @param listener - the notification listener (must be synchronous and
+*   never throw).
+*/
+function subscribeSkillsChange(ctx, listener) {
+	ctx.on?.("skills/change", listener);
+}
+/**
+* Whether one summary passes the OFFICIAL user-invocation policy — the
+* adapter's exported guard, used by every human entry point (direct
+* wrappers, `/skill`, the picker, and final body loads). A malformed
+* `invocation` (missing, non-object, non-boolean flag) is treated as NOT
+* user-invocable: the policy defaults are never reinterpreted, and a
+* hostile entry can neither throw nor sneak into a human surface.
+*/
+function isUserInvocableSkill(skill) {
+	const invocation = skill.invocation;
+	if (typeof invocation !== "object" || invocation === null) return false;
+	if (typeof invocation.userInvocable !== "boolean") return false;
+	return isUserInvocable(skill);
+}
+/** Copy one summary, keeping ONLY the supported display fields. An entry
+* with a non-string name or description is rejected (never copied, never
+* trusted); a non-string `whenToUse` is dropped. */
+function toHumanSummary(skill) {
+	if (typeof skill.name !== "string" || skill.name === "") return void 0;
+	if (typeof skill.description !== "string") return void 0;
+	return Object.freeze({
+		name: skill.name,
+		description: skill.description,
+		...typeof skill.whenToUse === "string" && skill.whenToUse !== "" ? { whenToUse: skill.whenToUse } : {}
+	});
+}
+/** Whether one summary passes the OFFICIAL user-invocation policy. A
+* malformed `invocation` (missing, non-object, non-boolean flag) is treated
+* as NOT user-invocable — the policy defaults are never reinterpreted, and
+* a hostile entry can neither throw nor sneak into the human catalog. */
+function userInvocable(skill) {
+	return isUserInvocableSkill(skill);
+}
+/**
+* Read one human skill catalog from a registry: snapshot-first, official
+* policy filter, validated detached copies, stable name sort, deep freeze.
+* @param registry - the registry to read (the adapter's structural type).
+* @param options - cwd/scope/signal for the read.
+* @returns the detached catalog.
+* @throws on cancellation (ALWAYS, distinctly) and on non-abort read
+*   failures (the coordinator classifies them: retain last-good + diag).
+*/
+async function readHumanSkillCatalog(registry, options) {
+	options.signal?.throwIfAborted();
+	const observed = typeof registry.snapshot === "function" ? await registry.snapshot(options) : {
+		skills: await registry.list?.(options) ?? [],
+		complete: true
+	};
+	options.signal?.throwIfAborted();
+	const skills = observed.skills.filter(userInvocable).map(toHumanSummary).filter((summary) => summary !== void 0).sort((left, right) => left.name < right.name ? -1 : 1);
+	return Object.freeze({
+		skills: Object.freeze(skills),
+		complete: observed.complete === true
+	});
+}
+/**
+* Resolve the COLD (sessionless) skill target with capability detection:
+* - a preset roster with `standingKeyFor` → the standing scope of the
+*   effective preset;
+* - no roster / no `standingKeyFor` / a standing resolution failure → the
+*   global layer (with a one-shot degradation notice on failure);
+* - no skill registry at all → no target (nothing to read, no notice).
+* @param ctx - the context surface.
+* @param presetId - the effective preset id, or undefined for the default.
+* @param cwd - the workspace cwd for provider selection.
+*/
+async function resolveColdSkillTarget(ctx, presetId, cwd) {
+	const registry = ctx.get("skills");
+	if (registry === void 0) return {};
+	const presets = ctx.get("agentPresets");
+	if (presets === void 0 || typeof presets.standingKeyFor !== "function") return { target: {
+		kind: "cold-global",
+		registry,
+		cwd,
+		scope: void 0
+	} };
+	try {
+		return { target: {
+			kind: "cold-standing",
+			registry,
+			cwd,
+			scope: await presets.standingKeyFor(presetId)
+		} };
+	} catch (error) {
+		const message = safeErrorMessage(error);
+		return {
+			target: {
+				kind: "cold-global",
+				registry,
+				cwd,
+				scope: void 0
+			},
+			degraded: `skill catalog unavailable for preset "${presetId ?? "default"}": ${message}`
+		};
+	}
+}
+/**
+* Resolve the LIVE skill target: the registry the agent actually sees
+* (its preset's scoped instance when the preset mounts one, else the host
+* registry), with the AGENT OBJECT as the view scope.
+* @param ctx - the context surface.
+* @param agent - the live agent.
+* @param cwd - the session workspace cwd.
+* @returns the live target, or undefined when no registry is reachable.
+*/
+function resolveLiveSkillTarget(ctx, agent, cwd) {
+	const registry = ctx.get("agentPresets")?.serviceFor?.(agent, "skills") ?? ctx.get("skills");
+	if (registry === void 0) return void 0;
+	return {
+		kind: "live",
+		registry,
+		cwd,
+		scope: agent
+	};
+}
+//#endregion
+//#region src/surface-catalog.ts
+/**
+* The in-process global-layer command view. The public type requires an
+* `Agent`, but `commands.list(undefined)` resolves the global layer only
+* (ScopedLayers merges no overlays for an undefined key); the current TUI
+* already depends on this in-process behavior. The cast is isolated HERE so
+* the undefined key never reaches a remote RPC path, and the helper is the
+* single seam to replace if upstream ever ships a typed global-list API.
+* @param commands - the commands service.
+* @returns the global-layer descriptors (name-sorted by the registry).
+*/
+function listGlobalCommands(commands) {
+	return commands.list(void 0);
+}
+/** Copy one descriptor into a fresh frozen summary (never borrowed). */
+function commandSummaryOf(descriptor) {
+	return Object.freeze({
+		name: descriptor.name,
+		description: descriptor.description,
+		...descriptor.input === void 0 ? {} : { input: Object.freeze({ hint: descriptor.input.hint }) }
+	});
+}
+/** Whether two descriptors expose identical display fields (origin-blind:
+* an identical scoped entry needs no override because the visible result and
+* the real-agent execution are the same either way). */
+function sameCommand(left, right) {
+	return left.name === right.name && left.description === right.description && left.input?.hint === right.input?.hint;
+}
+/**
+* Read one agent's effective surface catalog: global + scoped commands and
+* human-invocable skills, fully detached and frozen.
+*
+* Provider isolation (per the probe contract):
+* - lifecycle/refresh cancellation terminates the WHOLE read and propagates;
+* - an ordinary provider failure empties only that field and records a
+*   detached issue; other providers continue;
+* - a missing service is that provider's successful empty result (no issue).
+*
+* This function only READS: it registers nothing, mutates nothing, and never
+* touches a runner's live agent. Probe and live agent share this collector
+* so the two surfaces cannot drift apart.
+* @param agent - the agent whose effective view to read.
+* @param signal - lifecycle/refresh cancellation.
+* @param ctx - the context surface resolving the services.
+* @returns a frozen, detached snapshot.
+*/
+async function readSurfaceCatalog(agent, signal, ctx) {
+	signal.throwIfAborted();
+	const issues = [];
+	let commands = [];
+	let scopedCommands = [];
+	const commandsService = ctx.get("commands");
+	if (commandsService !== void 0) try {
+		const global = listGlobalCommands(commandsService);
+		const globalBy = new Map(global.map((descriptor) => [descriptor.name, descriptor]));
+		const effective = commandsService.list(agent);
+		const scoped = [];
+		for (const descriptor of effective) {
+			const summary = commandSummaryOf(descriptor);
+			const baseline = globalBy.get(descriptor.name);
+			if (baseline === void 0 || !sameCommand(descriptor, baseline)) scoped.push(summary);
+		}
+		commands = sortCommands(effective.map(commandSummaryOf));
+		scopedCommands = sortCommands(scoped);
+	} catch (error) {
+		issues.push({
+			provider: "commands",
+			message: safeErrorMessage(error)
+		});
+	}
+	let skills = [];
+	const skillTarget = resolveLiveSkillTarget(ctx, agent, agent.session.header.cwd ?? process.cwd());
+	if (skillTarget !== void 0) try {
+		signal.throwIfAborted();
+		const catalog = await readHumanSkillCatalog(skillTarget.registry, {
+			cwd: skillTarget.cwd,
+			scope: skillTarget.scope,
+			signal
+		});
+		skills = catalog.skills;
+		if (catalog.complete !== true) issues.push({
+			provider: "skills",
+			message: "incomplete skill observation"
+		});
+	} catch (error) {
+		if (signal.aborted) throw error;
+		issues.push({
+			provider: "skills",
+			message: safeErrorMessage(error)
+		});
+	}
+	return Object.freeze({
+		commands,
+		scopedCommands,
+		skills,
+		issues: Object.freeze(issues.map((issue) => Object.freeze({ ...issue })))
+	});
+}
+/** Name-stable sort for command summaries (copies, never mutates input). */
+function sortCommands(commands) {
+	return Object.freeze([...commands].sort((left, right) => left.name < right.name ? -1 : 1));
+}
+//#endregion
 //#region src/commands.ts
 /**
 * The TUI-owned slash commands (/exit /settings /sessions /skill /model
@@ -16311,17 +17260,71 @@ function presetDisplayText(preset) {
 		...preset.description === void 0 ? {} : { description: preset.description }
 	};
 }
+/** The credential-target options for /login and /logout: the deepseek
+* official ref always first, then every llm-pi-ai provider route's
+* apiKeyEnv (deduped by ref). `providers` is the llm-pi-ai settings
+* section's `providers` dict, or undefined when the adapter or the settings
+* service is absent — which degrades /login to the official target only.
+*/
+function credentialOptionsFor(providers) {
+	const options = [{
+		label: "deepseek official",
+		ref: "DEEPSEEK_API_KEY"
+	}];
+	if (providers === void 0) return options;
+	const seen = new Set(options.map((option) => option.ref));
+	for (const [route, profile] of Object.entries(providers)) {
+		const ref = profile?.apiKeyEnv;
+		if (ref === void 0 || ref === "" || seen.has(ref)) continue;
+		seen.add(ref);
+		options.push({
+			label: route,
+			ref
+		});
+	}
+	return options;
+}
+/** Resolve a /login or /logout argument to a credential ref. A
+* case-insensitive llm-pi-ai route name wins, then a literal env-var-looking
+* name (any casing, uppercased like the old behavior — `/login my_key` sets
+* `MY_KEY`); anything else is unknown and returns undefined so the caller
+* can list the valid options.
+*/
+function resolveCredentialArg(arg, options) {
+	const trimmed = arg.trim();
+	if (trimmed === "") return void 0;
+	const needle = trimmed.toLowerCase();
+	const route = options.find((option) => option.label.toLowerCase() === needle || option.label.split(" ")[0].toLowerCase() === needle);
+	if (route !== void 0) return route.ref;
+	if (/^[a-zA-Z][a-zA-Z0-9_]*$/.test(trimmed)) return trimmed.toUpperCase();
+}
+/** Read the llm-pi-ai adapter's `providers` dict from its settings section,
+* or undefined when the settings service or the section is absent. */
+function readLlmpiAiProviders(ctx) {
+	const settings = ctx.get("settings");
+	if (settings === void 0) return void 0;
+	try {
+		return settings.get(settingsNamespace("llm-pi-ai"))?.providers;
+	} catch {
+		return;
+	}
+}
 /**
 * Register the TUI-owned slash commands on the commands service. The
 * completion list is refreshed after every registration so TUI-owned
 * commands appear in the editor's tab list. Registration is sessionless:
 * the commands service's global layer needs no agent, so the whole surface
 * is available before the first session exists (deferred start).
+*
+* When an `initial` catalog was prefetched (resume snapshot or cold
+* standing-scope skills), it installs SYNCHRONOUSLY at the end of
+* registration — direct skill wrappers plus the completion merge — so the
+* first input is served by the complete catalog with zero async I/O in
+* between.
 * @param runner - the live runner surface.
-* @returns a hook that rebuilds the per-skill slash commands (a no-op until
-*   the first session exists, since the skill catalog scope is the agent).
+* @param initial - optional prefetched catalogs installed synchronously.
 */
-function registerTuiCommands(runner) {
+function registerTuiCommands(runner, initial) {
 	const { ctx, app } = runner;
 	const cwd = runner.cwd;
 	const signal = runner.signal;
@@ -16365,12 +17368,60 @@ function registerTuiCommands(runner) {
 		if (agent === void 0) throw new Error("session could not be created");
 		return agent;
 	};
-	const refreshCompletions = () => {
-		app.setCommandCompletions(commands.list(runner.liveAgent).map((command) => ({
+	/** The advertised names of the currently installed completion list. */
+	let claims = /* @__PURE__ */ new Set();
+	/**
+	* Install one completion list (sorted, claims refreshed). The single
+	* synchronous seam every catalog commit funnels through.
+	*/
+	const installCompletions = (entries) => {
+		const sorted = [...entries].sort((left, right) => left.name < right.name ? -1 : 1);
+		app.setCommandCompletions(sorted.map((command) => ({
 			name: command.name,
 			description: command.description,
 			argumentHint: command.input?.hint
 		})), runner.sessionCwd(), fdPath);
+		claims = new Set(sorted.map((command) => command.name));
+	};
+	/** The saved probed scoped overrides (see installSurfaceSnapshot). */
+	let savedScopedCommands = [];
+	/**
+	* The sessionless completion view: the CURRENT global layer (fresh read —
+	* TUI built-ins, global plugins and installed skill wrappers all flow in)
+	* overlaid with the saved scoped overrides from the latest snapshot.
+	*/
+	const mergeGlobalAndSavedScoped = () => {
+		const byName = /* @__PURE__ */ new Map();
+		for (const descriptor of listGlobalCommands(commands)) byName.set(descriptor.name, commandSummaryOf(descriptor));
+		for (const scoped of savedScopedCommands) byName.set(scoped.name, scoped);
+		return [...byName.values()];
+	};
+	/**
+	* Refresh completions from the registry: the LIVE agent's effective view
+	* when one exists (global + its scoped shadows), else the global layer
+	* overlaid with the saved scoped overrides (sessionless merge). The agent
+	* may be undefined before the first session exists: in-process
+	* `commands.list(undefined)` safely returns the global layer only (the
+	* remote RPC path's lookup guard does not apply in-process).
+	*/
+	const refreshCompletions = () => {
+		const liveAgent = runner.liveAgent;
+		installCompletions(liveAgent === void 0 ? mergeGlobalAndSavedScoped() : commands.list(liveAgent).map(commandSummaryOf));
+	};
+	let commandCommitDepth = 0;
+	let commandCommitDirty = false;
+	/** Run one bulk command commit; registry changes inside are coalesced. */
+	const withCommandCommit = (phase) => {
+		commandCommitDepth += 1;
+		try {
+			phase();
+		} finally {
+			commandCommitDepth -= 1;
+			if (commandCommitDepth === 0 && commandCommitDirty) {
+				commandCommitDirty = false;
+				refreshCompletions();
+			}
+		}
 	};
 	refreshCompletions();
 	const exitHandler = () => {
@@ -16633,29 +17684,44 @@ function registerTuiCommands(runner) {
 			return openSessionPicker(invocation, "resume");
 		}
 	});
-	const skillService = (agent) => {
-		return ctx.get("agentPresets")?.serviceFor(agent, "skills") ?? ctx.get("skills");
-	};
 	/** The workspace the live session runs in; fallback to the TUI's cwd. */
 	const sessionCwd = (agent) => agent.session.header.cwd ?? cwd;
+	const skillTarget = (agent) => resolveLiveSkillTarget(ctx, agent, sessionCwd(agent));
+	/**
+	* The execution boundary for loading one skill into the live session;
+	* shared by /skill and the per-skill slash commands. The skill is fetched
+	* from the CURRENT agent's registry and its invocation policy is RE-CHECKED
+	* here — a summary that passed the cold/live filter is never execution
+	* authorization. A model-only skill is refused with an explicit error and
+	* never injected.
+	*/
 	const loadSkill = async (agent, name) => {
-		const skills = skillService(agent);
-		if (skills === void 0) return {
+		const target = skillTarget(agent);
+		if (target === void 0) return {
 			kind: "error",
 			text: "skill service unavailable"
 		};
-		const skill = await skills.get(name, {
-			cwd: sessionCwd(agent),
-			scope: agent
+		const skill = await target.registry.get?.(name, {
+			cwd: target.cwd,
+			scope: target.scope
 		});
 		if (skill === void 0) return {
 			kind: "error",
 			text: "unknown skill \"" + name + "\""
 		};
+		if (!isUserInvocableSkill(skill)) return {
+			kind: "error",
+			text: `skill "${name}" is not invocable by the user`
+		};
+		if (typeof skill.name !== "string" || skill.name === "" || typeof skill.description !== "string") return {
+			kind: "error",
+			text: `skill "${name}" returned a malformed definition`
+		};
+		const body = typeof skill.content === "string" && skill.content !== "" ? skill.content : skill.description;
 		agent.inject(createUserMessage({
 			content: [{
 				type: "text",
-				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + (skill.content ?? skill.description)
+				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + body
 			}],
 			source: {
 				kind: "plugin",
@@ -16668,21 +17734,30 @@ function registerTuiCommands(runner) {
 		};
 	};
 	const skillDisposers = /* @__PURE__ */ new Map();
-	const registerSkillCommands = async () => {
-		const generation = runner.sessionGeneration;
+	/**
+	* Synchronously replace every direct skill wrapper from a snapshot. Pure
+	* install: no catalog fetch, no await — the callers (the initial snapshot
+	* commit, the live refresh, the coordinator) provide the data. The target
+	* set is computed FIRST (current global/effective view minus the wrappers
+	* this surface owns, plus the snapshot's scoped overrides), then the old
+	* wrappers are disposed and the new ones registered in one synchronous
+	* commit.
+	* @param skills - the human-invocable summaries to install.
+	* @param scopedNames - the snapshot's scoped command names: a preset-scoped
+	*   command must block a same-name wrapper even though the global view
+	*   cannot see it yet (sessionless install).
+	* @returns the number of wrappers installed.
+	*/
+	const replaceSkillCommands = (skills, scopedNames) => {
+		const owned = new Set(skillDisposers.keys());
+		const taken = /* @__PURE__ */ new Set();
+		const view = commands.list(runner.liveAgent);
+		for (const command of view) if (!owned.has(command.name)) taken.add(command.name);
+		for (const name of scopedNames) taken.add(name);
 		for (const dispose of skillDisposers.values()) dispose();
 		skillDisposers.clear();
-		const liveAgent = runner.liveAgent;
-		if (liveAgent === void 0) return 0;
-		const skills = skillService(liveAgent);
-		if (skills === void 0) return 0;
-		const taken = new Set(commands.list(liveAgent).map((command) => command.name));
-		const catalog = await skills.list({
-			cwd: sessionCwd(liveAgent),
-			scope: liveAgent
-		});
-		if (generation !== runner.sessionGeneration) return 0;
-		for (const skill of catalog) {
+		let count = 0;
+		for (const skill of skills) {
 			if (taken.has(skill.name)) continue;
 			try {
 				const dispose = commands.register({
@@ -16694,34 +17769,83 @@ function registerTuiCommands(runner) {
 					}
 				});
 				skillDisposers.set(skill.name, dispose);
+				count += 1;
 			} catch {}
 		}
-		refreshCompletions();
-		return catalog.length;
+		return count;
+	};
+	/**
+	* Install one whole snapshot on the surface in ONE synchronous commit:
+	* replace the direct skill wrappers, save the scoped overrides, and merge
+	* the completions (fresh global view + saved overrides). No await between
+	* the pieces, so a first input can never observe a half-installed catalog.
+	* A FAILED skills provider keeps the current wrappers (transitions or the
+	* previous catalog): they re-validate against the current agent at
+	* execution time, so a submitted skill name can never fall through to a
+	* plain model message while the catalog is unavailable.
+	*/
+	const installSurfaceSnapshot = (snapshot) => {
+		const scopedNames = new Set(snapshot.scopedCommands.map((command) => command.name));
+		const skillsFailed = snapshot.issues.some((issue) => issue.provider === "skills");
+		withCommandCommit(() => {
+			if (!skillsFailed) replaceSkillCommands(snapshot.skills, scopedNames);
+			savedScopedCommands = snapshot.scopedCommands;
+			installCompletions(mergeGlobalAndSavedScoped());
+		});
+	};
+	/**
+	* The revalidating transition (target/owner change): scoped previews clear
+	* so new inputs complete against the current global view only, and every
+	* old skill wrapper becomes a revalidating transition command whose
+	* handler re-fetches from the CURRENT live agent and re-checks the policy
+	* at execution time. The names survive so an already-submitted skill
+	* command can never become a plain model message mid-switch.
+	*/
+	const enterCatalogTransition = () => {
+		const names = [...skillDisposers.keys()];
+		withCommandCommit(() => {
+			for (const dispose of skillDisposers.values()) dispose();
+			skillDisposers.clear();
+			savedScopedCommands = [];
+			for (const name of names) try {
+				const dispose = commands.register({
+					name,
+					description: `[skill: revalidating] ${name}`,
+					handler: async () => {
+						const agent = await requireAgent();
+						return loadSkill(agent, name);
+					}
+				});
+				skillDisposers.set(name, dispose);
+			} catch {}
+			installCompletions(mergeGlobalAndSavedScoped());
+		});
 	};
-	detach("skill catalog refresh", () => registerSkillCommands());
+	/** Whether one command name is advertised by the CURRENT completion list
+	* (the claim captured at submit time, before any session creation). */
+	const wasAdvertised = (name) => claims.has(name);
 	commands.register({
 		name: "skill",
 		description: "Load a skill into the session context",
 		input: { hint: "<name>" },
 		handler: async (invocation) => {
 			const liveAgent = await requireAgent();
-			const skills = skillService(liveAgent);
-			if (skills === void 0) return {
+			const target = skillTarget(liveAgent);
+			if (target === void 0) return {
 				kind: "error",
 				text: "skill service unavailable"
 			};
 			const name = invocation.rawInput.trim();
 			if (name !== "") return loadSkill(liveAgent, name);
-			const catalog = await skills.list({
-				cwd: sessionCwd(liveAgent),
-				scope: liveAgent
+			const catalog = await readHumanSkillCatalog(target.registry, {
+				cwd: target.cwd,
+				scope: target.scope
 			});
-			if (catalog.length === 0) return {
+			if (catalog.skills.length === 0) return {
 				kind: "error",
 				text: "no skills available"
 			};
-			app.openSettings(catalog.map((skill) => ({
+			app.openSettings(catalog.skills.map((skill) => ({
 				id: skill.name,
 				label: skill.name,
 				description: skill.description,
@@ -16737,12 +17861,38 @@ function registerTuiCommands(runner) {
 	});
 	commands.register({
 		name: "reload",
-		description: "Reload TUI settings and refresh skill commands",
+		description: "Reload TUI settings and refresh the live command/skill catalog",
 		handler: async () => {
-			let skillCount = 0;
-			try {
-				skillCount = await registerSkillCommands();
-			} catch {}
+			let catalogText = "";
+			const liveAgent = runner.liveAgent;
+			if (liveAgent !== void 0) {
+				const outcome = await runner.refreshCatalog({
+					source: "reload",
+					target: {
+						kind: "agent",
+						key: runner.sessionGeneration
+					},
+					agent: liveAgent
+				});
+				if (outcome.kind === "applied") {
+					catalogText = `${outcome.snapshot.commands.length} commands \u00b7 ${outcome.snapshot.skills.length} skills`;
+					if (outcome.snapshot.issues.length > 0) catalogText += ` \u00b7 partial: ${outcome.snapshot.issues.map((issue) => issue.provider).join(", ")} unavailable`;
+				} else if (outcome.kind === "failed") catalogText = `catalog refresh failed: ${outcome.error}`;
+				else catalogText = "catalog refresh superseded";
+			} else {
+				const outcome = await runner.refreshCatalog({
+					source: "reload",
+					target: {
+						kind: "preset",
+						presetId: runner.effectivePresetId
+					}
+				});
+				if (outcome.kind === "applied") {
+					catalogText = `${outcome.snapshot.skills.length} human skills`;
+					if (outcome.notice !== void 0) catalogText += ` \u00b7 ${outcome.notice}`;
+				} else if (outcome.kind === "failed") catalogText = `catalog refresh failed: ${outcome.error}`;
+				else catalogText = "catalog refresh superseded";
+			}
 			const settings = runner.tuiSettings;
 			if (settings !== void 0) {
 				const doc = settings.get();
@@ -16761,7 +17911,7 @@ function registerTuiCommands(runner) {
 				app.setFooterPreset(doc.footer === "compact" ? "compact" : "full");
 				app.setFullscreen(doc.fullscreen === "on");
 			}
-			app.notify(`reloaded — ${skillCount} skills \u00b7 settings reapplied`, "info");
+			app.notify(`reloaded — ${catalogText} \u00b7 settings reapplied`, "info");
 			return { kind: "success" };
 		}
 	});
@@ -16953,12 +18103,17 @@ function registerTuiCommands(runner) {
 				kind: "error",
 				text: "no background jobs"
 			};
-			const now = Date.now();
-			app.openPicker(snapshots.map((job) => ({
+			app.openTaskBrowser(snapshots.map((job) => ({
 				value: job.id,
 				label: `${job.kind} · ${job.label}`,
-				description: `${job.status}${job.detail === void 0 ? "" : ` — ${job.detail}`} · ${Math.max(0, Math.floor((now - job.startedAt) / 1e3))}s`
-			})), (jobId) => runner.openJobView(jobId), () => {});
+				status: job.status,
+				detail: job.detail,
+				startedAt: job.startedAt,
+				group: "jobs"
+			})), (jobId) => runner.openJobView(jobId), () => {}, {
+				header: "tasks",
+				enableSearch: true
+			});
 			return { kind: "success" };
 		}
 	});
@@ -17012,11 +18167,28 @@ function registerTuiCommands(runner) {
 					kind: "success",
 					text: `default preset: ${settings.get(ns)?.default ?? presets.defaultId}`
 				};
-				await settings.mutate(ns, [{
-					op: "set",
-					path: ["default"],
-					value: rest
-				}]);
+				try {
+					await settings.mutate(ns, [{
+						op: "set",
+						path: ["default"],
+						value: rest
+					}]);
+				} catch (error) {
+					return {
+						kind: "error",
+						text: safeErrorMessage(error)
+					};
+				}
+				if (runner.effectivePresetId === void 0) {
+					const outcome = await runner.refreshCatalog({
+						source: "preset",
+						target: {
+							kind: "preset",
+							presetId: rest
+						}
+					});
+					if (outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
+				}
 				return {
 					kind: "success",
 					text: `default preset set: ${rest}`
@@ -17026,6 +18198,14 @@ function registerTuiCommands(runner) {
 				if (liveAgent === void 0) {
 					const resolved = await presets.resolve(id);
 					runner.pendingPreset = resolved.id;
+					const outcome = await runner.refreshCatalog({
+						source: "preset",
+						target: {
+							kind: "preset",
+							presetId: resolved.id
+						}
+					});
+					if (outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
 					return {
 						kind: "pending",
 						preset: resolved.id
@@ -17036,7 +18216,14 @@ function registerTuiCommands(runner) {
 					kind: "locked",
 					sessionId: liveAgent.session.id
 				};
-				refreshCompletions();
+				await runner.refreshCatalog({
+					source: "preset",
+					target: {
+						kind: "agent",
+						key: runner.sessionGeneration
+					},
+					agent: runner.liveAgent
+				});
 				runner.updateWelcomeCard();
 				return {
 					kind: "switched",
@@ -17109,7 +18296,11 @@ function registerTuiCommands(runner) {
 				};
 			}), (id) => {
 				close();
-				detach("preset pick", () => pickPreset(id));
+				runOwned("preset pick", () => pickPreset(id), {
+					diag: runner.diag,
+					sessionId: () => runner.liveAgent?.session.id,
+					onError: (error) => app.notify(`preset selection failed: ${safeErrorMessage(error)}`, "error")
+				});
 			}, () => {});
 			return { kind: "success" };
 		}
@@ -17403,15 +18594,37 @@ function registerTuiCommands(runner) {
 	});
 	commands.register({
 		name: "login",
-		description: "Set an API key credential for a provider (default DEEPSEEK_API_KEY)",
-		input: { hint: "[<env-var>]" },
+		description: "Set an API key — deepseek official or an llm-pi-ai provider route",
+		input: { hint: "[<route|env-var>]" },
 		handler: async (invocation) => {
 			const credentials = ctx.get("credentials");
 			if (credentials === void 0) return {
 				kind: "error",
 				text: "credentials service unavailable"
 			};
-			const ref = (invocation.rawInput.trim() || "DEEPSEEK_API_KEY").toUpperCase();
+			const options = credentialOptionsFor(readLlmpiAiProviders(ctx));
+			const arg = invocation.rawInput.trim();
+			let ref;
+			if (arg !== "") {
+				const resolved = resolveCredentialArg(arg, options);
+				if (resolved === void 0) return {
+					kind: "error",
+					text: `unknown credential target "${arg}" — ${options.map((option) => `${option.label} (${option.ref})`).join(", ")}`
+				};
+				ref = resolved;
+			} else if (options.length > 1) {
+				const picked = await new Promise((resolve) => {
+					app.openPicker(options.map((option) => ({
+						value: option.ref,
+						label: `${option.label} (${option.ref})`
+					})), (value) => resolve(value), () => resolve(void 0));
+				});
+				if (picked === void 0) return {
+					kind: "error",
+					text: "login cancelled"
+				};
+				ref = picked;
+			} else ref = options[0].ref;
 			try {
 				const key = (await app.askQuestions([{
 					id: "key",
@@ -17436,19 +18649,32 @@ function registerTuiCommands(runner) {
 	});
 	commands.register({
 		name: "logout",
-		description: "Clear a stored API key credential (default DEEPSEEK_API_KEY)",
-		input: { hint: "[<env-var>]" },
+		description: "Clear a stored API key — deepseek official or an llm-pi-ai provider route",
+		input: { hint: "[<route|env-var>]" },
 		handler: async (invocation) => {
 			const credentials = ctx.get("credentials");
 			if (credentials === void 0) return {
 				kind: "error",
 				text: "credentials service unavailable"
 			};
-			const ref = (invocation.rawInput.trim() || "DEEPSEEK_API_KEY").toUpperCase();
-			await credentials.unset(ref);
+			const options = credentialOptionsFor(readLlmpiAiProviders(ctx));
+			const arg = invocation.rawInput.trim();
+			if (arg !== "") {
+				const resolved = resolveCredentialArg(arg, options);
+				if (resolved === void 0) return {
+					kind: "error",
+					text: `unknown credential target "${arg}" — ${options.map((option) => `${option.label} (${option.ref})`).join(", ")}`
+				};
+				await credentials.unset(resolved);
+				return {
+					kind: "success",
+					text: `${resolved} cleared`
+				};
+			}
+			await credentials.unset(options[0].ref);
 			return {
 				kind: "success",
-				text: `${ref} cleared`
+				text: `${options[0].ref} cleared`
 			};
 		}
 	});
@@ -17551,8 +18777,28 @@ function registerTuiCommands(runner) {
 			return { kind: "success" };
 		}
 	});
-	refreshCompletions();
-	return { refreshSkills: () => registerSkillCommands() };
+	if (initial?.snapshot !== void 0) installSurfaceSnapshot(initial.snapshot);
+	else if (initial?.skills !== void 0) withCommandCommit(() => {
+		replaceSkillCommands(initial.skills.skills, /* @__PURE__ */ new Set());
+		savedScopedCommands = [];
+		installCompletions(mergeGlobalAndSavedScoped());
+	});
+	else refreshCompletions();
+	ctx.on("commands/change", () => {
+		if (commandCommitDepth > 0) {
+			commandCommitDirty = true;
+			return;
+		}
+		refreshCompletions();
+	});
+	return {
+		/** The claim test for the dispatch: is /name advertised right now? */
+		wasAdvertised,
+		/** One synchronous catalog commit (the coordinator's install hook). */
+		installSnapshot: (snapshot) => installSurfaceSnapshot(snapshot),
+		/** The revalidating transition (the coordinator's target-change hook). */
+		enterTransition: () => enterCatalogTransition()
+	};
 }
 //#endregion
 //#region src/diag.ts
@@ -17673,6 +18919,110 @@ function createDiag(options = {}) {
 	};
 }
 //#endregion
+//#region src/history.ts
+/**
+* Per-cwd input-history persistence — JSONL files under `$DSH_HOME/user-history/`,
+* one `{"content": "..."}` line per submitted prompt (kimi-code's
+* input-history pattern: a dedicated data file, never the settings
+* document). Append-only writes make concurrent windows in one directory
+* safe (O_APPEND lines cannot clobber each other), which whole-file settings
+* replaces could not guarantee.
+*
+* Semantics:
+* - File order is submission order (oldest first); the editor seeds
+*   oldest→newest so its recall list is newest-first.
+* - Empty submissions and consecutive repeats are skipped (shell-history
+*   behavior); non-consecutive repeats are legal history and survive.
+* - Corrupt lines are skipped on load, never fatal.
+* - The file is capped at HISTORY_LIMIT entries; the cap trims on load.
+* - `!` shell commands are stored verbatim (with the leading `!`), so ↑
+*   recall restores them as text and Enter re-runs the shell branch.
+*
+* Pure and injectable so pathing, parsing, and append rules are
+* unit-testable without touching the terminal or dsh services.
+* @module @xmoon76/dsh-pi-tui/history
+*/
+/** Directory name under `$DSH_HOME` holding the per-cwd history files. */
+const HISTORY_DIR_NAME = "user-history";
+/**
+* The history file for one working directory: `$DSH_HOME/user-history/<md5(cwd)>.jsonl`.
+* The cwd hash keeps the file list flat and free of path separators; the
+* hash is an identity, never shown to the user.
+* @param home - the dsh home directory (`$DSH_HOME`, default `~/.dsh`).
+* @param cwd - the working directory whose submissions the file records.
+*/
+function historyFilePath(home, cwd) {
+	const hash = createHash("md5").update(cwd, "utf-8").digest("hex");
+	return join(home, HISTORY_DIR_NAME, `${hash}.jsonl`);
+}
+/**
+* Parse one history file's text into entries, in file order (oldest first).
+* Blank lines and corrupt lines (unparsable JSON or a non-string `content`)
+* are skipped — a torn write or an older format must never abort recall.
+* @param text - the raw file content.
+*/
+function parseHistoryLines(text) {
+	const entries = [];
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed === "") continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (typeof parsed.content === "string" && parsed.content !== "") entries.push(parsed.content);
+		} catch {}
+	}
+	return entries;
+}
+/**
+* Load a history file, trimming it to the last HISTORY_LIMIT entries when it
+* outgrew the cap (the trim rewrites the file best-effort so it stops
+* growing). Never throws: an unreadable or absent file is empty history.
+* @param file - the JSONL history file path.
+* @returns entries in file order (oldest first).
+*/
+function loadHistoryFile(file) {
+	try {
+		if (!existsSync(file)) return [];
+		const entries = parseHistoryLines(readFileSync(file, "utf8"));
+		if (entries.length <= 100) return entries;
+		const kept = entries.slice(-100);
+		try {
+			const temp = `${file}.tmp`;
+			writeFileSync(temp, kept.map((entry) => JSON.stringify({ content: entry })).join("\n") + "\n", { mode: 384 });
+			renameSync(temp, file);
+		} catch {}
+		return kept;
+	} catch {
+		return [];
+	}
+}
+/**
+* Append one submitted line to the history file. Empty lines and a repeat of
+* `lastContent` (the newest known entry) are skipped, like shell history.
+* Multi-line submissions are stored as one JSON line (newlines escaped), so
+* the JSONL layout survives pastes.
+*
+* Throws on I/O failure (the caller decides how to surface it); the
+* skip verdicts return false without touching the file.
+* @param file - the JSONL history file path.
+* @param text - the submitted input.
+* @param lastContent - the newest entry known to the caller, or undefined.
+* @returns whether an entry was written.
+*/
+function appendHistoryLine(file, text, lastContent) {
+	const content = text.trim();
+	if (content === "" || content === lastContent) return false;
+	mkdirSync(dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	appendFileSync(file, JSON.stringify({ content }) + "\n", {
+		encoding: "utf8",
+		mode: 384
+	});
+	return true;
+}
+//#endregion
 //#region src/exit.ts
 /**
 * The TUI exit contract: flush the live session with a HARD timeout, record
@@ -18509,6 +19859,471 @@ function parseShellWords(line) {
 	return words;
 }
 //#endregion
+//#region src/skill-catalog-refresh.ts
+/** Whether two targets are the same owner (no transition needed). The
+* preset identity is the caller-provided presetId compared EXACTLY —
+* `undefined` (the deployment default) never conflates with a user preset
+* literally named `'default'`, and a resolved id never conflates with the
+* raw id it came from (the worst case is a benign extra transition). */
+function sameTarget(left, right) {
+	if (left === void 0) return false;
+	if (left.kind !== right.kind) return false;
+	return left.kind === "agent" ? left.key === right.key : left.presetId === right.presetId;
+}
+/**
+* The coordinator. One instance per runner; `dispose()` aborts the active
+* refresh on teardown.
+*/
+var CatalogRefreshCoordinator = class {
+	epoch = 0;
+	active;
+	appliedTarget;
+	snapshot;
+	hooks;
+	lifecycleSignal;
+	diag;
+	constructor(hooks, lifecycleSignal, diag) {
+		this.hooks = hooks;
+		this.lifecycleSignal = lifecycleSignal;
+		this.diag = diag;
+	}
+	/** The last applied snapshot (for same-target partial merges and the
+	* `/reload` report). */
+	get currentSnapshot() {
+		return this.snapshot;
+	}
+	/**
+	* Run one refresh request. A new request aborts the active one; only the
+	* LATEST epoch may commit. Returns the settled outcome; never rejects
+	* (failures and supersessions are outcomes, not exceptions).
+	*/
+	async refresh(request) {
+		this.active?.controller.abort();
+		const epoch = ++this.epoch;
+		const controller = new AbortController();
+		const signal = AbortSignal.any([this.lifecycleSignal, controller.signal]);
+		this.active = {
+			epoch,
+			controller
+		};
+		const targetChanged = !sameTarget(this.appliedTarget, request.target);
+		try {
+			if (targetChanged) this.hooks.enterCatalogTransition();
+			const committed = request.target.kind === "agent" ? { snapshot: await this.hooks.readAgent(request.agent, signal) } : await this.readStandingSnapshot(request.target.presetId, signal);
+			if (signal.aborted || epoch !== this.epoch) {
+				this.diag.debug("catalog refresh superseded", {
+					epoch,
+					source: request.source
+				});
+				return { kind: "superseded" };
+			}
+			const merged = targetChanged ? committed.snapshot : this.mergePartial(committed.snapshot);
+			this.hooks.installSnapshot(merged);
+			this.snapshot = merged;
+			this.appliedTarget = request.target;
+			this.diag.info("catalog applied", {
+				epoch,
+				source: request.source,
+				commands: merged.commands.length,
+				scopedCommands: merged.scopedCommands.length,
+				skills: merged.skills.length,
+				issues: merged.issues.length
+			});
+			return {
+				kind: "applied",
+				snapshot: merged,
+				...committed.notice === void 0 ? {} : { notice: committed.notice }
+			};
+		} catch (error) {
+			if (signal.aborted || epoch !== this.epoch) {
+				this.diag.debug("catalog refresh superseded", {
+					epoch,
+					source: request.source
+				});
+				return { kind: "superseded" };
+			}
+			const message = safeErrorMessage(error);
+			this.diag.warn("catalog unavailable", {
+				epoch,
+				source: request.source,
+				error: message
+			});
+			return {
+				kind: "failed",
+				error: message
+			};
+		} finally {
+			if (this.active?.epoch === epoch) this.active = void 0;
+		}
+	}
+	/** Abort the active refresh (app teardown). Late results are dropped. */
+	dispose() {
+		this.active?.controller.abort();
+	}
+	/** Same-target partial failure: a provider issue keeps the OLD field for
+	* that provider (the old snapshot is still more useful than a blank
+	* catalog); the successful providers update as usual. */
+	mergePartial(snapshot) {
+		const old = this.snapshot;
+		if (old === void 0) return snapshot;
+		const commandsFailed = snapshot.issues.some((issue) => issue.provider === "commands");
+		const skillsFailed = snapshot.issues.some((issue) => issue.provider === "skills");
+		if (!commandsFailed && !skillsFailed) return snapshot;
+		return Object.freeze({
+			commands: commandsFailed ? old.commands : snapshot.commands,
+			scopedCommands: commandsFailed ? old.scopedCommands : snapshot.scopedCommands,
+			skills: skillsFailed ? old.skills : snapshot.skills,
+			issues: snapshot.issues
+		});
+	}
+	/** One standing read wrapped into a skills-only surface snapshot: the
+	* sessionless view has no agent-scoped commands, and the global commands
+	* layer is already registered — only the skill wrappers are installed.
+	* An INCOMPLETE observation (`complete !== true`) is never an
+	* authoritative blank catalog: it carries a detached skills issue, so a
+	* same-target reload keeps the last-good skills (mergePartial) and a
+	* target change keeps the revalidating transition wrappers
+	* (installSurfaceSnapshot's skillsFailed guard). */
+	async readStandingSnapshot(presetId, signal) {
+		const read = await this.hooks.readStanding(presetId, signal);
+		const incomplete = read.catalog.complete !== true;
+		return {
+			snapshot: Object.freeze({
+				commands: Object.freeze([]),
+				scopedCommands: Object.freeze([]),
+				skills: read.catalog.skills,
+				issues: Object.freeze(incomplete ? [Object.freeze({
+					provider: "skills",
+					message: "incomplete skill observation"
+				})] : [])
+			}),
+			...read.notice === void 0 ? {} : { notice: read.notice }
+		};
+	}
+};
+/**
+* The deterministic, timer-free coalescer for invalidation notifications
+* (`skills/change`): while one refresh is in flight, further notifications
+* mark the gate DIRTY; when the in-flight refresh settles, ONE more refresh
+* runs if the gate is dirty. A burst therefore costs at most two reads, and
+* the re-run always observes the CURRENT ownership because the runner's
+* `start` callback reads live state at run time.
+*/
+var CoalescingRefreshGate = class {
+	inFlight = false;
+	dirty = false;
+	start;
+	/** @param start - invoked synchronously to START one owned refresh. Must
+	* never throw and must not itself be re-entrant (the gate owns the
+	* in-flight bookkeeping; `start` only launches the owned task). */
+	constructor(start) {
+		this.start = start;
+	}
+	/** One invalidation notification arrived. */
+	notify() {
+		if (this.inFlight) {
+			this.dirty = true;
+			return;
+		}
+		this.inFlight = true;
+		this.start();
+	}
+	/** Terminal settle of the in-flight refresh (called from EVERY terminal
+	* runOwned callback: onResult / onCancel / onError). Clears the in-flight
+	* flag; a dirty gate starts exactly one follow-up refresh. IDEMPOTENT: a
+	* second settle (e.g. onResult throws and runOwned routes to onError)
+	* must not clear the in-flight flag of a follow-up refresh it did not
+	* start. */
+	settled() {
+		if (!this.inFlight) return;
+		this.inFlight = false;
+		if (this.dirty) {
+			this.dirty = false;
+			this.notify();
+		}
+	}
+};
+//#endregion
+//#region src/session-lock.ts
+/** The lock file name, next to `session.jsonl[.zstd]` in the session directory. */
+const LOCK_FILE_NAME = "owner.lock";
+/**
+* Decide the lock repair after an INTERNAL swap failure (flush/dispose/
+* whenIdle throwing inside swapTo), given the single-slot tracker state and
+* the outgoing session id. Pure so the three-shape matrix is headless-testable:
+*
+* - tracker holds `from` itself (/new, /fork — the current lock was never
+*   pre-released): nothing to repair — `from` is still locked by us.
+* - tracker holds the TARGET (switchSession pre-released `from` and acquired
+*   the target before calling swapTo): release the target (we never entered
+*   it) and re-acquire `from` (the current session stays live).
+* - tracker is empty (switchSession's target acquire was `unavailable`):
+*   `from`'s lock was released and never re-taken — re-acquire it.
+*/
+function swapFailureLockRepair(tracker, from) {
+	if (from === void 0) return tracker === void 0 ? {
+		release: void 0,
+		reacquire: void 0
+	} : {
+		release: tracker.sessionId,
+		reacquire: void 0
+	};
+	if (tracker === void 0 || tracker.sessionId !== from) return {
+		release: tracker?.sessionId,
+		reacquire: from
+	};
+	return {
+		release: void 0,
+		reacquire: void 0
+	};
+}
+/** A tiny deterministic serializer for the lock record (single-line JSON). */
+function serializeLockInfo(info) {
+	return JSON.stringify(info);
+}
+/** Parse a lock file's content; malformed content yields undefined. */
+function parseLockInfo(content) {
+	try {
+		const parsed = JSON.parse(content);
+		if (typeof parsed.pid !== "number" || !Number.isSafeInteger(parsed.pid)) return void 0;
+		if (typeof parsed.starttime !== "number" || !Number.isSafeInteger(parsed.starttime)) return void 0;
+		if (typeof parsed.startedAt !== "number" || !Number.isSafeInteger(parsed.startedAt)) return void 0;
+		return {
+			pid: parsed.pid,
+			starttime: parsed.starttime,
+			startedAt: parsed.startedAt,
+			...typeof parsed.profile === "string" ? { profile: parsed.profile } : {},
+			...typeof parsed.tty === "string" ? { tty: parsed.tty } : {}
+		};
+	} catch {
+		return;
+	}
+}
+/** Derive the lock file path from the session artifact path. */
+function lockPathOf(artifactPath) {
+	return `${artifactPath}.${LOCK_FILE_NAME}`;
+}
+/**
+* Try to acquire the lock with an atomic create. Returns the path when this
+* process owns it, undefined when another process holds it or the create
+* cannot happen. Never throws.
+*/
+function tryCreate(fs, lockPath, self) {
+	try {
+		fs.writeFileSync(lockPath, serializeLockInfo(self), {
+			flag: "wx",
+			mode: 384
+		});
+		return { created: true };
+	} catch (error) {
+		if (error?.code === "EEXIST") return {
+			created: false,
+			reason: "exists"
+		};
+		return {
+			created: false,
+			reason: "error",
+			error
+		};
+	}
+}
+/**
+* Acquire the open-time lock for one session.
+*
+* Returns `acquired` (with an idempotent `release`), `held` (another live dsh
+* process owns it), `taken-over-stale` (a dead owner's lock was replaced),
+* `unverifiable` (the owner could not be probed — refuse), or `unavailable`
+* (this deployment cannot lock; callers should proceed as before, the guard
+* still protects the write path). Never throws.
+*/
+function acquireSessionLock(deps, session, self) {
+	const { persistence, fs, proc } = deps;
+	if (persistence === void 0) return {
+		kind: "unavailable",
+		reason: "no-persistence"
+	};
+	const artifact = persistence.locate({
+		id: session.id,
+		cwd: session.header?.cwd
+	});
+	if (artifact === void 0) return {
+		kind: "unavailable",
+		reason: "no-artifact"
+	};
+	const lockPath = lockPathOf(artifact.path);
+	let tookOver = false;
+	for (let attempt = 0;; attempt += 1) {
+		const created = tryCreate(fs, lockPath, self);
+		if (created.created) return tookOver ? {
+			kind: "taken-over-stale",
+			release: makeRelease(fs, lockPath, self)
+		} : {
+			kind: "acquired",
+			release: makeRelease(fs, lockPath, self)
+		};
+		if (created.reason === "error") return {
+			kind: "unavailable",
+			reason: created.error?.code === "ENOENT" ? "no-lock-dir" : "write-error"
+		};
+		let owner;
+		try {
+			owner = parseLockInfo(fs.readFileSync(lockPath));
+		} catch (error) {
+			if (error?.code === "ENOENT") {
+				if (attempt >= 2) return {
+					kind: "unverifiable",
+					owner
+				};
+				continue;
+			}
+			return {
+				kind: "unverifiable",
+				owner
+			};
+		}
+		if (owner === void 0) return {
+			kind: "unverifiable",
+			owner
+		};
+		if (owner.pid === self.pid && owner.starttime === self.starttime) return {
+			kind: "acquired",
+			release: makeRelease(fs, lockPath, self)
+		};
+		const verdict = proc.probe(owner, self);
+		if (verdict.kind === "alive") return {
+			kind: "held",
+			owner
+		};
+		if (verdict.kind === "unknown") return {
+			kind: "unverifiable",
+			owner
+		};
+		let removed = false;
+		try {
+			const current = parseLockInfo(fs.readFileSync(lockPath));
+			if (current !== void 0 && current.pid === owner.pid && current.starttime === owner.starttime) {
+				fs.unlinkSync(lockPath);
+				removed = true;
+			}
+		} catch {}
+		if (removed) tookOver = true;
+		else if (attempt >= 2) return {
+			kind: "held",
+			owner
+		};
+	}
+}
+/**
+* An idempotent release that only removes the lock if it is still OURS.
+* Compare-and-delete: after ownership is lost (a concurrent takeover, manual
+* removal and recreation by another process), the exit-time release must not
+* delete the new owner's lock file.
+*/
+function makeRelease(fs, lockPath, self) {
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		try {
+			const owner = parseLockInfo(fs.readFileSync(lockPath));
+			if (owner !== void 0 && owner.pid === self.pid && owner.starttime === self.starttime) fs.unlinkSync(lockPath);
+		} catch {}
+	};
+}
+//#endregion
+//#region src/session-lock-proc.ts
+/**
+* Real `/proc`-based owner probe for the open-time session lock.
+*
+* Verifies that a recorded lock owner is the SAME live dsh invocation:
+* - the process exists (`/proc/<pid>/stat` readable),
+* - it is not a zombie (state `Z`),
+* - its starttime (stat field 22) matches the lock record — a reused pid
+*   would carry a different starttime,
+* - its command line identifies a dsh process (the same family of tools the
+*   lock speaks for).
+*
+* The probe never takes a lock over on doubt: any inability to verify
+* (missing /proc, permission errors, unparsable stat) reports `unknown` and
+* the caller refuses the open. An ENOENT stat, a zombie state, a starttime
+* mismatch, or a non-dsh command line is a definitive `stale`.
+*
+* Non-Linux platforms degrade: `process.kill(pid, 0)` checks existence, then
+* the command line is compared when `ps` is available; when it is not, the
+* probe reports `unknown` (conservative refusal) instead of guessing.
+* @module @xmoon76/dsh-pi-tui/session-lock-proc
+*/
+/** Parse `/proc/<pid>/stat`: state (field 3) and starttime (field 22). */
+function parseProcStat(content) {
+	const close = content.lastIndexOf(")");
+	if (close < 0) return void 0;
+	const fields = content.slice(close + 2).trim().split(" ");
+	if (fields.length < 20) return void 0;
+	const state = fields[0] ?? "";
+	const starttime = Number(fields[19]);
+	if (!Number.isSafeInteger(starttime)) return void 0;
+	return {
+		state,
+		starttime
+	};
+}
+/** The set of command names this lock family recognizes as "our own tool". */
+function looksLikeDsh(cmdline) {
+	if (cmdline === void 0) return false;
+	return cmdline.split(/\s+/).some((arg) => {
+		if (arg === "dsh") return true;
+		const base = arg.split("/").pop() ?? "";
+		return base === "dsh" || base === "dsh.exe";
+	});
+}
+/** The real probe: Linux /proc, with a conservative non-Linux degradation. */
+function createProcProbe(options) {
+	const platform = options?.platform ?? process.platform;
+	const execFile = options?.execFile ?? execFileSync;
+	const readFile = options?.readFile ?? ((path) => readFileSync(path, "utf8"));
+	return { probe(owner, self) {
+		if (owner.pid === self.pid && owner.starttime === self.starttime) return { kind: "alive" };
+		if (platform === "linux" || platform === "android") {
+			let statContent;
+			try {
+				statContent = readFile(`/proc/${owner.pid}/stat`);
+			} catch (error) {
+				if (error?.code === "ENOENT") return { kind: "stale" };
+				return { kind: "unknown" };
+			}
+			const parsed = parseProcStat(statContent);
+			if (parsed === void 0) return { kind: "unknown" };
+			if (parsed.state === "Z") return { kind: "stale" };
+			if (parsed.starttime !== owner.starttime) return { kind: "stale" };
+			let cmdline;
+			try {
+				cmdline = readFile(`/proc/${owner.pid}/cmdline`).split("\0").filter((arg) => arg !== "").join(" ");
+			} catch {
+				return { kind: "unknown" };
+			}
+			if (cmdline !== void 0 && !looksLikeDsh(cmdline)) return { kind: "stale" };
+			return { kind: "alive" };
+		}
+		try {
+			process.kill(owner.pid, 0);
+		} catch (error) {
+			if (error?.code === "ESRCH") return { kind: "stale" };
+		}
+		try {
+			const command = execFile("ps", [
+				"-p",
+				String(owner.pid),
+				"-o",
+				"command="
+			], { encoding: "utf8" }).trim();
+			if (command === "") return { kind: "stale" };
+			return looksLikeDsh(command) ? { kind: "alive" } : { kind: "stale" };
+		} catch {
+			return { kind: "unknown" };
+		}
+	} };
+}
+//#endregion
 //#region src/index.ts
 /**
 * @xmoon76/dsh-pi-tui — the bundle's runner plugin. Waits for the startup
@@ -18615,11 +20430,65 @@ function shouldSteerOnEnter(parsed, running, busyEnter, forceQueue) {
 	return running && busyEnter === "steer";
 }
 /**
-* Read an explicit child-session reference from a future/extended job record.
-* Current dsh JobSnapshot records do not expose one, so this normally returns
-* undefined. Crucially, label, registration order and timestamps are never
-* accepted as identity signals.
+* The advertised-claim miss decision (pure, exported for the headless
+* suite): a slash input whose name was advertised by the completion list at
+* submit time but that the REAL session's catalog lacks is CONSUMED with an
+* explicit error — never sent to the model as a plain user message. An
+* unadvertised miss keeps the existing plain-input fallback (the user may
+* deliberately send slash text to the model).
+* @param execution - the settled `commands.execute` outcome.
+* @param wasAdvertised - the claim captured BEFORE session creation.
+* @returns whether the miss must be consumed as an advertised miss.
 */
+function shouldConsumeAdvertisedMiss(execution, wasAdvertised) {
+	return execution === void 0 && wasAdvertised;
+}
+async function resolveInitialCatalog(options) {
+	const { liveAgent, presetId, signal, ctx, diag } = options;
+	if (liveAgent !== void 0) try {
+		const snapshot = await readSurfaceCatalog(liveAgent, signal, ctx);
+		diag.info("surface catalog prefetched", {
+			commands: snapshot.commands.length,
+			scopedCommands: snapshot.scopedCommands.length,
+			skills: snapshot.skills.length
+		});
+		return { snapshot };
+	} catch (error) {
+		if (isCancellation(error)) return {};
+		const message = safeErrorMessage(error);
+		diag.warn("surface catalog unavailable", {
+			phase: "resume",
+			error: message
+		});
+		return { notice: `surface catalog unavailable: ${message}` };
+	}
+	const target = await resolveColdSkillTarget(ctx, presetId, process.cwd());
+	if (target.target === void 0) return {};
+	try {
+		const catalog = await readHumanSkillCatalog(target.target.registry, {
+			cwd: target.target.cwd,
+			scope: target.target.scope,
+			signal
+		});
+		diag.info("skill catalog standing ready", {
+			preset: presetId ?? "default",
+			skills: catalog.skills.length,
+			complete: catalog.complete
+		});
+		return {
+			skills: catalog,
+			...target.degraded === void 0 ? {} : { notice: target.degraded }
+		};
+	} catch (error) {
+		if (isCancellation(error)) return {};
+		const message = safeErrorMessage(error);
+		diag.warn("skill catalog unavailable", {
+			phase: "cold",
+			error: message
+		});
+		return { notice: `skill catalog unavailable: ${message}` };
+	}
+}
 function subagentJobTranscriptId(snapshot) {
 	if (typeof snapshot !== "object" || snapshot === null) return void 0;
 	const childSessionId = snapshot.childSessionId;
@@ -18637,6 +20506,86 @@ function subagentJobViewHint(status, detail) {
 	].join("\n");
 }
 /**
+* Whether a plain submitted draft is the quit word: exactly `exit` (trimmed,
+* lowercase). The runner intercepts this BEFORE any session creation or
+* submission (shell muscle memory); anything else — `exit!`, `Exit`, or a
+* draft with a recalled entry still in it — is an ordinary message.
+* @param text - the submitted draft.
+*/
+function isPlainExitPrompt(text) {
+	return text.trim() === "exit";
+}
+/**
+* Whether an inbox message is a BACKGROUND-SUBAGENT settlement notice — the
+* runtime's account of a child ending, not steerable user input. Two dsh
+* producers push these into the parent's inbox:
+*  - continuable children: `source.kind === 'subagent-settled'` (the
+*    continuation manager's settlement notice);
+*  - one-shot background subagent jobs: tool-jobs completion notices whose
+*    summary starts with the job kind (`subagent <label> [status: …]`).
+* The queue pane mirrors the inbox, but these belong to the task browser
+* (terminal job rows / inactive child rows), so the mirror drops them and
+* only failures surface as a transient error notify.
+* @param source - the message source projection, or undefined for a plain row.
+*/
+function isSubagentSettlementNotice(source) {
+	if (source === void 0 || source.form !== "notice") return false;
+	if (source.kind === "subagent-settled") return true;
+	return source.kind === "plugin" && typeof source.summary === "string" && source.summary.startsWith("subagent ");
+}
+/**
+* Whether a subagent settlement notice reports FAILURE, classified on the
+* producers' own deterministic wording:
+*  - `subagent-settled` summaries: "finished and will do no further work"
+*    is the only success wording; aborted / max-tokens / refusal / error /
+*    unknown endings all fail;
+*  - tool-jobs subagent summaries carry the terminal status line, whose
+*    failure statuses are `failed` and `killed` (dsh JobStatus).
+* A notice that cannot be classified is treated as success (silent).
+* @param source - the message source projection.
+*/
+function subagentNoticeIsFailure(source) {
+	if (source === void 0 || source.form !== "notice") return false;
+	if (source.kind === "subagent-settled") return typeof source.summary === "string" && !source.summary.includes("finished and");
+	if (source.kind === "plugin" && typeof source.summary === "string" && source.summary.startsWith("subagent ")) return /\[status: (failed|killed)[,\]]/.test(source.summary);
+	return false;
+}
+/**
+* Build the queue-pane rows for one inbox batch, dropping background-subagent
+* settlement notices (the task browser is their surface) and reporting which
+* FAILED settlements should notify. Pure and injectable so the filter +
+* once-notify semantics are testable without the agent.
+* @param messages - one inbox batch (next-turn or next-step), in order.
+* @param mode - the delivery mode for surviving rows.
+* @param notified - the notify-once guard; failed notices already in it are
+*   skipped, and a newly-reported id is ADDED here so a re-render can never
+*   double-notify.
+*/
+function foldQueueRows(messages, mode, notified) {
+	const rows = [];
+	const failures = [];
+	for (const message of messages) {
+		const source = message.source;
+		if (isSubagentSettlementNotice(source)) {
+			if (source?.summary !== void 0 && subagentNoticeIsFailure(source) && !notified.has(message.id)) {
+				notified.add(message.id);
+				failures.push(source.summary);
+			}
+			continue;
+		}
+		rows.push({
+			id: message.id,
+			text: textOf(message.content),
+			mode,
+			notice: source?.form === "notice"
+		});
+	}
+	return {
+		rows,
+		failures
+	};
+}
+/**
 * The installed dsh version (e.g. `0.1.0-rc.6`), resolved from the launcher's
 * real path: `process.argv[1]` is the `dsh` bin, whose realpath walks up to
 * the `@deepseek-ai/dsh/package.json` that owns it. The version the welcome
@@ -18762,6 +20711,51 @@ function resumeCommand(profile, sessionId) {
 	if (id === "") return void 0;
 	return `dsh --profile ${profile} --session ${id}`;
 }
+/** The lock identity of THIS process: pid + boot-relative starttime. */
+let cachedSelfLockInfo;
+function selfLockInfo() {
+	if (cachedSelfLockInfo !== void 0) return cachedSelfLockInfo;
+	const info = {
+		pid: process.pid,
+		starttime: 0,
+		startedAt: Date.now(),
+		profile: runningProfile()
+	};
+	try {
+		info.starttime = parseProcStat(readFileSync(`/proc/self/stat`, "utf8"))?.starttime ?? 0;
+	} catch {}
+	cachedSelfLockInfo = info;
+	return info;
+}
+/** Human-readable lock owner description for the refusal notice. */
+function lockOwnerText(owner) {
+	const parts = [`pid ${owner.pid}`];
+	if (owner.profile !== void 0) parts.push(`profile ${owner.profile}`);
+	if (owner.startedAt > 0) {
+		const started = new Date(owner.startedAt);
+		parts.push(`started ${started.toLocaleTimeString()}`);
+	}
+	if (owner.tty !== void 0) parts.push(`tty ${owner.tty}`);
+	return parts.join(", ");
+}
+/** The refusal notice for a session held by another live dsh process. */
+function lockHeldNotice(sessionId, owner) {
+	return `Session ${sessionId} is open in another dsh process (${lockOwnerText(owner)}); opening it here could corrupt the log. Close it there first, or restart that process.`;
+}
+/**
+* A launch-time open-lock refusal: the requested session is held by another
+* live dsh process (or its lock cannot be verified). Unlike a stale/missing
+* session id, this is NOT recoverable by falling back to a fresh session —
+* the user asked for a specific session and must resolve the holder first.
+* Thrown from the resume path and re-thrown past the resume catch so the
+* runner exits with the refusal as the error message.
+*/
+var SessionLockRefusedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SessionLockRefusedError";
+	}
+};
 /**
 * The active goal badge text from the session log, or undefined. The latest
 * `goal/change` wins; a clear or completed goal hides the badge.
@@ -18951,9 +20945,81 @@ function apply(ctx, config) {
 				};
 			}
 		};
+		let heldLock;
+		const lockProc = createProcProbe();
+		/** Try to take the open-time lock for a session. Returns the refusal text
+		* when the session is held by another live dsh process (or unverifiable);
+		* undefined when the lock is now ours (or the deployment cannot lock —
+		* proceed as before). Never throws. */
+		const acquireOpenLock = (sessionId, header) => {
+			const outcome = acquireSessionLock({
+				persistence: ctx.get("sessionPersistence"),
+				fs: {
+					readFileSync: (path) => readFileSync(path, "utf8"),
+					writeFileSync: (path, content, options) => writeFileSync(path, content, options),
+					unlinkSync
+				},
+				proc: lockProc
+			}, {
+				id: sessionId,
+				header
+			}, selfLockInfo());
+			switch (outcome.kind) {
+				case "acquired":
+				case "taken-over-stale":
+					heldLock = {
+						sessionId,
+						release: outcome.release
+					};
+					if (outcome.kind === "taken-over-stale") diag.warn("session lock stale taken over", { session: sessionId });
+					return;
+				case "held":
+					diag.warn("session lock held", {
+						session: sessionId,
+						pid: outcome.owner.pid
+					});
+					return lockHeldNotice(sessionId, outcome.owner);
+				case "unverifiable":
+					diag.warn("session lock unverifiable", {
+						session: sessionId,
+						pid: outcome.owner?.pid
+					});
+					return outcome.owner === void 0 ? `Session ${sessionId} has an unreadable or malformed lock file; refusing to open it here. If no other dsh process is using it, delete the owner.lock file next to the session log and retry.` : `Session ${sessionId} has a lock file whose owner (pid ${outcome.owner.pid}) cannot be verified; refusing to open it here. If that process is gone, delete the owner.lock file next to the session log and retry.`;
+				case "unavailable": return;
+			}
+		};
+		/** Release the open-time lock for a session (idempotent). */
+		const releaseOpenLock = (sessionId) => {
+			if (heldLock === void 0 || heldLock.sessionId !== sessionId) return;
+			heldLock.release();
+			heldLock = void 0;
+		};
+		/** Re-take the lock for the still-live current session after a failed
+		* switch (refusal, resume failure, or an internal swap failure). The
+		* lock was released before the target acquire, so another process may
+		* have taken it in the window — the re-take result is checked and a
+		* failed re-take surfaces as a notice (the write-path guard remains the
+		* backstop, but the user must know the session is no longer locked by
+		* this TUI). */
+		const reacquireCurrentLock = (from, fromHeader) => {
+			if (from === void 0) return;
+			const refusal = acquireOpenLock(from, fromHeader ?? liveAgent?.session.header);
+			if (refusal !== void 0) {
+				const message = `the current session ${from} is no longer locked by this TUI (${refusal})`;
+				ctx.logger.warn(`tui-runner: ${message}`);
+				diag.warn("session lock lost on failed switch", { session: from });
+				app?.notify(message, "error");
+			}
+		};
 		let resumeFailure;
 		let handle;
 		if (sessionId !== void 0) try {
+			let lockHeader;
+			try {
+				lockHeader = (await ctx.get("sessionPersistence")?.list())?.find((candidate) => candidate.id === sessionId);
+			} catch {}
+			const lockRefusal = acquireOpenLock(sessionId, lockHeader);
+			if (lockRefusal !== void 0) throw new SessionLockRefusedError(lockRefusal);
 			const recorded = await recordedPreset(ctx, sessionId);
 			const composition = await compose(recorded);
 			handle = await agents.resume({
@@ -18985,6 +21051,7 @@ function apply(ctx, config) {
 				});
 			}
 		} catch (error) {
+			if (error instanceof SessionLockRefusedError) throw error;
 			const message = safeErrorMessage(error);
 			ctx.logger.warn(`tui-runner: resume ${sessionId} failed: ${message}`);
 			diag.error("resume failed", {
@@ -18992,6 +21059,7 @@ function apply(ctx, config) {
 				error: message
 			});
 			resumeFailure = `session ${sessionId} could not be resumed; started a fresh session`;
+			releaseOpenLock(sessionId);
 			const launched = await launchComposition();
 			if (launched.failure !== void 0) resumeFailure = launched.failure;
 			handle = await agents.create({
@@ -19003,10 +21071,34 @@ function apply(ctx, config) {
 				agentOptions,
 				setup: launched.composition.setup
 			});
+			acquireOpenLock(handle.agent.session.id, handle.agent.session.header);
 		}
 		let liveHandle = handle;
 		let liveAgent = handle?.agent;
 		if (liveAgent !== void 0) await liveAgent.whenIdle();
+		let initialSnapshot;
+		let initialSkills;
+		let surfaceNotice;
+		{
+			let effectivePresetId;
+			try {
+				const launched = await launchComposition();
+				if (launched.failure !== void 0) resumeFailure = launched.failure;
+				effectivePresetId = launched.composition.agentPreset;
+			} catch (error) {
+				diag.warn("preset resolution failed at startup", { error: safeErrorMessage(error) });
+			}
+			const resolution = await resolveInitialCatalog({
+				liveAgent,
+				presetId: effectivePresetId,
+				signal: lifecycleController.signal,
+				ctx,
+				diag
+			});
+			initialSnapshot = resolution.snapshot;
+			initialSkills = resolution.skills;
+			surfaceNotice = resolution.notice;
+		}
 		let guardState = freshGuardState();
 		let guardToken;
 		/**
@@ -19123,6 +21215,7 @@ function apply(ctx, config) {
 		/** Swap the live agent to a new handle, repainting for its session. */
 		const swapTo = async (next) => {
 			const from = liveAgent?.session.id;
+			const fromHeader = liveAgent?.session.header;
 			try {
 				if (liveAgent !== void 0) {
 					await sessions.flush(liveAgent.session);
@@ -19137,12 +21230,22 @@ function apply(ctx, config) {
 					from,
 					error: message
 				});
+				const repair = swapFailureLockRepair(heldLock, from);
+				if (repair.release !== void 0) releaseOpenLock(repair.release);
+				if (repair.reacquire !== void 0) reacquireCurrentLock(repair.reacquire, fromHeader);
 				return `swap failed: ${message}`;
 			}
+			if (from !== void 0) releaseOpenLock(from);
+			const swapLockRefusal = acquireOpenLock(next.agent.session.id, next.agent.session.header);
+			if (swapLockRefusal !== void 0) {
+				ctx.logger.warn(`tui-runner: lock refused on swap to ${next.agent.session.id}: ${swapLockRefusal}`);
+				diag.warn("session lock refused on swap", { session: next.agent.session.id });
+			}
 			guardState = freshGuardState();
 			guardToken = void 0;
 			bumpSessionGeneration();
 			await initLiveSession(next.agent);
+			await refreshLiveCatalog(next.agent);
 			diag.info("switch ok", {
 				from: from ?? "(none)",
 				to: next.agent.session.id,
@@ -19154,6 +21257,19 @@ function apply(ctx, config) {
 		* string so callers' `.then(error => ...)` need no rejection path. */
 		const switchSession = async (sessionId) => {
 			try {
+				const from = liveAgent?.session.id;
+				if (from !== void 0) releaseOpenLock(from);
+				let lockHeader;
+				try {
+					lockHeader = (await ctx.get("sessionPersistence")?.list())?.find((candidate) => candidate.id === sessionId);
+				} catch {}
+				const lockRefusal = acquireOpenLock(sessionId, lockHeader);
+				if (lockRefusal !== void 0) {
+					ctx.logger.warn(`tui-runner: switch to ${sessionId} refused: ${lockRefusal}`);
+					diag.warn("session lock held on switch", { session: sessionId });
+					reacquireCurrentLock(from);
+					return lockRefusal;
+				}
 				const composition = await compose(await recordedPreset(ctx, sessionId));
 				const next = await agents.resume({
 					resumeSessionId: SessionId(sessionId),
@@ -19171,6 +21287,8 @@ function apply(ctx, config) {
 					session: sessionId,
 					error: message
 				});
+				releaseOpenLock(sessionId);
+				reacquireCurrentLock(liveAgent?.session.id);
 				return `switch failed: ${message}`;
 			}
 		};
@@ -19228,7 +21346,12 @@ function apply(ctx, config) {
 			if (cleanedUp) return;
 			cleanedUp = true;
 			guardToken = void 0;
+			if (heldLock !== void 0) {
+				heldLock.release();
+				heldLock = void 0;
+			}
 			lifecycleController.abort();
+			catalogCoordinator?.dispose();
 			localShellController?.abort();
 			for (const file of shellTempFiles) try {
 				rmSync(file, { force: true });
@@ -19528,6 +21651,8 @@ function apply(ctx, config) {
 		* user input is the deferred trigger), guard against cross-process
 		* divergence, then execute a registered slash command or follow up. */
 		const dispatchViaSession = (text) => {
+			const parsedAtSubmit = parseCommand(text);
+			const wasAdvertised = parsedAtSubmit !== void 0 && wasAdvertisedClaim?.(parsedAtSubmit.name) === true;
 			runOwned("submit", () => ensureSession().then(async () => {
 				const agent = liveAgent;
 				if (agent === void 0) return;
@@ -19557,6 +21682,10 @@ function apply(ctx, config) {
 						diag,
 						sessionId: () => agent.session.id,
 						onResult: (execution) => {
+							if (shouldConsumeAdvertisedMiss(execution, wasAdvertised)) {
+								app.notify(`/${parsedAtSubmit?.name ?? "?"} is not available in the created session`, "error");
+								return;
+							}
 							if (execution === void 0) {
 								if (sessionUnchanged({
 									agent,
@@ -19693,6 +21822,12 @@ function apply(ctx, config) {
 			});
 		};
 		/**
+		* The newest input-history entry this process persisted (kimi's
+		* `lastHistoryContent` analogue): consecutive repeats are skipped per
+		* window, exactly like shell history.
+		*/
+		let lastHistoryContent;
+		/**
 		* Dispatch one user submission end to end: the viewer guard, the input-
 		* history persistence, `!` local shells, sessionless commands, the
 		* busy-Enter preference, and the session dispatch. The Ctrl+Enter
@@ -19702,22 +21837,23 @@ function apply(ctx, config) {
 		* @param forceQueue - the chord: never steer, queue instead.
 		*/
 		const dispatchUserInput = (text, forceQueue = false) => {
+			if (isPlainExitPrompt(text)) {
+				requestExit();
+				return;
+			}
 			if (viewing !== void 0) {
 				app.setEditorText(mergeDraft(app.getDraft(), text));
 				app.notify("viewing a subagent — Esc returns before submitting", "info");
 				return;
 			}
 			app.clearSettledLocalMessages();
-			const history = app.getInputHistory();
-			if (history.length > 0) {
-				const settings = tuiSettings;
-				if (settings !== void 0) runDetached("settings history write", () => settings.replace({
-					...settings.get(),
-					history: {
-						...settings.get().history,
-						[sessionCwd()]: history
-					}
-				}), {
+			const trimmed = text.trim();
+			if (trimmed !== "" && trimmed !== lastHistoryContent) {
+				const file = historyFilePath(dshHome(process.env), sessionCwd());
+				runDetached("input history write", () => {
+					appendHistoryLine(file, trimmed, lastHistoryContent);
+					lastHistoryContent = trimmed;
+				}, {
 					diag,
 					notify: (message) => app.notify(message, "error"),
 					recoverable: () => true
@@ -19855,7 +21991,6 @@ function apply(ctx, config) {
 				if (jobs !== void 0) try {
 					jobSnapshots = jobs.list(liveAgent);
 				} catch {}
-				const now = Date.now();
 				let rows = buildTaskRows(jobSnapshots, []);
 				const selectRow = (value) => {
 					const row = rows.find((candidate) => candidate.value === value);
@@ -19870,16 +22005,23 @@ function apply(ctx, config) {
 					}
 					openJobView(row.jobId);
 				};
-				const pickerItems = (target) => target.map((row) => ({
+				const taskPanelItems = (target) => target.map((row) => row.kind === "job" ? {
 					value: row.value,
 					label: taskRowLabel(row),
-					description: describeTaskRow(row, now),
+					status: row.status,
+					detail: row.detail,
+					startedAt: row.startedAt,
 					group: rowGroup(row)
-				}));
-				const handle = app.openPicker(pickerItems(rows), selectRow, () => {}, {
+				} : {
+					value: row.value,
+					label: taskRowLabel(row),
+					status: row.activity,
+					detail: row.hasChildren ? "has children" : void 0,
+					group: rowGroup(row)
+				});
+				const handle = app.openTaskBrowser(taskPanelItems(rows), selectRow, () => {}, {
 					header: "tasks · subagents",
-					enableSearch: true,
-					showHint: true
+					enableSearch: true
 				});
 				if (subagents !== void 0) {
 					const sessionId = liveAgent.session.id;
@@ -19890,7 +22032,7 @@ function apply(ctx, config) {
 						onResult: (entries) => {
 							if (sessionGeneration !== generation || liveAgent?.session.id !== sessionId) return;
 							rows = buildTaskRows(jobSnapshots, entries);
-							handle.setItems(pickerItems(rows));
+							handle.setItems(taskPanelItems(rows));
 						}
 					});
 				}
@@ -19903,14 +22045,12 @@ function apply(ctx, config) {
 			theme: z.string(),
 			footer: z.string(),
 			fullscreen: z.string(),
-			busyEnter: z.string(),
-			history: z.dict(z.array(z.string()))
+			busyEnter: z.string()
 		}), { base: {
 			theme: "auto",
 			footer: "full",
 			fullscreen: "on",
-			busyEnter: "queue",
-			history: {}
+			busyEnter: "queue"
 		} });
 		if (tuiSettings?.get().fullscreen === "on") app.setFullscreen(true);
 		const storedTheme = tuiSettings?.get().theme;
@@ -19929,6 +22069,39 @@ function apply(ctx, config) {
 			app.trackTerminalTheme(false);
 		}
 		if (tuiSettings?.get().footer === "compact") app.setFooterPreset("compact");
+		let legacyHistory;
+		try {
+			const value = ((ctx.get("settings")?.describe().find((d) => d.ns === settingsNamespace("dsh-pi-tui")))?.user)?.history;
+			if (typeof value === "object" && value !== null) legacyHistory = value;
+		} catch {}
+		if (legacyHistory !== void 0) {
+			const home = dshHome(process.env);
+			for (const [cwd, entries] of Object.entries(legacyHistory)) {
+				if (!Array.isArray(entries) || entries.length === 0) continue;
+				const file = historyFilePath(home, cwd);
+				if (existsSync(file)) continue;
+				for (const entry of entries.slice().reverse()) try {
+					appendHistoryLine(file, entry, void 0);
+				} catch {}
+			}
+			if (tuiSettings !== void 0) {
+				if (Object.entries(legacyHistory).every(([cwd, entries]) => {
+					if (!Array.isArray(entries) || entries.length === 0) return true;
+					return existsSync(historyFilePath(home, cwd));
+				})) runDetached("settings history cleanup", () => {
+					const doc = { ...tuiSettings.get() };
+					delete doc.history;
+					tuiSettings.replace(doc);
+				}, {
+					diag,
+					notify: (message) => app.notify(message, "error"),
+					recoverable: () => true
+				});
+			}
+		}
+		const bootHistoryEntries = loadHistoryFile(historyFilePath(dshHome(process.env), cwd));
+		lastHistoryContent = bootHistoryEntries.at(-1);
+		app.resetInputHistory([...bootHistoryEntries].reverse());
 		refreshStatus();
 		let refreshTasks = () => {};
 		let refreshAgents = () => {};
@@ -20044,26 +22217,24 @@ function apply(ctx, config) {
 		const jobStatusHint = (status, detail) => {
 			return `${status}${status === "running" || status === "stopping" ? " — output is delivered to the agent via job_output; viewing never consumes the job’s read cursor" : ` — final output: ask the agent to run job_output in the conversation${detail === void 0 ? "" : ` (${detail})`}`}`;
 		};
+		const notifiedSubagentNotices = /* @__PURE__ */ new Set();
 		const refreshQueue = () => {
 			if (liveAgent === void 0) {
 				app.setQueueItems([]);
 				return;
 			}
-			const queue = [...liveAgent.inbox.nextTurn.map((message) => ({
-				id: message.id,
-				text: textOf(message.content),
-				mode: "followup",
-				notice: message.source?.form === "notice"
-			})), ...liveAgent.inbox.nextStep.map((message) => ({
-				id: message.id,
-				text: textOf(message.content),
-				mode: "steer",
-				notice: message.source?.form === "notice"
-			}))];
-			app.setQueueItems(queue);
+			const turn = foldQueueRows(liveAgent.inbox.nextTurn, "followup", notifiedSubagentNotices);
+			const step = foldQueueRows(liveAgent.inbox.nextStep, "steer", notifiedSubagentNotices);
+			for (const summary of [...turn.failures, ...step.failures]) app.notify(summary, "error");
+			app.setQueueItems([...turn.rows, ...step.rows]);
 		};
 		refreshQueue();
-		/** Rebuild every live-session surface after resume, create, or swap. */
+		/**
+		* Rebuild every live-session surface after resume, create, or swap.
+		* The surface catalog is NOT touched here: the initial owner's catalog
+		* came from the pre-mount prefetch/probe, and the first deferred create
+		* plus every switch await the coordinator refresh themselves.
+		*/
 		const initLiveSession = async (agent) => {
 			folder = new TranscriptFolder();
 			folder.apply(agent.session.events);
@@ -20074,16 +22245,22 @@ function apply(ctx, config) {
 			app.setSessionTitle(foldSessionTitle(agent.session.events)?.title);
 			app.clearLocalMessages();
 			app.clearNotify();
+			notifiedSubagentNotices.clear();
 			repaint(app, folder);
 			refreshStatus();
 			refreshQueue();
 			refreshTasks();
 			refreshAgents();
-			app.resetInputHistory(tuiSettings?.get().history[sessionCwd()] ?? []);
+			const historyCwd = sessionCwd();
+			const historyEntries = loadHistoryFile(historyFilePath(dshHome(process.env), historyCwd));
+			lastHistoryContent = historyEntries.at(-1);
+			app.resetInputHistory([...historyEntries].reverse());
 			setTerminalTitle(`dsh-pi-tui · ${shortCwd(sessionCwd())} · ${agent.session.id}`);
 			updateWelcomeCard();
-			registerCommands();
-			refreshSkillCommands();
+			registerCommands({
+				snapshot: initialSnapshot,
+				skills: initialSkills
+			});
 		};
 		/**
 		* Create the first session lazily — the FIRST user message triggers it
@@ -20109,9 +22286,11 @@ function apply(ctx, config) {
 					});
 					liveHandle = created;
 					liveAgent = created.agent;
+					acquireOpenLock(liveAgent.session.id, liveAgent.session.header);
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
+					await refreshLiveCatalog(liveAgent);
 				} catch (error) {
 					const message = safeErrorMessage(error);
 					ctx.logger.warn(`tui-runner: failed to start with preset "${launchPreset ?? "default"}": ${message}`);
@@ -20132,9 +22311,11 @@ function apply(ctx, config) {
 					});
 					liveHandle = created;
 					liveAgent = created.agent;
+					acquireOpenLock(liveAgent.session.id, liveAgent.session.header);
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
+					await refreshLiveCatalog(liveAgent);
 				}
 				if (resumeFailure !== void 0) {
 					app.notify(resumeFailure, "error");
@@ -20146,7 +22327,67 @@ function apply(ctx, config) {
 			return creating;
 		};
 		let commandsRegistered = false;
-		let refreshSkills;
+		/** The claim test installed by registerTuiCommands: is a slash name
+		* advertised by the CURRENT completion list? The dispatch captures it
+		* BEFORE any session creation (see dispatchViaSession). */
+		let wasAdvertisedClaim;
+		/** The catalog refresh coordinator: the ONE post-mount refresh owner
+		* (first session, switches, /preset, /reload). Built inside
+		* registerCommands once the surface hooks exist. */
+		let catalogRefreshRequest;
+		let catalogCoordinator;
+		/** `skills/change` coalescing: bursts of invalidation notifications cost
+		* at most two reads, and the follow-up re-read observes the CURRENT
+		* ownership (live agent vs standing preset). */
+		let skillsChangeSubscribed = false;
+		const skillsChangeGate = new CoalescingRefreshGate(() => {
+			runOwned("skills/change refresh", async () => {
+				const refresh = catalogRefreshRequest;
+				if (refresh === void 0) return void 0;
+				const target = liveAgent === void 0 ? {
+					kind: "preset",
+					presetId: pendingPreset ?? launchPreset
+				} : {
+					kind: "agent",
+					key: sessionGeneration
+				};
+				return refresh({
+					source: "invalidation",
+					target,
+					...target.kind === "agent" ? { agent: liveAgent } : {}
+				});
+			}, {
+				diag,
+				sessionId: () => liveAgent?.session.id,
+				onResult: (outcome) => {
+					if (outcome !== void 0 && outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
+					skillsChangeGate.settled();
+				},
+				onCancel: () => {
+					skillsChangeGate.settled();
+				},
+				onError: (error) => {
+					skillsChangeGate.settled();
+					app.notify(`skill catalog refresh failed: ${safeErrorMessage(error)}`, "error");
+				}
+			});
+		});
+		/** Subscribe to the dsh-skill invalidation notification once, through
+		* the single-point adapter (plan appendix B.1). The event carries no
+		* scope or cwd, so the refresh target follows the CURRENT ownership; an
+		* unavailable or throwing subscription degrades to no subscription —
+		* owner switches and /reload still refresh. The flag is set only after
+		* a successful subscribe, so a throwing subscribe can retry on a later
+		* registration attempt. */
+		const subscribeSkillsChangeEvents = () => {
+			if (skillsChangeSubscribed) return;
+			try {
+				subscribeSkillsChange(ctx, () => skillsChangeGate.notify());
+				skillsChangeSubscribed = true;
+			} catch (error) {
+				diag.warn("skills/change subscription unavailable", { error: safeErrorMessage(error) });
+			}
+		};
 		const runner = {
 			ctx,
 			app,
@@ -20180,6 +22421,20 @@ function apply(ctx, config) {
 			set pendingPreset(id) {
 				pendingPreset = id;
 			},
+			/** The effective preset id for COLD (sessionless) reads: the run-local
+			* pending override ahead of the launch-time --preset (the SAME
+			* precedence ensureSession uses); undefined = the saved/default
+			* preset applies. */
+			get effectivePresetId() {
+				return pendingPreset ?? launchPreset;
+			},
+			refreshCatalog: (request) => {
+				const refresh = catalogRefreshRequest;
+				return refresh === void 0 ? Promise.resolve({
+					kind: "failed",
+					error: "catalog refresh unavailable"
+				}) : refresh(request);
+			},
 			switchSession,
 			swapTo: (next) => swapTo(next),
 			currentPreset,
@@ -20191,12 +22446,32 @@ function apply(ctx, config) {
 			requestExit,
 			exit
 		};
-		const registerCommands = () => {
+		const registerCommands = (initial) => {
 			if (commandsRegistered) return;
 			if (ctx.get("commands") === void 0) return;
 			commandsRegistered = true;
 			try {
-				refreshSkills = registerTuiCommands(runner).refreshSkills;
+				const installed = registerTuiCommands(runner, initial);
+				wasAdvertisedClaim = installed.wasAdvertised;
+				catalogCoordinator = new CatalogRefreshCoordinator({
+					readAgent: (agent, readSignal) => readSurfaceCatalog(agent, readSignal, ctx),
+					readStanding: async (presetId, readSignal) => {
+						const target = await resolveColdSkillTarget(ctx, presetId, process.cwd());
+						if (target.target === void 0) throw new Error("skill service unavailable");
+						return {
+							catalog: await readHumanSkillCatalog(target.target.registry, {
+								cwd: target.target.cwd,
+								scope: target.target.scope,
+								signal: readSignal
+							}),
+							...target.degraded === void 0 ? {} : { notice: target.degraded }
+						};
+					},
+					installSnapshot: (next) => installed.installSnapshot(next),
+					enterCatalogTransition: () => installed.enterTransition()
+				}, lifecycleController.signal, diag);
+				catalogRefreshRequest = (request) => catalogCoordinator.refresh(request);
+				subscribeSkillsChangeEvents();
 			} catch (error) {
 				commandsRegistered = false;
 				const message = safeErrorMessage(error);
@@ -20205,13 +22480,21 @@ function apply(ctx, config) {
 				app.notify(`command registration failed: ${message}`, "error");
 			}
 		};
-		/** Rebuild the agent-scoped per-skill commands after a session exists. */
-		const refreshSkillCommands = () => {
-			const refresh = refreshSkills;
+		/** Await one live-owner catalog refresh through the coordinator (the
+		* first deferred create and every session switch): the refresh attempt
+		* settles before the caller continues, and its outcome is an outcome —
+		* provider issues degrade fields, failures warn, the submission or the
+		* switch proceeds either way. */
+		const refreshLiveCatalog = async (agent) => {
+			const refresh = catalogRefreshRequest;
 			if (refresh === void 0) return;
-			runDetached("skill command refresh", () => refresh(), {
-				diag,
-				sessionId: () => liveAgent?.session.id
+			await refresh({
+				source: "live-session",
+				target: {
+					kind: "agent",
+					key: sessionGeneration
+				},
+				agent
 			});
 		};
 		if (liveAgent !== void 0) await initLiveSession(liveAgent);
@@ -20220,7 +22503,14 @@ function apply(ctx, config) {
 			refreshStatus();
 			setTerminalTitle(`dsh-pi-tui · ${shortCwd(sessionCwd())}`);
 		}
-		registerCommands();
+		registerCommands({
+			snapshot: initialSnapshot,
+			skills: initialSkills
+		});
+		if (surfaceNotice !== void 0) {
+			app.notify(surfaceNotice, "error");
+			surfaceNotice = void 0;
+		}
 		if (resumeFailure !== void 0) {
 			app.notify(resumeFailure, "error");
 			resumeFailure = void 0;
@@ -20330,4 +22620,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, LOCAL_COMMANDS, SESSIONLESS_COMMANDS, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset, resumeCommand, runningProfile, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint };
+export { Config, LOCAL_COMMANDS, SESSIONLESS_COMMANDS, SessionLockRefusedError, apply, composeAgent, dangerCommand, foldQueueRows, forkSeed, inject, isPlainExitPrompt, isSubagentSettlementNotice, name, recomposeBlank, recordedPreset, resolveInitialCatalog, resumeCommand, runningProfile, shouldConsumeAdvertisedMiss, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint, subagentNoticeIsFailure };