@xmoon76/dsh-pi-tui 0.1.5 → 0.1.7

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";
@@ -148,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";
@@ -295,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]),
@@ -303,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
@@ -1531,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
@@ -6079,6 +6246,7 @@ var Editor = class {
 	isInPaste = false;
 	pasteBurst = new PasteBurst();
 	disablePasteBurst = false;
+	inlineSlashTrigger = false;
 	history = [];
 	historyIndex = -1;
 	historyDraft = null;
@@ -6118,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() {
@@ -6405,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());
@@ -6711,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();
 	}
@@ -7343,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("/");
 	}
@@ -12555,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
@@ -13150,12 +13577,24 @@ var QuestionFlow = class {
 			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;
 		}
@@ -14179,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). */
@@ -14244,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
@@ -14315,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);
@@ -14324,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);
@@ -14733,6 +15176,10 @@ var TuiApp = class TuiApp {
 					component: this.todoPanel,
 					shrink: 0
 				},
+				{
+					component: this.goalLine,
+					shrink: 0
+				},
 				{
 					component: this.queuePane,
 					shrink: 0
@@ -14882,6 +15329,17 @@ var TuiApp = class TuiApp {
 		this.requestRender();
 	}
 	/**
+	* Anchor the transcript view to its END (the latest content). Fullscreen
+	* scrolls its ScrollView; the regular surface has no scroll view (it draws
+	* into the terminal scrollback), so a forced full repaint re-renders from
+	* row 0 and the main screen's viewport tracking lands on the bottom — the
+	* same mechanism the fullscreen-toggle path uses to redraw cleanly.
+	*/
+	scrollToBottom() {
+		if (this.fullscreenScroll !== void 0) this.fullscreenScroll.scrollToEnd();
+		else this.tui.requestRender(true);
+	}
+	/**
 	* Set the live session's auto-generated title (from the session/title
 	* log) for the header; undefined clears it.
 	*/
@@ -15171,9 +15629,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("$ ");
@@ -15184,12 +15645,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;
@@ -15267,10 +15728,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;
 				}
 			}
@@ -15311,6 +15773,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);
@@ -15338,7 +15812,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));
 		}
 	}
 	/**
@@ -15360,21 +15839,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();
 	}
@@ -15382,6 +15852,7 @@ var TuiApp = class TuiApp {
 	toggleTodoPanel() {
 		this.todoPanelVisible = !this.todoPanelVisible;
 		this.renderTodoPanel();
+		this.renderDock();
 		this.requestRender();
 		return this.todoPanelVisible;
 	}
@@ -15390,8 +15861,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) {
@@ -15404,15 +15876,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() {
@@ -15424,15 +15903,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();
 	}
 	/**
@@ -15448,29 +15927,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). */
@@ -15478,9 +15955,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) {
@@ -15496,7 +15973,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)), "…");
@@ -15540,45 +16017,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. */
@@ -15603,7 +16072,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,
@@ -15662,6 +16130,50 @@ var TuiApp = class TuiApp {
 		};
 	}
 	/**
+	* 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).
+	*/
+	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
@@ -15741,6 +16253,7 @@ var TuiApp = class TuiApp {
 		this.renderFooter();
 		this.renderDock();
 		this.renderTodoPanel();
+		this.renderGoalLine();
 		this.renderQueuePane();
 		this.working.refresh();
 		this.editor.invalidate();
@@ -16150,14 +16663,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
 /**
@@ -16766,6 +17271,55 @@ 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
@@ -17175,7 +17729,7 @@ function registerTuiCommands(runner, initial) {
 			text: `skill "${name}" returned a malformed definition`
 		};
 		const body = typeof skill.content === "string" && skill.content !== "" ? skill.content : skill.description;
-		agent.inject(createUserMessage({
+		const message = createUserMessage({
 			content: [{
 				type: "text",
 				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + body
@@ -17184,7 +17738,9 @@ function registerTuiCommands(runner, initial) {
 				kind: "plugin",
 				plugin: "tui-skill"
 			}
-		}));
+		});
+		if (agent.status === "running") agent.steer(message);
+		else agent.followup(message);
 		return {
 			kind: "success",
 			text: "skill " + name + " loaded"
@@ -17560,12 +18116,17 @@ function registerTuiCommands(runner, initial) {
 				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" };
 		}
 	});
@@ -18046,15 +18607,37 @@ function registerTuiCommands(runner, initial) {
 	});
 	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",
@@ -18079,19 +18662,32 @@ function registerTuiCommands(runner, initial) {
 	});
 	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`
 			};
 		}
 	});
@@ -18336,6 +18932,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
@@ -19357,6 +20057,286 @@ var CoalescingRefreshGate = class {
 	}
 };
 //#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
@@ -19476,6 +20456,26 @@ function shouldSteerOnEnter(parsed, running, busyEnter, forceQueue) {
 function shouldConsumeAdvertisedMiss(execution, wasAdvertised) {
 	return execution === void 0 && wasAdvertised;
 }
+/**
+* Match the child a user is about to view against the unsettled subagent
+* calls (pure, exported for the headless suite). The child's durable label
+* is the delegation's `description`; duplicate descriptions take the MOST
+* RECENT call (the one the user is most likely watching), an empty/absent
+* label falls back to a LONE pending call, and no match disables the
+* auto-pop (the user exits the viewer with Esc as before — never a wrong
+* pop). Mutates `pending` by removing the matched call.
+* @param pending - the unsettled calls, in order (oldest first).
+* @param label - the child's durable label; '' or undefined = no description.
+* @returns the matched call, or undefined when nothing matches.
+*/
+function matchPendingSubagentCall(pending, label) {
+	if (label !== void 0 && label !== "") {
+		for (let index = pending.length - 1; index >= 0; index -= 1) if (pending[index].description === label) return pending.splice(index, 1)[0];
+		if (pending.length === 1) return pending.splice(0, 1)[0];
+		return;
+	}
+	if (pending.length === 1) return pending.splice(0, 1)[0];
+}
 async function resolveInitialCatalog(options) {
 	const { liveAgent, presetId, signal, ctx, diag } = options;
 	if (liveAgent !== void 0) try {
@@ -19539,6 +20539,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
@@ -19664,6 +20744,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.
@@ -19853,9 +20978,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({
@@ -19887,6 +21084,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", {
@@ -19894,6 +21092,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({
@@ -19905,6 +21104,7 @@ 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;
@@ -20048,6 +21248,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);
@@ -20062,8 +21263,17 @@ 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();
@@ -20080,6 +21290,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),
@@ -20097,6 +21320,8 @@ function apply(ctx, config) {
 					session: sessionId,
 					error: message
 				});
+				releaseOpenLock(sessionId);
+				reacquireCurrentLock(liveAgent?.session.id);
 				return `switch failed: ${message}`;
 			}
 		};
@@ -20154,6 +21379,10 @@ 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();
@@ -20368,6 +21597,8 @@ function apply(ctx, config) {
 		};
 		let repaintTimer;
 		let viewing;
+		const pendingSubagentCalls = [];
+		const viewCallToChild = /* @__PURE__ */ new Map();
 		const activeFolder = () => viewing?.folder ?? folder;
 		const paintNow = () => {
 			if (repaintTimer !== void 0) {
@@ -20390,6 +21621,8 @@ function apply(ctx, config) {
 		const bumpSessionGeneration = () => {
 			sessionGeneration += 1;
 			callArgs.clear();
+			pendingSubagentCalls.length = 0;
+			viewCallToChild.clear();
 			searchMatches = [];
 			searchCurrent = -1;
 			app.setSearchResult(0, 0);
@@ -20417,6 +21650,8 @@ function apply(ctx, config) {
 					childFolder.apply((await persistence.inspect(childId)).events);
 				} catch {}
 			}
+			const matched = matchPendingSubagentCall(pendingSubagentCalls, label);
+			if (matched !== void 0) viewCallToChild.set(matched.callId, childId);
 			viewing = {
 				id: childId,
 				folder: childFolder
@@ -20435,6 +21670,7 @@ function apply(ctx, config) {
 			app.clearNotify();
 			app.setViewerMode(void 0);
 			repaint(app, folder);
+			app.scrollToBottom();
 			refreshStatus();
 			return true;
 		};
@@ -20626,6 +21862,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
@@ -20635,22 +21877,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
@@ -20788,7 +22031,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);
@@ -20803,16 +22045,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;
@@ -20823,7 +22072,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));
 						}
 					});
 				}
@@ -20836,14 +22085,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;
@@ -20862,6 +22109,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 = () => {};
@@ -20977,23 +22257,16 @@ 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();
 		/**
@@ -21012,12 +22285,16 @@ 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({
@@ -21049,6 +22326,7 @@ function apply(ctx, config) {
 					});
 					liveHandle = created;
 					liveAgent = created.agent;
+					acquireOpenLock(liveAgent.session.id, liveAgent.session.header);
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
@@ -21073,6 +22351,7 @@ function apply(ctx, config) {
 					});
 					liveHandle = created;
 					liveAgent = created.agent;
+					acquireOpenLock(liveAgent.session.id, liveAgent.session.header);
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
@@ -21279,17 +22558,42 @@ function apply(ctx, config) {
 		ctx.on("session/event", (session, event) => {
 			if (liveAgent === void 0) return;
 			if (viewing !== void 0) {
-				if (session.id !== viewing.id) return;
-				viewing.folder.apply([event]);
-				schedulePaint();
-				if (event.type === "turn/end") paintNow();
-				return;
+				if (session.id === viewing.id) {
+					viewing.folder.apply([event]);
+					schedulePaint();
+					if (event.type === "turn/end") paintNow();
+					return;
+				}
 			}
 			if (session.id !== liveAgent.session.id) return;
 			if (event.type === "tool/call") {
 				callArgs.set(event.data.callId, typeof event.data.arguments === "string" ? event.data.arguments : JSON.stringify(event.data.arguments));
-				if (typeof event.data.name === "string" && event.data.name.startsWith("subagent")) refreshAgents();
-			} else if (event.type === "tool/result") callArgs.delete(event.data.message.content[0]?.toolCallId ?? "");
+				if (typeof event.data.name === "string" && event.data.name.startsWith("subagent")) {
+					refreshAgents();
+					let description = "";
+					try {
+						const parsed = JSON.parse(event.data.arguments);
+						if (typeof parsed === "object" && parsed !== null && typeof parsed.description === "string") description = parsed.description;
+					} catch {}
+					pendingSubagentCalls.push({
+						callId: event.data.callId,
+						description
+					});
+				}
+			} else if (event.type === "tool/result") {
+				const callId = event.data.message.content[0]?.toolCallId;
+				callArgs.delete(callId ?? "");
+				const callIndex = pendingSubagentCalls.findIndex((call) => call.callId === callId);
+				if (callIndex !== -1) pendingSubagentCalls.splice(callIndex, 1);
+				const childId = callId === void 0 ? void 0 : viewCallToChild.get(callId);
+				if (childId !== void 0) viewCallToChild.delete(callId);
+				if (childId !== void 0 && viewing !== void 0 && viewing.id === childId) {
+					folder.apply([event]);
+					statsFolder.apply([event]);
+					exitView();
+					return;
+				}
+			}
 			folder.apply([event]);
 			statsFolder.apply([event]);
 			if (event.type === "goal/change") goalText = foldGoal([event]);
@@ -21381,4 +22685,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, LOCAL_COMMANDS, SESSIONLESS_COMMANDS, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset, resolveInitialCatalog, resumeCommand, runningProfile, shouldConsumeAdvertisedMiss, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint };
+export { Config, LOCAL_COMMANDS, SESSIONLESS_COMMANDS, SessionLockRefusedError, apply, composeAgent, dangerCommand, foldQueueRows, forkSeed, inject, isPlainExitPrompt, isSubagentSettlementNotice, matchPendingSubagentCall, name, recomposeBlank, recordedPreset, resolveInitialCatalog, resumeCommand, runningProfile, shouldConsumeAdvertisedMiss, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint, subagentNoticeIsFailure };