@xmoon76/dsh-pi-tui 0.1.3 → 0.1.4

package/dist/index.mjs

@@ -12607,25 +12607,36 @@ 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, 8..24 content rows) 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;
+/**
+* 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 MIN_SUPPORTED_BUDGET = 8;
 /**
 * Total physical-row budget for the question body (question text + detail),
 * shared so a single unbroken long line cannot push the options and hints
@@ -12658,14 +12669,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 +12735,14 @@ var QuestionFlow = class {
 	otherInput = new Input();
 	/** Review-page action highlight (0 = Submit, 1 = Cancel). */
 	submitIdx = 0;
-	focused = false;
+	/**
+	* Current content-row budget (8..24). 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;
 	constructor(questions, onDone, onCancel) {
 		this.questions = questions;
 		this.onDone = onDone;
@@ -12737,6 +12756,28 @@ 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, DEFAULT_BUDGET] are clamped.
+	*/
+	setMaxRows(rows) {
+		this.budget = Math.max(MIN_SUPPORTED_BUDGET, Math.min(DEFAULT_BUDGET, Math.floor(rows)));
+	}
 	/** The rows of the current question (options plus the free-text row). */
 	rows() {
 		const question = this.questions[this.tab];
@@ -12983,7 +13024,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,31 +13051,37 @@ 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);
+		const rows = this.rows();
+		const multi = question.multiSelect === true;
+		this.editingOther && rows.some((row) => row.key === OTHER_ROW);
+		const skippedRow = draft.skipped ? 1 : 0;
+		const optionless = rows.length === 0 || rows.length === 1 && rows[0]?.key === OTHER_ROW;
+		const tail = optionless ? 3 + skippedRow : 4 + skippedRow;
+		let bodyAllowance = this.budget - lines.length - tail;
+		const header = question.header;
+		if (header !== void 0 && header !== "" && bodyAllowance >= 2) {
+			lines.push(color.textDim(header));
+			bodyAllowance -= 1;
+		}
+		const bodyBudget = Math.min(MAX_BODY_LINES, Math.max(1, bodyAllowance));
+		let bodyLeft = appendContentFirst(lines, `${color.primary("?")}  `, "    ", color.textStrong(question.question), safeWidth, bodyBudget);
 		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) {
-			if (bodyBudget <= 1) {
-				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), safeWidth, bodyBudget);
+			if (bodyLeft <= 1) {
+				appendWrappedBudgeted(lines, "   ", "   ", color.textDim("... more content hidden"), safeWidth, bodyLeft);
 				break;
 			}
-			bodyBudget = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), safeWidth, bodyBudget);
+			bodyLeft = appendWrappedBudgeted(lines, "   ", "   ", color.textDim(line), safeWidth, bodyLeft);
 		}
