@oh-my-pi/pi-coding-agent 16.3.5 → 16.3.7

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

@@ -4,9 +4,9 @@ import { formatNumber } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { AssistantThinkingRenderer } from "../../extensibility/extensions/types";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
-import { resolveAbortLabel, shouldRenderAbortReason } from "../../session/messages";
 import { getPreviewLines, resolveImageOptions, TRUNCATE_LENGTHS } from "../../tools/render-utils";
 import { canonicalizeMessage, formatThinkingForDisplay, hasDisplayableThinking } from "../../utils/thinking-display";
+import { resolveAssistantErrorPresentation } from "../utils/transcript-render-helpers";
 import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cache-invalidation-marker";
 
 /**
@@ -18,15 +18,6 @@ import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cach
  */
 const MAX_TRANSCRIPT_ERROR_LINES = 8;
 
-/**
- * A GFM table delimiter row (`| --- | :--: |`, with or without bounding pipes).
- * The header row alone does not render a table — this delimiter is what makes
- * Markdown lay one out, and a streaming table re-aligns its columns as rows
- * arrive. Requires at least one column pipe so a bare thematic break (`---`)
- * does not match.
- */
-const MARKDOWN_TABLE_DELIMITER = /^ {0,3}\|?(?:[ \t]*:?-+:?[ \t]*\|)+[ \t]*:?-*:?[ \t]*$/;
-
 /** Opening or closing fence of a code block: ≥3 backticks/tildes plus info string. */
 const CODE_FENCE_LINE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 
@@ -48,20 +39,15 @@ function resolveThinkingDisplay(block: ThinkingContentBlock, proseOnly: boolean)
 }
 
 /**
- * Whether `text` currently contains reflowing Markdown whose layout is not yet
- * permanent: an open ` ```mermaid ` fence (the diagram reshapes as source
- * arrives) or a GFM table (columns re-align as rows arrive). Used by
- * {@link AssistantMessageComponent.isTranscriptBlockCommitStable}.
- *
- * Fence-aware: a mermaid block is detected by its opener, and table delimiters
- * inside ordinary fenced code (shell pipes, ASCII separators, doc examples) are
- * ignored so a long streamed code block is never held out of native scrollback.
- * A delimiter counts only directly under a pipe-bearing header row, outside any
- * code fence.
+ * Whether `text` contains a ` ```mermaid ` fence (open or closed) outside
+ * ordinary code fences. Mermaid defers native-scrollback settling wholesale
+ * (see {@link AssistantMessageComponent.getTranscriptBlockSettledRows}): its
+ * ASCII rendering resolves asynchronously, so even a completed fence can
+ * re-layout rows that already looked settled. Fence-aware so a mermaid
+ * example inside a regular code block never triggers the deferral.
  */
-function detectLiveReflowingMarkdown(text: string): boolean {
+function containsMermaidFence(text: string): boolean {
 	let fence: string | null = null;
-	let prevLine = "";
 	for (const line of text.split("\n")) {
 		const fenceMatch = CODE_FENCE_LINE.exec(line);
 		if (fence !== null) {
@@ -79,11 +65,7 @@ function detectLiveReflowingMarkdown(text: string): boolean {
 		if (fenceMatch) {
 			if (/^mermaid\b/.test(fenceMatch[2]!.trim())) return true;
 			fence = fenceMatch[1]!;
-			prevLine = "";
-			continue;
 		}
-		if (prevLine.includes("|") && MARKDOWN_TABLE_DELIMITER.test(line)) return true;
-		prevLine = line;
 	}
 	return false;
 }
@@ -194,14 +176,16 @@ export class AssistantMessageComponent extends Container {
 	#kittyConversionsInFlight = new Set<string>();
 	#transcriptBlockFinalized: boolean;
 	/**
-	 * True while a non-finalized text item carries reflowing Markdown — a
-	 * ` ```mermaid ` fence or a GFM table — whose layout re-flows every frame as
-	 * source arrives (a diagram reshaping, a table re-aligning its columns), so
-	 * no prefix is byte-stable until the message finalizes. See
-	 * {@link isTranscriptBlockCommitStable}. Recomputed in {@link updateContent}
-	 * ahead of the fast-path return, so it tracks every stream tick.
+	 * True while any rendered item carries a ` ```mermaid ` fence. Mermaid's
+	 * ASCII form resolves asynchronously and can re-layout rows that already
+	 * looked settled, so settling defers until the message finalizes. See
+	 * {@link getTranscriptBlockSettledRows}. Recomputed in
+	 * {@link updateContent} ahead of the fast-path return, so it tracks every
+	 * stream tick. Streaming GFM tables need no gate: they live in markdown's
+	 * unfrozen tail while re-aligning and render deterministically once their
+	 * block completes.
 	 */
-	#hasLiveReflowingMarkdown = false;
+	#containsMermaidSource = false;
 	/**
 	 * When true, the turn-ending `Error: …` line for `stopReason === "error"` is
 	 * suppressed because the same error is currently shown in the pinned banner
@@ -222,6 +206,9 @@ export class AssistantMessageComponent extends Container {
 	/** Whether the last updateContent carried an in-flight streaming partial; such
 	 *  renders bypass the markdown module LRU (see Markdown.transientRenderCache). */
 	#lastUpdateTransient = false;
+	/** Width of the most recent render(); the settled-rows walk reads child
+	 *  renders at exactly this width (L1 cache hits). */
+	#lastRenderWidth = 0;
 	// Fast-path state: reuse Markdown children when message shape is stable during streaming.
 	#fastPathKey: string | undefined;
 	#fastPathItems:
@@ -299,6 +286,11 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	override render(width: number): readonly string[] {
+		this.#lastRenderWidth = width;
+		return super.render(width);
+	}
+
 	setHideThinkingBlock(hide: boolean): void {
 		this.hideThinkingBlock = hide;
 	}
@@ -415,18 +407,44 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	/**
-	 * Whether this still-live block's scrolled-off rows may be committed to
-	 * immutable native scrollback (the {@link TranscriptContainer} durable-
-	 * snapshot path). Reflowing Markdown — a streaming mermaid diagram or a GFM
-	 * table — re-lays-out its body as source arrives (the diagram reshapes, the
-	 * table re-aligns its columns), so committing an intermediate layout strands
-	 * a stale fragment in native scrollback that only a full repaint (Ctrl+L) can
-	 * clear. While such content is still streaming the block therefore stays
-	 * wholly in the repaintable live region and commits once, at its final
-	 * layout, when the turn finalizes.
+	 * Settled leading rows for mid-stream native-scrollback commits (see
+	 * `FinalizableBlock.getTranscriptBlockSettledRows`). Completed content
+	 * blocks render in final form (non-transient) and settle in full; the
+	 * actively streaming markdown contributes its rendered frozen-token
+	 * prefix. The walk stops at the first child that is not declared
+	 * byte-stable (the animated thinking pulse, extension components, images,
+	 * error rows), and a cache-invalidation marker above the content defers
+	 * settling entirely. Mermaid anywhere defers wholesale — its ASCII
+	 * rendering resolves asynchronously and can re-layout settled-looking
+	 * rows. Reads only L1-cached child renders at the width recorded by this
+	 * frame's render().
 	 */
-	isTranscriptBlockCommitStable(): boolean {
-		return this.#transcriptBlockFinalized || !this.#hasLiveReflowingMarkdown;
+	getTranscriptBlockSettledRows(): number {
+		if (this.#transcriptBlockFinalized || !this.#lastUpdateTransient) return 0;
+		if (this.#containsMermaidSource) return 0;
+		if (this.#markerSlot.children.length > 0) return 0;
+		const items = this.#fastPathItems;
+		const width = this.#lastRenderWidth;
+		if (!items || items.length === 0 || width <= 0) return 0;
+		const streaming = items[items.length - 1]!.md;
+		// Items are captured in child order: match completed mds positionally.
+		let itemIndex = 0;
+		let settled = 0;
+		for (const child of this.#contentContainer.children) {
+			if (child === streaming) return settled + streaming.getLastRenderSettledRows();
+			if (itemIndex < items.length - 1 && items[itemIndex]!.md === child) {
+				itemIndex++;
+				settled += child.render(width).length;
+				continue;
+			}
+			if (child instanceof Spacer) {
+				settled += child.render(width).length;
+				continue;
+			}
+			// Not declared byte-stable: the boundary stops here.
+			return settled;
+		}
+		return settled;
 	}
 
 	getTranscriptBlockVersion(): number {
@@ -445,6 +463,24 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	applyRetryRecovery(retryRecovery: AssistantMessage["retryRecovery"]): void {
+		if (!this.#lastMessage || !retryRecovery) return;
+		this.setErrorPinned(false);
+		this.updateContent({ ...this.#lastMessage, retryRecovery });
+	}
+
+	messagePersistenceKey(): string | undefined {
+		if (!this.#lastMessage) return undefined;
+		return [
+			"assistant",
+			this.#lastMessage.timestamp,
+			this.#lastMessage.provider,
+			this.#lastMessage.model,
+			this.#lastMessage.responseId ?? "",
+			this.#lastMessage.stopReason,
+		].join(":");
+	}
+
 	/**
 	 * Render a turn-ending provider error inline. Drops blank lines, clamps the
 	 * line count to {@link MAX_TRANSCRIPT_ERROR_LINES}, and width-truncates each
@@ -454,7 +490,7 @@ export class AssistantMessageComponent extends Container {
 	#appendErrorBlock(message: string): void {
 		const lines = getPreviewLines(message, MAX_TRANSCRIPT_ERROR_LINES, TRUNCATE_LENGTHS.LINE);
 		if (lines.length === 0) lines.push("Unknown error");
-		this.#contentContainer.addChild(new Spacer(1));
+		// The caller owns the separating Spacer; adding one here doubled the gap.
 		this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${lines[0]}`), 1, 0));
 		for (const line of lines.slice(1)) {
 			this.#contentContainer.addChild(new Text(theme.fg("error", `  ${line}`), 1, 0));
@@ -587,15 +623,11 @@ export class AssistantMessageComponent extends Container {
 			if (content.type === "toolCall") return false;
 		}
 		if (this.#toolImagesByCallId.size > 0) return false;
-		if (message.stopReason === "aborted" && shouldRenderAbortReason(message)) return false;
-		if (message.stopReason === "error" && !this.#errorPinned) return false;
-		if (
-			message.errorMessage &&
-			shouldRenderAbortReason(message) &&
-			message.stopReason !== "aborted" &&
-			message.stopReason !== "error"
-		)
+		const errorPresentation = resolveAssistantErrorPresentation(message);
+		if (errorPresentation.kind === "compact-recovered") return false;
+		if (errorPresentation.kind === "full" && !(message.stopReason === "error" && this.#errorPinned)) {
 			return false;
+		}
 		// Extension stability: if thinking renderers exist and any tracked thinking
 		// block's text changed, extensions may produce a different child count.
 		if (this.thinkingRenderers.length > 0 && this.#fastPathItems) {
@@ -626,8 +658,9 @@ export class AssistantMessageComponent extends Container {
 		}
 		const transient = opts?.transient === true;
 		// Shape is identical — setText only on Markdown children whose source changed.
-		for (const item of this.#fastPathItems) {
-			item.md.transientRenderCache = transient;
+		this.#applyItemTransience(transient);
+		for (let i = 0; i < this.#fastPathItems.length; i++) {
+			const item = this.#fastPathItems[i]!;
 			const content = message.content[item.contentIndex];
 			if (!content) {
 				this.#fastPathKey = undefined;
@@ -645,6 +678,14 @@ export class AssistantMessageComponent extends Container {
 				return false;
 			}
 			if (newText !== item.lastText) {
+				// Only the last (actively streaming) block may mutate in place: a
+				// delta into an earlier block would invalidate rows the settled
+				// walk already declared final, so tear down and rebuild instead.
+				if (i < this.#fastPathItems.length - 1) {
+					this.#fastPathKey = undefined;
+					this.#fastPathItems = undefined;
+					return false;
+				}
 				item.md.setText(newText);
 				item.lastText = newText;
 			}
@@ -698,14 +739,19 @@ export class AssistantMessageComponent extends Container {
 			this.#thinkingRateLive = false;
 		}
 
-		// Streaming reflowing Markdown (a mermaid diagram reshaping, a GFM table
-		// re-aligning columns) re-lays-out its body each frame; see
-		// isTranscriptBlockCommitStable. Detect it from raw text — a Markdown
-		// parser only resolves these once the closing fence / delimiter row
-		// arrives, but the stale native-scrollback commits happen mid-stream.
-		this.#hasLiveReflowingMarkdown = message.content.some(
-			content => content.type === "text" && detectLiveReflowingMarkdown(content.text),
-		);
+		// Mermaid ASCII rendering resolves asynchronously, so a fence anywhere
+		// in the rendered source (text or visible thinking) defers settling; see
+		// getTranscriptBlockSettledRows. Detected from raw source — a Markdown
+		// parser only resolves the fence once it closes, but the stale commits
+		// would happen mid-stream.
+		this.#containsMermaidSource = message.content.some(content => {
+			if (content.type === "text") return containsMermaidFence(content.text);
+			if (content.type === "thinking" && !this.hideThinkingBlock) {
+				const display = resolveThinkingDisplay(content, this.proseOnlyThinking);
+				return display.visible && containsMermaidFence(display.text);
+			}
+			return false;
+		});
 
 		// Fast path: reuse Markdown children when shape is stable during streaming
 		if (this.#tryFastPathUpdate(message, opts)) return;
@@ -781,37 +827,43 @@ export class AssistantMessageComponent extends Container {
 		}
 
 		this.#renderToolImages();
-		// Check if aborted - show after partial content
-		// But only if there are no tool calls (tool execution components will show the error)
+		const errorPresentation = resolveAssistantErrorPresentation(message);
 		const hasToolCalls = message.content.some(c => c.type === "toolCall");
-		if (!hasToolCalls) {
-			if (message.stopReason === "aborted" && shouldRenderAbortReason(message)) {
-				const abortMessage = resolveAbortLabel(message);
-				if (hasVisibleContent) {
-					this.#contentContainer.addChild(new Spacer(1));
+		if (errorPresentation.kind === "compact-recovered") {
+			this.#contentContainer.addChild(new Spacer(1));
+			this.#contentContainer.addChild(new Text(theme.fg("dim", errorPresentation.text), 1, 0));
+		} else if (!hasToolCalls && errorPresentation.kind === "full") {
+			if (!(message.stopReason === "error" && this.#errorPinned)) {
+				this.#contentContainer.addChild(new Spacer(1));
+				if (message.stopReason === "aborted") {
+					this.#contentContainer.addChild(new Text(theme.fg("error", errorPresentation.text), 1, 0));
 				} else {
-					this.#contentContainer.addChild(new Spacer(1));
+					this.#appendErrorBlock(errorPresentation.text);
 				}
-				this.#contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
-			} else if (message.stopReason === "error" && !this.#errorPinned) {
-				this.#appendErrorBlock(message.errorMessage || "Unknown error");
 			}
 		}
-		if (
-			message.errorMessage &&
-			shouldRenderAbortReason(message) &&
-			message.stopReason !== "aborted" &&
-			message.stopReason !== "error"
-		) {
-			this.#appendErrorBlock(message.errorMessage);
-		}
 		// Store fast-path state for next call
 		if (shouldCapture) {
 			this.#fastPathItems = captureItems;
 			this.#fastPathKey = this.#computeShapeKey(message);
+			this.#applyItemTransience(this.#lastUpdateTransient);
 		} else {
 			this.#fastPathKey = undefined;
 			this.#fastPathItems = undefined;
 		}
 	}
+
+	/**
+	 * Only the actively streaming (last) markdown renders in transient mode;
+	 * completed blocks render final — syntax-highlighted, module-LRU-cached,
+	 * byte-stable — so their rows can settle into native scrollback mid-turn
+	 * and are byte-identical to the finalize render.
+	 */
+	#applyItemTransience(transient: boolean): void {
+		const items = this.#fastPathItems;
+		if (!items) return;
+		for (let i = 0; i < items.length; i++) {
+			items[i]!.md.transientRenderCache = transient && i === items.length - 1;
+		}
+	}
 }

package/src/modes/components/bash-execution.ts

@@ -64,6 +64,15 @@ export class BashExecutionComponent extends Container {
 		this.#contentContainer.addChild(this.#loader);
 	}
 
+	/**
+	 * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+	 * streaming preview rewrites its tail window every chunk, so the block must
+	 * stay out of native scrollback until the command completes.
+	 */
+	isTranscriptBlockFinalized(): boolean {
+		return this.#status !== "running";
+	}
+
 	/**
 	 * Set whether the output is expanded (shows full output) or collapsed (preview only).
 	 */

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

@@ -29,11 +29,12 @@ import type { SessionMessageEntry } from "../../session/session-entries";
 import { theme } from "../theme/theme";
 import {
 	assistantHasVisibleContent,
+	assistantUsageIsBilled,
 	buildAsyncResultBlock,
 	buildFileMentionBlock,
 	buildIrcMessageCard,
 	normalizeToolArgs,
-	resolveAssistantErrorMessage,
+	resolveAssistantErrorPresentation,
 } from "../utils/transcript-render-helpers";
 import { createAdvisorMessageCard } from "./advisor-message";
 import { AssistantMessageComponent } from "./assistant-message";
@@ -153,7 +154,7 @@ export class ChatTranscriptBuilder {
 		const previous = this.#waitingPoll;
 		if (!previous) return;
 		this.#waitingPoll = null;
-		if (nextToolName === "job" && previous.isDisplaceableBlock()) {
+		if (nextToolName === "job" && previous.isDisplaceableBlock() && this.container.isBlockUncommitted(previous)) {
 			this.container.removeChild(previous);
 		}
 		previous.seal();
@@ -168,7 +169,9 @@ export class ChatTranscriptBuilder {
 		}
 		if (previous.canBeDisplacedBy(nextToolName)) {
 			this.#todoSnapshot = null;
-			this.container.removeChild(previous);
+			if (this.container.isBlockUncommitted(previous)) {
+				this.container.removeChild(previous);
+			}
 			previous.seal();
 			return;
 		}
@@ -268,13 +271,15 @@ export class ChatTranscriptBuilder {
 	}
 
 	#appendAssistantMessage(message: Extract<AgentMessage, { role: "assistant" }>): void {
+		const hideThinkingBlock = this.deps.hideThinkingBlock?.() ?? false;
+		const proseOnlyThinking = this.deps.proseOnlyThinking ? this.deps.proseOnlyThinking() : true;
 		const assistantComponent = new AssistantMessageComponent(
 			message,
-			this.deps.hideThinkingBlock?.() ?? false,
+			hideThinkingBlock,
 			() => this.deps.requestRender(),
 			this.deps.getMessageRenderer ? undefined : [], // placeholder for thinkingRenderers
 			undefined, // placeholder for imageBudget
-			this.deps.proseOnlyThinking ? this.deps.proseOnlyThinking() : true,
+			proseOnlyThinking,
 		);
 		this.container.addChild(assistantComponent);
 
@@ -293,7 +298,9 @@ export class ChatTranscriptBuilder {
 			this.#readGroup = null;
 		}
 
-		const { hasErrorStop, errorMessage } = resolveAssistantErrorMessage(message);
+		const errorPresentation = resolveAssistantErrorPresentation(message);
+		const hasErrorStop = errorPresentation.kind === "full";
+		const errorMessage = hasErrorStop ? errorPresentation.text : null;
 
 		for (const content of message.content) {
 			if (content.type !== "toolCall") continue;
@@ -350,7 +357,8 @@ export class ChatTranscriptBuilder {
 			}
 		}
 
-		this.#pendingUsage = settings.get("display.showTokenUsage") ? message.usage : undefined;
+		this.#pendingUsage =
+			settings.get("display.showTokenUsage") && assistantUsageIsBilled(message.usage) ? message.usage : undefined;
 		this.#pendingUsageDuration = message.duration;
 		this.#pendingUsageTtft = message.ttft;
 	}

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

@@ -53,6 +53,8 @@ function gutterCells(hasNext: boolean): string {
 export class CopySelectorComponent implements Component {
 	#roots: CopyTarget[];
 	#cursorId: string;
+	#lastSourceTarget?: CopyTarget;
+	#lastSource?: string;
 	#treeRows = MIN_TREE_ROWS;
 	// Reused across renders to wrap preview content to the pane width.
 	#previewText = new Text("", 0, 0);
@@ -65,7 +67,10 @@ export class CopySelectorComponent implements Component {
 		this.#cursorId = roots[0]?.id ?? "";
 	}
 
-	invalidate(): void {}
+	invalidate(): void {
+		this.#lastSourceTarget = undefined;
+		this.#lastSource = undefined;
+	}
 
 	#flatten(): FlatNode[] {
 		const out: FlatNode[] = [];
@@ -153,9 +158,16 @@ export class CopySelectorComponent implements Component {
 		// Code/command previews are syntax-highlighted; everything else is shown
 		// as plain text. Both are wrapped (not hard-truncated) to the pane width.
 		const isCode = target.language !== undefined;
-		const source = isCode
-			? highlightCode(replaceTabs(target.preview), target.language).join("\n")
-			: replaceTabs(target.preview);
+		let source: string;
+		if (target === this.#lastSourceTarget && this.#lastSource !== undefined) {
+			source = this.#lastSource;
+		} else {
+			source = isCode
+				? highlightCode(replaceTabs(target.preview), target.language).join("\n")
+				: replaceTabs(target.preview);
+			this.#lastSourceTarget = target;
+			this.#lastSource = source;
+		}
 		this.#previewText.setText(source);
 		const wrapped = this.#previewText.render(Math.max(1, width - 4));
 

package/src/modes/components/eval-execution.ts

@@ -61,6 +61,15 @@ export class EvalExecutionComponent extends Container {
 		this.#contentContainer.addChild(this.#loader);
 	}
 
+	/**
+	 * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+	 * streaming preview rewrites its tail window every chunk, so the block must
+	 * stay out of native scrollback until the cell completes.
+	 */
+	isTranscriptBlockFinalized(): boolean {
+		return this.#status !== "running";
+	}
+
 	setExpanded(expanded: boolean): void {
 		this.#expanded = expanded;
 		this.#updateDisplay();

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

@@ -704,29 +704,22 @@ export class ModelSelectorComponent extends Container {
 	#filterModels(query: string): void {
 		const activeProviderId = this.#getActiveProviderId();
 
-		let baseModels = this.#allModels;
-		if (activeProviderId) {
-			baseModels = this.#allModels.filter(m => m.provider === activeProviderId);
-		}
+		const baseModels = activeProviderId
+			? this.#allModels.filter(m => m.provider === activeProviderId)
+			: this.#allModels;
 
 		if (query.trim()) {
-			// If user is searching from a provider tab, auto-switch to ALL to show global provider results.
-			if (activeProviderId) {
-				this.#activeTabIndex = 0;
-				if (this.#tabBar && this.#tabBar.getActiveIndex() !== 0) {
-					this.#tabBar.setActiveIndex(0);
-					return;
-				}
-				this.#updateTabBar();
-				baseModels = this.#allModels;
-			}
-
 			// Match against the displayed "provider/id" string so the user can
 			// type what they see: bare names (`mimo`, `kimi`), provider prefixes
 			// (`openrouter`), or scoped queries (`openrouter/mimo`) all flow
 			// through the same fuzzy matcher. The score is biased by provider-
 			// prefix length, so re-sort by MRU/version afterwards; skip role
 			// rank so a weakly matching default doesn't trump a stronger match.
+			//
+			// Search stays scoped to the active provider tab. Auto-escaping to
+			// ALL on non-empty queries used to let the user pick a same-named
+			// model from a different provider and silently persist it under
+			// their default role — see issue #4522.
 			const fuzzyMatches = fuzzyFilter(baseModels, query, ({ id, provider }) => `${provider}/${id}`);
 			this.#sortModels(fuzzyMatches, { skipRoleRank: true });
 			this.#filteredModels = fuzzyMatches;
@@ -891,8 +884,15 @@ export class ModelSelectorComponent extends Container {
 				this.#listContainer.addChild(new Text(theme.fg("error", line), 0, 0));
 			}
 		} else if (visibleItems.length === 0) {
-			const statusMessage = this.#getProviderEmptyStateMessage();
-			this.#listContainer.addChild(new Text(theme.fg("muted", statusMessage ?? "  No matching models"), 0, 0));
+			const providerStatus = this.#getProviderEmptyStateMessage();
+			const activeProviderId = this.#getActiveProviderId();
+			const searching = this.#searchInput.getValue().trim().length > 0;
+			const message =
+				providerStatus ??
+				(searching && activeProviderId
+					? `  No matching models in ${formatProviderTabLabel(activeProviderId)}. Switch to ALL to search every provider.`
+					: "  No matching models");
+			this.#listContainer.addChild(new Text(theme.fg("muted", message), 0, 0));
 		} else {
 			const selected = visibleItems[this.#selectedIndex];
 			if (!selected) {

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

@@ -414,15 +414,23 @@ class SessionList implements Component {
 	}
 
 	handleInput(keyData: string): void {
-		// Delete key - request delete confirmation from parent
-		if (matchesKey(keyData, "delete")) {
+		// Delete key — or Backspace on an empty search query — request delete
+		// confirmation from the parent. macOS laptops have no dedicated Forward
+		// Delete key: Fn+Backspace is the only way to send \e[3~, and many macOS
+		// terminals (Terminal.app, some iTerm2 profiles) deliver \x7f for that
+		// combo instead. Regular Backspace on an empty query means "delete
+		// session"; with a typed query it stays bound to the search Input so users
+		// can still edit their filter text.
+		if (
+			matchesKey(keyData, "delete") ||
+			(matchesKey(keyData, "backspace") && this.#searchInput.getValue().length === 0)
+		) {
 			const selected = this.#filteredSessions[this.#selectedIndex];
 			if (selected && this.onDeleteRequest) {
 				this.onDeleteRequest(selected);
 			}
 			return;
 		}
-
 		// Up arrow
 		if (matchesSelectUp(keyData)) {
 			this.#selectedIndex = Math.max(0, this.#selectedIndex - 1);
@@ -702,7 +710,7 @@ export class SessionSelectorComponent extends Container {
 	/** Blank · keybinding hint · bottom border. Rendered by {@link render}. */
 	#footerLines(width: number): string[] {
 		const scopeHint = this.#scope === "all" ? "current folder" : "all projects";
-		const hint = theme.fg("muted", `  [Del delete · Enter select · Tab ${scopeHint} · Esc cancel]`);
+		const hint = theme.fg("muted", `  [Del/⌫ delete · Enter select · Tab ${scopeHint} · Esc cancel]`);
 		return ["", hint, "", ...this.#bottomBorder.render(width)];
 	}
 

package/src/modes/components/status-line/component.ts

@@ -998,6 +998,10 @@ export class StatusLineComponent implements Component {
 			output: 0,
 			cacheRead: 0,
 			cacheWrite: 0,
+			totalTokens: 0,
+			orchestrationInput: 0,
+			orchestrationOutput: 0,
+			orchestrationCacheRead: 0,
 			premiumRequests: 0,
 			cost: 0,
 		};

package/src/modes/components/status-line/segments.ts

@@ -362,10 +362,11 @@ const tokenTotalSegment: StatusLineSegment = {
 	id: "token_total",
 	render(ctx) {
 		// Excludes cacheRead: that field re-reads the full cached context every
-		// turn, making the cumulative sum N×context_size. The dedicated cache_read
-		// segment handles cache monitoring; the cost segment handles billing.
-		const { input, output, cacheWrite } = ctx.usageStats;
-		const total = input + output + cacheWrite;
+		// turn, making the cumulative sum N×context_size. Orchestration cache read
+		// follows the same rule; orchestration input/output remain in the total so
+		// provider-side service work is preserved without labeling it prompt input.
+		const { input, output, cacheWrite, orchestrationInput, orchestrationOutput } = ctx.usageStats;
+		const total = input + output + cacheWrite + orchestrationInput + orchestrationOutput;
 		if (!total) return { content: "", visible: false };
 
 		const content = withIcon(theme.icon.tokens, formatNumber(total));
@@ -379,7 +380,7 @@ const tokenRateSegment: StatusLineSegment = {
 		const { tokensPerSecond } = ctx.usageStats;
 		if (!tokensPerSecond) return { content: "", visible: false };
 
-		const content = withIcon(theme.icon.throughput, `${tokensPerSecond.toFixed(1)}/s`);
+		const content = withIcon(theme.icon.throughput, `${tokensPerSecond.toFixed(1)} tok/s`);
 		return { content: theme.fg("statusLineOutput", content), visible: true };
 	},
 };

package/src/modes/components/status-line/types.ts

@@ -74,6 +74,10 @@ export interface SegmentContext {
 		output: number;
 		cacheRead: number;
 		cacheWrite: number;
+		totalTokens: number;
+		orchestrationInput: number;
+		orchestrationOutput: number;
+		orchestrationCacheRead: number;
 		premiumRequests: number;
 		cost: number;
 		tokensPerSecond: number | null;