@oh-my-pi/pi-coding-agent 17.0.7 → 17.0.9

package/src/modes/components/agent-hub.ts

@@ -76,26 +76,43 @@ function formatModelBadge(modelId: string, level: ThinkingLevel | undefined): st
 	return `${model} ${theme.getThinkingBorderColor(level)(display)}`;
 }
 
+/** Format a resolved selector, preserving provider identity when requested. */
+function formatResolvedModelBadge(resolved: string, preserveProvider = false): string {
+	// Model ids may themselves contain colons (`qwen3:14b`), so only treat the
+	// suffix as a thinking level when it parses as one.
+	const colon = resolved.lastIndexOf(":");
+	const level = colon >= 0 ? parseThinkingLevel(resolved.slice(colon + 1)) : undefined;
+	const selector = level !== undefined ? resolved.slice(0, colon) : resolved;
+	const label = preserveProvider ? selector : selector.slice(selector.indexOf("/") + 1);
+	return formatModelBadge(label, level);
+}
+
 /**
  * Active model + reasoning level for a hub row: live session state when the
  * agent is attached, else the executor-reported `resolvedModel` selector
- * (`provider/id`, optionally `:<level>`). Undefined when neither is known
+ * (`provider/id`, optionally `:<level>`). Active retry fallbacks retain their
+ * provider and carry an explicit marker. Undefined when no model is known
  * (e.g. a parked historical agent restored from disk).
  */
 function modelBadge(ref: AgentRef, observed: ObservableSession | undefined): string | undefined {
+	const progress = observed?.progress;
+	// Prefer the live session's own resolved fallback selector; else honor the
+	// executor-reported fallback flag. The latter covers observer-only rows (no
+	// live session) AND live rows whose fallback armed no session retry state —
+	// e.g. the Fireworks Fast → base degrade, which emits `retry_fallback_applied`
+	// without populating `#activeRetryFallback`, so `retryFallbackModel` is undefined.
+	const fallbackSelector =
+		ref.session?.retryFallbackModel ?? (progress?.resolvedModelIsFallback ? progress.resolvedModel : undefined);
+	if (fallbackSelector) {
+		return `${theme.fg("warning", "fallback →")} ${formatResolvedModelBadge(fallbackSelector, true)}`;
+	}
 	const model = ref.session?.model;
 	if (model) {
 		const level = model.thinking ? ref.session?.thinkingLevel : undefined;
 		return formatModelBadge(model.id, level);
 	}
-	const resolved = observed?.progress?.resolvedModel;
-	if (!resolved) return undefined;
-	// Model ids may themselves contain colons (`qwen3:14b`), so only treat the
-	// suffix as a thinking level when it parses as one.
-	const colon = resolved.lastIndexOf(":");
-	const level = colon >= 0 ? parseThinkingLevel(resolved.slice(colon + 1)) : undefined;
-	const selector = level !== undefined ? resolved.slice(0, colon) : resolved;
-	return formatModelBadge(selector.slice(selector.indexOf("/") + 1), level);
+	const resolved = progress?.resolvedModel;
+	return resolved ? formatResolvedModelBadge(resolved) : undefined;
 }
 
 /** Result of one host-backed transcript read for the Agent Hub viewer. */

package/src/modes/components/chat-transcript-builder.ts

@@ -56,7 +56,7 @@ import { SkillMessageComponent } from "./skill-message";
 import { ToolExecutionComponent } from "./tool-execution";
 import { TranscriptContainer } from "./transcript-container";
 import { createUsageRowBlock } from "./usage-row";
-import { UserMessageComponent } from "./user-message";
+import { CollapsedSyntheticMessageComponent, UserMessageComponent } from "./user-message";
 
 export interface ChatTranscriptBuilderDeps {
 	ui: TUI;
@@ -233,7 +233,18 @@ export class ChatTranscriptBuilder {
 				const textContent = message.role === "user" ? userMessageText(message) : "";
 				if (textContent) {
 					const isSynthetic = message.role === "developer" ? true : (message.synthetic ?? false);
-					this.container.addChild(new UserMessageComponent(textContent, isSynthetic));
+					// Synthetic (agent-attributed) inputs — chiefly the advisor's `Session
+					// update` replay dumps — can be hundreds of KiB of Markdown each.
+					// Rendering their full body on cold open blocked the TUI (issue #6308);
+					// collapse them behind a compact summary that builds Markdown only on
+					// ctrl+o expand. Real user prompts stay fully rendered.
+					if (isSynthetic) {
+						const collapsed = new CollapsedSyntheticMessageComponent(textContent);
+						this.#trackExpandable(collapsed);
+						this.container.addChild(collapsed);
+					} else {
+						this.container.addChild(new UserMessageComponent(textContent, false));
+					}
 				}
 				break;
 			}

package/src/modes/components/diff.ts

@@ -1,5 +1,5 @@
+import { diffWords } from "@oh-my-pi/pi-natives";
 import { DEFAULT_TAB_WIDTH, sanitizeText } from "@oh-my-pi/pi-utils";
-import * as Diff from "diff";
 import { getLanguageFromPath, highlightCode, theme } from "../../modes/theme/theme";
 import { type CodeFrameMarker, formatCodeFrameLine, replaceTabs } from "../../tools/render-utils";
 
@@ -53,7 +53,7 @@ function parseDiffLine(line: string): { prefix: CodeFrameMarker; lineNum: string
  * Strips leading whitespace from inverse to avoid highlighting indentation.
  */
 function renderIntraLineDiff(oldContent: string, newContent: string): { removedLine: string; addedLine: string } {
-	const wordDiff = Diff.diffWords(oldContent, newContent);
+	const wordDiff = diffWords(oldContent, newContent);
 
 	let removedLine = "";
 	let addedLine = "";

package/src/modes/components/oauth-selector.ts

@@ -60,6 +60,8 @@ export class OAuthSelectorComponent extends Container {
 	/** First provider index of the visible ScrollView window (last #updateList). */
 	#scrollStart = 0;
 	#visibleCount = 0;
+	/** Visible list window, shrunk by {@link setMaxHeight} on short screens. */
+	#maxVisible = OAUTH_SELECTOR_MAX_VISIBLE;
 	#mode: "login" | "logout";
 	#authStorage: AuthStorage;
 	#onSelectCallback: (providerId: string) => void;
@@ -111,6 +113,24 @@ export class OAuthSelectorComponent extends Container {
 		this.#validationGeneration += 1;
 		this.#stopSpinner();
 	}
+
+	/**
+	 * Fit the selector into `lines` rendered rows by shrinking the visible list
+	 * window (the window is centered on the selection, so the selected row is
+	 * always visible at any height). Prefers keeping the full chrome — borders,
+	 * spacers, title, search status — but sacrifices the trailing spacer/border
+	 * (clipped by the host) before dropping below three visible rows.
+	 */
+	setMaxHeight(lines: number): void {
+		// Above the rows: LIST_ROW_OFFSET; below: search status + spacer + border.
+		const strict = lines - LIST_ROW_OFFSET - 3;
+		// Keeps only the rows + search status inside `lines`.
+		const relaxed = lines - LIST_ROW_OFFSET - 1;
+		const rows = Math.min(OAUTH_SELECTOR_MAX_VISIBLE, Math.max(1, strict, Math.min(relaxed, 3)));
+		if (rows === this.#maxVisible) return;
+		this.#maxVisible = rows;
+		this.#updateList();
+	}
 	#hasSelectableAuth(providerId: string): boolean {
 		return this.#mode === "logout" ? this.#authStorage.has(providerId) : this.#authStorage.hasAuth(providerId);
 	}
@@ -227,7 +247,7 @@ export class OAuthSelectorComponent extends Container {
 	}
 
 	#isSearchEnabled(): boolean {
-		return this.#allProviders.length > OAUTH_SELECTOR_MAX_VISIBLE;
+		return this.#allProviders.length > this.#maxVisible;
 	}
 
 	#shouldRenderSearchStatus(): boolean {
@@ -286,7 +306,7 @@ export class OAuthSelectorComponent extends Container {
 		this.#listContainer.clear();
 
 		const total = this.#filteredProviders.length;
-		const maxVisible = OAUTH_SELECTOR_MAX_VISIBLE;
+		const maxVisible = this.#maxVisible;
 		const startIndex =
 			total <= maxVisible
 				? 0
@@ -381,7 +401,7 @@ export class OAuthSelectorComponent extends Container {
 		// Page up - jump up by one visible page
 		else if (matchesKey(keyData, "pageUp")) {
 			if (this.#filteredProviders.length > 0) {
-				this.#selectedIndex = Math.max(0, this.#selectedIndex - OAUTH_SELECTOR_MAX_VISIBLE);
+				this.#selectedIndex = Math.max(0, this.#selectedIndex - this.#maxVisible);
 			}
 			this.#statusMessage = undefined;
 			this.#updateList();
@@ -389,10 +409,7 @@ export class OAuthSelectorComponent extends Container {
 		// Page down - jump down by one visible page
 		else if (matchesKey(keyData, "pageDown")) {
 			if (this.#filteredProviders.length > 0) {
-				this.#selectedIndex = Math.min(
-					this.#filteredProviders.length - 1,
-					this.#selectedIndex + OAUTH_SELECTOR_MAX_VISIBLE,
-				);
+				this.#selectedIndex = Math.min(this.#filteredProviders.length - 1, this.#selectedIndex + this.#maxVisible);
 			}
 			this.#statusMessage = undefined;
 			this.#updateList();

package/src/modes/components/plan-review-overlay.ts

@@ -152,6 +152,14 @@ export class PlanReviewOverlay implements Component {
 	 *  motion mouse reports and cleared when the pointer leaves the option rows. */
 	#hoveredOption: number | undefined;
 
+	// Once a choice fires, the promise-based caller resolves but keeps this
+	// overlay mounted while it runs slow async approval work (e.g. context
+	// compaction). Lock input and switch to a "submitting" indicator so the
+	// overlay stops looking interactive and repeat Enter/Esc are not silently
+	// swallowed with zero feedback (#5926).
+	#committed = false;
+	/** Label of the committed choice, shown while the async approval settles. */
+	#committedLabel: string | undefined;
 	#annotating = false;
 	#input: Input;
 
@@ -283,11 +291,14 @@ export class PlanReviewOverlay implements Component {
 	#confirmSelection(): void {
 		const index = this.#selectedIndex;
 		if (index >= 0 && index < this.#options.length && !this.#disabled.has(index)) {
+			this.#committed = true;
+			this.#committedLabel = this.#options[index]!;
 			this.callbacks.onPick(this.#options[index]!);
 		}
 	}
 
 	handleInput(keyData: string): void {
+		if (this.#committed) return;
 		if (keyData.startsWith("\x1b[<") && this.#handleMouse(keyData)) return;
 		if (this.#annotating) {
 			if (this.callbacks.onAnnotationExternalEditor && matchesAppExternalEditor(keyData)) {
@@ -300,6 +311,7 @@ export class PlanReviewOverlay implements Component {
 			return;
 		}
 		if (matchesSelectCancel(keyData)) {
+			this.#committed = true;
 			this.callbacks.onCancel();
 			return;
 		}
@@ -838,10 +850,14 @@ export class PlanReviewOverlay implements Component {
 		const innerWidth = Math.max(1, width - 4);
 		const bodyContentWidth = sidebarShown ? splitBodyWidth(width, sidebarWidth) : innerWidth;
 
-		const sliderLines = this.#renderSliderLines();
-		const optionLines = this.#renderOptionLines();
+		const committed = this.#committed;
+		const sliderLines = committed ? [] : this.#renderSliderLines();
+		const submittingLabel = this.#committedLabel ? `${this.#committedLabel} — submitting…` : "Submitting…";
+		const optionLines = committed ? [theme.bold(theme.fg("accent", submittingLabel))] : this.#renderOptionLines();
 		const promptLines = this.#promptTitle ? [theme.bold(theme.fg("accent", this.#promptTitle))] : [];
-		const footerLines = this.#renderFooterLines(innerWidth);
+		const footerLines = committed
+			? [theme.fg("dim", "Applying your selection — this can take a moment while context is prepared.")]
+			: this.#renderFooterLines(innerWidth);
 
 		// Chrome rows: top border, two dividers, bottom border, plus the
 		// prompt/slider/option/footer rows between them.
@@ -884,7 +900,7 @@ export class PlanReviewOverlay implements Component {
 		for (const line of promptLines) out.push(row(line, width));
 		for (const line of sliderLines) out.push(row(line, width));
 		for (let i = 0; i < optionLines.length; i++) {
-			this.#optionClickRows.set(out.length, i);
+			if (!committed) this.#optionClickRows.set(out.length, i);
 			out.push(row(optionLines[i]!, width));
 		}
 		out.push(divider(width));

package/src/modes/components/settings-defs.ts

@@ -66,6 +66,7 @@ export interface SubmenuSettingDef extends BaseSettingDef {
 
 export interface TextInputSettingDef extends BaseSettingDef {
 	type: "text";
+	secret: boolean;
 }
 
 export interface ProviderLimitsSettingDef extends BaseSettingDef {
@@ -176,11 +177,13 @@ function pathToSettingDef(path: SettingPath): SettingDef | null {
 		if (options) {
 			return { ...base, type: "submenu", options };
 		}
-		return { ...base, type: "text" };
+		return { ...base, type: "text", secret: ui.secret === true };
 	}
 
 	if (schemaType === "record") {
-		return path === "providers.maxInFlightRequests" ? { ...base, type: "providerLimits" } : { ...base, type: "text" };
+		return path === "providers.maxInFlightRequests"
+			? { ...base, type: "providerLimits" }
+			: { ...base, type: "text", secret: false };
 	}
 
 	return null;

package/src/modes/components/settings-selector.ts

@@ -65,6 +65,7 @@ class TextInputSubmenu extends Container {
 		label: string,
 		description: string,
 		currentValue: string,
+		secret: boolean,
 		private readonly onSubmit: (value: string) => void,
 		private readonly onCancel: () => void,
 	) {
@@ -78,6 +79,7 @@ class TextInputSubmenu extends Container {
 		this.addChild(new Spacer(1));
 
 		this.#input = new Input();
+		this.#input.mask = secret;
 		if (currentValue) {
 			this.#input.setValue(currentValue);
 		}
@@ -293,6 +295,7 @@ class ProviderLimitsSubmenu extends Container {
 				`Max In-Flight Requests: ${provider}`,
 				"Enter a positive number. Decimals round down. Clear the field to make this provider unlimited.",
 				limits[provider]?.toString() ?? "",
+				false,
 				value => {
 					const next = { ...limits };
 					const trimmed = value.trim();
@@ -837,7 +840,7 @@ export class SettingsSelectorComponent implements Component {
 					id: def.path,
 					label: def.label,
 					description: def.description,
-					currentValue: this.#formatTextInputValue(def.path, currentValue),
+					currentValue: this.#formatTextInputValue(def, currentValue),
 					submenu: (cv, done) => this.#createTextInput(def, cv, done),
 					changed,
 				};
@@ -992,12 +995,13 @@ export class SettingsSelectorComponent implements Component {
 			def.label,
 			def.description,
 			this.#formatTextInputEditValue(def.path, 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);
 				this.callbacks.onChange(def.path, settings.get(def.path));
-				wrappedDone(this.#formatTextInputValue(def.path, settings.get(def.path)));
+				wrappedDone(this.#formatTextInputValue(def, settings.get(def.path)));
 			},
 			() => wrappedDone(),
 		);
@@ -1022,9 +1026,9 @@ export class SettingsSelectorComponent implements Component {
 		return entries.map(([provider, limit]) => `${provider}: ${limit}`).join(", ");
 	}
 
-	#formatTextInputValue(path: SettingPath, value: unknown): string {
-		if (path === "providers.maxInFlightRequests") return this.#formatProviderLimitsValue(value);
-		return this.#formatTextInputEditValue(path, value);
+	#formatTextInputValue(def: SettingDef & { type: "text" }, value: unknown): string {
+		if (def.secret) return value ? "••••••••" : "";
+		return this.#formatTextInputEditValue(def.path, value);
 	}
 
 	#formatTextInputEditValue(_path: SettingPath, value: unknown): string {

package/src/modes/components/tool-execution.test.ts

@@ -1,7 +1,9 @@
-import { beforeAll, describe, expect, it } from "bun:test";
+import { afterEach, beforeAll, describe, expect, it } from "bun:test";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
-import { Settings } from "../../config/settings";
+import { Settings, settings } from "../../config/settings";
+import { renderMCPResult } from "../../mcp/render";
+import type { MCPToolDetails } from "../../mcp/tool-bridge";
 import { getThemeByName, setThemeInstance, theme } from "../theme/theme";
 import { ToolExecutionComponent, type ToolExecutionUi } from "./tool-execution";
 
@@ -26,6 +28,10 @@ describe("ToolExecutionComponent custom renderer failures", () => {
 		setThemeInstance(loaded);
 	});
 
+	afterEach(() => {
+		settings.set("mcp.renderMarkdownResults", true);
+	});
+
 	it("falls back to the custom tool label when a renderCall child component throws during render", () => {
 		const tool: AgentTool = {
 			name: "graphify_graph",
@@ -99,3 +105,58 @@ describe("ToolExecutionComponent custom renderer failures", () => {
 		expect(text).toContain(rawResultText);
 	});
 });
+
+describe("MCP result Markdown rendering", () => {
+	const details: MCPToolDetails = {
+		serverName: "context-mode",
+		mcpToolName: "ctx_search",
+	};
+
+	beforeAll(async () => {
+		await Settings.init({ inMemory: true });
+		const loaded = await getThemeByName("dark");
+		if (!loaded) throw new Error("theme unavailable");
+		setThemeInstance(loaded);
+	});
+
+	afterEach(() => {
+		settings.set("mcp.renderMarkdownResults", true);
+	});
+
+	it("renders inline Markdown by default", () => {
+		const component = renderMCPResult(
+			{ content: [{ type: "text", text: "**bold result** and `code`" }], details },
+			{ expanded: true, isPartial: false },
+			theme,
+		);
+		const rendered = visibleText(component.render(80));
+
+		expect(rendered).toContain("bold result and code");
+		expect(rendered).not.toContain("**bold result**");
+		expect(rendered).not.toContain("`code`");
+	});
+
+	it("keeps Markdown syntax literal when the setting is disabled", () => {
+		settings.set("mcp.renderMarkdownResults", false);
+		const component = renderMCPResult(
+			{ content: [{ type: "text", text: "**bold result**" }], details },
+			{ expanded: true, isPartial: false },
+			theme,
+		);
+
+		expect(visibleText(component.render(80))).toContain("**bold result**");
+	});
+
+	it("preserves structured JSON rendering when Markdown is enabled", () => {
+		settings.set("mcp.renderMarkdownResults", true);
+		const component = renderMCPResult(
+			{ content: [{ type: "text", text: '{"status":"**ok**"}' }], details },
+			{ expanded: true, isPartial: false },
+			theme,
+		);
+		const rendered = visibleText(component.render(80));
+
+		expect(rendered).toContain("status");
+		expect(rendered).toContain("**ok**");
+	});
+});

package/src/modes/components/user-message.ts

@@ -1,4 +1,5 @@
-import { Container, Markdown } from "@oh-my-pi/pi-tui";
+import { type Component, Container, Markdown } from "@oh-my-pi/pi-tui";
+import { formatBytes } from "@oh-my-pi/pi-utils";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { imageReferenceHyperlink, renderPlaceholders } from "../image-references";
 import { highlightMagicKeywords } from "../magic-keywords";
@@ -66,3 +67,101 @@ export class UserMessageComponent extends Container {
 		return wrapped;
 	}
 }
+
+/**
+ * Collapsed placeholder for a synthetic (agent-attributed) user input in the
+ * file/remote-backed transcript viewer — chiefly the advisor's `Session update`
+ * replay dumps, which can each be hundreds of KiB of Markdown and, on cold open,
+ * blocked the TUI for tens of seconds while every historical body was laid out
+ * before the viewport clip (issue #6308).
+ *
+ * Collapsed by default: renders one dim summary row (label · size · line count ·
+ * expand hint) and builds NO Markdown. The heavy {@link UserMessageComponent} is
+ * constructed lazily only when expanded via `ctrl+o`, so blocks above the
+ * viewport never pay layout cost until the reader asks to see them. The raw
+ * observability data stays intact in `__advisor.jsonl`.
+ */
+export class CollapsedSyntheticMessageComponent implements Component {
+	#expanded = false;
+	#cache?: { width: number; lines: readonly string[] };
+	#body?: UserMessageComponent;
+	readonly #summary: string;
+
+	constructor(
+		private readonly text: string,
+		private readonly imageLinks?: readonly (string | undefined)[],
+	) {
+		this.#summary = summarizeSyntheticInput(text);
+	}
+
+	/** ctrl+o toggle: reveal/hide the full Markdown body. */
+	setExpanded(expanded: boolean): void {
+		if (this.#expanded === expanded) return;
+		this.#expanded = expanded;
+		this.#cache = undefined;
+	}
+
+	invalidate(): void {
+		this.#cache = undefined;
+		this.#body?.invalidate?.();
+	}
+
+	dispose(): void {
+		this.#body?.dispose?.();
+	}
+
+	render(width: number): readonly string[] {
+		width = Math.max(1, width);
+		if (this.#cache?.width === width) return this.#cache.lines;
+		const lines = this.#expanded ? this.#renderExpanded(width) : [` ${this.#summaryRow(width)}`];
+		this.#cache = { width, lines };
+		return lines;
+	}
+
+	#renderExpanded(width: number): readonly string[] {
+		if (!this.#body) this.#body = new UserMessageComponent(this.text, true, this.imageLinks);
+		return [` ${this.#summaryRow(width)}`, ...this.#body.render(width)];
+	}
+
+	#summaryRow(width: number): string {
+		const hint = `${theme.sep.dot.trim()} ctrl+o`;
+		return theme.fg("dim", truncateSummary(`${this.#summary} ${hint}`, Math.max(10, width - 1)));
+	}
+}
+
+/** Truncate a plain summary label to `maxWidth` display columns, appending `…`. */
+function truncateSummary(text: string, maxWidth: number): string {
+	if (Bun.stringWidth(text, { countAnsiEscapeCodes: false }) <= maxWidth) return text;
+	let out = "";
+	let w = 0;
+	for (const ch of text) {
+		const cw = Bun.stringWidth(ch, { countAnsiEscapeCodes: false });
+		if (w + cw > maxWidth - 1) break;
+		out += ch;
+		w += cw;
+	}
+	return `${out}…`;
+}
+
+/**
+ * One-line summary for a collapsed synthetic input: `<label> · <size> · <n>
+ * lines`. The label is the first Markdown heading's text (e.g. `Session
+ * update`), falling back to `Synthetic input` when the body opens with none.
+ */
+function summarizeSyntheticInput(text: string): string {
+	const size = formatBytes(Buffer.byteLength(text, "utf-8"));
+	const lineCount = text === "" ? 0 : text.split("\n").length;
+	const dot = theme.sep.dot.trim();
+	return `${syntheticInputLabel(text)} ${dot} ${size} ${dot} ${lineCount} line${lineCount === 1 ? "" : "s"}`;
+}
+
+/** First Markdown heading text in `text`, else `Synthetic input`. */
+function syntheticInputLabel(text: string): string {
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line) continue;
+		const heading = /^#{1,6}\s+(.*)$/.exec(line);
+		return heading ? heading[1]!.trim() || "Synthetic input" : "Synthetic input";
+	}
+	return "Synthetic input";
+}

package/src/modes/controllers/command-controller.ts

@@ -1311,7 +1311,7 @@ export class CommandController {
 
 			compactingLoader.stop();
 			this.ctx.statusContainer.disposeChildren();
-			this.ctx.rebuildChatFromMessages();
+			this.ctx.rebuildChatFromMessages({ reuseSettledComponents: true });
 
 			this.ctx.statusLine.invalidate();
 			// Same as the auto-compaction rebuild: a collapsed transcript is an
@@ -1636,17 +1636,24 @@ function formatAggregateAmount(limits: UsageLimit[]): string {
 }
 
 function resolveResetRange(limits: UsageLimit[], nowMs: number): string | null {
-	const absolute = limits
-		.map(limit => limit.window?.resetsAt)
-		.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > nowMs);
-	if (absolute.length === 0) return null;
-	const offsets = absolute.map(value => value - nowMs);
+	const windows = limits
+		.map(limit => limit.window)
+		.filter(
+			(window): window is NonNullable<UsageLimit["window"]> =>
+				window?.resetsAt !== undefined && Number.isFinite(window.resetsAt) && window.resetsAt > nowMs,
+		);
+	if (windows.length === 0) return null;
+	// Use the shared verb when every contributing window agrees (e.g. all "tick");
+	// mixed or absent labels fall back to the generic "resets".
+	const labels = new Set(windows.map(window => window.resetLabel ?? "resets"));
+	const verb = labels.size === 1 ? [...labels][0]! : "resets";
+	const offsets = windows.map(window => window.resetsAt! - nowMs);
 	const minReset = Math.min(...offsets);
 	const maxReset = Math.max(...offsets);
 	if (maxReset - minReset > 60_000) {
-		return `resets in ${formatDuration(minReset)}–${formatDuration(maxReset)}`;
+		return `${verb} in ${formatDuration(minReset)}–${formatDuration(maxReset)}`;
 	}
-	return `resets in ${formatDuration(minReset)}`;
+	return `${verb} in ${formatDuration(minReset)}`;
 }
 /**
  * Compact one-line quota summary for a single advisor's provider.
@@ -1857,17 +1864,34 @@ export function renderUsageReports(
 			for (const line of resetAccountLines) lines.push(uiTheme.fg("dim", line));
 		}
 
+		// Order account columns ONCE per provider (worst-first), then apply that
+		// same order to every window group. Sorting each group independently by
+		// its own used fraction (issue #6067) desynchronized the columns: an
+		// account exhausted on its 5h window but light on the weekly window would
+		// land in different column positions on each row, so the positional
+		// `account N` labels denoted different credentials per row and an
+		// exhausted limit appeared under a sibling that still had quota.
+		const accountRank = new Map<UsageReport, number>();
+		providerReports.forEach((report, position) => {
+			const worst = report.limits.reduce((max, limit) => {
+				const fraction = resolveUsedFraction(limit) ?? -1;
+				return fraction > max ? fraction : max;
+			}, -1);
+			// Encode worst-first primary key with the stable position as tiebreak
+			// so accounts tied on pressure keep their discovery order.
+			accountRank.set(report, -worst * 1000 + position);
+		});
+
 		const renderableGroups = Array.from(limitGroups.values()).map(group => {
 			const entries = group.limits.map((limit, index) => ({
 				limit,
 				report: group.reports[index],
-				fraction: resolveUsedFraction(limit),
 				index,
 			}));
 			entries.sort((a, b) => {
-				const aFraction = a.fraction ?? -1;
-				const bFraction = b.fraction ?? -1;
-				if (aFraction !== bFraction) return bFraction - aFraction;
+				const aRank = accountRank.get(a.report) ?? a.index;
+				const bRank = accountRank.get(b.report) ?? b.index;
+				if (aRank !== bRank) return aRank - bRank;
 				return a.index - b.index;
 			});
 			const sortedLimits = entries.map(entry => entry.limit);

package/src/modes/controllers/event-controller.ts

@@ -920,6 +920,9 @@ export class EventController {
 					),
 				);
 			}
+			if (displayMessage === event.message) {
+				this.ctx.transcriptMessageComponents.set(event.message, this.ctx.streamingComponent);
+			}
 			this.ctx.streamingComponent = undefined;
 			this.ctx.streamingMessage = undefined;
 			// Pin a turn-ending provider error (e.g. Anthropic content-filter block)
@@ -1316,7 +1319,7 @@ export class EventController {
 			}
 		} else if (event.result) {
 			this.ctx.lastAssistantUsage = undefined;
-			this.ctx.rebuildChatFromMessages();
+			this.ctx.rebuildChatFromMessages({ reuseSettledComponents: true });
 			this.ctx.statusLine.invalidate();
 			// When history collapses behind the summary divider, the frame
 			// shrinks far below the committed row count; without clearing, the

package/src/modes/controllers/extension-ui-controller.ts

@@ -70,6 +70,12 @@ export class ExtensionUiController {
 	// the rest queue. See `#presentDialog`.
 	#dialogActive = false;
 	#dialogQueue: Array<() => void> = [];
+	/**
+	 * Built once in `initHooksAndCustomTools()`. Reused directly by `/tree`
+	 * `ask` re-answer (issue #5642) to drive a standalone `AskTool.execute()`
+	 * call with the same picker/dialog primitives a live tool call would get.
+	 */
+	#toolUIContext: ExtensionUIContext | undefined;
 	constructor(private ctx: InteractiveModeContext) {}
 
 	/**
@@ -121,6 +127,7 @@ export class ExtensionUiController {
 			setToolsExpanded: expanded => this.ctx.setToolsExpanded(expanded),
 		};
 		this.ctx.setToolUIContext(uiContext, true);
+		this.#toolUIContext = uiContext;
 
 		const extensionRunner = this.ctx.session.extensionRunner;
 		if (!extensionRunner) {
@@ -275,6 +282,17 @@ export class ExtensionUiController {
 		});
 	}
 
+	/**
+	 * The `ExtensionUIContext` built in `initHooksAndCustomTools()` — the same
+	 * picker/dialog primitives passed as `context.ui` for every live tool
+	 * call. `/tree` `ask` re-answer (issue #5642) reuses this to drive a
+	 * standalone `AskTool.execute()` call outside a normal agent turn.
+	 * `undefined` before hooks have initialized.
+	 */
+	getToolUIContext(): ExtensionUIContext | undefined {
+		return this.#toolUIContext;
+	}
+
 	setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void {
 		const placement = options?.placement ?? "aboveEditor";
 		this.#removeHookWidget(this.#hookWidgetsAbove, key);