@oh-my-pi/pi-tui 18.3.0 → 18.3.1

package/src/chat/tool-execution.ts

@@ -1297,12 +1297,14 @@ export class ToolExecutionComponent extends Container {
 			}
 			context.renderDiff = renderDiff;
 		} else if (this.#toolName === "write") {
-			// Device-dispatch previews resolve renderers from the canonical tool map.
+			// Device-dispatch previews render through the host's canonical resolver,
+			// which covers mounted devices and active top-level tools (the `write`
+			// transport accepts both). Deciding the predicate here instead would
+			// leave a `write xd://<top-level tool>` card on the generic fallback.
 			const writeTool = this.#tool as { session?: { xdev?: XdevMountedState } } | undefined;
-			const xdev = writeTool?.session?.xdev;
-			if (xdev) {
-				context.resolveXdevMounted = (name: string) =>
-					xdev.mountedNames.has(name) ? xdev.tools.get(name) : undefined;
+			const resolveXdevMounted = writeTool?.session?.xdev?.resolve;
+			if (resolveXdevMounted) {
+				context.resolveXdevMounted = resolveXdevMounted;
 			}
 		}
 

package/src/chat/user-message.ts

@@ -48,6 +48,8 @@ export interface UserBubbleOptions {
 	imageLinks?: readonly (string | undefined)[];
 	/** Agent-attributed input: dim, flat prose. */
 	synthetic?: boolean;
+	/** Delivered into the response that was streaming; marked `*` at the bubble's top-left. */
+	liveSteered?: boolean;
 	/** SKILL.md path for a skill chip by name; `undefined` leaves the chip unlinked. */
 	skillPath?: (name: string) => string | undefined;
 }
@@ -102,7 +104,8 @@ export function userBubbleColor(
 
 /**
  * Component that renders a user message. Accepts an agent reaction badge
- * (see {@link ReactionTarget}) drawn right-aligned in the bubble's top padding row.
+ * (see {@link ReactionTarget}) drawn right-aligned in the bubble's top padding row;
+ * a live-steered message carries a `*` marker left-aligned in the same row.
  */
 export class UserMessageComponent extends Container implements ReactionTarget {
 	// Memoized OSC 133 zone wrapping keyed on the underlying container render
@@ -112,6 +115,7 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 	#zoneSource: readonly string[] | undefined;
 	#zoneLines: string[] | undefined;
 	readonly #bgColor: (value: string) => string;
+	readonly #liveSteered: boolean;
 	#reaction: string | undefined;
 
 	constructor(text: string, options: UserBubbleOptions = {}) {
@@ -130,6 +134,7 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 		});
 		const bgColor = (value: string) => theme.bg("userMessageBg", value);
 		this.#bgColor = bgColor;
+		this.#liveSteered = options.liveSteered === true;
 		const md = new Markdown(text, 1, 1, getMarkdownTheme(), {
 			bgColor,
 			color: userBubbleColor(options, composerTokenRegex(mentionLabels)),
@@ -144,10 +149,15 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 		this.#zoneLines = undefined;
 	}
 
-	/** The top padding row with the reaction badge right-aligned inside the horizontal padding. */
-	#reactionRow(width: number): string {
-		const emoji = this.#reaction!;
-		return applyBackgroundToLine(padding(width - 1 - visibleWidth(emoji)) + emoji, width, this.#bgColor);
+	/**
+	 * The top padding row: the live-steering marker left-aligned and the reaction
+	 * badge right-aligned, both inside the horizontal padding.
+	 */
+	#badgeRow(width: number): string {
+		const marker = this.#liveSteered ? theme.fg("accent", "*") : "";
+		const emoji = this.#reaction ?? "";
+		const gap = Math.max(0, width - 2 - visibleWidth(marker) - visibleWidth(emoji));
+		return applyBackgroundToLine(` ${marker}${padding(gap)}${emoji}`, width, this.#bgColor);
 	}
 
 	override render(width: number): readonly string[] {
@@ -159,7 +169,7 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 			return this.#zoneLines;
 		}
 		const wrapped = lines.slice();
-		if (this.#reaction !== undefined) wrapped[0] = this.#reactionRow(width);
+		if (this.#reaction !== undefined || this.#liveSteered) wrapped[0] = this.#badgeRow(width);
 		wrapped[0] = OSC133_ZONE_START + wrapped[0];
 		wrapped[wrapped.length - 1] = wrapped[wrapped.length - 1] + OSC133_ZONE_CLOSE;
 		this.#zoneSource = lines;

package/src/components/editor.ts

@@ -528,8 +528,6 @@ export class Editor implements Component, Focusable {
 
 	/** When set, replaces the normal cursor glyph at end-of-text with this ANSI-styled string. */
 	cursorOverride: string | undefined;
-	/** Display width of the cursorOverride glyph (needed because override may contain ANSI escapes). */
-	cursorOverrideWidth: number | undefined;
 	/** Optional hook that decorates displayed user text after source-text layout.
 	 *  Width-changing output is allowed on lines without the cursor; it is truncated
 	 *  to the content width rather than reflowed. Cursor glyphs and inline hints are excluded. */
@@ -1304,7 +1302,7 @@ export class Editor implements Component, Focusable {
 				if (hasCursor && !this.#useTerminalCursor) {
 					const zeroWidthCursorBudget = visibleWidth(gutterText);
 					const zeroWidthCursorReplacement = this.cursorOverride
-						? { text: this.cursorOverride, width: this.cursorOverrideWidth ?? 1 }
+						? { text: this.cursorOverride, width: visibleWidth(this.cursorOverride) }
 						: this.#getStyledInputCursor();
 					if (showPromptGutter && zeroWidthCursorBudget > 0) {
 						// Keep the leading prompt glyph visible when the gutter consumes the whole row.
@@ -1405,7 +1403,7 @@ export class Editor implements Component, Focusable {
 					// displayWidth stays the same - we're replacing, not adding
 				} else if (this.cursorOverride) {
 					// Cursor override replaces the normal end-of-text cursor glyph
-					const overrideWidth = this.cursorOverrideWidth ?? 1;
+					const overrideWidth = visibleWidth(this.cursorOverride);
 					if (!isSideBordered && displayWidth + overrideWidth > lineContentWidth) {
 						// Borderless editors have no spare padding cell for an end-of-line cursor glyph.
 						// Preserve cursorOverride by replacing the tail of the line with it.

package/src/components/input.ts

@@ -1,7 +1,8 @@
 import { BracketedPasteHandler, decodeReencodedPasteControls } from "../bracketed-paste";
 import { getKeybindings } from "../keybindings";
-import { extractPrintableText } from "../keys";
+import { extractPrintableText, matchesKey } from "../keys";
 import { KillRing } from "../kill-ring";
+import { SpaceHoldGesture } from "../space-hold";
 import { type Component, CURSOR_MARKER, type Focusable } from "../tui";
 import { cursorColumnWindow } from "./scroll-viewport";
 import {
@@ -17,6 +18,30 @@ import {
 
 const segmenter = getSegmenter();
 
+/**
+ * Clean text entering the single-line value from outside the keyboard (pastes, dictation) —
+ * decode tmux's re-encoded control bytes (both extended-keys formats, e.g. Ctrl+J → "\n") back to
+ * literal bytes so the escape tail does not leak in, remove newlines/carriage returns, expand tabs,
+ * NFC-normalize, then strip any remaining control bytes. The decoder can synthesize Ctrl+A..Ctrl+Z
+ * (0x01..0x1A) from a paste, and a single-line value must hold none of them — newlines are already
+ * gone and tabs are already spaces by the time the C0/DEL strip runs.
+ *
+ * NFC normalization rationale: macOS Finder drag-drops file paths in NFD
+ * (Conjoining Jamo, U+1100..U+11FF). `Bun.stringWidth` counts each
+ * conjoining jamo as a separate cell — a Korean syllable like `화` is
+ * 1 char and 2 cells in NFC, but 2 chars and 3 cells in NFD (ᄒ=2 cells
+ * + ᅪ=1 cell). The terminal renders the NFD sequence as a single
+ * combined syllable (2 cells visible), so the width mismatch shows up
+ * as cursor drift past the visible filename — N×~1.5 cells for a path
+ * with N Korean syllables. NFC normalization at insert time stores the
+ * value in the same form everything else in the codebase assumes.
+ */
+function toSingleLine(text: string): string {
+	return replaceTabs(decodeReencodedPasteControls(text).replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, ""))
+		.normalize("NFC")
+		.replace(/[\x00-\x1F\x7F]/g, "");
+}
+
 interface InputState {
 	value: string;
 	cursor: number;
@@ -35,6 +60,10 @@ export class Input implements Component, Focusable {
 	mask = false;
 	onSubmit?: (value: string) => void;
 	onEscape?: () => void;
+	/** Space-bar push-to-talk; set its `handler` to enable it. */
+	readonly spaceHold = new SpaceHoldGesture(count => this.deleteBeforeCursor(count));
+	/** When set, replaces the cursor glyph at end-of-text with this ANSI-styled string. */
+	cursorOverride: string | undefined;
 
 	/** Focusable interface - set by TUI when focus changes */
 	focused: boolean = false;
@@ -49,6 +78,9 @@ export class Input implements Component, Focusable {
 	// Undo support
 	#undoStack: InputState[] = [];
 
+	/** Code units of the current volatile speech-to-text preview (see {@link setVolatileText}). */
+	#volatileTextLen = 0;
+
 	getValue(): string {
 		return this.#value;
 	}
@@ -93,6 +125,15 @@ export class Input implements Component, Focusable {
 			return;
 		}
 
+		// Space-hold push-to-talk: a sustained space bar starts/stops STT instead of typing spaces.
+		switch (this.spaceHold.process(matchesKey(data, "space"))) {
+			case "type":
+				this.#insertCharacter(" ");
+				return;
+			case "swallow":
+				return;
+		}
+
 		const kb = getKeybindings();
 
 		// Escape/Cancel
@@ -212,6 +253,52 @@ export class Input implements Component, Focusable {
 		this.#handlePaste(text);
 	}
 
+	/** Programmatically trigger submission (e.g. for voice submit). */
+	submit(): void {
+		this.onSubmit?.(this.#value);
+	}
+
+	/** Delete up to `count` characters immediately before the cursor. */
+	deleteBeforeCursor(count: number): void {
+		const removable = Math.min(count, this.#cursor);
+		if (removable <= 0) return;
+		this.#lastAction = null;
+		this.#pushUndo();
+		this.#replaceBeforeCursor(removable, "");
+	}
+
+	/** Show or replace a volatile speech-to-text preview at the cursor, outside undo history.
+	 *  Finalize it with {@link commitVolatileText} or drop it with {@link clearVolatileText}. */
+	setVolatileText(text: string): void {
+		const clean = toSingleLine(text);
+		this.#replaceBeforeCursor(this.#volatileTextLen, clean);
+		this.#volatileTextLen = clean.length;
+	}
+
+	/** Remove the current volatile preview without committing it. */
+	clearVolatileText(): void {
+		this.setVolatileText("");
+	}
+
+	/** Drop any volatile preview, then insert `text` as a single undoable edit. */
+	commitVolatileText(text: string): void {
+		this.clearVolatileText();
+		const clean = toSingleLine(text);
+		if (!clean) return;
+		this.#lastAction = null;
+		this.#pushUndo();
+		this.#replaceBeforeCursor(0, clean);
+	}
+
+	/** Replace up to `count` code units before the cursor with `text`, leaving the cursor after it. The
+	 *  range stops at the start of the value: a volatile preview's length can outrun the cursor once
+	 *  the caret moves while dictation is still streaming. */
+	#replaceBeforeCursor(count: number, text: string): void {
+		const start = Math.max(0, this.#cursor - count);
+		this.#value = this.#value.slice(0, start) + text + this.#value.slice(this.#cursor);
+		this.#cursor = start + text.length;
+	}
+
 	#insertCharacter(text: string): void {
 		const isWordChunk = [...segmenter.segment(text)].every(seg => getWordNavKind(seg.segment) !== "whitespace");
 		// Undo coalescing: consecutive word typing coalesces into one undo unit.
@@ -390,32 +477,7 @@ export class Input implements Component, Focusable {
 	#handlePaste(pastedText: string): void {
 		this.#lastAction = null;
 		this.#pushUndo();
-
-		// Clean the pasted text — decode tmux's re-encoded control bytes (both
-		// extended-keys formats, e.g. Ctrl+J → "\n") back to literal bytes so the escape
-		// tail does not leak in, remove newlines/carriage returns, expand tabs, NFC-normalize,
-		// then strip any remaining control bytes. The decoder can synthesize Ctrl+A..Ctrl+Z
-		// (0x01..0x1A) from a paste, and a single-line value must hold none of them — newlines
-		// are already gone and tabs are already spaces by the time the C0/DEL strip runs.
-		//
-		// NFC normalization rationale: macOS Finder drag-drops file paths in NFD
-		// (Conjoining Jamo, U+1100..U+11FF). `Bun.stringWidth` counts each
-		// conjoining jamo as a separate cell — a Korean syllable like `화` is
-		// 1 char and 2 cells in NFC, but 2 chars and 3 cells in NFD (ᄒ=2 cells
-		// + ᅪ=1 cell). The terminal renders the NFD sequence as a single
-		// combined syllable (2 cells visible), so the width mismatch shows up
-		// as cursor drift past the visible filename — N×~1.5 cells for a path
-		// with N Korean syllables. NFC normalization at paste time stores the
-		// value in the same form everything else in the codebase assumes.
-		const cleanText = replaceTabs(
-			decodeReencodedPasteControls(pastedText).replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, ""),
-		)
-			.normalize("NFC")
-			.replace(/[\x00-\x1F\x7F]/g, "");
-
-		// Insert at cursor position
-		this.#value = this.#value.slice(0, this.#cursor) + cleanText + this.#value.slice(this.#cursor);
-		this.#cursor += cleanText.length;
+		this.#replaceBeforeCursor(0, toSingleLine(pastedText));
 	}
 
 	invalidate(): void {
@@ -440,7 +502,13 @@ export class Input implements Component, Focusable {
 			visibleValue = "•".repeat(graphemes.length);
 			cursorIndex = graphemes.filter(grapheme => grapheme.index < this.#cursor).length;
 		}
-		const displayValue = this.#cursor >= this.#value.length ? `${visibleValue} ` : visibleValue;
+		// At end of text the cursor sits on trailing padding, sized to fit a (possibly wide) cursor override.
+		const atEnd = this.#cursor >= this.#value.length;
+		const override =
+			atEnd && this.cursorOverride !== undefined
+				? { text: this.cursorOverride, width: visibleWidth(this.cursorOverride) }
+				: undefined;
+		const displayValue = atEnd ? visibleValue + " ".repeat(override?.width ?? 1) : visibleValue;
 
 		const window = cursorColumnWindow(displayValue, cursorIndex, availableWidth);
 		const visibleText = window.text;
@@ -456,11 +524,10 @@ export class Input implements Component, Focusable {
 
 		// Hardware cursor marker (zero-width, emitted before the cursor cell for IME positioning)
 		const marker = this.focused ? CURSOR_MARKER : "";
-		const cursorChar = this.#useTerminalCursor ? atCursor : `\x1b[7m${atCursor || " "}\x1b[27m`;
+		const { text: cursorChar, width: cursorWidth } = override ?? this.#cursorCell(atCursor);
 
 		// Clamp only the trailing text (measured in terminal cells), keeping the cursor marker intact.
 		const beforeWidth = visibleWidth(beforeCursor);
-		const cursorWidth = this.#useTerminalCursor ? visibleWidth(atCursor) : visibleWidth(atCursor || " ");
 		const remainingAfterWidth = Math.max(0, availableWidth - beforeWidth - cursorWidth);
 		const clampedAfterCursor = sliceWithWidth(afterCursor, 0, remainingAfterWidth, true).text;
 		const renderedNoMarker = beforeCursor + cursorChar + clampedAfterCursor;
@@ -471,4 +538,10 @@ export class Input implements Component, Focusable {
 		const line = prompt + textWithCursor + pad;
 		return [line];
 	}
+
+	/** The rendered cursor cell: the grapheme under the cursor, inverted unless the terminal draws its own cursor. */
+	#cursorCell(atCursor: string): { text: string; width: number } {
+		if (this.#useTerminalCursor) return { text: atCursor, width: visibleWidth(atCursor) };
+		return { text: `\x1b[7m${atCursor || " "}\x1b[27m`, width: visibleWidth(atCursor || " ") };
+	}
 }

package/src/components/markdown.ts

@@ -2882,6 +2882,14 @@ export class Markdown implements Component {
 		};
 	}
 
+	#quoteStyle(text: string): string {
+		return this.#theme.quote(this.#theme.italic(text));
+	}
+
+	#getQuoteStylePrefix(): string {
+		return this.#getStylePrefix(text => this.#quoteStyle(text));
+	}
+
 	#renderToken(
 		token: Token,
 		width: number,
@@ -3004,7 +3012,7 @@ export class Markdown implements Component {
 			case "blockquote": {
 				const quoteInlineStyleContext: InlineStyleContext = {
 					applyText: (text: string) => text,
-					stylePrefix: "",
+					stylePrefix: this.#getQuoteStylePrefix(),
 				};
 				const quoteContentWidth = Math.max(1, width - 2);
 				const quoteTokens = token.tokens || [];
@@ -3074,14 +3082,13 @@ export class Markdown implements Component {
 	 * `width` is the full content width; the border reserves two cells.
 	 */
 	#applyQuoteBorder(renderedLines: RenderedLine[], width: number): RenderedLine[] {
-		const quoteStyle = (text: string) => this.#theme.quote(this.#theme.italic(text));
-		const quoteStylePrefix = this.#getStylePrefix(quoteStyle);
+		const quoteStylePrefix = this.#getQuoteStylePrefix();
 		const applyQuoteStyle = (line: string): string => {
 			if (!quoteStylePrefix) {
-				return quoteStyle(line);
+				return this.#quoteStyle(line);
 			}
 			const lineWithReappliedStyle = line.replace(/\x1b\[0m/g, `\x1b[0m${quoteStylePrefix}`);
-			return quoteStyle(lineWithReappliedStyle);
+			return this.#quoteStyle(lineWithReappliedStyle);
 		};
 		const quoteContentWidth = Math.max(1, width - 2);
 		const lines: RenderedLine[] = [];
@@ -3140,7 +3147,12 @@ export class Markdown implements Component {
 
 	/** Render the inner content of an HTML `<blockquote>` with quote styling. */
 	#renderHtmlBlockquote(inner: string, width: number): RenderedLine[] {
-		const cleaned = normalizeHtmlForTerminal(inner, createHtmlNormalizationState(), text => this.#theme.code(text));
+		const quoteStylePrefix = this.#getQuoteStylePrefix();
+		const cleaned = normalizeHtmlForTerminal(
+			inner,
+			createHtmlNormalizationState(),
+			text => this.#theme.code(text) + quoteStylePrefix,
+		);
 		const innerLines = splitTerminalLines(cleaned).map(line => renderedLine(line.trimEnd()));
 		while (innerLines.length > 0 && innerLines[innerLines.length - 1].text === "") innerLines.pop();
 		return this.#applyQuoteBorder(innerLines, width);

package/src/overlays/annotation-overlay.ts

@@ -251,7 +251,6 @@ export class AnnotationOverlay implements Component {
 		// Keep the editor's CURSOR_MARKER for terminal cursor placement, but
 		// replace its visible end-of-input caret with a stable blank cell.
 		this.#editor.cursorOverride = " ";
-		this.#editor.cursorOverrideWidth = 1;
 		this.#editor.setScrollbarVisible(true);
 		this.#editor.onSubmit = value => this.#commitAnnotation(value);
 		this.#externalEditorLabel = keybindings.getDisplayString("app.editor.external");

package/src/overlays/btw-history-panel.ts

@@ -25,6 +25,7 @@ import {
 	matchesSelectPageUp,
 	matchesSelectUp,
 } from "../keybinding-matchers";
+import type { SpaceHoldHandler } from "../space-hold";
 import { sanitizeErrorLine } from "../chrome/error-block";
 import { sanitizeDisplayLine, sanitizeDisplayText } from "./extensions/display-text";
 import { editorKey, rawKeyHint } from "../chrome/keybinding-hints";
@@ -40,6 +41,8 @@ interface BtwHistoryPanelOptions {
 	onCancel: (record: BtwHistoryRecord) => void;
 	canFollowUp?: (record: BtwHistoryRecord) => boolean;
 	onFollowUp?: (record: BtwHistoryRecord, question: string, signal: AbortSignal) => Promise<boolean>;
+	/** Space-bar push-to-talk for a follow-up composer: dictates into `input` while Space is held. */
+	spaceHold?: (input: Input) => SpaceHoldHandler;
 	requestRender: () => void;
 	getHeight: () => number;
 }
@@ -226,6 +229,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 	#openComposer(record: BtwHistoryRecord): void {
 		const input = new Input();
 		input.prompt = theme.fg("accent", "Follow up: ");
+		input.spaceHold.handler = this.#options.spaceHold?.(input);
 		const composer: FollowUpComposer = { recordId: record.id, input, abortController: new AbortController() };
 		input.onEscape = () => {
 			composer.abortController.abort();

package/src/overlays/settings-defs.ts

@@ -75,6 +75,7 @@ export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 		"Todos",
 		"Grep & Browser",
 		"Computer",
+		"IDA Pro",
 		"GitHub",
 		"Output Limits",
 		"Execution",
@@ -131,6 +132,11 @@ export interface SettingsHost {
 	entries: readonly SettingsDisplayEntry[];
 	get(path: string): unknown;
 	set(path: string, value: unknown): void;
+	/**
+	 * Removes the value from the global config: a project or other layer, or an environment
+	 * variable, that configures the setting still applies; otherwise the default does.
+	 */
+	unset(path: string): void;
 	normalizeProviderLimits(value: unknown): Record<string, number>;
 	validateProviderLimits(value: unknown): Record<string, number>;
 }

package/src/overlays/settings-selector.ts

@@ -1100,9 +1100,10 @@ export class SettingsSelectorComponent implements Component {
 			this.#formatTextInputEditValue(def.path, this.#context.settings.get(def.path)),
 			def.secret,
 			value => {
-				// Empty string clears the setting; undefined-typed string settings
-				// store "" which the browser.ts expandPath ignores (no-op fallback).
-				this.#setSettingValue(def.path, value);
+				// An empty field removes the persisted value, so the default (or an
+				// environment fallback) applies again instead of a pinned "".
+				if (value === "") this.#context.settings.unset(def.path);
+				else this.#setSettingValue(def.path, value);
 				this.#callbacks.onChange(def.path, this.#context.settings.get(def.path));
 				wrappedDone(this.#formatTextInputValue(def, this.#context.settings.get(def.path)));
 			},

package/src/prompt/composer.ts

@@ -91,6 +91,18 @@ export interface ComposerOptions {
 	readonly now?: () => number;
 }
 
+/** How {@link Composer.setRuntimeChildren} bills below-transcript roots against transcript retirement. */
+export interface RuntimeChildrenOptions {
+	/**
+	 * Below-transcript roots whose growth is momentary (inline dialogs, a tall
+	 * multi-line editor). They are billed at their smallest height so expansion
+	 * clips the live tail instead of retiring rows a later shrink could not
+	 * reclaim (#11007). Every other root is billed at its current height, so
+	 * settled rows it displaces retire to native scrollback.
+	 */
+	readonly transient?: readonly Component[];
+}
+
 /** Controls the first terminal paint for a composer that does not already own the terminal. */
 export interface ComposerStartOptions {
 	readonly clearScrollback?: boolean;
@@ -253,15 +265,18 @@ export class Composer implements TerminalFrameProvider {
 	#retiredHeaderStart = 0;
 	#resizeRetiredHeaderStart: number | undefined;
 	#lastNormalRows = 0;
-	// Smallest below-transcript chrome height (editor + status + any transient
-	// inline dialog) seen since mount. Retirement is billed against this
-	// persistent baseline, never the transient peak, so a dialog or tall editor
-	// that later shrinks never leaves committed transcript rows the live viewport
-	// cannot reclaim (#11007). The baseline is terminal-height independent — the
-	// editor and status floors do not scale with rows — so it is retained across
-	// resizes rather than rediscovered from whatever chrome is expanded at the
-	// moment the height changes.
-	#retirementBelowFloor: number | undefined;
+	// Roots from `RuntimeChildrenOptions.transient`, and the smallest height
+	// they have rendered at since mount. Retirement bills transient roots at
+	// this floor, never their peak, so a dialog or tall editor that later
+	// shrinks never leaves committed transcript rows the live viewport cannot
+	// reclaim (#11007). Persistent roots (loader, todo/subagent HUDs) bill at
+	// their current height: they stay up for a whole turn, and billing them at
+	// an idle floor hid the settled rows they displaced until the turn ended.
+	// The floor is terminal-height independent — editor and dialog heights do
+	// not scale with rows — so it is retained across resizes rather than
+	// rediscovered from whatever chrome is expanded when the height changes.
+	#transientChrome: ReadonlySet<Component> = new Set();
+	#transientChromeFloor: number | undefined;
 	#lastInterruptAt = 0;
 	#started = false;
 	#stopped = false;
@@ -346,60 +361,24 @@ export class Composer implements TerminalFrameProvider {
 		const afterRoots = roots.slice(transcriptIndex + 1);
 		const after: string[] = [];
 		const afterSpans: ViewportClickSpan[] = [];
+		let transientRows = 0;
 		for (const root of afterRoots) {
 			const start = after.length;
-			// Row targets usually nest one level down: chrome roots are plain
-			// containers (the HUD lives inside `subagentContainer`), and
-			// `Container.render` is a pure concatenation, so child spans tile
-			// the root span exactly. Render those children once and share the
-			// rows for composition and measurement — a second render per frame
-			// would duplicate render-time side effects (image placement
-			// registration). Roots with a custom render keep the composed
-			// output as the source of truth and measure up to the last target.
-			const plainContainer = root instanceof Container && root.render === Container.prototype.render;
-			const targets = root instanceof Container ? root.children : [root];
-			const resolves = targets.map(rowTargetCandidates);
-			const lastTarget = resolves.findLastIndex(resolve => resolve !== undefined);
-			if (plainContainer) {
-				let offset = start;
-				for (let index = 0; index < targets.length; index++) {
-					const childLines = targets[index]!.render(width);
-					after.push(...childLines);
-					if (index > lastTarget) continue;
-					const resolve = resolves[index];
-					if (resolve !== undefined && childLines.length > 0) {
-						afterSpans.push({ start: offset, end: offset + childLines.length, candidates: resolve });
-					}
-					offset += childLines.length;
-				}
-				continue;
-			}
-			after.push(...root.render(width));
-			if (lastTarget === -1) continue;
-			let offset = start;
-			for (let index = 0; index <= lastTarget; index++) {
-				const childLines = targets[index] === root ? after.length - start : targets[index]!.render(width).length;
-				const resolve = resolves[index];
-				if (resolve !== undefined && childLines > 0) {
-					afterSpans.push({ start: offset, end: offset + childLines, candidates: resolve });
-				}
-				offset += childLines;
-			}
+			this.#renderBelowRoot(root, width, after, afterSpans);
+			if (this.#transientChrome.has(root)) transientRows += after.length - start;
 		}
 		// Offer history under capacity pressure only: blocks stay live (and keep
 		// reflowing to the current width) while the screen has room. A batch
 		// leaves the mutable viewport in the same frame it is appended, so its
 		// rows are never painted twice.
 		//
-		// Retirement is billed against the persistent below-transcript chrome
-		// baseline, not the transient peak: a confirmation dialog or a tall
-		// multi-line editor swapped in below the transcript clips the live tail
-		// for its lifetime, but must not permanently commit transcript rows to
-		// native history — otherwise a later shrink cannot refill the freed rows
-		// and the editor drifts up above a band of blank rows (#11007).
-		this.#retirementBelowFloor =
-			this.#retirementBelowFloor === undefined ? after.length : Math.min(this.#retirementBelowFloor, after.length);
-		const belowFloor = this.#retirementBelowFloor;
+		// Retirement bills transient roots at their floor, not their peak: a
+		// confirmation dialog or a tall multi-line editor clips the live tail for
+		// its lifetime, but must not permanently commit transcript rows to native
+		// history — otherwise a later shrink cannot refill the freed rows and the
+		// editor drifts up above a band of blank rows (#11007).
+		this.#transientChromeFloor = Math.min(this.#transientChromeFloor ?? transientRows, transientRows);
+		const belowFloor = after.length - transientRows + this.#transientChromeFloor;
 		const history = this.#offerHistory(transcript, width, rows, preRoots.length + belowFloor);
 		const headerVisible = !this.#headerRetired && this.#offeredHistory?.source !== "header";
 		const headerRows = headerVisible ? this.#header.render(width) : [];
@@ -443,6 +422,52 @@ export class Composer implements TerminalFrameProvider {
 		return { history, viewport: this.#paintHoverBand(mutable, spans) };
 	}
 
+	/**
+	 * Append one below-transcript root's rows to `after`, recording click spans
+	 * for its row targets in `after` coordinates.
+	 *
+	 * Row targets usually nest one level down: chrome roots are plain
+	 * containers (the HUD lives inside `subagentContainer`), and
+	 * `Container.render` is a pure concatenation, so child spans tile the root
+	 * span exactly. Render those children once and share the rows for
+	 * composition and measurement — a second render per frame would duplicate
+	 * render-time side effects (image placement registration). Roots with a
+	 * custom render keep the composed output as the source of truth and measure
+	 * up to the last target.
+	 */
+	#renderBelowRoot(root: Component, width: number, after: string[], spans: ViewportClickSpan[]): void {
+		const start = after.length;
+		const plainContainer = root instanceof Container && root.render === Container.prototype.render;
+		const targets = root instanceof Container ? root.children : [root];
+		const resolves = targets.map(rowTargetCandidates);
+		const lastTarget = resolves.findLastIndex(resolve => resolve !== undefined);
+		if (plainContainer) {
+			let offset = start;
+			for (let index = 0; index < targets.length; index++) {
+				const childLines = targets[index]!.render(width);
+				after.push(...childLines);
+				if (index > lastTarget) continue;
+				const resolve = resolves[index];
+				if (resolve !== undefined && childLines.length > 0) {
+					spans.push({ start: offset, end: offset + childLines.length, candidates: resolve });
+				}
+				offset += childLines.length;
+			}
+			return;
+		}
+		after.push(...root.render(width));
+		if (lastTarget === -1) return;
+		let offset = start;
+		for (let index = 0; index <= lastTarget; index++) {
+			const childLines = targets[index] === root ? after.length - start : targets[index]!.render(width).length;
+			const resolve = resolves[index];
+			if (resolve !== undefined && childLines > 0) {
+				spans.push({ start: offset, end: offset + childLines, candidates: resolve });
+			}
+			offset += childLines;
+		}
+	}
+
 	/**
 	 * Band the hovered click target's current rows. Id-anchored (not
 	 * line-anchored) so the band follows an agent whose rows shift while it
@@ -847,8 +872,10 @@ export class Composer implements TerminalFrameProvider {
 	}
 
 	/** Mount or replace session-aware root children while preserving the header and status hosts. */
-	setRuntimeChildren(children: readonly Component[]): void {
+	setRuntimeChildren(children: readonly Component[], options: RuntimeChildrenOptions = {}): void {
 		if (this.#stopped) return;
+		this.#transientChrome = new Set(options.transient);
+		this.#transientChromeFloor = undefined;
 		this.ui.removeChild(this.#statusHost);
 		if (this.#runtimeMounted) {
 			for (const child of this.#runtimeChildren) this.ui.removeChild(child);