@oh-my-pi/pi-tui 18.4.9 → 18.4.10

package/src/overlays/advisor-config.ts

@@ -44,6 +44,12 @@ import { col, node, span, text } from "../native/describe";
 import type { DescribeContext, NativeChild, NativeNode, NativeUiEvent } from "../native/node";
 import { actionHint, hintsRow, type NativeHint, overlayCard } from "../native/overlay";
 
+export const ADVISOR_REVIEW_MODES = ["turn", "agent-end"] as const;
+export const ADVISOR_SYNC_BACKLOG_MODES = ["off", "1", "3", "5", "strict"] as const;
+
+export type AdvisorReviewMode = (typeof ADVISOR_REVIEW_MODES)[number];
+export type AdvisorSyncBacklog = (typeof ADVISOR_SYNC_BACKLOG_MODES)[number];
+
 /** One advisor declared in `WATCHDOG.yml`; its instructions specialize the shared baseline. */
 export interface AdvisorConfig {
 	name: string;
@@ -56,6 +62,9 @@ export interface AdvisorConfig {
 	enabled?: boolean;
 	/** Maximum non-blocker notes per advisor prompt update (default 4); blockers are exempt. */
 	maxNotesPerUpdate?: number;
+	reviewMode?: AdvisorReviewMode;
+	reviewInterval?: number;
+	syncBacklog?: AdvisorSyncBacklog;
 }
 
 /** Which level a `WATCHDOG.yml` lives at: the project root or the user agent dir. */
@@ -115,6 +124,7 @@ export interface AdvisorConfigDeps {
 	externalEditor?: (text: string) => Promise<string | null>;
 	scopedModels: ReadonlyArray<{ model: Model; thinkingLevel?: ThinkingLevel }>;
 	availableToolNames: string[];
+	syncBacklog?: AdvisorSyncBacklog;
 	/** Formatted advisor-role model shown on the seeded default row (e.g. "anthropic/claude-..."). */
 	defaultModelLabel?: string;
 }
@@ -192,13 +202,44 @@ function formatAdvisorTools(tools: readonly string[] | undefined, emptyLabel: st
 	return tools.length > 0 ? tools.join(", ") : emptyLabel;
 }
 
+/** Choice value for "no per-advisor override"; matches no {@link ADVISOR_SYNC_BACKLOG_MODES} entry. */
+const SYNC_BACKLOG_INHERIT = "inherit";
+
+/** One-line cadence label: mode plus interval. */
+function formatReviewCadence(advisor: AdvisorConfig): string {
+	const reviewInterval = advisor.reviewInterval ?? 1;
+	return `${advisor.reviewMode ?? "turn"} · every ${reviewInterval} eligible update${reviewInterval === 1 ? "" : "s"}`;
+}
+
+/** Picker description for one explicit catch-up policy value. */
+function describeSyncBacklogMode(mode: AdvisorSyncBacklog): string {
+	switch (mode) {
+		case "off":
+			return "Never wait for this advisor's backlog.";
+		case "strict":
+			return "Wait for all of this advisor's scheduled reviews; no wall-clock cap.";
+		default:
+			return `Wait until fewer than ${mode} scheduled reviews remain (30s cap).`;
+	}
+}
+
 /** Soft-wrap plain text to `width`, returning at least one (possibly empty) line. */
 function wrap(text: string, width: number): string[] {
 	if (!text) return [""];
 	return Bun.wrapAnsi(text, Math.max(1, width), { trim: false }).split("\n");
 }
 
-type Screen = "list" | "detail" | "name" | "model" | "tools" | "thinking" | "instructions";
+type Screen =
+	| "list"
+	| "detail"
+	| "name"
+	| "model"
+	| "tools"
+	| "thinking"
+	| "review-mode"
+	| "review-interval"
+	| "sync-backlog"
+	| "instructions";
 
 /** Footer key hints per screen for the described overlay (the ANSI footer strings carry the same keys). */
 function screenHints(screen: Screen): (NativeHint | undefined)[] {
@@ -220,7 +261,11 @@ function screenHints(screen: Screen): (NativeHint | undefined)[] {
 				actionHint("tui.select.cancel", "back"),
 			];
 		case "thinking":
+		case "review-mode":
+		case "sync-backlog":
 			return [actionHint("tui.select.confirm", "pick"), actionHint("tui.select.cancel", "back")];
+		case "review-interval":
+			return [actionHint("tui.input.submit", "save"), actionHint("tui.select.cancel", "cancel")];
 		case "tools":
 			return [
 				actionHint("tui.select.confirm", "toggle"),
@@ -432,6 +477,44 @@ export class AdvisorConfigOverlayComponent implements Component {
 					defaultLabel: model ? (this.#defaultModelLabel ?? "advisor role default") : undefined,
 					control: { k: "action", label: model || this.#defaultModelLabel || "advisor role default", act: "edit" },
 				},
+				{
+					id: "reviewMode",
+					label: "Review mode",
+					hint: "turn reviews every primary turn; agent-end reviews only final yields.",
+					changed: advisor.reviewMode !== undefined ? true : undefined,
+					control: {
+						k: "choice",
+						value: advisor.reviewMode ?? "turn",
+						options: ADVISOR_REVIEW_MODES.map(mode => ({ value: mode, label: mode })),
+						style: "segmented",
+					},
+				},
+				{
+					id: "reviewInterval",
+					label: "Review interval",
+					hint: "Review every Nth eligible update; skipped updates join the next review.",
+					changed: advisor.reviewInterval !== undefined ? true : undefined,
+					control: { k: "number", value: advisor.reviewInterval ?? 1, min: 1, step: 1 },
+				},
+				{
+					id: "syncBacklog",
+					label: "Sync backlog",
+					hint: `Catch-up policy; inherit follows advisor.syncBacklog (currently ${this.#deps.syncBacklog ?? "off"}).`,
+					changed: advisor.syncBacklog !== undefined ? true : undefined,
+					control: {
+						k: "choice",
+						value: advisor.syncBacklog ?? SYNC_BACKLOG_INHERIT,
+						options: [
+							{ value: SYNC_BACKLOG_INHERIT, label: "inherit" },
+							...ADVISOR_SYNC_BACKLOG_MODES.map(mode => ({
+								value: mode,
+								label: mode,
+								detail: describeSyncBacklogMode(mode),
+							})),
+						],
+						style: "menu",
+					},
+				},
 				{
 					id: "tools",
 					label: "Tools",
@@ -499,6 +582,9 @@ export class AdvisorConfigOverlayComponent implements Component {
 		const overlay =
 			this.#screen === "model" ||
 			this.#screen === "thinking" ||
+			this.#screen === "review-mode" ||
+			this.#screen === "review-interval" ||
+			this.#screen === "sync-backlog" ||
 			this.#screen === "tools" ||
 			this.#screen === "instructions";
 		const editor = overlay ? this.#active : undefined;
@@ -573,6 +659,24 @@ export class AdvisorConfigOverlayComponent implements Component {
 					advisor.name = event.value.trim();
 					this.#dirty = true;
 					this.#showDetail(index);
+				} else if (event.item === "reviewMode" && (typeof event.value === "string" || event.value === null)) {
+					// `turn` is the default, stored as an omitted field; `null` resets to it.
+					const mode = event.value === null ? "turn" : ADVISOR_REVIEW_MODES.find(m => m === event.value);
+					if (!mode) return;
+					advisor.reviewMode = mode === "turn" ? undefined : mode;
+					this.#dirty = true;
+					this.#showDetail(index);
+				} else if (event.item === "reviewInterval" && (typeof event.value === "number" || event.value === null)) {
+					const interval = event.value ?? 1;
+					if (!Number.isSafeInteger(interval) || interval < 1) return;
+					advisor.reviewInterval = interval === 1 ? undefined : interval;
+					this.#dirty = true;
+					this.#showDetail(index);
+				} else if (event.item === "syncBacklog" && (typeof event.value === "string" || event.value === null)) {
+					// The inherit sentinel and `null` match no mode, so the override clears.
+					advisor.syncBacklog = ADVISOR_SYNC_BACKLOG_MODES.find(mode => mode === event.value);
+					this.#dirty = true;
+					this.#showDetail(index);
 				}
 				return;
 			}
@@ -689,6 +793,8 @@ export class AdvisorConfigOverlayComponent implements Component {
 					{ k: "Enabled", v: advisor.enabled === false ? "○ off" : "● on" },
 					{ k: "Model", v: model },
 					{ k: "Tools", v: formatAdvisorTools(advisor.tools, "no tools") },
+					{ k: "Review", v: formatReviewCadence(advisor) },
+					{ k: "Sync backlog", v: this.#syncBacklogLabel(advisor) },
 				],
 			}),
 			text([span("Instructions:", "dim")]),
@@ -822,12 +928,15 @@ export class AdvisorConfigOverlayComponent implements Component {
 	#advisorPreview(advisor: AdvisorConfig, bodyWidth: number): string[] {
 		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
 		const tools = formatAdvisorTools(advisor.tools, "no tools");
+		const syncBacklog = this.#syncBacklogLabel(advisor);
 		const lines = [
 			theme.bold(advisor.name || "(unnamed)"),
 			"",
 			`${theme.fg("dim", "Enabled:")} ${advisor.enabled === false ? "○ off" : "● on"}`,
 			`${theme.fg("dim", "Model:")} ${model}`,
 			`${theme.fg("dim", "Tools:")} ${tools}`,
+			`${theme.fg("dim", "Review:")} ${formatReviewCadence(advisor)}`,
+			`${theme.fg("dim", "Sync backlog:")} ${syncBacklog}`,
 			"",
 			theme.fg("dim", "Instructions:"),
 		];
@@ -893,6 +1002,9 @@ export class AdvisorConfigOverlayComponent implements Component {
 			advisor?.name === "default" &&
 			!advisor.model?.trim() &&
 			advisor.tools === undefined &&
+			advisor.reviewMode === undefined &&
+			advisor.reviewInterval === undefined &&
+			advisor.syncBacklog === undefined &&
 			!advisor.instructions?.trim() &&
 			advisor.enabled !== false &&
 			advisor.maxNotesPerUpdate === undefined
@@ -902,7 +1014,12 @@ export class AdvisorConfigOverlayComponent implements Component {
 	#advisorSummary(advisor: AdvisorConfig): string {
 		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
 		const tools = formatAdvisorTools(advisor.tools, "no tools");
-		return `${model} · ${tools}`;
+		return `${model} · ${tools} · review ${advisor.reviewMode ?? "turn"}/${advisor.reviewInterval ?? 1}`;
+	}
+
+	/** The advisor's explicit catch-up override, else the inherited global policy. */
+	#syncBacklogLabel(advisor: AdvisorConfig): string {
+		return advisor.syncBacklog ?? `${this.#deps.syncBacklog ?? "off"} (inherited)`;
 	}
 
 	#showList(): void {
@@ -1000,6 +1117,8 @@ export class AdvisorConfigOverlayComponent implements Component {
 		this.#detailIndex = index;
 		const modelDescription = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
 		const toolsDescription = formatAdvisorTools(advisor.tools, "no tools");
+		const reviewMode = advisor.reviewMode ?? "turn";
+		const reviewInterval = advisor.reviewInterval ?? 1;
 		const items: SelectItem[] = [
 			{ value: "name", label: "Name", description: advisor.name },
 			{
@@ -1008,6 +1127,13 @@ export class AdvisorConfigOverlayComponent implements Component {
 				description: advisor.enabled === false ? "○ off" : "● on",
 			},
 			{ value: "model", label: "Model", description: modelDescription },
+			{ value: "reviewMode", label: "Review mode", description: reviewMode },
+			{ value: "reviewInterval", label: "Review interval", description: String(reviewInterval) },
+			{
+				value: "syncBacklog",
+				label: "Sync backlog",
+				description: this.#syncBacklogLabel(advisor),
+			},
 		];
 		if (advisor.model?.trim()) {
 			items.push({ value: "resetModel", label: "Reset model to advisor-role default" });
@@ -1043,6 +1169,15 @@ export class AdvisorConfigOverlayComponent implements Component {
 			case "model":
 				this.#showModelPicker(index);
 				return;
+			case "reviewMode":
+				this.#showReviewModePicker(index);
+				return;
+			case "reviewInterval":
+				this.#showReviewIntervalEditor(index);
+				return;
+			case "syncBacklog":
+				this.#showSyncBacklogPicker(index);
+				return;
 			case "tools":
 				this.#showToolsEditor(index, new Set(this.#doc.advisors[index].tools ?? this.#deps.defaultToolNames), 0);
 				return;
@@ -1137,6 +1272,97 @@ export class AdvisorConfigOverlayComponent implements Component {
 			`Thinking effort for ${selector} · ${editorKey("tui.select.confirm")} / click pick · ${editorKey("tui.select.cancel")} back`,
 		);
 	}
+	#showReviewModePicker(index: number): void {
+		const advisor = this.#doc.advisors[index];
+		if (!advisor) {
+			this.#showList();
+			return;
+		}
+		const current = advisor.reviewMode ?? ADVISOR_REVIEW_MODES[0];
+		const items: SelectItem[] = ADVISOR_REVIEW_MODES.map(mode => ({
+			value: mode,
+			label: mode === current ? `${mode} (current)` : mode,
+			description:
+				mode === "turn"
+					? "Review every primary turn (tool-call round)."
+					: "Review only at agent end (once per run).",
+		}));
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.setSelectedIndex(ADVISOR_REVIEW_MODES.indexOf(current));
+		list.onSelect = item => {
+			advisor.reviewMode = item.value === "turn" ? undefined : "agent-end";
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		list.onCancel = () => this.#showDetail(index);
+		this.#setScreen(
+			"review-mode",
+			list,
+			`${editorKey("tui.select.confirm")} / click choose review mode · ${editorKey("tui.select.cancel")} back`,
+		);
+	}
+
+	#showReviewIntervalEditor(index: number): void {
+		const advisor = this.#doc.advisors[index];
+		if (!advisor) {
+			this.#showList();
+			return;
+		}
+		const input = new Input();
+		input.setValue(String(advisor.reviewInterval ?? 1));
+		input.onSubmit = value => {
+			const interval = Number(value.trim());
+			if (!Number.isSafeInteger(interval) || interval < 1) {
+				this.#cb.notify("Review interval must be a positive integer.");
+				return;
+			}
+			advisor.reviewInterval = interval === 1 ? undefined : interval;
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		input.onEscape = () => this.#showDetail(index);
+		this.#setScreen(
+			"review-interval",
+			input,
+			`Type a positive integer · ${editorKey("tui.input.submit")} save · ${editorKey("tui.select.cancel")} cancel`,
+		);
+	}
+
+	#showSyncBacklogPicker(index: number): void {
+		const advisor = this.#doc.advisors[index];
+		if (!advisor) {
+			this.#showList();
+			return;
+		}
+		const global = this.#deps.syncBacklog ?? "off";
+		const current = advisor.syncBacklog;
+		const items: SelectItem[] = [
+			{
+				value: SYNC_BACKLOG_INHERIT,
+				label: current === undefined ? "inherit (current)" : "inherit",
+				description: `Follow the global advisor.syncBacklog setting (currently "${global}").`,
+			},
+			...ADVISOR_SYNC_BACKLOG_MODES.map(mode => ({
+				value: mode,
+				label: mode === current ? `${mode} (current)` : mode,
+				description: describeSyncBacklogMode(mode),
+			})),
+		];
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.setSelectedIndex(current === undefined ? 0 : ADVISOR_SYNC_BACKLOG_MODES.indexOf(current) + 1);
+		list.onSelect = item => {
+			// The inherit sentinel matches no mode, so `find` yields undefined — the override clears.
+			advisor.syncBacklog = ADVISOR_SYNC_BACKLOG_MODES.find(mode => mode === item.value);
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		list.onCancel = () => this.#showDetail(index);
+		this.#setScreen(
+			"sync-backlog",
+			list,
+			`${editorKey("tui.select.confirm")} / click choose catch-up policy · ${editorKey("tui.select.cancel")} back`,
+		);
+	}
 
 	#showToolsEditor(index: number, selected: Set<string>, cursor: number): void {
 		const all = this.#availableToolNames;

package/src/overlays/ask-dialog.ts

@@ -528,6 +528,7 @@ export function normalizeDialogQuestions(questions: ExtensionAskDialogQuestion[]
 }
 
 export class AskDialogComponent implements Component {
+	readonly retireDisplacedTranscript = true;
 	#states: QuestionState[];
 	#activeTabIndex = 0;
 	#submitScrollOffset = 0;

package/src/overlays/model-hub.ts

@@ -23,6 +23,7 @@ import type {
 import type { KeysApi, Model } from "@oh-my-pi/pi-ai";
 import { getOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
+import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import { providerEntry } from "@oh-my-pi/pi-catalog/compat/providers";
 import { MODEL_KINDS, modelKind, type ModelKind } from "@oh-my-pi/pi-catalog/types";
 import type { Component, TUI } from "../tui";
@@ -483,6 +484,22 @@ export class ModelHubComponent implements Component {
 		return this.#settings.knownRoleIds.filter(role => !this.#settings.getRoleInfo(role).hidden);
 	}
 
+	/**
+	 * Models a `--models`/`enabledModels` scope exposes. The scope only resolves
+	 * chat models (it feeds Ctrl+P cycling), so available non-chat runners
+	 * (judge, search, image, …) join from the registry — runtime role
+	 * resolution ignores the scope for them as well.
+	 */
+	#scopedPool(): Model[] {
+		const pool = this.#scopedModels.map(scoped => scoped.model);
+		for (const model of this.#registry.getAvailable("all")) {
+			if (modelKind(model) === "chat") continue;
+			if (this.#scopedModels.some(scoped => modelsAreEqual(scoped.model, model))) continue;
+			pool.push(model);
+		}
+		return pool;
+	}
+
 	/** Resolve every known role: configured values first, auto-selection for the rest. */
 	#reloadRoles(autoCandidates: ReadonlyArray<Model>): void {
 		const allModels = this.#scopedModels.length > 0 ? autoCandidates : this.#registry.getAll("all");
@@ -499,9 +516,14 @@ export class ModelHubComponent implements Component {
 		let allModels: ReadonlyArray<Model>;
 		let availableModels: ReadonlyArray<Model>;
 		if (this.#scopedModels.length > 0) {
-			allModels = this.#scopedModels.map(scoped => scoped.model);
-			availableModels = allModels;
 			this.#configError = undefined;
+			try {
+				allModels = this.#scopedPool();
+			} catch (error) {
+				this.#configError = error instanceof Error ? error.message : String(error);
+				allModels = this.#scopedModels.map(scoped => scoped.model);
+			}
+			availableModels = allModels;
 		} else {
 			const loadError = this.#registry.getError();
 			this.#configError = loadError ? String(loadError) : undefined;
@@ -1081,8 +1103,7 @@ export class ModelHubComponent implements Component {
 	#roleForScope(role: string, scope: ModelRoleSelectionScope): ResolvedModelRoleValue {
 		const roleValue =
 			scope === "project" ? this.#settings.getProjectModelRole(role) : this.#settings.getGlobalModelRole(role);
-		const allModels =
-			this.#scopedModels.length > 0 ? this.#scopedModels.map(scoped => scoped.model) : this.#registry.getAll("all");
+		const allModels = this.#scopedModels.length > 0 ? this.#scopedPool() : this.#registry.getAll("all");
 		const roleLookup: ModelRoleLookup = {
 			getModelRole: scopedRole =>
 				scope === "project"

package/src/overlays/session-info-overlay.ts

@@ -4,9 +4,9 @@ import { matchesSelectCancel } from "../keybinding-matchers";
 import { OverlayPanel, PanelDivider, PanelRows } from "../chrome/overlay-box";
 import { formatKeyHints } from "../app-keybindings";
 import { editorKey } from "../chrome/keybinding-hints";
-import type { TspSpan } from "@oh-my-pi/pi-wire";
+import type { TspProps, TspSpan } from "@oh-my-pi/pi-wire";
 import { formatNumber } from "@oh-my-pi/pi-utils";
-import { col, node, span, text } from "../native/describe";
+import { col, node, row, span, text } from "../native/describe";
 import type { DescribeContext, NativeChild, NativeNode, NativeUiEvent } from "../native/node";
 import { actionBar, actionButton } from "../native/overlay";
 import { plainText, styledSpans } from "../native/spans";
@@ -52,6 +52,39 @@ function parseKvReport(report: string): KvReportSection[] {
 	return sections.filter(section => section.head !== undefined || section.entries.length > 0);
 }
 
+/** The plain text of `spans`. */
+function joined(spans: readonly TspSpan[]): string {
+	return spans.map(part => part.t).join("");
+}
+
+/**
+ * A value with a copy button after it: a click anywhere on the line copies its
+ * text (the terminal-local `copy` action takes the leaf text; the icon has none).
+ */
+function copyLine(
+	spans: TspSpan[],
+	title: string,
+	key: string,
+	props: Omit<TspProps<"text">, "text" | "spans"> = {},
+): NativeNode {
+	return node(
+		"row",
+		{
+			gap: "sm",
+			align: "center",
+			grow: 1,
+			role: "omp.info.copy",
+			actions: { click: "copy" },
+			title,
+		},
+		[
+			text(spans, { ...props, grow: 1, shrink: 1 }),
+			node("icon", { name: "copy", role: "omp.info.copy.ic", aria: title }),
+		],
+		key,
+	);
+}
+
 /** Terminal surface needed to size the session info viewport. */
 export interface SessionInfoOverlayHost {
 	readonly terminal: {
@@ -155,16 +188,21 @@ export class SessionInfoOverlay implements Component {
 				} else if (section.head === undefined && entry.k === "ID") {
 					// The id leads the sheet, once, as a copyable mono line.
 					body.push(
-						node(
-							"text",
+						copyLine([span(joined(entry.v), "mono muted")], "Copy session ID", "id", { truncate: "middle" }),
+					);
+				} else if (section.head === undefined && entry.k === "File") {
+					flush();
+					children.push(
+						row(
+							[
+								text([span("File", "muted")], { wrap: "none", shrink: 0 }),
+								copyLine([span(joined(entry.v), "mono")], "Copy file path", "path", { wrap: "char" }),
+							],
 							{
-								spans: [span(entry.v.map(part => part.t).join(""), "mono muted")],
-								actions: { click: "copy" },
-								title: "Copy session ID",
-								truncate: "middle",
+								gap: "md",
+								align: "start",
+								role: "omp.info.file",
 							},
-							undefined,
-							"id",
 						),
 					);
 				} else {
@@ -195,7 +233,13 @@ export class SessionInfoOverlay implements Component {
 			[
 				text([span("Context", "muted")]),
 				meter
-					? node("meter", { value, style: "bar", size: "md", thresholds: { warn: 0.7, bad: 0.9 }, grow: 1 })
+					? node("meter", {
+							value,
+							style: "bar",
+							size: "md",
+							thresholds: { warn: 0.7, bad: 0.9 },
+							grow: 1,
+						})
 					: node("progress", { value, grow: 1 }),
 				text([span(figure, "mono")]),
 			],

package/src/prompt/composer.ts

@@ -98,7 +98,9 @@ export interface RuntimeChildrenOptions {
 	 * 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.
+	 * settled rows it displaces retire to native scrollback. Decision panels
+	 * declaring `retireDisplacedTranscript` opt out of this floor even when
+	 * mounted as a child of a transient editor container.
 	 */
 	readonly transient?: readonly Component[];
 	/**
@@ -266,7 +268,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 	#lastNormalRows = 0;
 	// 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
+	// this floor, never their peak, so a transient 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
@@ -276,6 +278,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 	// rediscovered from whatever chrome is expanded when the height changes.
 	#transientChrome: ReadonlySet<Component> = new Set();
 	#transientChromeFloor: number | undefined;
+	#anchorAfterInlineRetirement = false;
 	#lastInterruptAt = 0;
 	/** Last described surface; its arrays are reused while their children are unchanged. */
 	#nativeSurface: NativeSurface = { main: [], dock: [] };
@@ -368,29 +371,43 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		const after: string[] = [];
 		const afterSpans: ViewportClickSpan[] = [];
 		let transientRows = 0;
+		let displacingRows = 0;
+		let decisionPanelOpen = false;
 		for (const root of afterRoots) {
+			const chrome: Component = root;
 			const start = after.length;
 			this.#renderBelowRoot(root, width, after, afterSpans);
 			if (this.#transientChrome.has(root)) transientRows += after.length - start;
+			if (
+				chrome.retireDisplacedTranscript ||
+				(root instanceof Container && root.children.some(child => child.retireDisplacedTranscript))
+			) {
+				if (this.#transientChrome.has(root)) displacingRows += after.length - start;
+				decisionPanelOpen = true;
+			}
 		}
 		// 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 bills transient roots at their floor, not their peak: a
-		// confirmation dialog or a tall multi-line editor clips the live tail for
+		// Retirement bills ordinary 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;
+		// An ask panel remains open while the user reads the preceding response.
+		// Its displaced settled rows must be reachable in scrollback now, rather
+		// than clipped until the panel closes. Ordinary drafts retain their floor.
+		const belowFloor = after.length - transientRows + Math.max(this.#transientChromeFloor, displacingRows);
 		const now = performance.now();
 		const frame: AnimationFrame = { now, tick: Math.floor(now / 80) };
 		// Retirement measures the same live blocks the viewport lays out below;
 		// one open frame renders each of them once for both.
 		transcript.beginFrame(frame);
 		const history = this.#offerHistory(transcript, width, rows, preRoots.length + belowFloor);
+		if (decisionPanelOpen && history !== undefined) this.#anchorAfterInlineRetirement = true;
 		const headerVisible = !this.#headerRetired && this.#offeredHistory?.source !== "header";
 		const headerRows = headerVisible ? this.#header.render(width) : [];
 		const before = [...headerRows, ...preRoots];
@@ -408,6 +425,13 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		}
 		const drop = Math.max(0, before.length + active.length + after.length - rows);
 		const mutable = [...before, ...active, ...after].slice(drop);
+		// Once live rows fill the screen again, the retired gap is gone.
+		if (!decisionPanelOpen && mutable.length >= rows) this.#anchorAfterInlineRetirement = false;
+		// Rows retired during a decision panel cannot be pulled back from native
+		// history when it closes. Keep the input pinned to the bottom without
+		// replaying those rows (which would duplicate them) or clearing history.
+		const topPadding = this.#anchorAfterInlineRetirement ? Math.max(0, rows - mutable.length) : 0;
+		if (topPadding > 0) mutable.unshift(...Array<string>(topPadding).fill(""));
 		const viewportLength = mutable.length;
 		const spans: ViewportClickSpan[] = [];
 		const shift = (span: ViewportClickSpan, base: number): void => {
@@ -421,8 +445,8 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 				spans.push({ start: clamped, end, candidates: (local: number) => span.candidates(local + skew) });
 			}
 		};
-		for (const span of activeSpans) shift(span, before.length - drop);
-		for (const span of afterSpans) shift(span, before.length + active.length - drop);
+		for (const span of activeSpans) shift(span, topPadding + before.length - drop);
+		for (const span of afterSpans) shift(span, topPadding + before.length + active.length - drop);
 		this.#lastClickSpans = spans;
 		if (history !== undefined && this.#offeredHistory?.source === "header") {
 			const visibleHeaderRows = Math.max(0, rows - (mutable.length + drop));
@@ -901,6 +925,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		if (this.#stopped) return;
 		this.#transientChrome = new Set(options.transient);
 		this.#transientChromeFloor = undefined;
+		this.#anchorAfterInlineRetirement = false;
 		this.#nativeDock = options.nativeDock;
 		this.ui.removeChild(this.#statusHost);
 		if (this.#runtimeMounted) {

package/src/status-line/context-usage.ts

@@ -859,16 +859,32 @@ export function describeContextUsage(breakdown: ContextBreakdown): NativeNode {
  * has them and as the glyph grid otherwise.
  */
 export class ContextUsageView extends Container {
-	readonly #breakdown: ContextBreakdown;
+	#breakdown: ContextBreakdown;
 	#native: { meter: boolean; node: NativeNode } | undefined;
+	readonly #theme: Theme;
 
 	constructor(breakdown: ContextBreakdown, theme: Theme) {
 		super();
 		this.#breakdown = breakdown;
+		this.#theme = theme;
+		this.#build();
+	}
+
+	/** Replace the shown breakdown in place, refreshing both the ANSI and native views. */
+	setBreakdown(breakdown: ContextBreakdown): void {
+		this.#breakdown = breakdown;
+		this.#native = undefined;
+		this.clear();
+		this.#build();
+		this.invalidate();
+	}
+
+	#build(): void {
+		const theme = this.#theme;
 		this.addChild(new DynamicBorder());
 		this.addChild(new Text(theme.bold(theme.fg("accent", "Context Usage")), 1, 0));
 		this.addChild(new Spacer(1));
-		this.addChild(new Text(renderContextUsage(breakdown, theme), 1, 0));
+		this.addChild(new Text(renderContextUsage(this.#breakdown, theme), 1, 0));
 		this.addChild(new DynamicBorder());
 	}
 

package/src/terminal-capabilities.ts

@@ -283,6 +283,14 @@ export function isInsideZellij(env: NodeJS.ProcessEnv = Bun.env): boolean {
 	return Boolean(env.ZELLIJ);
 }
 
+/**
+ * Whether the agent process runs in an SSH session, so the terminal emulator
+ * is remote and host-local input/keyboard modes cannot be assumed.
+ */
+export function isSshSession(env: NodeJS.ProcessEnv = Bun.env): boolean {
+	return Boolean(env.SSH_CONNECTION || env.SSH_TTY || env.SSH_CLIENT);
+}
+
 export function isNotificationSuppressed(): boolean {
 	const value = $env.PI_NOTIFICATIONS;
 	if (!value) return false;