-		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)) {
+		if (!optionless) {
 			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 optionBudget = this.budget - lines.length - skippedRow - 2;
 			const maxWindow = Math.max(1, Math.min(MAX_VISIBLE_OPTIONS, optionBudget));
 			const visibleCount = Math.min(rows.length, maxWindow);
 			const half = Math.floor(maxWindow / 2);
 			const maxStart = Math.max(0, rows.length - visibleCount);
 			const start = Math.max(0, Math.min(this.cursor - half, maxStart));
 			const end = Math.min(rows.length, start + visibleCount);
-			if (optionBudget > 0) {
+			{
 				const cursorRow = rows[this.cursor];
 				let reserved = 1;
 				if (cursorRow !== void 0 && cursorRow.key !== OTHER_ROW) {
@@ -13066,7 +13113,7 @@ var QuestionFlow = class {
 					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);
+					if (isCursor) appendContentFirst(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
 					else appendWrappedBudgeted(lines, prefix, indent, `${label}${badge}`, safeWidth, available);
 					left -= lines.length - beforeLabel;
 					if (row.description !== void 0 && row.description !== "" && left > 0) {
@@ -13077,9 +13124,9 @@ var QuestionFlow = class {
 					}
 					if (isCursor) cursorRendered = true;
 				}
-				if (showingRow === 1 && left > 0) left = appendWrappedBudgeted(lines, "   ", "   ", `showing ${start + 1}-${end} of ${rows.length}`, safeWidth, left);
+				if (rows.length > MAX_VISIBLE_OPTIONS && left > 0) left = appendWrappedBudgeted(lines, "   ", "   ", `showing ${start + 1}-${end} of ${rows.length}`, safeWidth, left);
 			}
-		} else if (this.editingOther || (question.options?.length ?? 0) === 0) {
+		} else {
 			const inputLine = this.otherInput.render(Math.max(1, safeWidth - 2))[0] ?? "";
 			const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
 			lines.push(` ${stripped}`);
@@ -13610,13 +13657,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 +13680,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 +13693,36 @@ 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;
+	constructor(flow, heightOf) {
+		super(flow, true);
+		this.flow = flow;
+		this.heightOf = heightOf;
+	}
+	render(width) {
+		const rows = Math.max(1, this.heightOf());
+		const frameRows = Math.max(10, Math.min(26, Math.floor(rows * .6)));
+		this.flow.setMaxRows(frameRows - 2);
+		return super.render(width);
+	}
+	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 +13792,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 +13959,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 +14004,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 +14027,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 +14104,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 +14136,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 +14180,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 +14191,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 +14225,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 +14300,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 +14315,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 +14346,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 +14489,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 +14525,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 +14560,7 @@ var TuiApp = class TuiApp {
 					shrink: 0
 				},
 				{
-					component: this.editor,
+					component: this.editorSeat,
 					shrink: 0
 				},
 				{
@@ -14258,6 +14574,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 +14582,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.
@@ -14467,11 +14787,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 +14923,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 +14996,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 +15064,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 +15103,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 +15137,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 +15231,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 +15257,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 +15310,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 +15371,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 +15396,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 +15553,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 +15673,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 +15756,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 +15774,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 +15805,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 +15822,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 +15865,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
@@ -15619,10 +16243,10 @@ async function loadSessionTitles(query, persistence, ids, signal) {
 //#region src/commands.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
+* /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
@@ -15647,6 +16271,47 @@ 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:
@@ -15730,6 +16395,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 +16450,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 +16510,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 +16545,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");
 				}
@@ -16058,11 +16746,17 @@ function registerTuiCommands(runner) {
 			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");
@@ -16128,7 +16822,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 +16987,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() ?? "";
@@ -16328,14 +17022,53 @@ function registerTuiCommands(runner) {
 					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;
+					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();
 				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 +17084,33 @@ 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();
+				detach("preset pick", () => pickPreset(id));
+			}, () => {});
 			return { kind: "success" };
 		}
 	});
@@ -16469,31 +17218,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 +17460,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 +17532,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: ""
 				},
 				{
@@ -17323,13 +18101,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 +18125,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 +18154,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
@@ -17685,6 +18541,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,9 +18557,64 @@ const SESSIONLESS_COMMANDS = /* @__PURE__ */ new Set([
 	"resume",
 	"search",
 	"new",
-	"fork"
+	"fork",
+	"preset"
 ]);
 /**
+* 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";
+}
+/**
 * 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
@@ -17998,6 +18912,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 +18937,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}`);
@@ -18341,22 +19256,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 +19284,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 +19341,7 @@ function apply(ctx, config) {
 					result,
 					status
 				});
+				if (includeInContext && !localSignal.aborted) submitResult(result);
 			};
 			const shell = ctx.get("shell");
 			if (shell !== void 0) {
@@ -18537,7 +19495,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 +19506,7 @@ function apply(ctx, config) {
 			viewing = void 0;
 			app.clearLocalMessages();
 			app.clearNotify();
+			app.setViewerMode(void 0);
 			repaint(app, folder);
 			refreshStatus();
 			return true;
@@ -18671,44 +19633,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 +19761,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 +19850,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 +19903,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 +19946,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
@@ -19032,6 +20077,8 @@ 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();
@@ -19127,6 +20174,12 @@ function apply(ctx, config) {
 				return sessionGeneration;
 			},
 			compose,
+			get pendingPreset() {
+				return pendingPreset;
+			},
+			set pendingPreset(id) {
+				pendingPreset = id;
+			},
 			switchSession,
 			swapTo: (next) => swapTo(next),
 			currentPreset,
@@ -19182,8 +20235,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 +20269,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 +20330,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, resumeCommand, runningProfile, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint };