@xmoon76/dsh-pi-tui 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -29,6 +29,7 @@ import { eastAsianWidth } from "get-east-asian-width";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
 import { EventEmitter } from "events";
+import { isUserInvocable } from "@deepseek-ai/dsh-skill";
 //#region src/present.ts
 /** Figma row titles per variant (design literals, not translatable copy). */
 const VARIANT_TITLES = {
@@ -12607,33 +12608,56 @@ var TranscriptSearchComponent = class {
 //#endregion
 //#region src/question.ts
 /**
-* The user-questions dialog flow (ask_user_question v2): a focusable overlay
-* component that walks one question at a time, collects drafts per question,
-* and submits the whole batch at the end — the Web QuestionComposer
-* semantics (per-question paging, batch submit, skip) with pi/kimi keyboard
-* ergonomics (↑↓ highlight, digits, real Input for free text, review page).
+* The user-questions dialog flow (ask_user_question v2): the component that
+* sits in the EDITOR SEAT (kimi's mountEditorReplacement pattern) while the
+* agent asks — one question at a time, drafts per question, whole batch
+* submitted at the end — the Web QuestionComposer semantics (per-question
+* paging, batch submit, skip) with pi/kimi keyboard ergonomics (↑↓
+* highlight, digits, real Input for free text, review page).
 *
-* Pure component: the app layer owns the promise/abort plumbing and routes
-* input here while the flow is active.
+* Pure component: the app layer owns the promise/abort plumbing, the seat
+* swap, and routes input here while the flow is active.
 * @module @xmoon76/dsh-pi-tui/question
 */
 /** The "type your own answer" row shown below options (pi isOther parity). */
 const OTHER_ROW = "\0other";
 /**
-* Total physical-row budget of the question flow itself. The Frame wrapper
-* adds its two border rows, and the overlay clips past maxHeight 26 instead
-* of scrolling — so EVERYTHING (tabs, question, detail, options with their
-* descriptions, scroll marker, skipped note, hint) must fit in 24 rows.
+* Default total physical-row budget of the question flow itself. The
+* QuestionFrame in tui-app.ts re-derives the budget from the terminal height
+* on every render (60% cap COLLAPSED, 8..24 content rows; up to 38 when
+* expanded) and pushes it through {@link QuestionFlow.setMaxRows}; 24 is the
+* fallback for direct renders.
+* The Frame wrapper adds its two border rows, and NOTHING clips the flow's
+* output in the editor-seat layout — so EVERYTHING (tabs, question, detail,
+* options with their descriptions, scroll marker, skipped note, hint) must
+* fit in the budget.
 */
-const DIALOG_BUDGET = 24;
+const DEFAULT_BUDGET = 24;
 /**
-* Total physical-row budget for the question body (question text + detail),
-* shared so a single unbroken long line cannot push the options and hints
-* out of the dialog's maxHeight (kimi MAX_BODY_LINES scale).
+* Smallest supported content-row budget (a 16-row terminal caps the frame at
+* 10 rows). Below this the required rows (tabs, the question's first row,
+* the current option, the hint) cannot all coexist.
 */
-const MAX_BODY_LINES = 12;
-/** Max visible option rows before the list windows around the cursor. */
-const MAX_VISIBLE_OPTIONS = 7;
+const MIN_SUPPORTED_BUDGET = 8;
+/**
+* Largest supported content-row budget: the EXPANDED frame cap (80% of the
+* terminal, at most 40 frame rows) minus the two frame borders. An explicit
+* body expand ('e' / marker click) grows the panel beyond the default 60%
+* cap — the user asked for the room; the budget math is linear and holds
+* for every budget >= MIN_SUPPORTED_BUDGET.
+*/
+const MAX_BUDGET = 38;
+/**
+* Cap for the WRAPPED page scrollport content (question + detail + options
+* with their descriptions). Beyond it the content ends in a `... more
+* content hidden` note — wrapping an unbounded 100KB detail every frame
+* would be wasteful. 256 rows keeps realistic questions AND all their
+* answerable options reachable (7 options × ~19 wrapped description rows
+* at 50 columns fits); the cap is a hard wall, so a page whose content
+* alone exceeds 256 rows ends in the note — that page is unreachable in
+* practice, and the note makes the cut non-silent.
+*/
+const MAX_CONTENT_ROWS = 256;
 /**
 * Budgeted push of `content` to `lines`, wrapping it to `width`: pushes at
 * most `budget` PHYSICAL (wrapped) rows, appends a `... N more` marker when
@@ -12658,14 +12682,15 @@ function appendWrappedBudgeted(lines, firstPrefix, continuationPrefix, content,
 	return Math.max(0, budget - used);
 }
 /**
-* Push the CURRENT option's label: its first physical row is ALWAYS emitted
-* (the `→` pointer must stay on screen), extra rows fill `budget`, and a
-* `... N more` marker reports a label that was itself cut. Unlike
-* {@link appendWrappedBudgeted}, a 1-row budget shows the label content, not
-* just the cut marker — the anchored current option may never vanish.
+* Required-first push: the FIRST physical row always carries `content` —
+* never just a cut marker — while extra rows fill `budget` and a `... N
+* more` marker reports content that was itself cut, only when a row remains
+* after the content. Used for the question body and the highlighted option
+* label, whose first rows may never vanish (a 1-row budget shows the
+* content, not the marker).
 * @returns the remaining budget (≥ 0).
 */
-function appendCurrentLabel(lines, firstPrefix, continuationPrefix, content, width, budget) {
+function appendContentFirst(lines, firstPrefix, continuationPrefix, content, width, budget) {
 	if (budget <= 0) return 0;
 	const prefixWidth = Math.max(visibleWidth(firstPrefix), visibleWidth(continuationPrefix));
 	const wrapped = wrapTextWithAnsi(content, Math.max(1, width - prefixWidth));
@@ -12723,7 +12748,47 @@ var QuestionFlow = class {
 	otherInput = new Input();
 	/** Review-page action highlight (0 = Submit, 1 = Cancel). */
 	submitIdx = 0;
-	focused = false;
+	/**
+	* Current content-row budget (8..38). The editor-seat QuestionFrame in
+	* tui-app.ts re-derives it from the terminal height on every render and
+	* pushes it through {@link setMaxRows}; nothing clips the flow's output
+	* in that layout, so every render must fit the budget exactly.
+	*/
+	budget = DEFAULT_BUDGET;
+	_focused = false;
+	/**
+	* Scroll offset (content rows) into the UNIFIED page scrollport (question,
+	* detail, then every option with its description, then the free-text row).
+	* PageUp/PageDown move it; ↑↓/digits/click move the cursor and the render
+	* follows it into view (pendingCursorScroll).
+	*/
+	bodyScroll = 0;
+	/**
+	* Expanded mode ('e' / marker click): the FRAME grows toward 80% (the
+	* QuestionFrame reads isBodyExpanded each render), so the scrollport is
+	* taller and more of the page — including option descriptions — is visible
+	* at once. Everything stays reachable by scrolling either way.
+	*/
+	bodyExpanded = false;
+	/** Cursor moved since the last render: the next render must scroll the
+	* cursor's rows into view. */
+	pendingCursorScroll = false;
+	/** Hit map from the last render: content row -> option row key. Built each
+	* render; drives fullscreen click-to-select. */
+	hitMap = /* @__PURE__ */ new Map();
+	/** Content row of the scroll marker in the last render (-1 = none);
+	* clicking it toggles the expanded panel. */
+	lastMarkerRow = -1;
+	/** Scrollport height from the last render (scroll page math). */
+	lastRegionHeight = 0;
+	/** Wrapped page content length from the last render. */
+	lastContentRows = 0;
+	/** Content rows visible in the region from the last render (region minus
+	* the marker row when overflowing). */
+	lastVisibleRows = 0;
+	/** Whether the page content overflows the scrollport on the last render —
+	* 'e' (and the scroll verbs) are available when true. */
+	lastExpandable = false;
 	constructor(questions, onDone, onCancel) {
 		this.questions = questions;
 		this.onDone = onDone;
@@ -12737,6 +12802,162 @@ var QuestionFlow = class {
 		this.otherInput.onEscape = () => this.exitOther();
 		this.syncEditMode();
 	}
+	/**
+	* Focus mirror for the editor-seat layout: the app focuses the wrapping
+	* QuestionFrame, which forwards here. The free-text Input renders its
+	* hardware cursor only while focused AND editing, so the mirror must sync
+	* it — a plain field would leave the cursor permanently hidden.
+	*/
+	get focused() {
+		return this._focused;
+	}
+	set focused(value) {
+		this._focused = value;
+		if (this.editingOther) this.otherInput.focused = value;
+	}
+	/**
+	* Replace the content-row budget (the Frame wrapper adds its two border
+	* rows on top). Called by QuestionFrame on every render immediately
+	* before the flow renders, so no invalidation is needed; values outside
+	* [MIN_SUPPORTED_BUDGET, MAX_BUDGET] are clamped.
+	*/
+	setMaxRows(rows) {
+		this.budget = Math.max(MIN_SUPPORTED_BUDGET, Math.min(MAX_BUDGET, Math.floor(rows)));
+	}
+	/** Whether the panel is expanded (the frame grows toward 80% of the
+	* terminal — QuestionFrame reads this every render). */
+	isBodyExpanded() {
+		return this.bodyExpanded;
+	}
+	/**
+	* Reset the view (scroll + expanded + pending cursor follow) — called on
+	* every tab change so each question starts at its top, collapsed.
+	*/
+	resetBodyView() {
+		this.bodyScroll = 0;
+		this.bodyExpanded = false;
+		this.pendingCursorScroll = false;
+	}
+	/**
+	* Page the unified scrollport. One page = the visible content rows. No-op
+	* when the content fits the region.
+	*/
+	scrollBody(direction) {
+		const visible = this.lastVisibleRows;
+		if (visible <= 0 || this.lastContentRows <= visible) return;
+		const maxScroll = this.lastContentRows - visible;
+		this.bodyScroll = Math.max(0, Math.min(this.bodyScroll + direction * visible, maxScroll));
+	}
+	/** Toggle the expanded panel ('e' or a click on the scroll marker).
+	* Expanding is only meaningful when the page content overflows the
+	* scrollport (everything fits -> a taller panel shows nothing new). The
+	* SCROLL POSITION is kept: the taller region reveals MORE rows where the
+	* user is looking (e.g. the option descriptions they scrolled to), instead
+	* of jumping back to the top — the render clamps the offset to the new
+	* maxScroll. */
+	toggleExpanded() {
+		if (!this.bodyExpanded && !this.lastExpandable) return;
+		this.bodyExpanded = !this.bodyExpanded;
+	}
+	/**
+	* Primary-click routing (fullscreen): an option row selects it (single-
+	* select advances, multi-select toggles, the "Type something." row enters
+	* free-text), and the scroll marker toggles the expanded panel. The hit
+	* map reflects the LAST rendered frame, which is what the user sees.
+	*/
+	clickRow(row) {
+		if (row < 0 || this.tab >= this.questions.length) return;
+		const key = this.hitMap.get(row);
+		if (key === OTHER_ROW) {
+			if (this.editingOther) return;
+			const index = this.rows().findIndex((candidate) => candidate.key === OTHER_ROW);
+			if (index >= 0) {
+				this.cursor = index;
+				this.pendingCursorScroll = true;
+				this.enterOther();
+			}
+			return;
+		}
+		if (key !== void 0) {
+			this.cursor = Number(key);
+			this.pendingCursorScroll = true;
+			this.confirm();
+			return;
+		}
+		if (row === this.lastMarkerRow) this.toggleExpanded();
+	}
+	/**
+	* Build the UNIFIED page scrollport content: the question + detail first
+	* (required-first — row 0 is always the question's first physical row),
+	* a separator, then every option row (label + description), then the
+	* free-text row. Each option row maps to its key for click hit-testing.
+	* Capped at MAX_CONTENT_ROWS with a trailing `... more content hidden`
+	* note, so wrapping an unbounded detail/description stays cheap.
+	*/
+	buildPageContent(question, rows, draft, multi, width) {
+		const lines = [];
+		const hits = [];
+		let left = MAX_CONTENT_ROWS;
+		left = appendContentFirst(lines, `${color.primary("?")}  `, "    ", color.textStrong(question.question), width, left);
+		hits.push(...new Array(lines.length).fill(void 0));
+		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) {
+			if (left <= 1) {
+				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), width, left);
+				break;
+			}
+			left = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), width, left);
+		}
+		hits.push(...new Array(lines.length - hits.length).fill(void 0));
+		lines.push("");
+		hits.push(void 0);
+		for (const row of rows) {
+			const isCursor = rows[this.cursor] === row;
+			const selected = row.key === OTHER_ROW ? draft.custom !== "" : draft.selected.has(question.options?.[Number(row.key)]?.label ?? "");
+			const marker = multi || row.key === OTHER_ROW ? selected ? color.success("[✓]") : color.textDim("[ ]") : selected ? color.success(`[${Number(row.key) + 1}]`) : color.textDim(`[${Number(row.key) + 1}]`);
+			const prefix = `${isCursor ? color.primary("→") : " "} ${marker} `;
+			const indent = " ".repeat(visibleWidth(prefix));
+			const badge = row.recommended ? ` ${color.primary("[recommended]")}` : "";
+			const label = isCursor ? color.textStrong(row.label) : row.label;
+			if (row.key === OTHER_ROW && this.editingOther) {
+				const inputLine = this.otherInput.render(Math.max(1, width - visibleWidth(prefix)))[0] ?? "";
+				const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
+				lines.push(prefix + (this.otherInput.getValue() === "" ? color.textDim(row.label) : stripped));
+				hits.push(OTHER_ROW);
+				continue;
+			}
+			const labelWidth = Math.max(1, width - visibleWidth(prefix));
+			for (const wrapped of wrapTextWithAnsi(`${label}${badge}`, labelWidth)) if (!this.pushPageRow(lines, hits, prefix + wrapped, row.key)) return {
+				lines,
+				hits
+			};
+			if (row.description !== void 0 && row.description !== "" && !(row.key === OTHER_ROW && this.editingOther)) {
+				const descWidth = Math.max(1, width - visibleWidth(indent));
+				for (const wrapped of wrapTextWithAnsi(color.textDim(row.description), descWidth)) if (!this.pushPageRow(lines, hits, indent + wrapped, row.key)) return {
+					lines,
+					hits
+				};
+			}
+		}
+		return {
+			lines,
+			hits
+		};
+	}
+	/** Push one page-content row, capping at MAX_CONTENT_ROWS with a single
+	* `... more content hidden` note (never a second one after the detail's).
+	* @returns false when the cap was hit (callers stop building). */
+	pushPageRow(lines, hits, line, key) {
+		if (lines.length >= MAX_CONTENT_ROWS) {
+			if (lines[lines.length - 1]?.includes("more content hidden") !== true) {
+				lines.push(color.textDim("... more content hidden"));
+				hits.push(void 0);
+			}
+			return false;
+		}
+		lines.push(line);
+		hits.push(key);
+		return true;
+	}
 	/** The rows of the current question (options plus the free-text row). */
 	rows() {
 		const question = this.questions[this.tab];
@@ -12805,6 +13026,7 @@ var QuestionFlow = class {
 	}
 	/** Optionless questions edit text directly; options start in list mode. */
 	syncEditMode() {
+		this.resetBodyView();
 		const question = this.questions[this.tab];
 		const optionless = question !== void 0 && (question.options?.length ?? 0) === 0;
 		this.editingOther = optionless;
@@ -12879,6 +13101,7 @@ var QuestionFlow = class {
 		if (this.editingOther) {
 			if (data === "\r" || data === "\n") this.commitOther(this.otherInput.getValue());
 			else if (data === "\x1B") this.exitOther();
+			else if (data === "\x1B[5~" || data === "\x1B[6~") this.scrollBody(data === "\x1B[5~" ? -1 : 1);
 			else if (data === "\x1B[D") {
 				if (this.tab > 0) {
 					this.tab -= 1;
@@ -12921,16 +13144,27 @@ var QuestionFlow = class {
 			const row = rows[Number(digit[0]) - 1];
 			if (row !== void 0) {
 				this.cursor = rows.indexOf(row);
+				this.pendingCursorScroll = true;
 				this.confirm();
 			}
 			return;
 		}
 		if (data === "\x1B[A" || data === "k") {
 			if (rows.length > 0) this.cursor = (this.cursor - 1 + rows.length) % rows.length;
+			this.pendingCursorScroll = true;
 			return;
 		}
 		if (data === "\x1B[B" || data === "j") {
 			if (rows.length > 0) this.cursor = (this.cursor + 1) % rows.length;
+			this.pendingCursorScroll = true;
+			return;
+		}
+		if (data === "\x1B[5~" || data === "\x1B[6~") {
+			this.scrollBody(data === "\x1B[5~" ? -1 : 1);
+			return;
+		}
+		if (data === "e") {
+			this.toggleExpanded();
 			return;
 		}
 		if (data === "\r" || data === "\n") {
@@ -12951,6 +13185,7 @@ var QuestionFlow = class {
 				this.tab += 1;
 				this.cursor = 0;
 				this.submitIdx = 0;
+				this.syncEditMode();
 			} else {
 				this.tab = this.questions.length;
 				this.cursor = 0;
@@ -12971,6 +13206,8 @@ var QuestionFlow = class {
 	render(width) {
 		const safeWidth = Math.max(1, width);
 		const lines = [];
+		this.hitMap.clear();
+		this.lastMarkerRow = -1;
 		const tabs = this.questions.map((_, index) => {
 			const draft = this.drafts[index];
 			const answered = draft !== void 0 && (draft.selected.size > 0 || draft.custom !== "" || draft.skipped);
@@ -12983,7 +13220,7 @@ var QuestionFlow = class {
 		lines.push(tabs.join("  "));
 		lines.push("");
 		if (this.tab >= this.questions.length) {
-			let reviewBudget = 19;
+			let reviewBudget = this.budget - lines.length - 2;
 			reviewBudget = appendWrappedBudgeted(lines, "", "", color.textStrong("Review your answer before submit"), safeWidth, reviewBudget);
 			if (reviewBudget > 0) {
 				lines.push("");
@@ -13010,98 +13247,75 @@ var QuestionFlow = class {
 		const question = this.questions[this.tab];
 		const draft = this.draft();
 		if (question === void 0 || draft === void 0) return lines;
-		if (question.header !== void 0 && question.header !== "") lines.push(color.textDim(question.header));
-		let bodyBudget = MAX_BODY_LINES;
-		bodyBudget = appendWrappedBudgeted(lines, `${color.primary("?")}  `, "    ", color.textStrong(question.question), safeWidth, bodyBudget);
-		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) {
-			if (bodyBudget <= 1) {
-				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), safeWidth, bodyBudget);
-				break;
-			}
-			bodyBudget = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), safeWidth, bodyBudget);
-		}
 		const rows = this.rows();
 		const multi = question.multiSelect === true;
-		this.editingOther && rows.some((row) => row.key === OTHER_ROW);
-		if (rows.length > 0 && !(rows.length === 1 && rows[0]?.key === OTHER_ROW)) {
-			lines.push("");
-			const showingRow = rows.length > MAX_VISIBLE_OPTIONS ? 1 : 0;
-			const skippedRow = draft.skipped ? 1 : 0;
-			let optionBudget = DIALOG_BUDGET - lines.length - 2 - showingRow - skippedRow;
-			const maxWindow = Math.max(1, Math.min(MAX_VISIBLE_OPTIONS, optionBudget));
-			const visibleCount = Math.min(rows.length, maxWindow);
-			const half = Math.floor(maxWindow / 2);
-			const maxStart = Math.max(0, rows.length - visibleCount);
-			const start = Math.max(0, Math.min(this.cursor - half, maxStart));
-			const end = Math.min(rows.length, start + visibleCount);
-			if (optionBudget > 0) {
-				const cursorRow = rows[this.cursor];
-				let reserved = 1;
-				if (cursorRow !== void 0 && cursorRow.key !== OTHER_ROW) {
-					const prefix = `→ ${multi || cursorRow.key === OTHER_ROW ? draft.selected.has(question.options?.[Number(cursorRow.key)]?.label ?? "") ? "[✓]" : "[ ]" : draft.selected.has(question.options?.[Number(cursorRow.key)]?.label ?? "") ? `[${Number(cursorRow.key) + 1}]` : `[${Number(cursorRow.key) + 1}]`} `;
-					const badge = cursorRow.recommended ? ` ${color.primary("[recommended]")}` : "";
-					reserved = Math.min(Math.max(1, wrapTextWithAnsi(`${color.textStrong(cursorRow.label)}${badge}`, Math.max(1, safeWidth - visibleWidth(prefix))).length), maxWindow);
-				}
-				let left = optionBudget;
-				let cursorRendered = false;
-				for (let index = start; index < end; index++) {
-					const row = rows[index];
-					if (row === void 0) continue;
-					const isCursor = index === this.cursor;
-					if (!isCursor && (cursorRendered ? left <= 0 : left <= reserved)) continue;
-					if (row.key === OTHER_ROW && this.editingOther) {
-						const prefix = `${color.primary("→")} ${color.textDim(`[${index + 1}]`)} `;
-						const inputLine = this.otherInput.render(Math.max(1, safeWidth - visibleWidth(prefix)))[0] ?? "";
-						const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
-						left -= 1;
-						lines.push(prefix + stripped);
-						if (isCursor) cursorRendered = true;
-						continue;
-					}
-					const selected = row.key === OTHER_ROW ? draft.custom !== "" : draft.selected.has(question.options?.[Number(row.key)]?.label ?? "");
-					const marker = multi || row.key === OTHER_ROW ? selected ? color.success("[✓]") : color.textDim("[ ]") : selected ? color.success(`[${Number(row.key) + 1}]`) : color.textDim(`[${Number(row.key) + 1}]`);
-					const prefix = `${isCursor ? color.primary("→") : " "} ${marker} `;
-					const badge = row.recommended ? ` ${color.primary("[recommended]")}` : "";
-					const label = isCursor ? color.textStrong(row.label) : row.label;
-					const indent = " ".repeat(visibleWidth(prefix));
-					const available = isCursor || cursorRendered ? left : left - reserved;
-					const beforeLabel = lines.length;
-					if (isCursor) appendCurrentLabel(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
-					else appendWrappedBudgeted(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
-					left -= lines.length - beforeLabel;
-					if (row.description !== void 0 && row.description !== "" && left > 0) {
-						const descCap = isCursor || cursorRendered ? left : left - reserved;
-						const beforeDescription = lines.length;
-						appendWrappedBudgeted(lines, indent, indent, color.textDim(row.description), safeWidth, descCap);
-						left -= lines.length - beforeDescription;
-					}
-					if (isCursor) cursorRendered = true;
+		const skippedRow = draft.skipped ? 1 : 0;
+		const optionless = rows.length === 0 || rows.length === 1 && rows[0]?.key === OTHER_ROW;
+		const tail = optionless ? 3 + skippedRow : 2 + skippedRow;
+		const header = question.header;
+		if (header !== void 0 && header !== "" && this.budget - lines.length - tail >= 2) lines.push(color.textDim(header));
+		const content = this.buildPageContent(question, rows, draft, multi, safeWidth);
+		const regionHeight = Math.max(1, this.budget - lines.length - tail);
+		const overflow = content.lines.length > regionHeight;
+		const visible = overflow && regionHeight >= 2 ? regionHeight - 1 : regionHeight;
+		this.lastRegionHeight = regionHeight;
+		this.lastContentRows = content.lines.length;
+		this.lastVisibleRows = visible;
+		this.lastExpandable = overflow && regionHeight >= 2;
+		const maxScroll = Math.max(0, content.lines.length - visible);
+		this.bodyScroll = Math.min(this.bodyScroll, maxScroll);
+		if (this.pendingCursorScroll) {
+			this.pendingCursorScroll = false;
+			const cursorKey = rows[this.cursor]?.key;
+			if (cursorKey !== void 0) {
+				const first = content.hits.indexOf(cursorKey);
+				if (first >= 0) {
+					if (first < this.bodyScroll) this.bodyScroll = first;
+					else if (first >= this.bodyScroll + visible) this.bodyScroll = first - visible + 1;
+					this.bodyScroll = Math.max(0, Math.min(this.bodyScroll, maxScroll));
 				}
-				if (showingRow === 1 && left > 0) left = appendWrappedBudgeted(lines, "   ", "   ", `showing ${start + 1}-${end} of ${rows.length}`, safeWidth, left);
 			}
-		} else if (this.editingOther || (question.options?.length ?? 0) === 0) {
+		}
+		for (let index = this.bodyScroll; index < this.bodyScroll + visible && index < content.lines.length; index++) {
+			const hit = content.hits[index];
+			if (hit !== void 0) this.hitMap.set(lines.length, hit);
+			lines.push(content.lines[index]);
+		}
+		if (overflow && regionHeight >= 2) {
+			const above = this.bodyScroll;
+			const below = content.lines.length - (this.bodyScroll + visible);
+			const marker = above > 0 && below > 0 ? `↑ ${above} up · ↓ ${below} more lines` : above > 0 ? `↑ ${above} up` : `↓ ${below} more lines`;
+			this.lastMarkerRow = lines.length;
+			lines.push(color.textDim(marker));
+		} else this.lastMarkerRow = -1;
+		if (optionless) {
 			const inputLine = this.otherInput.render(Math.max(1, safeWidth - 2))[0] ?? "";
 			const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
-			lines.push(` ${stripped}`);
+			lines.push(this.otherInput.getValue() === "" ? color.textDim(" Type your answer…") : ` ${stripped}`);
 		}
 		if (draft.skipped) lines.push(color.textDim("(skipped)"));
 		lines.push("");
 		const optionCount = Math.min(rows.length, 9);
+		const scrollable = this.lastExpandable;
 		const hintParts = [
 			"↑↓ select",
 			optionCount > 0 ? `1-${optionCount} choose` : "",
 			multi ? "↵ toggle" : "↵ confirm",
+			scrollable ? "pgup/pgdn scroll" : "",
+			!this.editingOther ? this.bodyExpanded ? "e collapse" : scrollable ? "e expand" : "" : "",
 			this.questions.length > 1 ? "←→ switch" : "",
 			"s skip",
 			"esc cancel"
 		].filter((part) => part !== "");
+		const cancel = "esc cancel";
+		const verbs = hintParts.filter((part) => part !== cancel);
 		let hint = "";
-		for (const part of hintParts) {
+		for (const part of verbs) {
 			const next = hint === "" ? part : `${hint} · ${part}`;
-			if (visibleWidth(next) > safeWidth) break;
+			if (visibleWidth(`${next} · ${cancel}`) > safeWidth) break;
 			hint = next;
 		}
-		lines.push(color.textDim(hint === "" ? "esc cancel" : hint));
+		lines.push(color.textDim(hint === "" ? cancel : `${hint} · ${cancel}`));
 		return lines;
 	}
 };
@@ -13610,13 +13824,16 @@ function preview(text, lines) {
 const CONTEXT_BAR_WIDTH = 12;
 /**
 * Rounded-frame wrapper for overlay content: `╭─╮` border in the border
-* token, one cell of padding, width sized to the content. Keyboard input
-* forwards to the wrapped component.
+* token, one cell of padding, width sized to the content. With `fillWidth`
+* the frame keeps the overlay's full width instead of hugging the widest
+* content row. Keyboard input forwards to the wrapped component.
 */
 var Frame = class {
 	child;
-	constructor(child) {
+	fillWidth;
+	constructor(child, fillWidth = false) {
 		this.child = child;
+		this.fillWidth = fillWidth;
 	}
 	invalidate() {
 		this.child.invalidate?.();
@@ -13630,7 +13847,7 @@ var Frame = class {
 	render(width) {
 		const inner = Math.max(1, Math.floor(width) - 4);
 		const lines = this.child.render(inner).map((line) => truncateToWidth(line, inner, "…"));
-		const contentWidth = Math.min(inner, Math.max(1, ...lines.map((line) => visibleWidth(line))));
+		const contentWidth = this.fillWidth ? inner : Math.min(inner, Math.max(1, ...lines.map((line) => visibleWidth(line))));
 		const frameWidth = contentWidth + 4;
 		const b = color.border;
 		const out = [b(`╭${"─".repeat(frameWidth - 2)}╮`)];
@@ -13643,6 +13860,51 @@ var Frame = class {
 		return out;
 	}
 };
+/**
+* Frame for the question flow in the EDITOR SEAT: it re-derives the flow's
+* row budget from the terminal height on EVERY render (60% cap, 8..24
+* content rows — the flow's render output IS its height in the seat layout,
+* nothing clips it), so an active resize or a queued flow presented later
+* always budgets against the current terminal. It also forwards focus to the
+* flow so its free-text Input keeps the hardware cursor (a plain Frame would
+* swallow the focus flag).
+*/
+var QuestionFrame = class extends Frame {
+	flow;
+	heightOf;
+	/** Rendered height of the last frame (fullscreen click hit-testing). */
+	lastRows = 0;
+	/** Terminal height the last render used (click staleness guard). */
+	lastTermRows = 0;
+	constructor(flow, heightOf) {
+		super(flow, true);
+		this.flow = flow;
+		this.heightOf = heightOf;
+	}
+	render(width) {
+		const rows = Math.max(1, this.heightOf());
+		this.lastTermRows = rows;
+		const frameRows = this.flow.isBodyExpanded() ? Math.max(10, Math.min(40, Math.floor(rows * .8))) : Math.max(10, Math.min(26, Math.floor(rows * .6)));
+		this.flow.setMaxRows(frameRows - 2);
+		const out = super.render(width);
+		this.lastRows = out.length;
+		return out;
+	}
+	/** The frame's height from the last render (0 before the first one). */
+	get rows() {
+		return this.lastRows;
+	}
+	/** The terminal height the last render used. */
+	get termRows() {
+		return this.lastTermRows;
+	}
+	get focused() {
+		return this.flow.focused;
+	}
+	set focused(value) {
+		this.flow.focused = value;
+	}
+};
 /** The session head card: identity facts, wrapped to the available width so
 * nothing is truncated, framed with a box whose width matches the editor's
 * border below it (a fixed-width rule looked misaligned next to the frame). */
@@ -13712,6 +13974,134 @@ var Spacer = class {
 		return [""];
 	}
 };
+/**
+* Bullet + continuation-indent wrapper that keeps its child LIVE, so a
+* terminal resize re-renders the child at the new width instead of
+* re-wrapping a frozen render (the 5a76526 regression: assistant/user
+* messages were flattened to a static Text at build time, so markdown
+* tables could never reflow and border lines wrapped as plain text on
+* narrow windows). The bullet leads the FIRST line; wrapped continuation
+* lines indent under it (kimi prefix+indent parity).
+*
+* The prefixed output keeps a REFERENCE-STABLE cache: when the child
+* returns the same array instance (its own text+width cache hit) at the
+* same width, the wrapper returns the same prefixed array — so the fork's
+* per-frame processed-line reuse (fork AGENTS.md divergence 5) keeps
+* hitting on steady frames instead of re-normalizing every line.
+*/
+var BulletedComponent = class {
+	child;
+	prefix;
+	prefixWidth;
+	indent;
+	lastChild;
+	lastWidth = -1;
+	cached;
+	constructor(child, prefix) {
+		this.child = child;
+		this.prefix = prefix;
+		this.prefixWidth = visibleWidth(prefix);
+		this.indent = " ".repeat(this.prefixWidth);
+	}
+	invalidate() {
+		this.child.invalidate?.();
+	}
+	dispose() {
+		this.child.dispose?.();
+	}
+	render(width) {
+		const inner = Math.max(1, width - this.prefixWidth);
+		const child = this.child.render(inner);
+		if (child === this.lastChild && width === this.lastWidth && this.cached !== void 0) return this.cached;
+		this.lastChild = child;
+		this.lastWidth = width;
+		this.cached = child.map((line, index) => (index === 0 ? this.prefix : this.indent) + line);
+		return this.cached;
+	}
+};
+/**
+* Longest prefix of `text` whose WRAPPED height fits `budget` rows at
+* `width`, with an ellipsis marking a cut — the approval dialog's height
+* budget must count wrapped rows, not raw lines, because a single long
+* line can wrap across many display rows. Wrapped height is monotonic in
+* the prefix length, so a binary search bounds the wrap calls. The
+* ellipsis reserves its own row when truncating (a full last row would
+* otherwise push it onto a new row and overflow the budget).
+* @param text - the candidate text ('' yields '').
+* @param width - the wrap width.
+* @param budget - the row budget; 0 or negative yields '…' for non-empty.
+* @returns the fitted text and whether it was truncated.
+*/
+function capWrappedToHeight(text, width, budget) {
+	if (text === "") return {
+		text: "",
+		truncated: false
+	};
+	if (budget <= 0) return {
+		text: "",
+		truncated: true
+	};
+	const fits = (candidate, rows) => wrapTextWithAnsi(candidate, width).length <= rows;
+	if (fits(text, budget)) return {
+		text,
+		truncated: false
+	};
+	if (budget === 1) return {
+		text: truncateToWidth(text, width, "…"),
+		truncated: true
+	};
+	const target = budget - 1;
+	let low = 0;
+	let high = text.length;
+	while (low < high) {
+		const mid = Math.ceil((low + high) / 2);
+		if (fits(text.slice(0, mid), target)) low = mid;
+		else high = mid - 1;
+	}
+	return {
+		text: `${text.slice(0, low)}…`,
+		truncated: true
+	};
+}
+/**
+* Fit `text` into `budget` wrapped rows for the approval dialog, ending with
+* a dimmed `... N more` marker row when the content is cut. The marker rides
+* INSIDE the budget (content rows cap at budget−1, the marker itself is
+* width-cropped so it can never wrap), so a section can never silently
+* overflow the dialog's maxHeight — same marker semantics as the
+* question flow's `appendWrappedBudgeted`. A single-row budget keeps
+* the old width-cropped ellipsis (a bare marker row would waste the row).
+* @returns the display text (rows joined with '\n') and the hidden row count.
+*/
+function capWrappedToMarker(text, width, budget) {
+	if (text === "" || budget <= 0) return {
+		text: "",
+		hidden: 0
+	};
+	const total = wrapTextWithAnsi(text, width).length;
+	if (total <= budget) return {
+		text,
+		hidden: 0
+	};
+	if (budget === 1) return {
+		text: truncateToWidth(text, width, "…"),
+		hidden: total - 1
+	};
+	const target = budget - 1;
+	let low = 0;
+	let high = text.length;
+	while (low < high) {
+		const mid = Math.ceil((low + high) / 2);
+		if (wrapTextWithAnsi(text.slice(0, mid), width).length <= target) low = mid;
+		else high = mid - 1;
+	}
+	const hidden = total - target;
+	const marker = truncateToWidth(color.textDim(`... ${hidden} more line${hidden > 1 ? "s" : ""}`), width, "…");
+	return {
+		text: `${text.slice(0, low)}\n${marker}`,
+		hidden
+	};
+}
 /** The live job-output viewer body: a title line + refreshable text panel. */
 var OutputViewerPanel = class {
 	title;
@@ -13751,6 +14141,13 @@ var TuiApp = class TuiApp {
 	terminal;
 	tui;
 	editor;
+	/**
+	* The editor's SEAT (kimi's editorContainer): holds the editor normally,
+	* the QuestionFrame while a question flow is active — so the dialog
+	* renders in the editor's row position (full width, above the footer)
+	* instead of a centered modal that covered the transcript.
+	*/
+	editorSeat;
 	header;
 	messagesView;
 	footer;
@@ -13789,6 +14186,8 @@ var TuiApp = class TuiApp {
 	dock;
 	/** Active background tasks for the dock/footer lines (label + status). */
 	dockTasks = [];
+	/** Live child subagents (continuable or running one-shot) for the dock/footer lines (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.
@@ -13810,6 +14209,19 @@ var TuiApp = class TuiApp {
 	}
 	/** Fullscreen (alt-screen) instance; absent in regular mode. */
 	fullscreen;
+	/** One shared in-flight autodetect; concurrent callers coalesce onto it
+	* (overlapping OSC 11 queries would mis-pair replies by FIFO order). */
+	autoDetectInFlight;
+	/** The LATEST shouldApply guard of the in-flight autodetect; consulted at
+	* settle time so a late result can never override a newer explicit
+	* choice; reset when the flight settles. */
+	autoDetectGuard;
+	/** Whether the terminal's live scheme reports are being tracked. */
+	followingTerminalTheme = false;
+	/** Terminal-scheme listeners, fanned out from every screen's reports. */
+	terminalSchemeListeners = /* @__PURE__ */ new Set();
+	/** Per-screen scheme-report registrations, rebuilt on screen switches. */
+	schemeDisposers = [];
 	/** The mounted transcript-search overlay, while one is open. */
 	searchOverlay;
 	/** The search input component, while one is open (for match counts). */
@@ -13874,6 +14286,13 @@ var TuiApp = class TuiApp {
 	externalEditorInFlight = false;
 	/** The live session's auto-generated title, shown in the header when set. */
 	sessionTitleText = "";
+	/** The read-only subagent viewer: while set, the editor bar shows a
+	* placeholder, the editor border switches to the accent color, and the
+	* header carries a persistent badge — the transient notify line is not
+	* the only signal. */
+	viewerMode;
+	/** The real draft preserved while the viewer covers the editor bar. */
+	draftBeforeViewer;
 	constructor(terminal, events, options = {}) {
 		if (events.openExternalEditor !== void 0 && events.runOwned === void 0) throw new Error("openExternalEditor requires runOwned (the owned-task entry — AGENTS.md)");
 		this.terminal = terminal;
@@ -13899,13 +14318,15 @@ var TuiApp = class TuiApp {
 		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);
+		this.editorSeat = new Container();
+		this.editorSeat.addChild(this.editor);
 		this.tui.addChild(this.header);
 		this.tui.addChild(this.messagesView);
 		this.tui.addChild(this.dock);
 		this.tui.addChild(this.todoPanel);
 		this.tui.addChild(this.queuePane);
 		this.tui.addChild(this.working);
-		this.tui.addChild(this.editor);
+		this.tui.addChild(this.editorSeat);
 		this.tui.addChild(this.footer);
 		this.tui.setFocus(this.editor);
 		this.tui.addInputListener((data) => this.routeInput(data));
@@ -13941,6 +14362,8 @@ var TuiApp = class TuiApp {
 		this.clearNotify();
 		this.working.dispose();
 		this.cancelQuestionFlows();
+		for (const dispose of this.schemeDisposers) dispose();
+		this.schemeDisposers = [];
 		this.tui.stop();
 		this.fullscreen?.stop();
 		this.fullscreen = void 0;
@@ -13950,6 +14373,7 @@ var TuiApp = class TuiApp {
 		if (isKeyRelease(data) || isKeyRepeat(data)) return void 0;
 		if (this.activeQuestions !== void 0) return this.handleQuestionKey(data);
 		if (this.activeApproval !== void 0) return this.handleApprovalKey(data);
+		if (this.viewerMode !== void 0 && !this.overlayHost.hasOverlayEntries && !matchesKey(data, "escape") && !matchesKey(data, "ctrl+o")) return { consume: true };
 		if (this.searchOverlay !== void 0) {
 			if (matchesKey(data, "escape")) {
 				this.closeTranscriptSearch();
@@ -13983,6 +14407,17 @@ var TuiApp = class TuiApp {
 			this.events.onDequeue?.();
 			return { consume: true };
 		}
+		if (matchesKey(data, "ctrl+enter")) {
+			if (this.overlayHost.hasOverlayEntries) return void 0;
+			if (this.events.onQueueSubmit === void 0) return void 0;
+			const text = this.editor.getText();
+			if (text.trim() === "") return void 0;
+			this.rememberInput(text);
+			this.clearNotify();
+			this.editor.setText("");
+			this.events.onQueueSubmit(text);
+			return { consume: true };
+		}
 		if (matchesKey(data, "escape")) {
 			if (this.overlayHost.hasOverlayEntries) return void 0;
 			if (this.events.onSingleEscape?.() === true) return { consume: true };
@@ -14047,6 +14482,14 @@ var TuiApp = class TuiApp {
 	* compositor interleaves stacked boxes line by line (two different-width
 	* dialogs would garble into one frame), and modal hiding is done here so
 	* the vendored fork stays pristine.
+	*
+	* While a question flow owns the seat (a logical capturing modal), a NEW
+	* overlay joins the question's suspension set instead of appearing on top:
+	* it is hidden, the question's directly suspended handles become ITS
+	* dependents (kept hidden, restored only when it closes), and the overlay
+	* itself becomes the question's frontmost suspended handle — so reverse
+	* modal order survives the question. Question input keeps first priority
+	* either way (routeInput).
 	* @param component - the overlay content.
 	* @param options - overlay sizing/positioning.
 	* @returns the handle; hide() also forgets the handle.
@@ -14054,6 +14497,27 @@ var TuiApp = class TuiApp {
 	showOverlayOnHost(component, options) {
 		const handle = this.overlayHost.showOverlay(component, options);
 		this.overlayHandles.add(handle);
+		const question = this.activeQuestions;
+		if (question !== void 0) {
+			for (const other of this.overlayHandles) if (other !== handle && !other.isHidden()) {
+				other.setHidden(true);
+				question.suspendedOverlays.add(other);
+			}
+			if (options?.nonCapturing !== true) {
+				const dependents = /* @__PURE__ */ new Set();
+				for (const other of question.suspendedOverlays) dependents.add(other);
+				if (dependents.size > 0) {
+					for (const other of dependents) question.suspendedOverlays.delete(other);
+					this.overlayDependents.set(handle, dependents);
+				}
+			}
+			handle.setHidden(true);
+			question.suspendedOverlays.add(handle);
+			return {
+				...handle,
+				hide: () => this.closeOverlayHandle(handle)
+			};
+		}
 		if (options?.nonCapturing !== true) {
 			const hidden = /* @__PURE__ */ new Set();
 			for (const other of this.overlayHandles) if (other !== handle && !other.isHidden()) {
@@ -14064,15 +14528,33 @@ var TuiApp = class TuiApp {
 		}
 		return {
 			...handle,
-			hide: () => {
-				this.overlayDependents.get(handle)?.forEach((other) => other.setHidden(false));
-				this.overlayDependents.delete(handle);
-				this.overlayHandles.delete(handle);
-				handle.hide();
-			}
+			hide: () => this.closeOverlayHandle(handle)
 		};
 	}
 	/**
+	* Question-aware close for one tracked overlay handle (the wrapper's
+	* hide). Without an active question this matches the historical behavior:
+	* the handle's dependents are unhidden, the graph is cleaned, and the
+	* overlay is removed. While a question owns the seat, the handle leaves
+	* the question's suspension set, every dependency set drops it (no parent
+	* retains a dead child), and its still-mounted dependents remain hidden
+	* and become DIRECTLY owned by the question — they must not flash back
+	* while the question is still up.
+	*/
+	closeOverlayHandle(handle) {
+		const question = this.activeQuestions;
+		if (question !== void 0) question.suspendedOverlays.delete(handle);
+		for (const dependents of this.overlayDependents.values()) dependents.delete(handle);
+		const owned = this.overlayDependents.get(handle);
+		if (owned !== void 0) {
+			this.overlayDependents.delete(handle);
+			if (question !== void 0) for (const dependent of owned) question.suspendedOverlays.add(dependent);
+			else for (const dependent of owned) dependent.setHidden(false);
+		}
+		this.overlayHandles.delete(handle);
+		handle.hide();
+	}
+	/**
 	* Launch the external editor with the current draft. The TUI stops first
 	* (raw mode released) and restarts after the editor returns; a fullscreen
 	* mode is not restored (the editor session ends in regular mode).
@@ -14189,6 +14671,20 @@ var TuiApp = class TuiApp {
 		this.rebuildMessages();
 	}
 	/**
+	* Drop SETTLED local cards (completed `!`/`!!` shell runs); running cards
+	* survive so a live stream is never dismissed by a concurrent submit.
+	* Local cards are a live view, not a record: context runs clear on submit
+	* success (the transcript's user row takes over), local-only runs on the
+	* next user submission (dispatchUserInput / steerNow).
+	*/
+	clearSettledLocalMessages() {
+		const running = this.localMessages.filter((message) => message.kind === "tool" && message.status === "running");
+		if (running.length === this.localMessages.length) return;
+		this.localMessages.length = 0;
+		this.localMessages.push(...running);
+		this.rebuildMessages();
+	}
+	/**
 	* Toggle between regular (terminal scrollback) and fullscreen (alt screen).
 	* Overlays live on the active screen, so the switch hides every mounted
 	* overlay; a pending approval prompt is re-rendered on the new screen.
@@ -14211,6 +14707,8 @@ var TuiApp = class TuiApp {
 		pending?.handle?.hide();
 		for (const handle of this.overlayHandles) handle.hide();
 		this.overlayHandles.clear();
+		this.overlayDependents.clear();
+		if (this.activeQuestions !== void 0) this.activeQuestions.suspendedOverlays.clear();
 		if (enabled) {
 			const alt = new TuiAltScreen(this.terminal, void 0, void 0, { onCellClick: (x, y) => this.handleFullscreenClick(x, y) });
 			this.fullscreenScroll = new ScrollView(this.messagesView, {
@@ -14244,7 +14742,7 @@ var TuiApp = class TuiApp {
 					shrink: 0
 				},
 				{
-					component: this.editor,
+					component: this.editorSeat,
 					shrink: 0
 				},
 				{
@@ -14258,6 +14756,7 @@ var TuiApp = class TuiApp {
 			alt.start();
 			alt.setFocus(this.editor);
 			this.fullscreen = alt;
+			this.refreshSchemeRegistrations();
 		} else {
 			this.fullscreen?.stop();
 			this.fullscreen = void 0;
@@ -14265,9 +14764,12 @@ var TuiApp = class TuiApp {
 			this.tui.start();
 			this.tui.requestRender(true);
 			this.tui.setFocus(this.editor);
+			this.refreshSchemeRegistrations();
 		}
 		this.events.onFullscreenChange?.(enabled);
 		if (pending !== void 0) this.renderApprovalDialog(pending);
+		const question = this.activeQuestions;
+		if (question?.frame !== void 0) (this.fullscreen ?? this.tui).setFocus(question.frame);
 	}
 	/**
 	* Open the transcript-search overlay (Ctrl+Shift+F) and focus its input.
@@ -14394,6 +14896,23 @@ var TuiApp = class TuiApp {
 	* The global Ctrl+O fold still wins, so keyboard behavior is unchanged.
 	*/
 	handleFullscreenClick(x, y) {
+		const question = this.activeQuestions;
+		if (question?.frame !== void 0) {
+			if (this.terminal.rows !== question.frame.termRows) return;
+			const width = this.terminal.columns;
+			const height = this.terminal.rows;
+			const footerHeight = this.footer.render(width).length;
+			const seatHeight = question.frame.rows;
+			const seatBottom = height - footerHeight;
+			const seatTop = seatBottom - seatHeight;
+			if (y >= seatTop && y < seatBottom) {
+				if (x >= 2 && x <= width - 3) {
+					question.flow.clickRow(y - seatTop - 1);
+					this.requestRender();
+				}
+				return;
+			}
+		}
 		const width = this.terminal.columns;
 		const rowInScroll = y - this.header.render(width).length;
 		if (rowInScroll < 0) return;
@@ -14467,11 +14986,46 @@ var TuiApp = class TuiApp {
 	/**
 	* Replace the editor draft. The runner restores a submission that the
 	* divergence guard blocked, so the user's text survives for a retry.
+	* While the subagent viewer covers the editor, the write goes to the
+	* preserved draft (the placeholder bar stays up; the draft is restored
+	* on exit).
 	*/
 	setEditorText(text) {
+		if (this.viewerMode !== void 0) {
+			this.draftBeforeViewer = text;
+			return;
+		}
 		this.editor.setText(text);
 	}
 	/**
+	* Enter or leave the read-only subagent viewer. While viewing, the
+	* editor bar is covered by a placeholder (the real draft is preserved
+	* and restored on exit), the editor border switches to the accent color,
+	* and the header shows a persistent `[viewing subagent]` badge — so the
+	* mode reads at a glance instead of relying on the transient notify.
+	* @param mode - the child identity + label; `undefined` leaves the viewer.
+	*/
+	setViewerMode(mode) {
+		if (mode === void 0) {
+			if (this.viewerMode === void 0) return;
+			this.viewerMode = void 0;
+			this.editor.borderColor = this.editorBorder;
+			this.editor.setText(this.draftBeforeViewer ?? "");
+			this.draftBeforeViewer = void 0;
+			this.editor.invalidate();
+			this.renderHeader();
+			this.requestRender();
+			return;
+		}
+		if (this.viewerMode === void 0) this.draftBeforeViewer = this.editor.getText();
+		this.viewerMode = mode;
+		this.editor.borderColor = color.accent;
+		this.editor.setText(`viewing subagent: ${mode.label} — read-only · Esc returns`);
+		this.editor.invalidate();
+		this.renderHeader();
+		this.requestRender();
+	}
+	/**
 	* Set the session head rendered above the transcript: the session identity,
 	* model, version, preset, and cwd, wrapped to the terminal width with a
 	* full-width rule beneath. Replaces any previous head.
@@ -14568,16 +15122,8 @@ var TuiApp = class TuiApp {
 	}
 	/** Render one transcript message as a pi-tui component. */
 	renderMessage(message, boundary) {
-		if (message.kind === "user") {
-			const prefix = `${color.roleUser("❯")} `;
-			const indent = " ".repeat(visibleWidth(prefix));
-			return new Text(new Text(message.text, 0, 0).render(Math.max(1, this.terminal.columns - visibleWidth(prefix))).map((line, index) => (index === 0 ? prefix : indent) + line).join("\n"), 0, 0);
-		}
-		if (message.kind === "assistant") {
-			const prefix = `${color.primary("🐋")}  `;
-			const indent = " ".repeat(visibleWidth(prefix));
-			return new Text(new Markdown(message.text, 0, 0, markdownTheme).render(Math.max(1, this.terminal.columns - visibleWidth(prefix))).map((line, index) => (index === 0 ? prefix : indent) + line).join("\n"), 0, 0);
-		}
+		if (message.kind === "user") return new BulletedComponent(new Text(message.text, 0, 0), `${color.roleUser("❯")} `);
+		if (message.kind === "assistant") return new BulletedComponent(new Markdown(message.text, 0, 0, markdownTheme), `${color.primary("🐋")}  `);
 		if (message.kind === "thinking") {
 			if (message.turn >= boundary || this.expandedOverride.get(message) === true) return new Text(color.textDimItalic(`🐳  ${message.text}`), 0, 0);
 			const lines = message.text.split("\n").filter((line) => line !== "");
@@ -14649,6 +15195,34 @@ var TuiApp = class TuiApp {
 		return card;
 	}
 	/**
+	* The expanded card's terminal-command row: `$ cmd` (bash) or `PS> cmd`
+	* (pwsh) in the shell prompt token, dimmed (kimi ShellExecution parity —
+	* the folded card shows the command; the expanded body must not drop
+	* it). Multi-line commands render every line under the prompt. No-op for
+	* an empty command.
+	* @param card - the card container to fill.
+	* @param command - the command text.
+	* @param prompt - the shell prompt token (`$ ` or `PS> `).
+	*/
+	addTerminalCommandRow(card, command, prompt) {
+		if (command === "") return;
+		const styledPrompt = color.shellMode(prompt);
+		const lines = command.split("\n");
+		for (const [index, line] of lines.entries()) {
+			const prefix = index === 0 ? styledPrompt : " ".repeat(visibleWidth(styledPrompt));
+			card.addChild(new Text(`${prefix}${color.textDim(line)}`, 0, 0));
+		}
+	}
+	/** The bash/pwsh command from the raw args ('' when not a terminal call). */
+	terminalCommand(name, argsRaw) {
+		const call = parseCallPreview(name, argsRaw);
+		return call?.kind === "bash" ? call.command : "";
+	}
+	/** The shell prompt token for a terminal tool (pwsh renders `PS> `). */
+	shellPrompt(name) {
+		return name === "pwsh" ? "PS> " : "$ ";
+	}
+	/**
 	* Render one expanded tool card's body. When the runner wired a presenter,
 	* the body follows the tool's own render intent (presentResult): a read
 	* card shows numbered lines plus the relativized path and total line
@@ -14689,12 +15263,18 @@ var TuiApp = class TuiApp {
 					this.renderDiffBody(card, callView.diffs, explicitlyExpanded);
 					return;
 				}
+				if (callView.card === "terminal") {
+					this.addTerminalCommandRow(card, callView.title, this.shellPrompt(message.name));
+					return;
+				}
 				if (callView.card === "generic" && callView.rawInput !== void 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));
 					return;
 				}
 			}
+			this.addTerminalCommandRow(card, this.terminalCommand(message.name, message.args), this.shellPrompt(message.name));
 			return;
 		}
 		if (message.result === "" && (message.resultBlocks?.length ?? 0) === 0) return;
@@ -14722,6 +15302,7 @@ var TuiApp = class TuiApp {
 				}
 				return;
 			case "terminal": {
+				this.addTerminalCommandRow(card, this.terminalCommand(message.name, message.args), this.shellPrompt(message.name));
 				if (resultView.output !== void 0 && resultView.output !== "") for (const line of resultView.output.split("\n")) card.addChild(new Text(color.textDim(line), 0, 0));
 				const exit = resultView.exitCode !== void 0 ? `[exit ${resultView.exitCode}]` : resultView.signal !== void 0 ? `[signal ${resultView.signal}]` : "";
 				if (exit !== "") card.addChild(new Text(color.textDim(exit), 0, 0));
@@ -14755,7 +15336,10 @@ 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 card.addChild(new Text(color.textDim(message.result), 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));
+		}
 	}
 	/**
 	* Fill a tool card with a diff body: LCS-aligned clustered lines, capped
@@ -14846,8 +15430,9 @@ var TuiApp = class TuiApp {
 	* switch only has to re-run this. */
 	renderHeader() {
 		const badge = this.planMode ? ` ${color.warning("[plan]")}` : "";
-		const title = this.sessionTitleText === "" ? "" : ` · ${color.textMuted(this.sessionTitleText)}`;
-		this.header.setText(`🐋  dsh-pi-tui${title}${this.todoText}${badge}`);
+		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.requestRender();
 	}
 	/**
@@ -14871,7 +15456,20 @@ var TuiApp = class TuiApp {
 	*/
 	setTasks(tasks) {
 		this.dockTasks = tasks;
-		this.tasksActive = tasks.length > 0;
+		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.
+	* @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();
 	}
@@ -14911,15 +15509,35 @@ var TuiApp = class TuiApp {
 	}
 	/**
 	* Replace the editor draft wholesale (the Alt+↑ dequeue path pulls every
-	* queued message back into the editor for editing).
+	* queued message back into the editor for editing). While the subagent
+	* viewer covers the editor, the write goes to the preserved draft.
 	*/
 	setDraft(text) {
+		if (this.viewerMode !== void 0) {
+			this.draftBeforeViewer = text;
+			return;
+		}
 		this.editor.setText(text);
 		this.requestRender();
 	}
-	/** The editor's current draft text (the Alt+↑ dequeue merge reads it). */
+	/** The editor's current draft text (the Alt+↑ dequeue merge reads it);
+	* while the viewer covers the editor, the preserved draft is returned. */
 	getDraft() {
-		return this.editor.getText();
+		return this.viewerMode !== void 0 && this.draftBeforeViewer !== void 0 ? this.draftBeforeViewer : this.editor.getText();
+	}
+	/**
+	* Headless-test hook: current overlay tracking-graph sizes. The graph
+	* (overlayHandles / overlayDependents / the active question's suspension)
+	* is behaviorally invisible — stale entries only leak memory — so the
+	* headless suite asserts its sizes directly (e.g. the fullscreen teardown
+	* must leave it empty instead of retaining dead handles).
+	*/
+	overlayGraphState() {
+		return {
+			handles: this.overlayHandles.size,
+			dependents: this.overlayDependents.size,
+			suspended: this.activeQuestions?.suspendedOverlays.size ?? 0
+		};
 	}
 	/**
 	* Rebuild the persistent dock strip above the todo panel: todo summary and
@@ -14952,6 +15570,14 @@ var TuiApp = class TuiApp {
 			}
 			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"));
 		this.requestRender();
 	}
@@ -14969,12 +15595,17 @@ var TuiApp = class TuiApp {
 	/** Rebuild the two footer lines from the current status and plan badge. */
 	renderFooter() {
 		const context = this.status.contextTokens !== void 0 && this.status.contextWindow !== void 0 && this.status.contextWindow > 0 ? contextBar(this.status.contextTokens, this.status.contextWindow) : "";
+		const permissionBadge = this.status.permission === "danger-full-access" ? color.warning("[yolo]") : this.status.permission === "read-only" ? color.textMuted("[read-only]") : this.status.permission === "workspace-write" ? color.text("[workspace-write]") : this.status.permission === "custom" ? color.warning("[custom]") : "";
+		const badgeParts = [];
+		if (this.dockTasks.length > 0) badgeParts.push(`${this.dockTasks.length} task${this.dockTasks.length === 1 ? "" : "s"} running`);
+		if (this.dockAgents.length > 0) badgeParts.push(`${this.dockAgents.length} agent${this.dockAgents.length === 1 ? "" : "s"}`);
+		const taskBadge = badgeParts.length === 0 ? "" : color.primary(`[${badgeParts.join(" · ")}${this.editor.getText().trim() === "" ? " · ↓ view" : ""}]`);
 		const line1 = [
-			this.status.permission === "danger-full-access" ? color.warning("[yolo]") : this.status.permission === "read-only" ? color.textMuted("[read-only]") : this.status.permission === "workspace-write" ? color.text("[workspace-write]") : this.status.permission === "custom" ? color.warning("[custom]") : "",
+			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}]`,
-			this.tasksActive ? color.primary(`[${this.dockTasks.length} task${this.dockTasks.length === 1 ? "" : "s"} running${this.editor.getText().trim() === "" ? " · ↓ view" : ""}]`) : "",
+			taskBadge,
 			this.status.cwd,
 			this.status.branch === "" ? "" : this.status.branch,
 			context,
@@ -15121,25 +15752,85 @@ var TuiApp = class TuiApp {
 	* FORCE_COLOR=0 / CI) stay dark without querying; a terminal that never
 	* answers falls back to COLORFGBG (VT100/xterm convention); a terminal
 	* with neither leaves the current theme untouched.
+	*
+	* The query targets the screen that OWNS the terminal input handler (the
+	* alt screen in fullscreen mode): a query on the stopped main screen
+	* would have its reply swallowed by the alt screen's OSC 11 consumer and
+	* time out, silently turning `auto` into a no-op.
+	*
+	* Concurrent calls COALESCE onto one shared in-flight query — overlapping
+	* OSC 11 queries have no sequence ids, so replies would mis-pair by FIFO
+	* order. The LATEST {@link AutoDetectOptions.shouldApply} guard is
+	* consulted at settle time, so a late result can never override a newer
+	* explicit theme choice.
+	* @param options.shouldApply - returns false to drop the settled result
+	*   instead of applying it (default: always apply).
 	*/
-	async autoDetectTheme() {
+	async autoDetectTheme(options) {
 		if (themeOptOut()) return;
-		const rgb = await this.tui.queryTerminalBackgroundColor({ timeoutMs: 800 });
+		if (options?.shouldApply !== void 0) this.autoDetectGuard = options.shouldApply;
+		if (this.autoDetectInFlight === void 0) this.autoDetectInFlight = this.runAutoDetect().finally(() => {
+			this.autoDetectInFlight = void 0;
+			this.autoDetectGuard = void 0;
+		});
+		return this.autoDetectInFlight;
+	}
+	async runAutoDetect() {
+		const rgb = await this.overlayHost.queryTerminalBackgroundColor({ timeoutMs: 800 });
+		const guard = this.autoDetectGuard;
+		const apply = () => guard === void 0 || guard();
 		if (rgb !== void 0) {
-			this.applyTheme(detectThemeFromBackground(rgb));
+			if (apply()) this.applyTheme(detectThemeFromBackground(rgb));
 			return;
 		}
 		const fromEnv = detectThemeFromColorFgBg();
-		if (fromEnv !== void 0) this.applyTheme(fromEnv);
+		if (fromEnv !== void 0 && apply()) this.applyTheme(fromEnv);
+	}
+	/**
+	* Follow the terminal's live colour-scheme reports while `following` is
+	* true. Enabling sends one DSR 996 query — xterm-class terminals only
+	* START reporting after being asked — and reported schemes fan out to the
+	* {@link onTerminalThemeChange} listeners (which guard whether to apply,
+	* typically against the persisted `auto` preference). Disabling stops
+	* tracking. Idempotent.
+	* @param following - whether to track and apply live scheme reports.
+	*/
+	trackTerminalTheme(following) {
+		if (following === this.followingTerminalTheme) return;
+		this.followingTerminalTheme = following;
+		if (!following) return;
+		this.overlayHost.queryTerminalColorScheme({ timeoutMs: 800 }).then((scheme) => {
+			if (scheme === void 0 || !this.followingTerminalTheme) return;
+			for (const listener of [...this.terminalSchemeListeners]) listener(scheme);
+		}).catch(() => {});
 	}
 	/**
 	* Register a live terminal-theme listener (colour-scheme reports). The
-	* runner uses it to follow the terminal when the preference is `auto`.
+	* listener is registered on EVERY screen: reports arrive only at the
+	* screen that owns the terminal input handler (the alt screen in
+	* fullscreen mode), so the registrations never double-fire. The caller
+	* guards whether to apply (typically: only while the persisted preference
+	* is `auto`).
 	* @param listener - receives the detected palette family.
 	* @returns a disposer.
 	*/
 	onTerminalThemeChange(listener) {
-		return this.tui.onTerminalColorSchemeChange((scheme) => listener(scheme));
+		this.terminalSchemeListeners.add(listener);
+		this.refreshSchemeRegistrations();
+		return () => {
+			this.terminalSchemeListeners.delete(listener);
+			this.refreshSchemeRegistrations();
+		};
+	}
+	/** (Re)register the scheme-report fan-out on every screen. */
+	refreshSchemeRegistrations() {
+		for (const dispose of this.schemeDisposers) dispose();
+		this.schemeDisposers = [];
+		const screens = [this.tui];
+		if (this.fullscreen !== void 0) screens.push(this.fullscreen);
+		for (const screen of screens) this.schemeDisposers.push(screen.onTerminalColorSchemeChange((scheme) => {
+			for (const listener of [...this.terminalSchemeListeners]) listener(scheme);
+		}));
 	}
 	/**
 	* Queue an approval prompt and resolve when the user decides. Requests
@@ -15181,19 +15872,31 @@ var TuiApp = class TuiApp {
 	}
 	/** Build and mount the approval dialog for one prompt on the active screen. */
 	renderApprovalDialog(pending) {
+		const width = this.terminal.columns;
+		const maxHeight = Math.max(8, Math.min(16, this.terminal.rows - 2));
+		const contentWidth = Math.max(1, width - 8);
+		const titleShown = truncateToWidth(`Approve ${pending.request.toolName}?`, contentWidth, "…");
+		const dangerShown = pending.request.danger === true ? truncateToWidth("⚠ DANGEROUS COMMAND — confirm carefully", contentWidth, "…") : "";
+		const hintShown = capWrappedToHeight("[y] allow once   [n] reject   [esc/ctrl+c] cancel", contentWidth, Math.max(0, maxHeight - (1 + (dangerShown === "" ? 0 : 1) + 1 + 2 + 2))).text;
+		const hintWrapped = hintShown === "" ? 0 : wrapTextWithAnsi(hintShown, contentWidth).length;
+		const chrome = 1 + (dangerShown === "" ? 0 : 1) + 1 + hintWrapped + 2 + 2;
+		const reasonBudget = Math.max(0, maxHeight - chrome);
+		const reasonShown = capWrappedToMarker(pending.request.reason ?? "", contentWidth, reasonBudget).text;
+		const reasonWrapped = reasonShown === "" ? 0 : wrapTextWithAnsi(reasonShown, contentWidth).length;
+		const previewBudget = Math.max(0, maxHeight - chrome - reasonWrapped);
 		const dialog = new Box(1, 1);
-		dialog.addChild(new Text(`Approve ${pending.request.toolName}?`));
-		if (pending.request.danger === true) dialog.addChild(new Text(color.error("⚠ DANGEROUS COMMAND — confirm carefully")));
-		if (pending.request.arguments !== void 0 && pending.request.arguments !== "") {
-			const preview = pending.request.arguments.split("\n").slice(0, 6).join("\n");
-			dialog.addChild(new Text(color.textDim(preview.length > 240 ? `${preview.slice(0, 240)}…` : preview)));
-		}
-		if (pending.request.reason !== void 0 && pending.request.reason !== "") dialog.addChild(new Text(pending.request.reason));
-		dialog.addChild(new Text(""));
-		dialog.addChild(new Text("[y] allow once   [n] reject   [esc/ctrl+c] cancel"));
+		dialog.addChild(new Text(titleShown, 1, 0));
+		if (dangerShown !== "") dialog.addChild(new Text(color.error(dangerShown), 1, 0));
+		if (pending.request.arguments !== void 0 && pending.request.arguments !== "" && previewBudget > 0) {
+			const previewShown = capWrappedToMarker(pending.request.arguments.split("\n").slice(0, 6).join("\n"), contentWidth, previewBudget).text;
+			if (previewShown !== "") dialog.addChild(new Text(color.textDim(previewShown), 1, 0));
+		}
+		if (reasonShown !== "") dialog.addChild(new Text(reasonShown, 1, 0));
+		dialog.addChild(new Text(" ", 1, 0));
+		dialog.addChild(new Text(hintShown, 1, 0));
 		pending.handle = this.showOverlayOnHost(new Frame(dialog), {
-			width: 60,
-			maxHeight: 16
+			width,
+			maxHeight
 		});
 	}
 	/** Route a key while a prompt is showing; every key is consumed. */
@@ -15252,6 +15955,7 @@ var TuiApp = class TuiApp {
 					...question.multiSelect !== void 0 ? { multiSelect: question.multiSelect } : {},
 					...question.intent !== void 0 ? { intent: question.intent } : {}
 				})), (answers) => this.settleQuestions(state, answers), () => this.settleQuestions(state, void 0)),
+				suspendedOverlays: /* @__PURE__ */ new Set(),
 				resolve,
 				reject,
 				signal
@@ -15269,13 +15973,20 @@ var TuiApp = class TuiApp {
 			else this.questionQueue.push(state);
 		});
 	}
-	/** Mount one flow's overlay and make it the active one. */
+	/** Mount one flow into the editor seat and make it the active one. */
 	presentQuestion(state) {
 		this.activeQuestions = state;
-		state.handle = this.showOverlayOnHost(new Frame(state.flow), {
-			width: 76,
-			maxHeight: 26
-		});
+		for (const handle of this.overlayHandles) if (!handle.isHidden()) {
+			handle.setHidden(true);
+			state.suspendedOverlays.add(handle);
+		}
+		const frame = new QuestionFrame(state.flow, () => this.terminal.rows);
+		state.frame = frame;
+		this.editorSeat.clear();
+		this.editorSeat.addChild(frame);
+		const screen = this.fullscreen ?? this.tui;
+		screen.setFocus(frame);
+		screen.requestRender();
 	}
 	/** Abort one flow (its signal fired). The ACTIVE flow settles rejected
 	* and the queue advances; a QUEUED flow is removed from the queue and
@@ -15293,12 +16004,6 @@ var TuiApp = class TuiApp {
 		if (index !== -1) this.questionQueue.splice(index, 1);
 		state.reject(cancellationError("question flow cancelled"));
 	}
-	/** Show the next queued flow, if any (called after the active one settles). */
-	nextQuestion() {
-		const next = this.questionQueue.shift();
-		if (next === void 0) return;
-		this.presentQuestion(next);
-	}
 	/** Cancel every pending flow: each promise rejects exactly once. */
 	cancelQuestionFlows() {
 		for (const state of [...this.questionQueue]) this.abortQuestion(state);
@@ -15316,13 +16021,36 @@ var TuiApp = class TuiApp {
 	settleQuestions(state, answers) {
 		if (this.activeQuestions !== state || state.settled === true) return;
 		state.settled = true;
-		this.activeQuestions = void 0;
-		state.handle?.hide();
 		if (state.onAbort !== void 0 && state.signal !== void 0) state.signal.removeEventListener("abort", state.onAbort);
-		this.overlayHost.setFocus(this.editor);
+		const next = this.questionQueue.shift();
+		if (next !== void 0) {
+			next.suspendedOverlays = state.suspendedOverlays;
+			state.suspendedOverlays = /* @__PURE__ */ new Set();
+			const frame = new QuestionFrame(next.flow, () => this.terminal.rows);
+			next.frame = frame;
+			this.editorSeat.clear();
+			this.editorSeat.addChild(frame);
+			this.activeQuestions = next;
+			const screen = this.fullscreen ?? this.tui;
+			screen.setFocus(frame);
+			screen.requestRender();
+			this.settle(state, answers);
+			return;
+		}
+		this.editorSeat.clear();
+		this.editorSeat.addChild(this.editor);
+		this.activeQuestions = void 0;
+		const screen = this.fullscreen ?? this.tui;
+		screen.setFocus(this.editor);
+		for (const handle of state.suspendedOverlays) if (this.overlayHandles.has(handle)) handle.setHidden(false);
+		state.suspendedOverlays.clear();
+		screen.requestRender();
+		this.settle(state, answers);
+	}
+	/** Resolve or reject the settled promise (exactly once, by construction). */
+	settle(state, answers) {
 		if (answers === void 0) state.reject(cancellationError("question flow cancelled"));
 		else state.resolve(answers);
-		this.nextQuestion();
 	}
 };
 const dim = color.textDim;
@@ -15336,6 +16064,101 @@ function startProcessTui(events, options = {}) {
 	return app;
 }
 //#endregion
+//#region src/tasks-browser.ts
+/**
+* Task-browser row model — the merged view over the two background surfaces.
+*
+* Source A — the jobs registry (`ctx.jobs`): bash jobs and one-shot
+* subagent jobs. A job row is STATUS-ONLY:
+*  - a bash job's output has a single read cursor owned by the model's
+*    `job_output`; consuming it from the UI would swallow the main
+*    session's result;
+*  - a one-shot subagent job record carries no child session id, so it can
+*    never be matched to its child transcript — label/order/time are never
+*    identity (see subagentJobTranscriptId).
+*
+* Source B — the subagent registry (`ctx.subagents.listChildren`):
+* live child subagents. Continuable children are separate durable
+* conversations that deliver no result to the parent, so Enter may open
+* the read-only transcript viewer directly. A RUNNING one-shot child
+* (the parent's pending foreground tool call, which registers no job
+* record) is merged the same way, so the ↓ trigger stays armed while a
+* foreground delegation is in flight. A finished one-shot child is not
+* merged — its work is over and `/subagents` remains its surface.
+*
+* Deliberate overlap: a running BACKGROUND one-shot has BOTH a job record
+* and a child record with no cross-reference, so it may appear twice — the
+* job row (status-only) and the child row (transcript viewable). Dedup is
+* impossible without the missing childSessionId on the job record; the
+* viewable child row is strictly more useful, so the overlap is accepted.
+*
+* Pure and injectable so row typing, ordering, and descriptions are
+* unit-testable without any dsh service.
+* @module @xmoon76/dsh-pi-tui/tasks-browser
+*/
+/** Picker-value prefix for a subagent row. */
+const AGENT_ROW_PREFIX = "agent:";
+/** Picker-value prefix for a job row. */
+const JOB_ROW_PREFIX = "job:";
+/** Picker group label for continuable subagents. */
+const SUBAGENT_GROUP = "subagents";
+/** Picker group label for jobs. */
+const JOB_GROUP = "jobs";
+const isActiveJob = (status) => status === "running" || status === "stopping";
+/**
+* Ordering shared with kimi's tasks browser: active rows first, terminal
+* rows last. Jobs keep their registry order within each class (active by
+* startedAt, terminal newest-finish first); subagents keep the registry's
+* createdAt order (running before inactive).
+*/
+function buildTaskRows(jobs, agents) {
+	const sortedAgents = [...agents.filter((agent) => agent.kind === "child" && (agent.mode === "continuable" || agent.mode === "one-shot" && agent.activity === "running")).map((agent) => ({
+		kind: "subagent",
+		value: `${AGENT_ROW_PREFIX}${agent.id}`,
+		childId: agent.id,
+		label: agent.label ?? agent.id,
+		activity: agent.activity ?? "inactive",
+		hasChildren: agent.hasChildren ?? false
+	}))].sort((a, b) => {
+		if (a.activity !== b.activity) return a.activity === "running" ? -1 : 1;
+		return 0;
+	});
+	const sortedJobs = [...jobs].sort((a, b) => {
+		const aTerminal = !isActiveJob(a.status);
+		if (aTerminal !== !isActiveJob(b.status)) return aTerminal ? 1 : -1;
+		if (!aTerminal) return a.startedAt - b.startedAt;
+		return (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt);
+	}).map((job) => ({
+		kind: "job",
+		value: `${JOB_ROW_PREFIX}${job.id}`,
+		jobId: job.id,
+		jobKind: job.kind,
+		label: job.label,
+		status: job.status,
+		detail: job.detail,
+		startedAt: job.startedAt,
+		finishedAt: job.finishedAt
+	}));
+	return [...sortedAgents, ...sortedJobs];
+}
+/** The one-line picker label for a row. */
+function taskRowLabel(row) {
+	if (row.kind === "job") return `${row.jobKind} · ${row.label}`;
+	return `subagent · ${row.label}`;
+}
+/** The picker group a row belongs to. */
+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
 /**
 * In-place submenu components for `/model`: the model list and the
@@ -15616,23 +16439,279 @@ async function loadSessionTitles(query, persistence, ids, signal) {
 	return titles;
 }
 //#endregion
-//#region src/commands.ts
+//#region src/skill-catalog.ts
 /**
-* The TUI-owned slash commands (/exit /settings /sessions /skill /model
-* /new /tasks /preset /subagents /search /title /copy /export /fork
-* /status /login /logout /help), extracted from the runner's monolithic
-* apply() so the registration surface is testable and the runner closure
-* shrinks. Every command reads the live runner state through the
-* {@link TuiCommandRunner} interface, whose accessors re-read the current
-* agent/settings on every access (sessions can swap the live agent).
-* @module @xmoon76/dsh-pi-tui/commands
+* The standing-scope skill catalog adapter: the SINGLE narrow seam between
+* the TUI and the dsh skill services (the non-public-API isolation
+* contract, plan appendix B).
+*
+* Everything the TUI knows about dsh-skill and agent-presets lives here:
+* - structural service types (never upstream classes) with OPTIONAL
+*   capability members — `snapshot` and `standingKeyFor` are detected at
+*   call time, so an upstream change degrades instead of breaking;
+* - `readHumanSkillCatalog()`: snapshot-first collector (list() fallback),
+*   official `isUserInvocable` filter, field validation, stable sort,
+*   deep freeze, distinct abort propagation;
+* - `resolveColdSkillTarget()`: capability-gated cold target selection
+*   (standing scope → rosterless global → degraded global with a notice);
+* - `resolveLiveSkillTarget()`: the agent's own registry + agent scope.
+*
+* Failure contract: ordinary provider/composition failures surface as
+* degraded targets or rethrown errors for the coordinator to classify;
+* aborts ALWAYS propagate as aborts. No failure may hang or crash the TUI —
+* the worst outcome is "the corresponding commands are missing".
+* @module @xmoon76/dsh-pi-tui/skill-catalog
 */
-/** A balanced completed-turn prefix for forking: the log up to (and including)
-* the last `turn/end`. Undefined when no turn has completed yet.
-* @param events - the session log.
-* @returns the fork seed events, or undefined.
+/**
+* Subscribe to the dsh-skill invalidation notification. The event carries
+* no scope or cwd — consumers refetch for their own cwd and scope — and the
+* subscription itself is optional: an unavailable `on` or a throwing
+* subscribe degrades to NO subscription (owner switches and `/reload` still
+* refresh). The CALLER owns the listener's failure totality (route the
+* refresh through `runOwned`).
+* @param ctx - the context surface exposing the event bus.
+* @param listener - the notification listener (must be synchronous and
+*   never throw).
 */
-function forkSeed(events) {
+function subscribeSkillsChange(ctx, listener) {
+	ctx.on?.("skills/change", listener);
+}
+/**
+* Whether one summary passes the OFFICIAL user-invocation policy — the
+* adapter's exported guard, used by every human entry point (direct
+* wrappers, `/skill`, the picker, and final body loads). A malformed
+* `invocation` (missing, non-object, non-boolean flag) is treated as NOT
+* user-invocable: the policy defaults are never reinterpreted, and a
+* hostile entry can neither throw nor sneak into a human surface.
+*/
+function isUserInvocableSkill(skill) {
+	const invocation = skill.invocation;
+	if (typeof invocation !== "object" || invocation === null) return false;
+	if (typeof invocation.userInvocable !== "boolean") return false;
+	return isUserInvocable(skill);
+}
+/** Copy one summary, keeping ONLY the supported display fields. An entry
+* with a non-string name or description is rejected (never copied, never
+* trusted); a non-string `whenToUse` is dropped. */
+function toHumanSummary(skill) {
+	if (typeof skill.name !== "string" || skill.name === "") return void 0;
+	if (typeof skill.description !== "string") return void 0;
+	return Object.freeze({
+		name: skill.name,
+		description: skill.description,
+		...typeof skill.whenToUse === "string" && skill.whenToUse !== "" ? { whenToUse: skill.whenToUse } : {}
+	});
+}
+/** Whether one summary passes the OFFICIAL user-invocation policy. A
+* malformed `invocation` (missing, non-object, non-boolean flag) is treated
+* as NOT user-invocable — the policy defaults are never reinterpreted, and
+* a hostile entry can neither throw nor sneak into the human catalog. */
+function userInvocable(skill) {
+	return isUserInvocableSkill(skill);
+}
+/**
+* Read one human skill catalog from a registry: snapshot-first, official
+* policy filter, validated detached copies, stable name sort, deep freeze.
+* @param registry - the registry to read (the adapter's structural type).
+* @param options - cwd/scope/signal for the read.
+* @returns the detached catalog.
+* @throws on cancellation (ALWAYS, distinctly) and on non-abort read
+*   failures (the coordinator classifies them: retain last-good + diag).
+*/
+async function readHumanSkillCatalog(registry, options) {
+	options.signal?.throwIfAborted();
+	const observed = typeof registry.snapshot === "function" ? await registry.snapshot(options) : {
+		skills: await registry.list?.(options) ?? [],
+		complete: true
+	};
+	options.signal?.throwIfAborted();
+	const skills = observed.skills.filter(userInvocable).map(toHumanSummary).filter((summary) => summary !== void 0).sort((left, right) => left.name < right.name ? -1 : 1);
+	return Object.freeze({
+		skills: Object.freeze(skills),
+		complete: observed.complete === true
+	});
+}
+/**
+* Resolve the COLD (sessionless) skill target with capability detection:
+* - a preset roster with `standingKeyFor` → the standing scope of the
+*   effective preset;
+* - no roster / no `standingKeyFor` / a standing resolution failure → the
+*   global layer (with a one-shot degradation notice on failure);
+* - no skill registry at all → no target (nothing to read, no notice).
+* @param ctx - the context surface.
+* @param presetId - the effective preset id, or undefined for the default.
+* @param cwd - the workspace cwd for provider selection.
+*/
+async function resolveColdSkillTarget(ctx, presetId, cwd) {
+	const registry = ctx.get("skills");
+	if (registry === void 0) return {};
+	const presets = ctx.get("agentPresets");
+	if (presets === void 0 || typeof presets.standingKeyFor !== "function") return { target: {
+		kind: "cold-global",
+		registry,
+		cwd,
+		scope: void 0
+	} };
+	try {
+		return { target: {
+			kind: "cold-standing",
+			registry,
+			cwd,
+			scope: await presets.standingKeyFor(presetId)
+		} };
+	} catch (error) {
+		const message = safeErrorMessage(error);
+		return {
+			target: {
+				kind: "cold-global",
+				registry,
+				cwd,
+				scope: void 0
+			},
+			degraded: `skill catalog unavailable for preset "${presetId ?? "default"}": ${message}`
+		};
+	}
+}
+/**
+* Resolve the LIVE skill target: the registry the agent actually sees
+* (its preset's scoped instance when the preset mounts one, else the host
+* registry), with the AGENT OBJECT as the view scope.
+* @param ctx - the context surface.
+* @param agent - the live agent.
+* @param cwd - the session workspace cwd.
+* @returns the live target, or undefined when no registry is reachable.
+*/
+function resolveLiveSkillTarget(ctx, agent, cwd) {
+	const registry = ctx.get("agentPresets")?.serviceFor?.(agent, "skills") ?? ctx.get("skills");
+	if (registry === void 0) return void 0;
+	return {
+		kind: "live",
+		registry,
+		cwd,
+		scope: agent
+	};
+}
+//#endregion
+//#region src/surface-catalog.ts
+/**
+* The in-process global-layer command view. The public type requires an
+* `Agent`, but `commands.list(undefined)` resolves the global layer only
+* (ScopedLayers merges no overlays for an undefined key); the current TUI
+* already depends on this in-process behavior. The cast is isolated HERE so
+* the undefined key never reaches a remote RPC path, and the helper is the
+* single seam to replace if upstream ever ships a typed global-list API.
+* @param commands - the commands service.
+* @returns the global-layer descriptors (name-sorted by the registry).
+*/
+function listGlobalCommands(commands) {
+	return commands.list(void 0);
+}
+/** Copy one descriptor into a fresh frozen summary (never borrowed). */
+function commandSummaryOf(descriptor) {
+	return Object.freeze({
+		name: descriptor.name,
+		description: descriptor.description,
+		...descriptor.input === void 0 ? {} : { input: Object.freeze({ hint: descriptor.input.hint }) }
+	});
+}
+/** Whether two descriptors expose identical display fields (origin-blind:
+* an identical scoped entry needs no override because the visible result and
+* the real-agent execution are the same either way). */
+function sameCommand(left, right) {
+	return left.name === right.name && left.description === right.description && left.input?.hint === right.input?.hint;
+}
+/**
+* Read one agent's effective surface catalog: global + scoped commands and
+* human-invocable skills, fully detached and frozen.
+*
+* Provider isolation (per the probe contract):
+* - lifecycle/refresh cancellation terminates the WHOLE read and propagates;
+* - an ordinary provider failure empties only that field and records a
+*   detached issue; other providers continue;
+* - a missing service is that provider's successful empty result (no issue).
+*
+* This function only READS: it registers nothing, mutates nothing, and never
+* touches a runner's live agent. Probe and live agent share this collector
+* so the two surfaces cannot drift apart.
+* @param agent - the agent whose effective view to read.
+* @param signal - lifecycle/refresh cancellation.
+* @param ctx - the context surface resolving the services.
+* @returns a frozen, detached snapshot.
+*/
+async function readSurfaceCatalog(agent, signal, ctx) {
+	signal.throwIfAborted();
+	const issues = [];
+	let commands = [];
+	let scopedCommands = [];
+	const commandsService = ctx.get("commands");
+	if (commandsService !== void 0) try {
+		const global = listGlobalCommands(commandsService);
+		const globalBy = new Map(global.map((descriptor) => [descriptor.name, descriptor]));
+		const effective = commandsService.list(agent);
+		const scoped = [];
+		for (const descriptor of effective) {
+			const summary = commandSummaryOf(descriptor);
+			const baseline = globalBy.get(descriptor.name);
+			if (baseline === void 0 || !sameCommand(descriptor, baseline)) scoped.push(summary);
+		}
+		commands = sortCommands(effective.map(commandSummaryOf));
+		scopedCommands = sortCommands(scoped);
+	} catch (error) {
+		issues.push({
+			provider: "commands",
+			message: safeErrorMessage(error)
+		});
+	}
+	let skills = [];
+	const skillTarget = resolveLiveSkillTarget(ctx, agent, agent.session.header.cwd ?? process.cwd());
+	if (skillTarget !== void 0) try {
+		signal.throwIfAborted();
+		const catalog = await readHumanSkillCatalog(skillTarget.registry, {
+			cwd: skillTarget.cwd,
+			scope: skillTarget.scope,
+			signal
+		});
+		skills = catalog.skills;
+		if (catalog.complete !== true) issues.push({
+			provider: "skills",
+			message: "incomplete skill observation"
+		});
+	} catch (error) {
+		if (signal.aborted) throw error;
+		issues.push({
+			provider: "skills",
+			message: safeErrorMessage(error)
+		});
+	}
+	return Object.freeze({
+		commands,
+		scopedCommands,
+		skills,
+		issues: Object.freeze(issues.map((issue) => Object.freeze({ ...issue })))
+	});
+}
+/** Name-stable sort for command summaries (copies, never mutates input). */
+function sortCommands(commands) {
+	return Object.freeze([...commands].sort((left, right) => left.name < right.name ? -1 : 1));
+}
+//#endregion
+//#region src/commands.ts
+/**
+* The TUI-owned slash commands (/exit /settings /sessions /skill /model
+* /new /tasks /preset /subagents /search /title /rename /copy /export
+* /fork /status /login /logout /help), extracted from the runner's
+* monolithic apply() so the registration surface is testable and the runner
+* closure shrinks. Every command reads the live runner state through the
+* {@link TuiCommandRunner} interface, whose accessors re-read the current
+* agent/settings on every access (sessions can swap the live agent).
+* @module @xmoon76/dsh-pi-tui/commands
+*/
+/** A balanced completed-turn prefix for forking: the log up to (and including)
+* the last `turn/end`. Undefined when no turn has completed yet.
+* @param events - the session log.
+* @returns the fork seed events, or undefined.
+*/
+function forkSeed(events) {
 	for (let index = events.length - 1; index >= 0; index -= 1) if (events[index]?.type === "turn/end") return events.slice(0, index + 1);
 }
 /** Shorten a session id for read-only display rows, capped at 28 characters. */
@@ -15647,16 +16726,62 @@ function metaOf(cwd, presetId) {
 	};
 }
 /**
+* Display copy for the four shipped agent presets, fixed in English — the
+* web surface's `BUILT_IN_PRESET_KEYS` mapping (`dsh-client-ui-agent-preset`),
+* TUI-side. The EFFECTIVE roster root is the dsh install's own
+* `config/agent-presets`: the dsh CLI's profile composition replaces this
+* bundle's shipped root with that one at boot (the `composeProfile`
+* agent-presets overlay), and its preset.yml language is not ours to
+* control. Mapping the known ids keeps the picker English regardless of
+* what the files say; everything else renders file metadata.
+*/
+const BUILT_IN_PRESET_COPY = {
+	standard: {
+		name: "Standard mode",
+		description: "Full coding agent with file editing, shell, file and web search, skills, planning, goals, subagents, and workflows."
+	},
+	code: {
+		name: "Code mode",
+		description: "All Standard mode capabilities, with tools exposed through the Code Mode SDK so the model can combine multi-step operations in one TypeScript program."
+	},
+	minimal: {
+		name: "Minimal mode",
+		description: "Two-tool coding agent with persistent bash and str_replace_editor."
+	},
+	cordis: {
+		name: "Creator mode",
+		description: "Built for creating custom agent presets, with all Standard mode capabilities plus runtime inspection, plugin experiments, and preset-authoring guidance."
+	}
+};
+/** Resolve one roster row's display copy: fixed English for a shipped
+* (system-trust) preset id, otherwise the preset's file metadata. */
+function presetDisplayText(preset) {
+	const builtIn = preset.trust === "system" ? BUILT_IN_PRESET_COPY[preset.id] : void 0;
+	if (builtIn !== void 0) return {
+		name: builtIn.name,
+		description: builtIn.description
+	};
+	return {
+		name: preset.name ?? preset.id,
+		...preset.description === void 0 ? {} : { description: preset.description }
+	};
+}
+/**
 * Register the TUI-owned slash commands on the commands service. The
 * completion list is refreshed after every registration so TUI-owned
 * commands appear in the editor's tab list. Registration is sessionless:
 * the commands service's global layer needs no agent, so the whole surface
 * is available before the first session exists (deferred start).
+*
+* When an `initial` catalog was prefetched (resume snapshot or cold
+* standing-scope skills), it installs SYNCHRONOUSLY at the end of
+* registration — direct skill wrappers plus the completion merge — so the
+* first input is served by the complete catalog with zero async I/O in
+* between.
 * @param runner - the live runner surface.
-* @returns a hook that rebuilds the per-skill slash commands (a no-op until
-*   the first session exists, since the skill catalog scope is the agent).
+* @param initial - optional prefetched catalogs installed synchronously.
 */
-function registerTuiCommands(runner) {
+function registerTuiCommands(runner, initial) {
 	const { ctx, app } = runner;
 	const cwd = runner.cwd;
 	const signal = runner.signal;
@@ -15700,12 +16825,60 @@ function registerTuiCommands(runner) {
 		if (agent === void 0) throw new Error("session could not be created");
 		return agent;
 	};
-	const refreshCompletions = () => {
-		app.setCommandCompletions(commands.list(runner.liveAgent).map((command) => ({
+	/** The advertised names of the currently installed completion list. */
+	let claims = /* @__PURE__ */ new Set();
+	/**
+	* Install one completion list (sorted, claims refreshed). The single
+	* synchronous seam every catalog commit funnels through.
+	*/
+	const installCompletions = (entries) => {
+		const sorted = [...entries].sort((left, right) => left.name < right.name ? -1 : 1);
+		app.setCommandCompletions(sorted.map((command) => ({
 			name: command.name,
 			description: command.description,
 			argumentHint: command.input?.hint
 		})), runner.sessionCwd(), fdPath);
+		claims = new Set(sorted.map((command) => command.name));
+	};
+	/** The saved probed scoped overrides (see installSurfaceSnapshot). */
+	let savedScopedCommands = [];
+	/**
+	* The sessionless completion view: the CURRENT global layer (fresh read —
+	* TUI built-ins, global plugins and installed skill wrappers all flow in)
+	* overlaid with the saved scoped overrides from the latest snapshot.
+	*/
+	const mergeGlobalAndSavedScoped = () => {
+		const byName = /* @__PURE__ */ new Map();
+		for (const descriptor of listGlobalCommands(commands)) byName.set(descriptor.name, commandSummaryOf(descriptor));
+		for (const scoped of savedScopedCommands) byName.set(scoped.name, scoped);
+		return [...byName.values()];
+	};
+	/**
+	* Refresh completions from the registry: the LIVE agent's effective view
+	* when one exists (global + its scoped shadows), else the global layer
+	* overlaid with the saved scoped overrides (sessionless merge). The agent
+	* may be undefined before the first session exists: in-process
+	* `commands.list(undefined)` safely returns the global layer only (the
+	* remote RPC path's lookup guard does not apply in-process).
+	*/
+	const refreshCompletions = () => {
+		const liveAgent = runner.liveAgent;
+		installCompletions(liveAgent === void 0 ? mergeGlobalAndSavedScoped() : commands.list(liveAgent).map(commandSummaryOf));
+	};
+	let commandCommitDepth = 0;
+	let commandCommitDirty = false;
+	/** Run one bulk command commit; registry changes inside are coalesced. */
+	const withCommandCommit = (phase) => {
+		commandCommitDepth += 1;
+		try {
+			phase();
+		} finally {
+			commandCommitDepth -= 1;
+			if (commandCommitDepth === 0 && commandCommitDirty) {
+				commandCommitDirty = false;
+				refreshCompletions();
+			}
+		}
 	};
 	refreshCompletions();
 	const exitHandler = () => {
@@ -15730,6 +16903,7 @@ function registerTuiCommands(runner) {
 			const tuiSettings = runner.tuiSettings;
 			const theme = tuiSettings?.get().theme ?? "auto";
 			const themeValue = theme.startsWith("custom:") ? theme.slice(7) : theme;
+			let lastThemeChoice = themeValue;
 			const settings = ctx.get("settings");
 			const permissionNames = [...ctx.get("permissionPresets")?.names ?? []];
 			let defaultPermission;
@@ -15784,6 +16958,13 @@ function registerTuiCommands(runner) {
 					currentValue: app.getFooterPreset(),
 					values: ["full", "compact"]
 				},
+				{
+					id: "busy-enter",
+					label: "Enter while busy",
+					description: "Steer injects the draft into the running turn; Ctrl+Enter uses the other behavior",
+					currentValue: tuiSettings?.get().busyEnter ?? "queue",
+					values: ["queue", "steer"]
+				},
 				{
 					id: "fullscreen",
 					label: "Fullscreen",
@@ -15837,12 +17018,19 @@ function registerTuiCommands(runner) {
 					}]), { notify: true });
 				} else if (id === "theme") {
 					if (value === "auto" || value === "dark" || value === "light" || customThemeNames().includes(value)) {
-						if (value === "auto") detach("theme autodetect", () => app.autoDetectTheme());
-						else if (value === "dark" || value === "light") app.applyTheme(value);
-						else {
+						lastThemeChoice = value;
+						if (value === "auto") {
+							detach("theme autodetect", () => app.autoDetectTheme({ shouldApply: () => lastThemeChoice === "auto" }));
+							app.trackTerminalTheme(true);
+						} else if (value === "dark" || value === "light") {
+							app.applyTheme(value);
+							app.trackTerminalTheme(false);
+						} else {
 							const palette = loadCustomTheme(value);
-							if (palette !== void 0) app.applyPalette(palette);
-							else {
+							if (palette !== void 0) {
+								app.applyPalette(palette);
+								app.trackTerminalTheme(false);
+							} else {
 								app.notify(`theme ${value} not found`, "error");
 								return;
 							}
@@ -15865,6 +17053,14 @@ function registerTuiCommands(runner) {
 							footer: value
 						}), { notify: true });
 					}
+				} else if (id === "busy-enter") {
+					if (value === "queue" || value === "steer") {
+						const settings = tuiSettings;
+						if (settings !== void 0) detach("settings busy enter write", () => settings.replace({
+							...settings.get(),
+							busyEnter: value
+						}), { notify: true });
+					}
 				} else if (id === "fullscreen") {
 					if (value === "off" || value === "on") app.setFullscreen(value === "on");
 				}
@@ -15945,29 +17141,44 @@ function registerTuiCommands(runner) {
 			return openSessionPicker(invocation, "resume");
 		}
 	});
-	const skillService = (agent) => {
-		return ctx.get("agentPresets")?.serviceFor(agent, "skills") ?? ctx.get("skills");
-	};
 	/** The workspace the live session runs in; fallback to the TUI's cwd. */
 	const sessionCwd = (agent) => agent.session.header.cwd ?? cwd;
+	const skillTarget = (agent) => resolveLiveSkillTarget(ctx, agent, sessionCwd(agent));
+	/**
+	* The execution boundary for loading one skill into the live session;
+	* shared by /skill and the per-skill slash commands. The skill is fetched
+	* from the CURRENT agent's registry and its invocation policy is RE-CHECKED
+	* here — a summary that passed the cold/live filter is never execution
+	* authorization. A model-only skill is refused with an explicit error and
+	* never injected.
+	*/
 	const loadSkill = async (agent, name) => {
-		const skills = skillService(agent);
-		if (skills === void 0) return {
+		const target = skillTarget(agent);
+		if (target === void 0) return {
 			kind: "error",
 			text: "skill service unavailable"
 		};
-		const skill = await skills.get(name, {
-			cwd: sessionCwd(agent),
-			scope: agent
+		const skill = await target.registry.get?.(name, {
+			cwd: target.cwd,
+			scope: target.scope
 		});
 		if (skill === void 0) return {
 			kind: "error",
 			text: "unknown skill \"" + name + "\""
 		};
+		if (!isUserInvocableSkill(skill)) return {
+			kind: "error",
+			text: `skill "${name}" is not invocable by the user`
+		};
+		if (typeof skill.name !== "string" || skill.name === "" || typeof skill.description !== "string") return {
+			kind: "error",
+			text: `skill "${name}" returned a malformed definition`
+		};
+		const body = typeof skill.content === "string" && skill.content !== "" ? skill.content : skill.description;
 		agent.inject(createUserMessage({
 			content: [{
 				type: "text",
-				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + (skill.content ?? skill.description)
+				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + body
 			}],
 			source: {
 				kind: "plugin",
@@ -15980,21 +17191,30 @@ function registerTuiCommands(runner) {
 		};
 	};
 	const skillDisposers = /* @__PURE__ */ new Map();
-	const registerSkillCommands = async () => {
-		const generation = runner.sessionGeneration;
+	/**
+	* Synchronously replace every direct skill wrapper from a snapshot. Pure
+	* install: no catalog fetch, no await — the callers (the initial snapshot
+	* commit, the live refresh, the coordinator) provide the data. The target
+	* set is computed FIRST (current global/effective view minus the wrappers
+	* this surface owns, plus the snapshot's scoped overrides), then the old
+	* wrappers are disposed and the new ones registered in one synchronous
+	* commit.
+	* @param skills - the human-invocable summaries to install.
+	* @param scopedNames - the snapshot's scoped command names: a preset-scoped
+	*   command must block a same-name wrapper even though the global view
+	*   cannot see it yet (sessionless install).
+	* @returns the number of wrappers installed.
+	*/
+	const replaceSkillCommands = (skills, scopedNames) => {
+		const owned = new Set(skillDisposers.keys());
+		const taken = /* @__PURE__ */ new Set();
+		const view = commands.list(runner.liveAgent);
+		for (const command of view) if (!owned.has(command.name)) taken.add(command.name);
+		for (const name of scopedNames) taken.add(name);
 		for (const dispose of skillDisposers.values()) dispose();
 		skillDisposers.clear();
-		const liveAgent = runner.liveAgent;
-		if (liveAgent === void 0) return 0;
-		const skills = skillService(liveAgent);
-		if (skills === void 0) return 0;
-		const taken = new Set(commands.list(liveAgent).map((command) => command.name));
-		const catalog = await skills.list({
-			cwd: sessionCwd(liveAgent),
-			scope: liveAgent
-		});
-		if (generation !== runner.sessionGeneration) return 0;
-		for (const skill of catalog) {
+		let count = 0;
+		for (const skill of skills) {
 			if (taken.has(skill.name)) continue;
 			try {
 				const dispose = commands.register({
@@ -16006,34 +17226,83 @@ function registerTuiCommands(runner) {
 					}
 				});
 				skillDisposers.set(skill.name, dispose);
+				count += 1;
 			} catch {}
 		}
-		refreshCompletions();
-		return catalog.length;
+		return count;
 	};
-	detach("skill catalog refresh", () => registerSkillCommands());
+	/**
+	* Install one whole snapshot on the surface in ONE synchronous commit:
+	* replace the direct skill wrappers, save the scoped overrides, and merge
+	* the completions (fresh global view + saved overrides). No await between
+	* the pieces, so a first input can never observe a half-installed catalog.
+	* A FAILED skills provider keeps the current wrappers (transitions or the
+	* previous catalog): they re-validate against the current agent at
+	* execution time, so a submitted skill name can never fall through to a
+	* plain model message while the catalog is unavailable.
+	*/
+	const installSurfaceSnapshot = (snapshot) => {
+		const scopedNames = new Set(snapshot.scopedCommands.map((command) => command.name));
+		const skillsFailed = snapshot.issues.some((issue) => issue.provider === "skills");
+		withCommandCommit(() => {
+			if (!skillsFailed) replaceSkillCommands(snapshot.skills, scopedNames);
+			savedScopedCommands = snapshot.scopedCommands;
+			installCompletions(mergeGlobalAndSavedScoped());
+		});
+	};
+	/**
+	* The revalidating transition (target/owner change): scoped previews clear
+	* so new inputs complete against the current global view only, and every
+	* old skill wrapper becomes a revalidating transition command whose
+	* handler re-fetches from the CURRENT live agent and re-checks the policy
+	* at execution time. The names survive so an already-submitted skill
+	* command can never become a plain model message mid-switch.
+	*/
+	const enterCatalogTransition = () => {
+		const names = [...skillDisposers.keys()];
+		withCommandCommit(() => {
+			for (const dispose of skillDisposers.values()) dispose();
+			skillDisposers.clear();
+			savedScopedCommands = [];
+			for (const name of names) try {
+				const dispose = commands.register({
+					name,
+					description: `[skill: revalidating] ${name}`,
+					handler: async () => {
+						const agent = await requireAgent();
+						return loadSkill(agent, name);
+					}
+				});
+				skillDisposers.set(name, dispose);
+			} catch {}
+			installCompletions(mergeGlobalAndSavedScoped());
+		});
+	};
+	/** Whether one command name is advertised by the CURRENT completion list
+	* (the claim captured at submit time, before any session creation). */
+	const wasAdvertised = (name) => claims.has(name);
 	commands.register({
 		name: "skill",
 		description: "Load a skill into the session context",
 		input: { hint: "<name>" },
 		handler: async (invocation) => {
 			const liveAgent = await requireAgent();
-			const skills = skillService(liveAgent);
-			if (skills === void 0) return {
+			const target = skillTarget(liveAgent);
+			if (target === void 0) return {
 				kind: "error",
 				text: "skill service unavailable"
 			};
 			const name = invocation.rawInput.trim();
 			if (name !== "") return loadSkill(liveAgent, name);
-			const catalog = await skills.list({
-				cwd: sessionCwd(liveAgent),
-				scope: liveAgent
+			const catalog = await readHumanSkillCatalog(target.registry, {
+				cwd: target.cwd,
+				scope: target.scope
 			});
-			if (catalog.length === 0) return {
+			if (catalog.skills.length === 0) return {
 				kind: "error",
 				text: "no skills available"
 			};
-			app.openSettings(catalog.map((skill) => ({
+			app.openSettings(catalog.skills.map((skill) => ({
 				id: skill.name,
 				label: skill.name,
 				description: skill.description,
@@ -16049,25 +17318,57 @@ function registerTuiCommands(runner) {
 	});
 	commands.register({
 		name: "reload",
-		description: "Reload TUI settings and refresh skill commands",
+		description: "Reload TUI settings and refresh the live command/skill catalog",
 		handler: async () => {
-			let skillCount = 0;
-			try {
-				skillCount = await registerSkillCommands();
-			} catch {}
+			let catalogText = "";
+			const liveAgent = runner.liveAgent;
+			if (liveAgent !== void 0) {
+				const outcome = await runner.refreshCatalog({
+					source: "reload",
+					target: {
+						kind: "agent",
+						key: runner.sessionGeneration
+					},
+					agent: liveAgent
+				});
+				if (outcome.kind === "applied") {
+					catalogText = `${outcome.snapshot.commands.length} commands \u00b7 ${outcome.snapshot.skills.length} skills`;
+					if (outcome.snapshot.issues.length > 0) catalogText += ` \u00b7 partial: ${outcome.snapshot.issues.map((issue) => issue.provider).join(", ")} unavailable`;
+				} else if (outcome.kind === "failed") catalogText = `catalog refresh failed: ${outcome.error}`;
+				else catalogText = "catalog refresh superseded";
+			} else {
+				const outcome = await runner.refreshCatalog({
+					source: "reload",
+					target: {
+						kind: "preset",
+						presetId: runner.effectivePresetId
+					}
+				});
+				if (outcome.kind === "applied") {
+					catalogText = `${outcome.snapshot.skills.length} human skills`;
+					if (outcome.notice !== void 0) catalogText += ` \u00b7 ${outcome.notice}`;
+				} else if (outcome.kind === "failed") catalogText = `catalog refresh failed: ${outcome.error}`;
+				else catalogText = "catalog refresh superseded";
+			}
 			const settings = runner.tuiSettings;
 			if (settings !== void 0) {
 				const doc = settings.get();
-				if (doc.theme === "auto") detach("theme autodetect", () => app.autoDetectTheme());
-				else if (doc.theme === "dark" || doc.theme === "light") app.applyTheme(doc.theme);
-				else if (doc.theme.startsWith("custom:")) {
-					const palette = loadCustomTheme(doc.theme.slice(7));
+				const reloadTheme = doc.theme;
+				if (reloadTheme === "auto") {
+					detach("theme autodetect", () => app.autoDetectTheme({ shouldApply: () => reloadTheme === "auto" }));
+					app.trackTerminalTheme(true);
+				} else if (reloadTheme === "dark" || reloadTheme === "light") {
+					app.applyTheme(reloadTheme);
+					app.trackTerminalTheme(false);
+				} else if (reloadTheme.startsWith("custom:")) {
+					const palette = loadCustomTheme(reloadTheme.slice(7));
 					if (palette !== void 0) app.applyPalette(palette);
+					app.trackTerminalTheme(false);
 				}
 				app.setFooterPreset(doc.footer === "compact" ? "compact" : "full");
 				app.setFullscreen(doc.fullscreen === "on");
 			}
-			app.notify(`reloaded — ${skillCount} skills \u00b7 settings reapplied`, "info");
+			app.notify(`reloaded — ${catalogText} \u00b7 settings reapplied`, "info");
 			return { kind: "success" };
 		}
 	});
@@ -16128,7 +17429,7 @@ function registerTuiCommands(runner) {
 		description: "Start a fresh session in this workspace",
 		handler: async () => {
 			const liveAgent = runner.liveAgent;
-			const composition = await runner.compose();
+			const composition = await runner.compose(runner.pendingPreset);
 			const presetId = composition.agentPreset;
 			const next = await runner.agents.create({
 				sessionId: SessionId(`session-${randomUUID()}`),
@@ -16293,13 +17594,13 @@ function registerTuiCommands(runner) {
 		description: "Show or switch the session agent preset",
 		input: { hint: "[status|<id>|default [<id>]]" },
 		handler: async (invocation) => {
-			const liveAgent = await requireAgent();
 			const presets = ctx.get("agentPresets");
 			if (presets === void 0) return {
 				kind: "error",
 				text: "agent presets unavailable in this deployment"
 			};
-			const current = presets.composedPreset(liveAgent.ctx) ?? resolveSessionPreset(liveAgent.session);
+			const liveAgent = runner.liveAgent;
+			const current = liveAgent === void 0 ? void 0 : presets.composedPreset(liveAgent.ctx) ?? resolveSessionPreset(liveAgent.session);
 			const matched = invocation.rawInput.trim().match(/^(\S+)(?:\s+(.*))?$/);
 			const verb = matched?.[1] ?? "";
 			const rest = matched?.[2]?.trim() ?? "";
@@ -16318,24 +17619,95 @@ function registerTuiCommands(runner) {
 					kind: "success",
 					text: `default preset: ${settings.get(ns)?.default ?? presets.defaultId}`
 				};
-				await settings.mutate(ns, [{
-					op: "set",
-					path: ["default"],
-					value: rest
-				}]);
+				try {
+					await settings.mutate(ns, [{
+						op: "set",
+						path: ["default"],
+						value: rest
+					}]);
+				} catch (error) {
+					return {
+						kind: "error",
+						text: safeErrorMessage(error)
+					};
+				}
+				if (runner.effectivePresetId === void 0) {
+					const outcome = await runner.refreshCatalog({
+						source: "preset",
+						target: {
+							kind: "preset",
+							presetId: rest
+						}
+					});
+					if (outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
+				}
 				return {
 					kind: "success",
 					text: `default preset set: ${rest}`
 				};
 			}
-			if (verb !== "") try {
-				const outcome = await runner.recomposeBlank(verb);
+			const applyPresetSelection = async (id) => {
+				if (liveAgent === void 0) {
+					const resolved = await presets.resolve(id);
+					runner.pendingPreset = resolved.id;
+					const outcome = await runner.refreshCatalog({
+						source: "preset",
+						target: {
+							kind: "preset",
+							presetId: resolved.id
+						}
+					});
+					if (outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
+					return {
+						kind: "pending",
+						preset: resolved.id
+					};
+				}
+				const outcome = await runner.recomposeBlank(id);
 				if (outcome.kind === "locked") return {
-					kind: "error",
-					text: `session "${liveAgent.session.id}" has already started; its agent preset is fixed`
+					kind: "locked",
+					sessionId: liveAgent.session.id
 				};
-				refreshCompletions();
+				await runner.refreshCatalog({
+					source: "preset",
+					target: {
+						kind: "agent",
+						key: runner.sessionGeneration
+					},
+					agent: runner.liveAgent
+				});
 				runner.updateWelcomeCard();
+				return {
+					kind: "switched",
+					preset: outcome.preset
+				};
+			};
+			const pickPreset = async (id) => {
+				let outcome;
+				try {
+					outcome = await applyPresetSelection(id);
+				} catch (error) {
+					app.notify(safeErrorMessage(error), "error");
+					return;
+				}
+				if (outcome.kind === "pending") app.notify(`new sessions will start on preset ${outcome.preset}`, "info");
+				else if (outcome.kind === "switched") app.notify(`session preset switched to ${outcome.preset}`, "info");
+				else app.notify(`session "${outcome.sessionId}" has already started; its agent preset is fixed — preset switching is only available in a new session`, "error");
+			};
+			if (verb !== "") try {
+				const outcome = await applyPresetSelection(verb);
+				if (outcome.kind === "pending") return {
+					kind: "success",
+					text: `new sessions will start on preset ${outcome.preset}`
+				};
+				if (outcome.kind === "locked") {
+					const message = `session "${outcome.sessionId}" has already started; its agent preset is fixed — preset switching is only available in a new session`;
+					app.notify(message, "error");
+					return {
+						kind: "error",
+						text: message
+					};
+				}
 				return {
 					kind: "success",
 					text: `session preset switched to ${outcome.preset}`
@@ -16351,17 +17723,37 @@ function registerTuiCommands(runner) {
 				kind: "success",
 				text: "no agent presets configured"
 			};
-			app.openSettings(roster.map((preset) => ({
-				id: preset.id,
-				label: preset.name === void 0 ? preset.id : `${preset.name} (${preset.id})`,
-				description: [
-					preset.trust === "system" ? "system" : "user",
-					preset.id === presets.defaultId ? "default" : void 0,
-					preset.id === current ? "← current" : void 0,
-					preset.broken
-				].filter(Boolean).join(" · "),
-				currentValue: ""
-			})), () => {}, () => {});
+			if (liveAgent !== void 0 && liveAgent.session.events.some((event) => event.type === "turn/start")) {
+				const message = `preset switching is only available in a new session — session "${liveAgent.session.id}" has already started; its preset is fixed (use /new for a fresh session, or /preset default <id> for future sessions)`;
+				app.notify(message, "error");
+				return {
+					kind: "error",
+					text: message
+				};
+			}
+			const close = app.openSettings(roster.map((preset) => {
+				const display = presetDisplayText(preset);
+				return {
+					id: preset.id,
+					label: `${display.name} (${preset.id})`,
+					description: [
+						display.description,
+						preset.trust === "system" ? "system" : "user",
+						preset.id === presets.defaultId ? "default" : void 0,
+						preset.id === current ? "← current" : void 0,
+						preset.broken
+					].filter(Boolean).join(" · "),
+					currentValue: "",
+					values: [preset.id]
+				};
+			}), (id) => {
+				close();
+				runOwned("preset pick", () => pickPreset(id), {
+					diag: runner.diag,
+					sessionId: () => runner.liveAgent?.session.id,
+					onError: (error) => app.notify(`preset selection failed: ${safeErrorMessage(error)}`, "error")
+				});
+			}, () => {});
 			return { kind: "success" };
 		}
 	});
@@ -16469,31 +17861,54 @@ function registerTuiCommands(runner) {
 			return { kind: "success" };
 		}
 	});
-	commands.register({
-		name: "title",
-		description: "Set or show the session title",
-		input: { hint: "<title>" },
-		handler: async (invocation) => {
-			const liveAgent = await requireAgent();
-			const titles = ctx.get("sessionTitle");
-			if (titles === void 0) return {
-				kind: "error",
-				text: "session title service unavailable"
-			};
-			const name = invocation.rawInput.trim();
-			if (name === "") {
-				const current = titles.get(liveAgent.session);
+	const titleHandler = async (invocation) => {
+		const liveAgent = await requireAgent();
+		const titles = ctx.get("sessionTitle");
+		if (titles === void 0) return {
+			kind: "error",
+			text: "session title service unavailable"
+		};
+		const name = invocation.rawInput.trim();
+		if (name !== "") {
+			try {
+				titles.rename(liveAgent.session, name);
+			} catch (error) {
 				return {
-					kind: "success",
-					text: current === void 0 ? "no title set" : `title: ${current.title}`
+					kind: "error",
+					text: safeErrorMessage(error)
 				};
 			}
-			titles.rename(liveAgent.session, name);
 			return {
 				kind: "success",
 				text: `title set: ${name}`
 			};
 		}
+		try {
+			const regenerated = await titles.refresh(liveAgent.session, invocation.signal);
+			if (regenerated === void 0) {
+				app.notify("no conversation yet — title left as-is", "info");
+				return { kind: "success" };
+			}
+			app.notify(`title regenerated: ${regenerated.title}`, "info");
+			return { kind: "success" };
+		} catch (error) {
+			return {
+				kind: "error",
+				text: safeErrorMessage(error)
+			};
+		}
+	};
+	commands.register({
+		name: "title",
+		description: "Set the session title; without an argument, regenerate it from the conversation (overwrites the current title)",
+		input: { hint: "<title>" },
+		handler: titleHandler
+	});
+	commands.register({
+		name: "rename",
+		description: "Alias of /title: set the session title, or regenerate it without an argument (overwrites the current title)",
+		input: { hint: "<title>" },
+		handler: titleHandler
 	});
 	commands.register({
 		name: "copy",
@@ -16688,7 +18103,13 @@ function registerTuiCommands(runner) {
 				{
 					id: "k-enter",
 					label: "Enter",
-					description: "Submit (slash commands dispatch without a model turn)",
+					description: "Submit (steers the running turn while busy when Enter while busy is Steer; skill commands steer too, UI commands run locally)",
+					currentValue: ""
+				},
+				{
+					id: "k-queue",
+					label: "Ctrl+Enter",
+					description: "Queue the draft while the agent is busy (the opposite of Enter while busy)",
 					currentValue: ""
 				},
 				{
@@ -16754,7 +18175,7 @@ function registerTuiCommands(runner) {
 				{
 					id: "k-bang",
 					label: "! cmd",
-					description: "Run a shell command locally; !! sends it to the model",
+					description: "Run a shell command and submit the command and its output to the session; !! runs locally without recording",
 					currentValue: ""
 				},
 				{
@@ -16773,8 +18194,28 @@ function registerTuiCommands(runner) {
 			return { kind: "success" };
 		}
 	});
-	refreshCompletions();
-	return { refreshSkills: () => registerSkillCommands() };
+	if (initial?.snapshot !== void 0) installSurfaceSnapshot(initial.snapshot);
+	else if (initial?.skills !== void 0) withCommandCommit(() => {
+		replaceSkillCommands(initial.skills.skills, /* @__PURE__ */ new Set());
+		savedScopedCommands = [];
+		installCompletions(mergeGlobalAndSavedScoped());
+	});
+	else refreshCompletions();
+	ctx.on("commands/change", () => {
+		if (commandCommitDepth > 0) {
+			commandCommitDirty = true;
+			return;
+		}
+		refreshCompletions();
+	});
+	return {
+		/** The claim test for the dispatch: is /name advertised right now? */
+		wasAdvertised,
+		/** One synchronous catalog commit (the coordinator's install hook). */
+		installSnapshot: (snapshot) => installSurfaceSnapshot(snapshot),
+		/** The revalidating transition (the coordinator's target-change hook). */
+		enterTransition: () => enterCatalogTransition()
+	};
 }
 //#endregion
 //#region src/diag.ts
@@ -17323,13 +18764,15 @@ function sessionUnchanged(locked, agent, generation) {
 * (a queue splice during the guard survives) and steers them with the
 * draft. Any state change — agent switch, generation bump, queue change —
 * aborts with `stale` and a retry notice; nothing is written and nothing
-* is lost.
+* is lost. With `onlyDraft` the queue is neither read nor removed: the
+* draft alone is steered (or followed up when the agent is idle).
 */
-async function steerAll(deps, text) {
+async function steerAll(deps, text, options = {}) {
+	const onlyDraft = options.onlyDraft === true;
 	const agent = deps.currentAgent();
 	if (agent === void 0) return "ok";
 	const generation = deps.currentGeneration();
-	const snapshot = [...agent.inbox.nextTurn, ...agent.inbox.nextStep];
+	const snapshot = onlyDraft ? [] : [...agent.inbox.nextTurn, ...agent.inbox.nextStep];
 	const verdict = await deps.guard.run(savePayloadIdentity(snapshot, text));
 	if (verdict.kind === "blocked") {
 		const verbatim = deps.restoreDraft(text);
@@ -17345,6 +18788,13 @@ async function steerAll(deps, text) {
 		deps.notify(verbatim ? deps.staleNotice() : deps.mergedNotice(), "error");
 		return "stale";
 	}
+	if (onlyDraft) {
+		if (verdict.kind === "forced") deps.notify(deps.forcedNotice(), "error");
+		const message = deps.createDraft(text);
+		if (now.status === "running") now.steer(message);
+		else now.followup(message);
+		return "ok";
+	}
 	const current = [...now.inbox.nextTurn, ...now.inbox.nextStep];
 	if (!(current.length === snapshot.length && current.every((message, index) => message.id === snapshot[index].id))) {
 		const verbatim = deps.restoreDraft(text);
@@ -17367,6 +18817,75 @@ async function steerAll(deps, text) {
 	return "ok";
 }
 //#endregion
+//#region src/shell-context.ts
+/**
+* `!` shell context submission (kimi parity): a completed local shell run
+* is submitted to the session as an ordinary guarded user message, so the
+* model sees the command AND its output on the next turn. `!!` runs stay
+* purely local — no session write, no model visibility (pi's
+* excluded-from-context semantics). Extracted from the runner so the
+* guard/TOCTOU races are testable headless, exactly like steer.ts:
+*
+* - The agent/generation identity is captured BEFORE the guard runs.
+* - AFTER the guard returns, the identity is re-validated: same agent
+*   object, same session generation. A switch while the guard read the
+*   file aborts (`stale`) — the output is never written to a session the
+*   guard did not check.
+* - A blocked write keeps the caller's card visible (the output is not
+*   lost) and the identical `!` re-run can force through its one-time
+*   guard token.
+* @module @xmoon76/dsh-pi-tui/shell-context
+*/
+/**
+* Submit a completed `!` shell run's command+output to the session:
+* capture identity → guard → re-validate → followup. No-op without an
+* agent. `blocked` keeps the caller's card (the output stays visible; the
+* identical `!` re-run can force through its one-time token); `stale`
+* aborts for a retry against the new session.
+*/
+async function submitShellResult(deps, text) {
+	const agent = deps.currentAgent();
+	if (agent === void 0) return "ok";
+	const generation = deps.currentGeneration();
+	const verdict = await deps.guard.run(text);
+	if (verdict.kind === "blocked") {
+		deps.notify(deps.blockedNotice(verdict.reason), "error");
+		return "blocked";
+	}
+	if (!sessionUnchanged({
+		agent,
+		generation
+	}, deps.currentAgent(), deps.currentGeneration())) {
+		deps.notify(deps.staleNotice(), "error");
+		return "stale";
+	}
+	if (verdict.kind === "forced") deps.notify(deps.forcedNotice(), "error");
+	agent.followup(deps.createMessage(text));
+	deps.onSubmitted();
+	return "ok";
+}
+/**
+* Classify one `!` line: 'context' submits the command+output to the
+* session (kimi parity), 'local' runs purely off-session (pi's `!!`
+* escape hatch). Returns undefined for a non-`!` line.
+*/
+function shellModeOf(text) {
+	if (!text.startsWith("!")) return void 0;
+	return text.startsWith("!!") ? "local" : "context";
+}
+/** Extract the command after the `!` prefix ('' when nothing follows). */
+function shellCommandOf(text) {
+	return text.replace(/^!+/, "").trim();
+}
+/**
+* The model-facing submission text: the command echoed `$`-style (kimi
+* ShellExecution parity) followed by the settled card result (output +
+* `[exit N]` / truncation lines).
+*/
+function formatShellSubmitText(command, result) {
+	return `$ ${command}\n${result}`;
+}
+//#endregion
 //#region src/bounded-output.ts
 /**
 * Bounded accumulation of local-shell output: the UI card only ever holds
@@ -17653,6 +19172,191 @@ function parseShellWords(line) {
 	return words;
 }
 //#endregion
+//#region src/skill-catalog-refresh.ts
+/** Whether two targets are the same owner (no transition needed). The
+* preset identity is the caller-provided presetId compared EXACTLY —
+* `undefined` (the deployment default) never conflates with a user preset
+* literally named `'default'`, and a resolved id never conflates with the
+* raw id it came from (the worst case is a benign extra transition). */
+function sameTarget(left, right) {
+	if (left === void 0) return false;
+	if (left.kind !== right.kind) return false;
+	return left.kind === "agent" ? left.key === right.key : left.presetId === right.presetId;
+}
+/**
+* The coordinator. One instance per runner; `dispose()` aborts the active
+* refresh on teardown.
+*/
+var CatalogRefreshCoordinator = class {
+	epoch = 0;
+	active;
+	appliedTarget;
+	snapshot;
+	hooks;
+	lifecycleSignal;
+	diag;
+	constructor(hooks, lifecycleSignal, diag) {
+		this.hooks = hooks;
+		this.lifecycleSignal = lifecycleSignal;
+		this.diag = diag;
+	}
+	/** The last applied snapshot (for same-target partial merges and the
+	* `/reload` report). */
+	get currentSnapshot() {
+		return this.snapshot;
+	}
+	/**
+	* Run one refresh request. A new request aborts the active one; only the
+	* LATEST epoch may commit. Returns the settled outcome; never rejects
+	* (failures and supersessions are outcomes, not exceptions).
+	*/
+	async refresh(request) {
+		this.active?.controller.abort();
+		const epoch = ++this.epoch;
+		const controller = new AbortController();
+		const signal = AbortSignal.any([this.lifecycleSignal, controller.signal]);
+		this.active = {
+			epoch,
+			controller
+		};
+		const targetChanged = !sameTarget(this.appliedTarget, request.target);
+		try {
+			if (targetChanged) this.hooks.enterCatalogTransition();
+			const committed = request.target.kind === "agent" ? { snapshot: await this.hooks.readAgent(request.agent, signal) } : await this.readStandingSnapshot(request.target.presetId, signal);
+			if (signal.aborted || epoch !== this.epoch) {
+				this.diag.debug("catalog refresh superseded", {
+					epoch,
+					source: request.source
+				});
+				return { kind: "superseded" };
+			}
+			const merged = targetChanged ? committed.snapshot : this.mergePartial(committed.snapshot);
+			this.hooks.installSnapshot(merged);
+			this.snapshot = merged;
+			this.appliedTarget = request.target;
+			this.diag.info("catalog applied", {
+				epoch,
+				source: request.source,
+				commands: merged.commands.length,
+				scopedCommands: merged.scopedCommands.length,
+				skills: merged.skills.length,
+				issues: merged.issues.length
+			});
+			return {
+				kind: "applied",
+				snapshot: merged,
+				...committed.notice === void 0 ? {} : { notice: committed.notice }
+			};
+		} catch (error) {
+			if (signal.aborted || epoch !== this.epoch) {
+				this.diag.debug("catalog refresh superseded", {
+					epoch,
+					source: request.source
+				});
+				return { kind: "superseded" };
+			}
+			const message = safeErrorMessage(error);
+			this.diag.warn("catalog unavailable", {
+				epoch,
+				source: request.source,
+				error: message
+			});
+			return {
+				kind: "failed",
+				error: message
+			};
+		} finally {
+			if (this.active?.epoch === epoch) this.active = void 0;
+		}
+	}
+	/** Abort the active refresh (app teardown). Late results are dropped. */
+	dispose() {
+		this.active?.controller.abort();
+	}
+	/** Same-target partial failure: a provider issue keeps the OLD field for
+	* that provider (the old snapshot is still more useful than a blank
+	* catalog); the successful providers update as usual. */
+	mergePartial(snapshot) {
+		const old = this.snapshot;
+		if (old === void 0) return snapshot;
+		const commandsFailed = snapshot.issues.some((issue) => issue.provider === "commands");
+		const skillsFailed = snapshot.issues.some((issue) => issue.provider === "skills");
+		if (!commandsFailed && !skillsFailed) return snapshot;
+		return Object.freeze({
+			commands: commandsFailed ? old.commands : snapshot.commands,
+			scopedCommands: commandsFailed ? old.scopedCommands : snapshot.scopedCommands,
+			skills: skillsFailed ? old.skills : snapshot.skills,
+			issues: snapshot.issues
+		});
+	}
+	/** One standing read wrapped into a skills-only surface snapshot: the
+	* sessionless view has no agent-scoped commands, and the global commands
+	* layer is already registered — only the skill wrappers are installed.
+	* An INCOMPLETE observation (`complete !== true`) is never an
+	* authoritative blank catalog: it carries a detached skills issue, so a
+	* same-target reload keeps the last-good skills (mergePartial) and a
+	* target change keeps the revalidating transition wrappers
+	* (installSurfaceSnapshot's skillsFailed guard). */
+	async readStandingSnapshot(presetId, signal) {
+		const read = await this.hooks.readStanding(presetId, signal);
+		const incomplete = read.catalog.complete !== true;
+		return {
+			snapshot: Object.freeze({
+				commands: Object.freeze([]),
+				scopedCommands: Object.freeze([]),
+				skills: read.catalog.skills,
+				issues: Object.freeze(incomplete ? [Object.freeze({
+					provider: "skills",
+					message: "incomplete skill observation"
+				})] : [])
+			}),
+			...read.notice === void 0 ? {} : { notice: read.notice }
+		};
+	}
+};
+/**
+* The deterministic, timer-free coalescer for invalidation notifications
+* (`skills/change`): while one refresh is in flight, further notifications
+* mark the gate DIRTY; when the in-flight refresh settles, ONE more refresh
+* runs if the gate is dirty. A burst therefore costs at most two reads, and
+* the re-run always observes the CURRENT ownership because the runner's
+* `start` callback reads live state at run time.
+*/
+var CoalescingRefreshGate = class {
+	inFlight = false;
+	dirty = false;
+	start;
+	/** @param start - invoked synchronously to START one owned refresh. Must
+	* never throw and must not itself be re-entrant (the gate owns the
+	* in-flight bookkeeping; `start` only launches the owned task). */
+	constructor(start) {
+		this.start = start;
+	}
+	/** One invalidation notification arrived. */
+	notify() {
+		if (this.inFlight) {
+			this.dirty = true;
+			return;
+		}
+		this.inFlight = true;
+		this.start();
+	}
+	/** Terminal settle of the in-flight refresh (called from EVERY terminal
+	* runOwned callback: onResult / onCancel / onError). Clears the in-flight
+	* flag; a dirty gate starts exactly one follow-up refresh. IDEMPOTENT: a
+	* second settle (e.g. onResult throws and runOwned routes to onError)
+	* must not clear the in-flight flag of a follow-up refresh it did not
+	* start. */
+	settled() {
+		if (!this.inFlight) return;
+		this.inFlight = false;
+		if (this.dirty) {
+			this.dirty = false;
+			this.notify();
+		}
+	}
+};
+//#endregion
 //#region src/index.ts
 /**
 * @xmoon76/dsh-pi-tui — the bundle's runner plugin. Waits for the startup
@@ -17685,6 +19389,9 @@ const REPAINT_FLUSH_MS = 50;
 * dispatches through `commands.execute`, which creates the session lazily
 * (the command line IS the first user input). Commands in this set must
 * tolerate `liveAgent === undefined` in their handlers.
+*
+* Exported for the headless suite: the gate is exactly where a sessionless
+* command silently starts creating sessions again.
 */
 const SESSIONLESS_COMMANDS = /* @__PURE__ */ new Set([
 	"exit",
@@ -17698,14 +19405,123 @@ const SESSIONLESS_COMMANDS = /* @__PURE__ */ new Set([
 	"resume",
 	"search",
 	"new",
-	"fork"
+	"fork",
+	"preset"
 ]);
 /**
-* Read an explicit child-session reference from a future/extended job record.
-* Current dsh JobSnapshot records do not expose one, so this normally returns
-* undefined. Crucially, label, registration order and timestamps are never
-* accepted as identity signals.
+* The LOCAL-execute command set: TUI-owned UI/control commands AND core
+* control commands the TUI does not itself register (e.g. /kill) that
+* must ALWAYS run locally through the commands service, never steered,
+* regardless of the busyEnter preference. Everything NOT in this set —
+* plain prompts AND non-local commands (the per-skill slash commands like
+* /grilling or /matrix-cli) — flows through the busy-Enter submission
+* policy while the agent is running: web parity, where a skill invocation
+* is a plain `session.prompt` whose leading `/name` line the host's
+* pre-step listener (dsh-tool-skill) resolves into the injected skill
+* body — there is no command-execution wire for skills.
 */
+const LOCAL_COMMANDS = /* @__PURE__ */ new Set([
+	"copy",
+	"exit",
+	"export",
+	"fork",
+	"help",
+	"kill",
+	"login",
+	"logout",
+	"model",
+	"new",
+	"preset",
+	"queue",
+	"quit",
+	"reload",
+	"rename",
+	"resume",
+	"search",
+	"sessions",
+	"settings",
+	"skill",
+	"status",
+	"subagents",
+	"tasks",
+	"title",
+	"yolo"
+]);
+/**
+* Whether one submission steers under the busy-Enter preference: NOT a
+* force-queued chord, NOT a TUI-owned local command, and the agent is
+* running with the preference set to 'steer'. Pure so the dispatch gate
+* (inside the runner closure) is testable headless.
+* @param parsed - the parsed slash command, undefined for a plain prompt.
+* @param running - whether the live agent reports running.
+* @param busyEnter - the persisted preference value (''/undefined = queue).
+* @param forceQueue - the Ctrl+Enter chord: always queue, never steer.
+*/
+function shouldSteerOnEnter(parsed, running, busyEnter, forceQueue) {
+	if (forceQueue) return false;
+	if (parsed !== void 0 && LOCAL_COMMANDS.has(parsed.name)) return false;
+	return running && busyEnter === "steer";
+}
+/**
+* The advertised-claim miss decision (pure, exported for the headless
+* suite): a slash input whose name was advertised by the completion list at
+* submit time but that the REAL session's catalog lacks is CONSUMED with an
+* explicit error — never sent to the model as a plain user message. An
+* unadvertised miss keeps the existing plain-input fallback (the user may
+* deliberately send slash text to the model).
+* @param execution - the settled `commands.execute` outcome.
+* @param wasAdvertised - the claim captured BEFORE session creation.
+* @returns whether the miss must be consumed as an advertised miss.
+*/
+function shouldConsumeAdvertisedMiss(execution, wasAdvertised) {
+	return execution === void 0 && wasAdvertised;
+}
+async function resolveInitialCatalog(options) {
+	const { liveAgent, presetId, signal, ctx, diag } = options;
+	if (liveAgent !== void 0) try {
+		const snapshot = await readSurfaceCatalog(liveAgent, signal, ctx);
+		diag.info("surface catalog prefetched", {
+			commands: snapshot.commands.length,
+			scopedCommands: snapshot.scopedCommands.length,
+			skills: snapshot.skills.length
+		});
+		return { snapshot };
+	} catch (error) {
+		if (isCancellation(error)) return {};
+		const message = safeErrorMessage(error);
+		diag.warn("surface catalog unavailable", {
+			phase: "resume",
+			error: message
+		});
+		return { notice: `surface catalog unavailable: ${message}` };
+	}
+	const target = await resolveColdSkillTarget(ctx, presetId, process.cwd());
+	if (target.target === void 0) return {};
+	try {
+		const catalog = await readHumanSkillCatalog(target.target.registry, {
+			cwd: target.target.cwd,
+			scope: target.target.scope,
+			signal
+		});
+		diag.info("skill catalog standing ready", {
+			preset: presetId ?? "default",
+			skills: catalog.skills.length,
+			complete: catalog.complete
+		});
+		return {
+			skills: catalog,
+			...target.degraded === void 0 ? {} : { notice: target.degraded }
+		};
+	} catch (error) {
+		if (isCancellation(error)) return {};
+		const message = safeErrorMessage(error);
+		diag.warn("skill catalog unavailable", {
+			phase: "cold",
+			error: message
+		});
+		return { notice: `skill catalog unavailable: ${message}` };
+	}
+}
 function subagentJobTranscriptId(snapshot) {
 	if (typeof snapshot !== "object" || snapshot === null) return void 0;
 	const childSessionId = snapshot.childSessionId;
@@ -17998,6 +19814,7 @@ function apply(ctx, config) {
 		const compose = (presetId) => composeAgent(ctx, selected, presetId);
 		const withPresetMeta = (composition) => composition.agentPreset === void 0 ? {} : { agentPreset: composition.agentPreset };
 		const launchPreset = startup.presetId ?? (process.env.DSH_PI_TUI_PRESET?.trim() || void 0);
+		let pendingPreset;
 		diag.info("boot", {
 			pid: process.pid,
 			dsh: dshVersion() ?? "unknown",
@@ -18022,7 +19839,7 @@ function apply(ctx, config) {
 		/** Resolve the launch composition, falling back to the default on an unknown id. */
 		const launchComposition = async () => {
 			try {
-				return { composition: await compose(launchPreset) };
+				return { composition: await compose(pendingPreset ?? launchPreset) };
 			} catch (error) {
 				const message = safeErrorMessage(error);
 				ctx.logger.warn(`tui-runner: launch preset unavailable: ${message}`);
@@ -18092,6 +19909,29 @@ function apply(ctx, config) {
 		let liveHandle = handle;
 		let liveAgent = handle?.agent;
 		if (liveAgent !== void 0) await liveAgent.whenIdle();
+		let initialSnapshot;
+		let initialSkills;
+		let surfaceNotice;
+		{
+			let effectivePresetId;
+			try {
+				const launched = await launchComposition();
+				if (launched.failure !== void 0) resumeFailure = launched.failure;
+				effectivePresetId = launched.composition.agentPreset;
+			} catch (error) {
+				diag.warn("preset resolution failed at startup", { error: safeErrorMessage(error) });
+			}
+			const resolution = await resolveInitialCatalog({
+				liveAgent,
+				presetId: effectivePresetId,
+				signal: lifecycleController.signal,
+				ctx,
+				diag
+			});
+			initialSnapshot = resolution.snapshot;
+			initialSkills = resolution.skills;
+			surfaceNotice = resolution.notice;
+		}
 		let guardState = freshGuardState();
 		let guardToken;
 		/**
@@ -18228,6 +20068,7 @@ function apply(ctx, config) {
 			guardToken = void 0;
 			bumpSessionGeneration();
 			await initLiveSession(next.agent);
+			await refreshLiveCatalog(next.agent);
 			diag.info("switch ok", {
 				from: from ?? "(none)",
 				to: next.agent.session.id,
@@ -18314,6 +20155,7 @@ function apply(ctx, config) {
 			cleanedUp = true;
 			guardToken = void 0;
 			lifecycleController.abort();
+			catalogCoordinator?.dispose();
 			localShellController?.abort();
 			for (const file of shellTempFiles) try {
 				rmSync(file, { force: true });
@@ -18341,22 +20183,19 @@ function apply(ctx, config) {
 				cleanup();
 			};
 		});
-		/** Run a `!` command locally; the output renders as a local card. */
+		/**
+		* Run a `!` shell command. `!` (context mode) runs the command and then
+		* submits the completed command+output to the session as an ordinary
+		* guarded user message (kimi parity: the model sees both on the next
+		* turn; the result wakes a turn but is never steered into a running
+		* one); `!!` (local mode) runs purely off-session — the card is the
+		* only record (pi's excluded-from-context escape hatch).
+		*/
 		const runLocalShell = (text) => {
-			const includeInContext = text.startsWith("!!");
-			const command = text.replace(/^!+/, "").trim();
+			const includeInContext = shellModeOf(text) === "context";
+			const command = shellCommandOf(text);
 			if (command === "") return;
-			if (includeInContext) {
-				if (liveAgent === void 0) return;
-				liveAgent.followup(createUserMessage({
-					content: [{
-						type: "text",
-						text: command
-					}],
-					source: { kind: "user" }
-				}));
-				return;
-			}
+			const generationAtRun = sessionGeneration;
 			localShellController?.abort();
 			localShellController = new AbortController();
 			const localSignal = localShellController.signal;
@@ -18372,6 +20211,51 @@ function apply(ctx, config) {
 			const releaseController = () => {
 				if (localShellController?.signal === localSignal) localShellController = void 0;
 			};
+			/**
+			* Submit the completed run to the session (context mode only): guard
+			* → re-validate → followup. Blocked keeps the card (the output stays
+			* visible; the identical `!` re-run forces through its one-time guard
+			* token); accepted clears the settled card — the transcript's user
+			* row becomes the record. An owned workflow: the outcome drives the
+			* notify and the card — runOwned (AGENTS.md), never a bare void.
+			*/
+			const submitResult = (result) => {
+				if (sessionGeneration !== generationAtRun) {
+					app.notify("the session changed while the command ran — the output was not submitted", "error");
+					return;
+				}
+				const submitted = formatShellSubmitText(command, result);
+				runOwned("shell submit", () => submitShellResult({
+					currentAgent: () => liveAgent,
+					currentGeneration: () => sessionGeneration,
+					guard: { run: async (identity) => {
+						const verdict = await guardSend("submit", identity);
+						if (verdict.kind === "blocked") return {
+							kind: "blocked",
+							reason: verdict.reason
+						};
+						return { kind: verdict.kind === "forced" ? "forced" : "ok" };
+					} },
+					notify: (message, kind) => app.notify(message, kind),
+					blockedNotice: (reason) => reason === "removed" ? `This session's log was removed externally — the command output was not submitted (it stays on the card). Run the same ! command again to force` : reason === "tail-mismatch" ? "This session file was rewritten by another process (same event count, different content) — the command output was not submitted (it stays on the card). Run the same ! command again to force (may corrupt the session log)" : reason === "unreadable" ? "This session's log could not be read (locked or corrupt) — the command output was not submitted (it stays on the card). Run the same ! command again to force (may corrupt the session log)" : "This session may be open in another dsh process (TUI/web) — the command output was not submitted (it stays on the card). Run the same ! command again to force (may corrupt the session log)",
+					forcedNotice: () => GUARD_FORCED_NOTIFY,
+					staleNotice: () => "the session changed while the submission was being checked — the output was not submitted",
+					createMessage: (text) => createUserMessage({
+						content: [{
+							type: "text",
+							text
+						}],
+						source: { kind: "user" }
+					}),
+					onSubmitted: () => app.clearSettledLocalMessages()
+				}, submitted), {
+					diag,
+					sessionId: () => liveAgent?.session.id,
+					onError: (error) => {
+						app.notify(`shell submit failed: ${safeErrorMessage(error)}`, "error");
+					}
+				});
+			};
 			let settled = false;
 			const settle = (result, status) => {
 				if (settled) return;
@@ -18384,6 +20268,7 @@ function apply(ctx, config) {
 					result,
 					status
 				});
+				if (includeInContext && !localSignal.aborted) submitResult(result);
 			};
 			const shell = ctx.get("shell");
 			if (shell !== void 0) {
@@ -18537,7 +20422,10 @@ function apply(ctx, config) {
 				folder: childFolder
 			};
 			repaint(app, childFolder);
-			app.notify(`viewing subagent ${label ?? childId} — Esc returns`, "info");
+			app.setViewerMode({
+				id: childId,
+				label: label ?? childId
+			});
 		};
 		/** Leave the subagent viewer (single Esc). Returns whether it exited. */
 		const exitView = () => {
@@ -18545,6 +20433,7 @@ function apply(ctx, config) {
 			viewing = void 0;
 			app.clearLocalMessages();
 			app.clearNotify();
+			app.setViewerMode(void 0);
 			repaint(app, folder);
 			refreshStatus();
 			return true;
@@ -18566,6 +20455,8 @@ function apply(ctx, config) {
 		* user input is the deferred trigger), guard against cross-process
 		* divergence, then execute a registered slash command or follow up. */
 		const dispatchViaSession = (text) => {
+			const parsedAtSubmit = parseCommand(text);
+			const wasAdvertised = parsedAtSubmit !== void 0 && wasAdvertisedClaim?.(parsedAtSubmit.name) === true;
 			runOwned("submit", () => ensureSession().then(async () => {
 				const agent = liveAgent;
 				if (agent === void 0) return;
@@ -18595,6 +20486,10 @@ function apply(ctx, config) {
 						diag,
 						sessionId: () => agent.session.id,
 						onResult: (execution) => {
+							if (shouldConsumeAdvertisedMiss(execution, wasAdvertised)) {
+								app.notify(`/${parsedAtSubmit?.name ?? "?"} is not available in the created session`, "error");
+								return;
+							}
 							if (execution === void 0) {
 								if (sessionUnchanged({
 									agent,
@@ -18671,44 +20566,119 @@ function apply(ctx, config) {
 				}
 			});
 		};
+		/**
+		* Steer into the running turn with guard re-validation. Shared by
+		* Ctrl+S (the whole queue plus a non-empty draft) and the busy-Enter
+		* preference — Enter while the agent is running with busyEnter=steer
+		* steers the DRAFT ONLY (web busyEnter parity): explicitly queued
+		* messages stay queued until Ctrl+S or the /queue actions, because
+		* already-steered input cannot be pulled back.
+		* @param text - the submitted draft ('' allowed for Ctrl+S).
+		* @param onlyDraft - busy-Enter mode: never read or remove the queue.
+		*/
+		const steerNow = (text, onlyDraft = false) => {
+			if (viewing !== void 0) {
+				if (text.trim() !== "") app.setEditorText(mergeDraft(app.getDraft(), text));
+				app.notify("viewing a subagent — Esc returns before steering", "info");
+				return;
+			}
+			app.clearSettledLocalMessages();
+			if (onlyDraft) {
+				if (text.trim() === "") return;
+			} else if (liveAgent !== void 0) {
+				if ([...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep].length === 0 && text.trim() === "") return;
+			} else if (text.trim() === "") return;
+			runOwned("steer", () => ensureSession().then(async () => {
+				if (liveAgent === void 0) return;
+				await steerAll({
+					currentAgent: () => liveAgent,
+					currentGeneration: () => sessionGeneration,
+					guard: { run: async (identity) => {
+						const verdict = await guardSend("save", identity);
+						if (verdict.kind === "blocked") return {
+							kind: "blocked",
+							reason: verdict.reason
+						};
+						return { kind: verdict.kind === "forced" ? "forced" : "ok" };
+					} },
+					notify: (message, kind) => app.notify(message, kind),
+					restoreDraft: (draft) => {
+						const merged = mergeDraft(app.getDraft(), draft);
+						app.setEditorText(merged);
+						return merged === draft;
+					},
+					createDraft: (draft) => createUserMessage({
+						content: [{
+							type: "text",
+							text: draft
+						}],
+						source: { kind: "user" }
+					}),
+					blockedNotice: (reason) => reason === "removed" ? GUARD_REMOVED_NOTIFY("save") : reason === "tail-mismatch" ? GUARD_TAIL_MISMATCH_NOTIFY("save") : GUARD_BLOCKED_NOTIFY("save"),
+					forcedNotice: () => GUARD_FORCED_NOTIFY,
+					staleNotice: () => "the queue or session changed while sending — try again",
+					mergedNotice: () => "the draft changed while sending — review it before submitting again (the earlier text was preserved below)"
+				}, text, onlyDraft ? { onlyDraft: true } : void 0);
+			}), {
+				diag,
+				sessionId: () => liveAgent?.session.id,
+				onError: failSubmission(text)
+			});
+		};
+		/**
+		* 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
+		* opposite chord forces the QUEUE mode (forceQueue), web busyEnter
+		* parity — the accelerated chord uses the other behavior.
+		* @param text - the submitted draft.
+		* @param forceQueue - the chord: never steer, queue instead.
+		*/
+		const dispatchUserInput = (text, forceQueue = false) => {
+			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
+					}
+				}), {
+					diag,
+					notify: (message) => app.notify(message, "error"),
+					recoverable: () => true
+				});
+			}
+			if (text.startsWith("!")) {
+				if (text.startsWith("!!")) runLocalShell(text);
+				else if (shellCommandOf(text) !== "") runOwned("contextual shell", () => ensureSession().then(() => runLocalShell(text)), {
+					diag,
+					sessionId: () => liveAgent?.session.id,
+					onError: failSubmission(text)
+				});
+				return;
+			}
+			const parsed = parseCommand(text);
+			if (parsed !== void 0 && liveAgent === void 0 && SESSIONLESS_COMMANDS.has(parsed.name)) {
+				runLocalCommand(parsed, text);
+				return;
+			}
+			if (shouldSteerOnEnter(parsed, liveAgent?.status === "running", tuiSettings?.get().busyEnter, forceQueue)) {
+				steerNow(text, true);
+				return;
+			}
+			dispatchViaSession(text);
+		};
 		app = startProcessTui({
-			onSubmit: (text) => {
-				if (viewing !== void 0) {
-					app.setEditorText(mergeDraft(app.getDraft(), text));
-					app.notify("viewing a subagent — Esc returns before submitting", "info");
-					return;
-				}
-				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
-						}
-					}), {
-						diag,
-						notify: (message) => app.notify(message, "error"),
-						recoverable: () => true
-					});
-				}
-				if (text.startsWith("!")) {
-					if (text.startsWith("!!")) runOwned("contextual shell", () => ensureSession().then(() => runLocalShell(text)), {
-						diag,
-						sessionId: () => liveAgent?.session.id,
-						onError: failSubmission(text)
-					});
-					else runLocalShell(text);
-					return;
-				}
-				const parsed = parseCommand(text);
-				if (parsed !== void 0 && liveAgent === void 0 && SESSIONLESS_COMMANDS.has(parsed.name)) {
-					runLocalCommand(parsed, text);
-					return;
-				}
-				dispatchViaSession(text);
-			},
+			onSubmit: (text) => dispatchUserInput(text),
+			onQueueSubmit: (text) => dispatchUserInput(text, true),
 			runOwned: (label, task, options) => {
 				runOwned(label, task, {
 					...options,
@@ -18724,52 +20694,7 @@ function apply(ctx, config) {
 				localShellController?.abort();
 				liveAgent?.cancel({ kind: "user" });
 			},
-			onSteer: (text) => {
-				if (viewing !== void 0) {
-					if (text.trim() !== "") app.setEditorText(mergeDraft(app.getDraft(), text));
-					app.notify("viewing a subagent — Esc returns before steering", "info");
-					return;
-				}
-				if (liveAgent !== void 0) {
-					if ([...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep].length === 0 && text.trim() === "") return;
-				} else if (text.trim() === "") return;
-				runOwned("steer", () => ensureSession().then(async () => {
-					if (liveAgent === void 0) return;
-					await steerAll({
-						currentAgent: () => liveAgent,
-						currentGeneration: () => sessionGeneration,
-						guard: { run: async (identity) => {
-							const verdict = await guardSend("save", identity);
-							if (verdict.kind === "blocked") return {
-								kind: "blocked",
-								reason: verdict.reason
-							};
-							return { kind: verdict.kind === "forced" ? "forced" : "ok" };
-						} },
-						notify: (message, kind) => app.notify(message, kind),
-						restoreDraft: (draft) => {
-							const merged = mergeDraft(app.getDraft(), draft);
-							app.setEditorText(merged);
-							return merged === draft;
-						},
-						createDraft: (draft) => createUserMessage({
-							content: [{
-								type: "text",
-								text: draft
-							}],
-							source: { kind: "user" }
-						}),
-						blockedNotice: (reason) => reason === "removed" ? GUARD_REMOVED_NOTIFY("save") : reason === "tail-mismatch" ? GUARD_TAIL_MISMATCH_NOTIFY("save") : GUARD_BLOCKED_NOTIFY("save"),
-						forcedNotice: () => GUARD_FORCED_NOTIFY,
-						staleNotice: () => "the queue or session changed while sending — try again",
-						mergedNotice: () => "the draft changed while sending — review it before submitting again (the earlier text was preserved below)"
-					}, text);
-				}), {
-					diag,
-					sessionId: () => liveAgent?.session.id,
-					onError: failSubmission(text)
-				});
-			},
+			onSteer: (text) => steerNow(text),
 			openExternalEditor: async (draft) => {
 				const [editor, ...editorArgs] = parseShellWords(process.env.VISUAL ?? process.env.EDITOR ?? "vi");
 				if (editor === void 0) throw new Error("empty editor command");
@@ -18858,31 +20783,50 @@ function apply(ctx, config) {
 				refreshQueue();
 			},
 			onOpenTasks: () => {
-				if (jobs === void 0 || liveAgent === void 0) return;
-				let snapshots;
-				try {
-					snapshots = jobs.list(liveAgent);
-				} catch {
-					return;
-				}
-				if (snapshots.length === 0) return;
+				if (liveAgent === void 0) return;
+				let jobSnapshots = [];
+				if (jobs !== void 0) try {
+					jobSnapshots = jobs.list(liveAgent);
+				} catch {}
 				const now = Date.now();
-				const terminal = (status) => status !== "running" && status !== "stopping";
-				const ordered = [...snapshots].sort((a, b) => {
-					const aTerminal = terminal(a.status);
-					if (aTerminal !== terminal(b.status)) return aTerminal ? 1 : -1;
-					if (!aTerminal) return a.startedAt - b.startedAt;
-					return (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt);
-				});
-				app.openPicker(ordered.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) => openJobView(jobId), () => {}, {
-					header: `tasks (${snapshots.length})`,
+				let rows = buildTaskRows(jobSnapshots, []);
+				const selectRow = (value) => {
+					const row = rows.find((candidate) => candidate.value === value);
+					if (row === void 0) return;
+					if (row.kind === "subagent") {
+						runOwned("subagent view from tasks", () => enterView(row.childId, row.label), {
+							diag,
+							sessionId: () => liveAgent?.session.id,
+							onError: (error) => app.notify(`could not open the subagent view: ${safeErrorMessage(error)}`, "error")
+						});
+						return;
+					}
+					openJobView(row.jobId);
+				};
+				const pickerItems = (target) => target.map((row) => ({
+					value: row.value,
+					label: taskRowLabel(row),
+					description: describeTaskRow(row, now),
+					group: rowGroup(row)
+				}));
+				const handle = app.openPicker(pickerItems(rows), selectRow, () => {}, {
+					header: "tasks · subagents",
 					enableSearch: true,
 					showHint: true
 				});
+				if (subagents !== void 0) {
+					const sessionId = liveAgent.session.id;
+					const generation = sessionGeneration;
+					runOwned("task browser children", () => subagents.listChildren(sessionId), {
+						diag,
+						sessionId: () => liveAgent?.session.id,
+						onResult: (entries) => {
+							if (sessionGeneration !== generation || liveAgent?.session.id !== sessionId) return;
+							rows = buildTaskRows(jobSnapshots, entries);
+							handle.setItems(pickerItems(rows));
+						}
+					});
+				}
 			}
 		}, {
 			present,
@@ -18892,28 +20836,35 @@ function apply(ctx, config) {
 			theme: z.string(),
 			footer: z.string(),
 			fullscreen: z.string(),
+			busyEnter: z.string(),
 			history: z.dict(z.array(z.string()))
 		}), { base: {
 			theme: "auto",
 			footer: "full",
 			fullscreen: "on",
+			busyEnter: "queue",
 			history: {}
 		} });
+		if (tuiSettings?.get().fullscreen === "on") app.setFullscreen(true);
 		const storedTheme = tuiSettings?.get().theme;
 		if (storedTheme === "auto") {
-			runDetached("theme autodetect", () => app.autoDetectTheme(), { diag });
+			runDetached("theme autodetect", () => app.autoDetectTheme({ shouldApply: () => tuiSettings?.get().theme === "auto" }), { diag });
 			app.onTerminalThemeChange((theme) => {
 				if (tuiSettings?.get().theme === "auto") app.applyTheme(theme);
 			});
-		} else if (storedTheme === "dark" || storedTheme === "light") app.applyTheme(storedTheme);
-		else if (storedTheme?.startsWith("custom:")) {
+			app.trackTerminalTheme(true);
+		} else if (storedTheme === "dark" || storedTheme === "light") {
+			app.applyTheme(storedTheme);
+			app.trackTerminalTheme(false);
+		} else if (storedTheme?.startsWith("custom:")) {
 			const palette = loadCustomTheme(storedTheme.slice(7));
 			if (palette !== void 0) app.applyPalette(palette);
+			app.trackTerminalTheme(false);
 		}
 		if (tuiSettings?.get().footer === "compact") app.setFooterPreset("compact");
-		if (tuiSettings?.get().fullscreen === "on") app.setFullscreen(true);
 		refreshStatus();
 		let refreshTasks = () => {};
+		let refreshAgents = () => {};
 		const jobs = ctx.get("jobs");
 		if (jobs !== void 0) {
 			refreshTasks = () => {
@@ -18928,9 +20879,36 @@ function apply(ctx, config) {
 				} catch {}
 				app.setTasks(tasks);
 			};
-			jobs.onJobsChanged(() => refreshTasks());
+			jobs.onJobsChanged(() => {
+				refreshTasks();
+				refreshAgents();
+			});
 			refreshTasks();
 		}
+		const subagents = ctx.get("subagents");
+		if (subagents !== void 0) {
+			refreshAgents = () => {
+				if (liveAgent === void 0) {
+					app.setAgents([]);
+					return;
+				}
+				const sessionId = liveAgent.session.id;
+				const generation = sessionGeneration;
+				runOwned("task browser agents refresh", () => subagents.listChildren(sessionId), {
+					diag,
+					sessionId: () => liveAgent?.session.id,
+					onResult: (entries) => {
+						if (sessionGeneration !== generation || liveAgent?.session.id !== sessionId) return;
+						app.setAgents(entries.filter((entry) => entry.kind === "child" && entry.activity === "running").map((entry) => ({
+							id: entry.id,
+							label: entry.label ?? entry.id,
+							activity: entry.activity
+						})));
+					}
+				});
+			};
+			refreshAgents();
+		}
 		/**
 		* Open one job from the task browser: a bash job shows a STATUS viewer
 		* (never the output — the job's single read cursor belongs to the agent's
@@ -19018,7 +20996,12 @@ function apply(ctx, config) {
 			app.setQueueItems(queue);
 		};
 		refreshQueue();
-		/** Rebuild every live-session surface after resume, create, or swap. */
+		/**
+		* Rebuild every live-session surface after resume, create, or swap.
+		* The surface catalog is NOT touched here: the initial owner's catalog
+		* came from the pre-mount prefetch/probe, and the first deferred create
+		* plus every switch await the coordinator refresh themselves.
+		*/
 		const initLiveSession = async (agent) => {
 			folder = new TranscriptFolder();
 			folder.apply(agent.session.events);
@@ -19032,11 +21015,15 @@ function apply(ctx, config) {
 			repaint(app, folder);
 			refreshStatus();
 			refreshQueue();
+			refreshTasks();
+			refreshAgents();
 			app.resetInputHistory(tuiSettings?.get().history[sessionCwd()] ?? []);
 			setTerminalTitle(`dsh-pi-tui · ${shortCwd(sessionCwd())} · ${agent.session.id}`);
 			updateWelcomeCard();
-			registerCommands();
-			refreshSkillCommands();
+			registerCommands({
+				snapshot: initialSnapshot,
+				skills: initialSkills
+			});
 		};
 		/**
 		* Create the first session lazily — the FIRST user message triggers it
@@ -19065,6 +21052,7 @@ function apply(ctx, config) {
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
+					await refreshLiveCatalog(liveAgent);
 				} catch (error) {
 					const message = safeErrorMessage(error);
 					ctx.logger.warn(`tui-runner: failed to start with preset "${launchPreset ?? "default"}": ${message}`);
@@ -19088,6 +21076,7 @@ function apply(ctx, config) {
 					await liveAgent.whenIdle();
 					bumpSessionGeneration();
 					await initLiveSession(liveAgent);
+					await refreshLiveCatalog(liveAgent);
 				}
 				if (resumeFailure !== void 0) {
 					app.notify(resumeFailure, "error");
@@ -19099,7 +21088,67 @@ function apply(ctx, config) {
 			return creating;
 		};
 		let commandsRegistered = false;
-		let refreshSkills;
+		/** The claim test installed by registerTuiCommands: is a slash name
+		* advertised by the CURRENT completion list? The dispatch captures it
+		* BEFORE any session creation (see dispatchViaSession). */
+		let wasAdvertisedClaim;
+		/** The catalog refresh coordinator: the ONE post-mount refresh owner
+		* (first session, switches, /preset, /reload). Built inside
+		* registerCommands once the surface hooks exist. */
+		let catalogRefreshRequest;
+		let catalogCoordinator;
+		/** `skills/change` coalescing: bursts of invalidation notifications cost
+		* at most two reads, and the follow-up re-read observes the CURRENT
+		* ownership (live agent vs standing preset). */
+		let skillsChangeSubscribed = false;
+		const skillsChangeGate = new CoalescingRefreshGate(() => {
+			runOwned("skills/change refresh", async () => {
+				const refresh = catalogRefreshRequest;
+				if (refresh === void 0) return void 0;
+				const target = liveAgent === void 0 ? {
+					kind: "preset",
+					presetId: pendingPreset ?? launchPreset
+				} : {
+					kind: "agent",
+					key: sessionGeneration
+				};
+				return refresh({
+					source: "invalidation",
+					target,
+					...target.kind === "agent" ? { agent: liveAgent } : {}
+				});
+			}, {
+				diag,
+				sessionId: () => liveAgent?.session.id,
+				onResult: (outcome) => {
+					if (outcome !== void 0 && outcome.kind === "applied" && outcome.notice !== void 0) app.notify(outcome.notice, "error");
+					skillsChangeGate.settled();
+				},
+				onCancel: () => {
+					skillsChangeGate.settled();
+				},
+				onError: (error) => {
+					skillsChangeGate.settled();
+					app.notify(`skill catalog refresh failed: ${safeErrorMessage(error)}`, "error");
+				}
+			});
+		});
+		/** Subscribe to the dsh-skill invalidation notification once, through
+		* the single-point adapter (plan appendix B.1). The event carries no
+		* scope or cwd, so the refresh target follows the CURRENT ownership; an
+		* unavailable or throwing subscription degrades to no subscription —
+		* owner switches and /reload still refresh. The flag is set only after
+		* a successful subscribe, so a throwing subscribe can retry on a later
+		* registration attempt. */
+		const subscribeSkillsChangeEvents = () => {
+			if (skillsChangeSubscribed) return;
+			try {
+				subscribeSkillsChange(ctx, () => skillsChangeGate.notify());
+				skillsChangeSubscribed = true;
+			} catch (error) {
+				diag.warn("skills/change subscription unavailable", { error: safeErrorMessage(error) });
+			}
+		};
 		const runner = {
 			ctx,
 			app,
@@ -19127,6 +21176,26 @@ function apply(ctx, config) {
 				return sessionGeneration;
 			},
 			compose,
+			get pendingPreset() {
+				return pendingPreset;
+			},
+			set pendingPreset(id) {
+				pendingPreset = id;
+			},
+			/** The effective preset id for COLD (sessionless) reads: the run-local
+			* pending override ahead of the launch-time --preset (the SAME
+			* precedence ensureSession uses); undefined = the saved/default
+			* preset applies. */
+			get effectivePresetId() {
+				return pendingPreset ?? launchPreset;
+			},
+			refreshCatalog: (request) => {
+				const refresh = catalogRefreshRequest;
+				return refresh === void 0 ? Promise.resolve({
+					kind: "failed",
+					error: "catalog refresh unavailable"
+				}) : refresh(request);
+			},
 			switchSession,
 			swapTo: (next) => swapTo(next),
 			currentPreset,
@@ -19138,12 +21207,32 @@ function apply(ctx, config) {
 			requestExit,
 			exit
 		};
-		const registerCommands = () => {
+		const registerCommands = (initial) => {
 			if (commandsRegistered) return;
 			if (ctx.get("commands") === void 0) return;
 			commandsRegistered = true;
 			try {
-				refreshSkills = registerTuiCommands(runner).refreshSkills;
+				const installed = registerTuiCommands(runner, initial);
+				wasAdvertisedClaim = installed.wasAdvertised;
+				catalogCoordinator = new CatalogRefreshCoordinator({
+					readAgent: (agent, readSignal) => readSurfaceCatalog(agent, readSignal, ctx),
+					readStanding: async (presetId, readSignal) => {
+						const target = await resolveColdSkillTarget(ctx, presetId, process.cwd());
+						if (target.target === void 0) throw new Error("skill service unavailable");
+						return {
+							catalog: await readHumanSkillCatalog(target.target.registry, {
+								cwd: target.target.cwd,
+								scope: target.target.scope,
+								signal: readSignal
+							}),
+							...target.degraded === void 0 ? {} : { notice: target.degraded }
+						};
+					},
+					installSnapshot: (next) => installed.installSnapshot(next),
+					enterCatalogTransition: () => installed.enterTransition()
+				}, lifecycleController.signal, diag);
+				catalogRefreshRequest = (request) => catalogCoordinator.refresh(request);
+				subscribeSkillsChangeEvents();
 			} catch (error) {
 				commandsRegistered = false;
 				const message = safeErrorMessage(error);
@@ -19152,13 +21241,21 @@ function apply(ctx, config) {
 				app.notify(`command registration failed: ${message}`, "error");
 			}
 		};
-		/** Rebuild the agent-scoped per-skill commands after a session exists. */
-		const refreshSkillCommands = () => {
-			const refresh = refreshSkills;
+		/** Await one live-owner catalog refresh through the coordinator (the
+		* first deferred create and every session switch): the refresh attempt
+		* settles before the caller continues, and its outcome is an outcome —
+		* provider issues degrade fields, failures warn, the submission or the
+		* switch proceeds either way. */
+		const refreshLiveCatalog = async (agent) => {
+			const refresh = catalogRefreshRequest;
 			if (refresh === void 0) return;
-			runDetached("skill command refresh", () => refresh(), {
-				diag,
-				sessionId: () => liveAgent?.session.id
+			await refresh({
+				source: "live-session",
+				target: {
+					kind: "agent",
+					key: sessionGeneration
+				},
+				agent
 			});
 		};
 		if (liveAgent !== void 0) await initLiveSession(liveAgent);
@@ -19167,7 +21264,14 @@ function apply(ctx, config) {
 			refreshStatus();
 			setTerminalTitle(`dsh-pi-tui · ${shortCwd(sessionCwd())}`);
 		}
-		registerCommands();
+		registerCommands({
+			snapshot: initialSnapshot,
+			skills: initialSkills
+		});
+		if (surfaceNotice !== void 0) {
+			app.notify(surfaceNotice, "error");
+			surfaceNotice = void 0;
+		}
 		if (resumeFailure !== void 0) {
 			app.notify(resumeFailure, "error");
 			resumeFailure = void 0;
@@ -19182,8 +21286,10 @@ function apply(ctx, config) {
 				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));
-			else if (event.type === "tool/result") callArgs.delete(event.data.message.content[0]?.toolCallId ?? "");
+			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 ?? "");
 			folder.apply([event]);
 			statsFolder.apply([event]);
 			if (event.type === "goal/change") goalText = foldGoal([event]);
@@ -19214,6 +21320,8 @@ function apply(ctx, config) {
 				});
 			} else if (event.type === "step/start") refreshStatus();
 		});
+		ctx.on("subagent/start", () => refreshAgents());
+		ctx.on("subagent/end", () => refreshAgents());
 		if (liveAgent !== void 0) {
 			app.setPlanMode(foldPlanMode(liveAgent.session.events));
 			app.setWorking(workingFromLog(liveAgent.session.events));
@@ -19273,4 +21381,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset, resumeCommand, runningProfile, subagentJobTranscriptId, subagentJobViewHint };
+export { Config, LOCAL_COMMANDS, SESSIONLESS_COMMANDS, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset, resolveInitialCatalog, resumeCommand, runningProfile, shouldConsumeAdvertisedMiss, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint };