@oh-my-pi/pi-coding-agent 16.1.6 → 16.1.8

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

@@ -1,10 +1,12 @@
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
 import { Container, Image, type ImageBudget, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@oh-my-pi/pi-tui";
+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 } from "../../utils/thinking-display";
+import { canonicalizeMessage, formatThinkingForDisplay, hasDisplayableThinking } from "../../utils/thinking-display";
 import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cache-invalidation-marker";
 
 /**
@@ -28,6 +30,18 @@ const MARKDOWN_TABLE_DELIMITER = /^ {0,3}\|?(?:[ \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,})(.*)$/;
 
+type ThinkingContentBlock = Extract<AssistantMessage["content"][number], { type: "thinking" }>;
+type DisplayThinkingContentBlock = ThinkingContentBlock & { rawThinking?: string };
+
+function resolveThinkingDisplay(block: ThinkingContentBlock, proseOnly: boolean): { text: string; visible: boolean } {
+	const rawThinking = (block as DisplayThinkingContentBlock).rawThinking ?? block.thinking;
+	const formatted = formatThinkingForDisplay(block.thinking, proseOnly);
+	return {
+		text: formatted.trim(),
+		visible: hasDisplayableThinking(rawThinking, formatted),
+	};
+}
+
 /**
  * Whether `text` currently contains reflowing Markdown whose layout is not yet
  * permanent: an open ` ```mermaid ` fence (the diagram reshapes as source
@@ -72,11 +86,96 @@ function detectLiveReflowingMarkdown(text: string): boolean {
 /**
  * Frames for the streaming "thinking" pulse rendered in place of a hidden
  * thinking block while the model is still producing it. A single fixed-width
- * glyph that rises ▁▃▄▃ so the indicator animates without shifting the line.
- * Advanced every {@link THINKING_DOTS_FRAME_MS}.
+ * starburst cycles through facets (✻ ✼ ❉ ❊ ✺ ✹ ✸ ✶) so the indicator animates
+ * in place without shifting the line or the trailing speed badge. The dwell per
+ * frame eases between {@link THINKING_DOTS_FRAME_MS_MIN} and
+ * {@link THINKING_DOTS_FRAME_MS_MAX} across each revolution (see
+ * {@link AssistantMessageComponent.thinkingDotsFrameDelay}).
  */
-const THINKING_DOTS_FRAMES = ["▁", "▃", "▄", "▃"] as const;
-const THINKING_DOTS_FRAME_MS = 320;
+const THINKING_DOTS_FRAMES = ["✻", "✼", "❉", "❊", "✺", "✹", "✸", "✶"] as const;
+/**
+ * Pulse cadence bounds (ms). Each frame's dwell eases between these on a
+ * raised-cosine "breath" — quickest at the cycle start, slowest at its midpoint —
+ * so the starburst accelerates and slows instead of ticking at one fixed rate.
+ * Mean ≈ 150ms, snappier than the previous flat 320ms.
+ */
+const THINKING_DOTS_FRAME_MS_MIN = 70;
+const THINKING_DOTS_FRAME_MS_MAX = 230;
+
+/** Rolling window (ms) over which streaming-rate observations are averaged. */
+const SPEED_WINDOW_MS = 3000;
+/** Color/clamp ceiling: a rate at or above this maps to the full accent color. */
+const SPEED_MAX = 200;
+
+/**
+ * Session-wide streaming-speed gauge. Only one thinking indicator animates at a
+ * time, so a single shared instance accumulates instantaneous tok/s observations
+ * and reports their windowed average — smoothing the jumpy per-delta numbers.
+ * Each thinking block resets the gauge on its first live sample (see
+ * {@link AssistantMessageComponent.updateContent}) so the average reflects only
+ * the active block, never a previous turn's trailing rate. Components feed it
+ * deltas (not cumulative totals), so a fresh turn restarting its token count at
+ * zero never produces a spike.
+ */
+class SpeedTracker {
+	#observations: Array<{ time: number; rate: number }> = [];
+
+	#prune(now: number): void {
+		const threshold = now - SPEED_WINDOW_MS;
+		while (this.#observations.length > 0 && this.#observations[0]!.time < threshold) {
+			this.#observations.shift();
+		}
+	}
+
+	/** Record one instantaneous tok/s reading, clamped to {@link SPEED_MAX} so a
+	 *  single oversized delta (e.g. a buffered reflow tick) can't poison the
+	 *  windowed average. Non-finite/negative rates ignored. */
+	observe(rate: number, now = performance.now()): void {
+		if (!Number.isFinite(rate) || rate < 0) return;
+		this.#observations.push({ time: now, rate: Math.min(rate, SPEED_MAX) });
+		this.#prune(now);
+	}
+
+	/** Windowed-average tok/s; 0 once observations age out of the window. */
+	getSpeed(now = performance.now()): number {
+		this.#prune(now);
+		if (this.#observations.length === 0) return 0;
+		let sum = 0;
+		for (const o of this.#observations) sum += o.rate;
+		return sum / this.#observations.length;
+	}
+
+	reset(): void {
+		this.#observations = [];
+	}
+}
+
+/** One gauge for the whole session — see {@link SpeedTracker}. */
+const sharedSpeedTracker = new SpeedTracker();
+
+/** Test-only: clear the shared gauge so observations don't leak across cases. */
+export function resetThinkingSpeedTracker(): void {
+	sharedSpeedTracker.reset();
+}
+
+/**
+ * Linear-interpolate two `#rrggbb` colors in sRGB space. `t` clamps to [0,1]:
+ * `t = 0` → `from`, `t = 1` → `to`. Drives the streaming speed badge, fading
+ * from a dim gray toward the theme accent as tok/s rises.
+ */
+function lerpHex(from: string, to: string, t: number): string {
+	const k = t < 0 ? 0 : t > 1 ? 1 : t;
+	const fr = Number.parseInt(from.slice(1, 3), 16);
+	const fg = Number.parseInt(from.slice(3, 5), 16);
+	const fb = Number.parseInt(from.slice(5, 7), 16);
+	const tr = Number.parseInt(to.slice(1, 3), 16);
+	const tg = Number.parseInt(to.slice(3, 5), 16);
+	const tb = Number.parseInt(to.slice(5, 7), 16);
+	const r = Math.round(fr + (tr - fr) * k);
+	const g = Math.round(fg + (tg - fg) * k);
+	const b = Math.round(fb + (tb - fb) * k);
+	return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+}
 
 /**
  * Component that renders a complete assistant message
@@ -128,6 +227,20 @@ export class AssistantMessageComponent extends Container {
 	#thinkingDots: Text | undefined;
 	#thinkingDotsTimer: NodeJS.Timeout | undefined;
 	#thinkingDotsFrame = 0;
+	/** Previous cumulative provider token count + timestamp, for deriving this
+	 *  block's instantaneous streaming rate fed into {@link sharedSpeedTracker}.
+	 *  Undefined until the first thinking update of this block. */
+	#lastTokenCount: number | undefined;
+	#lastTokenTime = 0;
+	/** Provider-reported tokens in the live thinking block — reasoning tokens when
+	 *  the provider streams them, else total output — shown dimmed beside the
+	 *  speed badge. 0 when no thinking is streaming. */
+	#thinkingTokens = 0;
+	/** Whether this block has observed a positive provider-token delta — i.e. it is
+	 *  genuinely streaming tokens right now. Gates the numeric speed badge so the
+	 *  session-wide {@link sharedSpeedTracker} can't surface a previous turn's rate
+	 *  on a fresh block that has no live token throughput of its own. */
+	#thinkingRateLive = false;
 
 	constructor(
 		message?: AssistantMessage,
@@ -135,6 +248,7 @@ export class AssistantMessageComponent extends Container {
 		private readonly onImageUpdate?: () => void,
 		private readonly thinkingRenderers: readonly AssistantThinkingRenderer[] = [],
 		private readonly imageBudget?: ImageBudget,
+		private proseOnlyThinking = true,
 	) {
 		super();
 		this.#transcriptBlockFinalized = message !== undefined;
@@ -184,6 +298,10 @@ export class AssistantMessageComponent extends Container {
 		this.hideThinkingBlock = hide;
 	}
 
+	setProseOnlyThinking(proseOnly: boolean): void {
+		this.proseOnlyThinking = proseOnly;
+	}
+
 	override dispose(): void {
 		this.#stopThinkingAnimation();
 		super.dispose();
@@ -210,16 +328,51 @@ export class AssistantMessageComponent extends Container {
 
 	#thinkingDotsLabel(): string {
 		const glyph = THINKING_DOTS_FRAMES[this.#thinkingDotsFrame % THINKING_DOTS_FRAMES.length] ?? "…";
-		return theme.fg("thinkingText", glyph);
+		const coloredGlyph = theme.fg("thinkingText", glyph);
+		const rate = Math.min(SPEED_MAX, sharedSpeedTracker.getSpeed());
+		// The numeric badge ("<total> · <rate> toks/s") only renders while this block
+		// is genuinely streaming provider tokens. A block that has observed no token
+		// delta (e.g. a provider that reports usage only at turn end) or whose rate
+		// has decayed to zero (a streaming lull) drops it entirely — the bare pulse
+		// keeps signalling that the model is thinking. The liveness flag also stops
+		// the session-wide gauge from leaking a previous turn's rate onto a fresh
+		// token-less block.
+		if (!this.#thinkingRateLive || rate < 0.05) return coloredGlyph;
+		// Total provider tokens, dimmed, sit next to the pulse.
+		const totalSpan = this.#thinkingTokens > 0 ? theme.fg("dim", ` ${formatNumber(this.#thinkingTokens)}`) : "";
+		// Speed badge color: dim gray at rest, brightening toward the theme accent as
+		// streaming speed climbs (gray → bright accent). Ease (sqrt) so typical
+		// mid-stream rates already read as clearly accent-tinted instead of staying
+		// gray until the rarely-hit SPEED_MAX ceiling.
+		const ratio = Math.sqrt(rate / SPEED_MAX);
+		const hex = lerpHex(theme.getColorHex("dim"), theme.getAccentColorHex(), ratio);
+		const rateText = ` · ${rate.toFixed(1)} toks/s`;
+		const rateSpan = theme.getColorMode() === "truecolor" ? chalk.hex(hex)(rateText) : theme.fg("muted", rateText);
+		return coloredGlyph + totalSpan + rateSpan;
 	}
 
 	#startThinkingAnimation(): void {
 		if (this.#thinkingDotsTimer) return;
-		this.#thinkingDotsTimer = setInterval(() => this.#advanceThinkingDots(), THINKING_DOTS_FRAME_MS);
+		this.#scheduleThinkingFrame();
+	}
+
+	/** Eased dwell (ms) for the current pulse frame: a raised cosine over the
+	 *  8-frame cycle, continuous across the wrap, so the rotation breathes rather
+	 *  than advancing at a fixed interval. */
+	#thinkingDotsFrameDelay(): number {
+		const phase = (1 - Math.cos((2 * Math.PI * this.#thinkingDotsFrame) / THINKING_DOTS_FRAMES.length)) / 2;
+		return THINKING_DOTS_FRAME_MS_MIN + (THINKING_DOTS_FRAME_MS_MAX - THINKING_DOTS_FRAME_MS_MIN) * phase;
+	}
+
+	/** Self-rescheduling timeout (not a fixed interval) so each frame can pick its
+	 *  own eased dwell. */
+	#scheduleThinkingFrame(): void {
+		this.#thinkingDotsTimer = setTimeout(() => this.#advanceThinkingDots(), this.#thinkingDotsFrameDelay());
 		this.#thinkingDotsTimer.unref?.();
 	}
 
 	#advanceThinkingDots(): void {
+		this.#thinkingDotsTimer = undefined;
 		if (!this.#thinkingDots) {
 			this.#stopThinkingAnimation();
 			return;
@@ -228,11 +381,12 @@ export class AssistantMessageComponent extends Container {
 		if (this.#thinkingDots.setText(this.#thinkingDotsLabel())) {
 			this.onImageUpdate?.();
 		}
+		this.#scheduleThinkingFrame();
 	}
 
 	#stopThinkingAnimation(): void {
 		if (this.#thinkingDotsTimer) {
-			clearInterval(this.#thinkingDotsTimer);
+			clearTimeout(this.#thinkingDotsTimer);
 			this.#thinkingDotsTimer = undefined;
 		}
 		this.#thinkingDotsFrame = 0;
@@ -403,13 +557,13 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	#computeShapeKey(message: AssistantMessage): string {
-		const parts: string[] = [`htb:${this.hideThinkingBlock ? 1 : 0}`];
+		const parts: string[] = [`htb:${this.hideThinkingBlock ? 1 : 0}|pot:${this.proseOnlyThinking ? 1 : 0}`];
 		for (const content of message.content) {
 			if (content.type === "text") {
 				parts.push(canonicalizeMessage(content.text) ? "T1" : "T0");
 			} else if (content.type === "thinking") {
-				const canon = canonicalizeMessage(content.thinking);
-				if (!canon) parts.push("K0");
+				const display = resolveThinkingDisplay(content, this.proseOnlyThinking);
+				if (!display.visible) parts.push("K0");
 				else if (this.hideThinkingBlock) parts.push("KH");
 				else parts.push("KV");
 			} else {
@@ -442,8 +596,10 @@ export class AssistantMessageComponent extends Container {
 			for (const item of this.#fastPathItems) {
 				if (item.blockType === "thinking") {
 					const content = message.content[item.contentIndex];
-					if (content?.type === "thinking" && canonicalizeMessage(content.thinking) !== item.lastText)
-						return false;
+					if (content?.type === "thinking") {
+						const display = resolveThinkingDisplay(content, this.proseOnlyThinking);
+						if (display.text !== item.lastText) return false;
+					}
 				}
 			}
 		}
@@ -476,7 +632,7 @@ export class AssistantMessageComponent extends Container {
 			if (item.blockType === "text" && content.type === "text") {
 				newText = content.text.trim();
 			} else if (item.blockType === "thinking" && content.type === "thinking") {
-				newText = canonicalizeMessage(content.thinking);
+				newText = resolveThinkingDisplay(content, this.proseOnlyThinking).text;
 			} else {
 				this.#fastPathKey = undefined;
 				this.#fastPathItems = undefined;
@@ -487,6 +643,11 @@ export class AssistantMessageComponent extends Container {
 				item.lastText = newText;
 			}
 		}
+		if (this.#thinkingDots) {
+			if (this.#thinkingDots.setText(this.#thinkingDotsLabel())) {
+				this.onImageUpdate?.();
+			}
+		}
 		return true;
 	}
 
@@ -495,6 +656,42 @@ export class AssistantMessageComponent extends Container {
 		this.#lastMessage = message;
 		this.#lastUpdateTransient = opts?.transient === true;
 
+		// Streaming-speed gauge: only a live, in-flight render of the single
+		// animating hidden-thinking block feeds the shared session tracker. The
+		// token count is the provider's own cumulative output — reasoning tokens when
+		// reported (Gemini's thoughtsTokenCount, OpenAI's reasoning_tokens), else
+		// total output tokens — never a character estimate, which undercounts when
+		// the provider streams a summarized reasoning trace. An instantaneous tok/s
+		// is derived from this block's delta and handed to the windowed averager.
+		// Only transient renders count: the final non-transient render at
+		// message_end carries the turn's end-of-stream usage, whose jump would spike
+		// the gauge and pollute the next block. Providers that report usage only at
+		// turn end leave the live count flat, so the rate stays 0 and the badge
+		// self-suppresses (see #thinkingDotsLabel).
+		const isThinkingNow = this.#lastUpdateTransient && this.#shouldAnimateThinking(message);
+		if (isThinkingNow) {
+			const currentTokens = message.usage.reasoningTokens ?? message.usage.output;
+			this.#thinkingTokens = currentTokens;
+			const now = performance.now();
+			if (this.#lastTokenCount !== undefined) {
+				const tokenDelta = currentTokens - this.#lastTokenCount;
+				const elapsedMs = now - this.#lastTokenTime;
+				if (tokenDelta > 0 && elapsedMs > 0) {
+					// First live sample of this block: drop the session gauge's prior-turn
+					// observations so the windowed average reflects only this block.
+					if (!this.#thinkingRateLive) sharedSpeedTracker.reset();
+					sharedSpeedTracker.observe((tokenDelta / elapsedMs) * 1000, now);
+					this.#thinkingRateLive = true;
+				}
+			}
+			this.#lastTokenCount = currentTokens;
+			this.#lastTokenTime = now;
+		} else {
+			this.#lastTokenCount = undefined;
+			this.#thinkingTokens = 0;
+			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
@@ -520,7 +717,9 @@ export class AssistantMessageComponent extends Container {
 		const hasVisibleContent = message.content.some(
 			c =>
 				(c.type === "text" && canonicalizeMessage(c.text)) ||
-				(!this.hideThinkingBlock && c.type === "thinking" && canonicalizeMessage(c.thinking)),
+				(!this.hideThinkingBlock &&
+					c.type === "thinking" &&
+					resolveThinkingDisplay(c, this.proseOnlyThinking).visible),
 		);
 
 		// Render content in order
@@ -534,8 +733,8 @@ export class AssistantMessageComponent extends Container {
 				md.transientRenderCache = this.#lastUpdateTransient;
 				this.#contentContainer.addChild(md);
 				captureItems?.push({ md, contentIndex: i, blockType: "text", lastText: trimmed });
-			} else if (content.type === "thinking" && canonicalizeMessage(content.thinking)) {
-				const thinkingText = canonicalizeMessage(content.thinking);
+			} else if (content.type === "thinking" && resolveThinkingDisplay(content, this.proseOnlyThinking).visible) {
+				const thinkingText = resolveThinkingDisplay(content, this.proseOnlyThinking).text;
 				if (this.hideThinkingBlock) {
 					thinkingIndex += 1;
 					continue;
@@ -547,7 +746,7 @@ export class AssistantMessageComponent extends Container {
 					.some(
 						c =>
 							(c.type === "text" && canonicalizeMessage(c.text)) ||
-							(c.type === "thinking" && canonicalizeMessage(c.thinking)),
+							(c.type === "thinking" && resolveThinkingDisplay(c, this.proseOnlyThinking).visible),
 					);
 
 				// Thinking traces in thinkingText color, italic

package/src/modes/components/btw-panel.ts

@@ -16,6 +16,7 @@ export class BtwPanelComponent extends Container {
 	#state: BtwPanelState = "running";
 	#answer = "";
 	#errorMessage: string | undefined;
+	#visibleAnswer = "";
 	#closed = false;
 
 	constructor(options: BtwPanelComponentOptions) {
@@ -28,12 +29,14 @@ export class BtwPanelComponent extends Container {
 	appendText(delta: string): void {
 		if (!delta || this.#closed) return;
 		this.#answer += delta;
+		this.#visibleAnswer = replaceTabs(this.#answer).trim();
 		this.#rebuild();
 	}
 
 	setAnswer(text: string): void {
 		if (this.#closed) return;
 		this.#answer = text;
+		this.#visibleAnswer = replaceTabs(text).trim();
 		this.#rebuild();
 	}
 
@@ -59,7 +62,16 @@ export class BtwPanelComponent extends Container {
 	}
 
 	isBranchable(): boolean {
-		return this.#state === "complete" && this.#answer.trim().length > 0;
+		return this.isCopyable();
+	}
+
+	isCopyable(): boolean {
+		return this.#state === "complete" && this.#visibleAnswer.length > 0;
+	}
+
+	getCopyText(): string | undefined {
+		if (!this.isCopyable()) return undefined;
+		return this.#visibleAnswer;
 	}
 
 	close(): void {
@@ -89,7 +101,7 @@ export class BtwPanelComponent extends Container {
 			case "running":
 				return theme.fg("muted", "Esc cancel /btw");
 			case "complete":
-				return theme.fg("muted", this.isBranchable() ? "b branch · Esc dismiss" : "Esc dismiss");
+				return theme.fg("muted", this.isCopyable() ? "c copy · b branch to chat · Esc dismiss" : "Esc dismiss");
 			case "aborted":
 				return theme.fg("warning", `${theme.status.warning} Cancelled · Esc dismiss`);
 			case "error":
@@ -101,7 +113,7 @@ export class BtwPanelComponent extends Container {
 		if (this.#state === "error") {
 			return new Text(theme.fg("error", replaceTabs(this.#errorMessage ?? "Unknown error")), 1, 0);
 		}
-		const text = replaceTabs(this.#answer).trim();
+		const text = this.#visibleAnswer;
 		if (!text) {
 			const waiting =
 				this.#state === "running" ? `${theme.status.pending} Waiting for response…` : "No text returned.";

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

@@ -59,6 +59,7 @@ export interface ChatTranscriptBuilderDeps {
 	getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
 	cwd: string;
 	hideThinkingBlock?: () => boolean;
+	proseOnlyThinking?: () => boolean;
 	requestRender: () => void;
 }
 
@@ -247,8 +248,13 @@ export class ChatTranscriptBuilder {
 	}
 
 	#appendAssistantMessage(message: Extract<AgentMessage, { role: "assistant" }>): void {
-		const assistantComponent = new AssistantMessageComponent(message, this.deps.hideThinkingBlock?.() ?? false, () =>
-			this.deps.requestRender(),
+		const assistantComponent = new AssistantMessageComponent(
+			message,
+			this.deps.hideThinkingBlock?.() ?? false,
+			() => this.deps.requestRender(),
+			this.deps.getMessageRenderer ? undefined : [], // placeholder for thinkingRenderers
+			undefined, // placeholder for imageBudget
+			this.deps.proseOnlyThinking ? this.deps.proseOnlyThinking() : true,
 		);
 		this.container.addChild(assistantComponent);
 

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

@@ -144,6 +144,9 @@ function formatProviderTabLabel(providerId: string): string {
 function createProviderTab(providerId: string): ProviderTabState {
 	return { id: providerId, label: formatProviderTabLabel(providerId), providerId };
 }
+const TEMPORARY_MODEL_PICKER_HINT =
+	"Temporary model selection is session-only. Use Alt+M or /model for role models (default/smol/plan/task/slow/custom roles).";
+
 /**
  * Component that renders a model selector with provider tabs and context menu.
  * - Tab/Arrow Left/Right: Switch between provider tabs
@@ -230,6 +233,10 @@ export class ModelSelectorComponent extends Container {
 				: "Only showing models with configured API keys (see README for details)";
 		this.addChild(new Text(theme.fg("warning", hintText), 0, 0));
 		this.addChild(new Spacer(1));
+		if (this.#temporaryOnly) {
+			this.addChild(new Text(theme.fg("muted", TEMPORARY_MODEL_PICKER_HINT), 0, 0));
+			this.addChild(new Spacer(1));
+		}
 
 		// Create header container for tab bar
 		this.#headerContainer = new Container();
@@ -698,11 +705,23 @@ export class ModelSelectorComponent extends Container {
 		return this.#getActiveTabId() === CANONICAL_TAB;
 	}
 
-	#isModelOverContextLimit(model: Model): boolean {
+	#isModelOverCurrentContext(model: Model): boolean {
 		const contextWindow = model.contextWindow ?? 0;
 		return this.#currentContextTokens > 0 && contextWindow > 0 && this.#currentContextTokens > contextWindow;
 	}
 
+	#isModelOverContextLimit(model: Model): boolean {
+		return this.#temporaryOnly && this.#isModelOverCurrentContext(model);
+	}
+
+	#isDefaultRoleActionOverContextLimit(action: MenuRoleAction, model: Model): boolean {
+		return action.role === "default" && this.#isModelOverCurrentContext(model);
+	}
+
+	#formatCurrentContextLimitSuffix(model: Model): string {
+		return ` ${theme.status.disabled} context>${formatNumber(model.contextWindow ?? 0).toLowerCase()}`;
+	}
+
 	#isItemDisabled(item: ModelItem | CanonicalModelItem): boolean {
 		return this.#isModelOverContextLimit(item.model);
 	}
@@ -711,7 +730,7 @@ export class ModelSelectorComponent extends Container {
 		if (!this.#isModelOverContextLimit(model)) {
 			return "";
 		}
-		return ` ${theme.status.disabled} context>${formatNumber(model.contextWindow ?? 0).toLowerCase()}`;
+		return this.#formatCurrentContextLimitSuffix(model);
 	}
 
 	#getVisibleItems(): ReadonlyArray<ModelItem | CanonicalModelItem> {
@@ -1046,6 +1065,50 @@ export class ModelSelectorComponent extends Container {
 			: this.#filteredModels[this.#selectedIndex];
 	}
 
+	#isMenuRoleIndexDisabled(index: number, selectedItem: ModelItem | CanonicalModelItem): boolean {
+		const action = this.#menuRoleActions[index];
+		return action ? this.#isDefaultRoleActionOverContextLimit(action, selectedItem.model) : false;
+	}
+
+	#coerceMenuSelectedIndex(index: number, selectedItem: ModelItem | CanonicalModelItem): number {
+		const maxIndex = this.#menuRoleActions.length - 1;
+		if (maxIndex < 0) {
+			return 0;
+		}
+		const clamped = Math.max(0, Math.min(index, maxIndex));
+		if (!this.#isMenuRoleIndexDisabled(clamped, selectedItem)) {
+			return clamped;
+		}
+		for (let i = clamped + 1; i <= maxIndex; i++) {
+			if (!this.#isMenuRoleIndexDisabled(i, selectedItem)) {
+				return i;
+			}
+		}
+		for (let i = clamped - 1; i >= 0; i--) {
+			if (!this.#isMenuRoleIndexDisabled(i, selectedItem)) {
+				return i;
+			}
+		}
+		return clamped;
+	}
+
+	#moveMenuSelection(delta: number, selectedItem: ModelItem | CanonicalModelItem, optionCount: number): void {
+		let index = this.#menuSelectedIndex;
+		for (let step = 0; step < optionCount; step++) {
+			index = (index + delta + optionCount) % optionCount;
+			if (this.#menuStep !== "role" || !this.#isMenuRoleIndexDisabled(index, selectedItem)) {
+				this.#menuSelectedIndex = index;
+				this.#updateMenu();
+				return;
+			}
+		}
+		this.#menuSelectedIndex =
+			this.#menuStep === "role"
+				? this.#coerceMenuSelectedIndex(this.#menuSelectedIndex, selectedItem)
+				: this.#menuSelectedIndex;
+		this.#updateMenu();
+	}
+
 	#openMenu(): void {
 		const selectedItem = this.#getSelectedItem();
 		if (!selectedItem || this.#isItemDisabled(selectedItem)) return;
@@ -1053,7 +1116,7 @@ export class ModelSelectorComponent extends Container {
 		this.#isMenuOpen = true;
 		this.#menuStep = "role";
 		this.#menuSelectedRole = null;
-		this.#menuSelectedIndex = 0;
+		this.#menuSelectedIndex = this.#coerceMenuSelectedIndex(0, selectedItem);
 		// Collapse the model list while the action/thinking menu is open so the
 		// menu owns the full viewport instead of stacking below a now-irrelevant
 		// (and often off-screen) list.
@@ -1086,7 +1149,9 @@ export class ModelSelectorComponent extends Container {
 				})
 			: this.#menuRoleActions.map((action, index) => {
 					const prefix = index === this.#menuSelectedIndex ? `  ${theme.nav.cursor} ` : "    ";
-					return `${prefix}${action.label}`;
+					const disabled = this.#isDefaultRoleActionOverContextLimit(action, selectedItem.model);
+					const suffix = disabled ? this.#formatCurrentContextLimitSuffix(selectedItem.model) : "";
+					return `${prefix}${action.label}${suffix}`;
 				});
 
 		const selectedRoleName = this.#menuSelectedRole ? getRoleInfo(this.#menuSelectedRole, this.#settings).name : "";
@@ -1224,21 +1289,19 @@ export class ModelSelectorComponent extends Container {
 		if (optionCount === 0) return;
 
 		if (matchesSelectUp(keyData)) {
-			this.#menuSelectedIndex = (this.#menuSelectedIndex - 1 + optionCount) % optionCount;
-			this.#updateMenu();
+			this.#moveMenuSelection(-1, selectedItem, optionCount);
 			return;
 		}
 
 		if (matchesSelectDown(keyData)) {
-			this.#menuSelectedIndex = (this.#menuSelectedIndex + 1) % optionCount;
-			this.#updateMenu();
+			this.#moveMenuSelection(1, selectedItem, optionCount);
 			return;
 		}
 
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			if (this.#menuStep === "role") {
 				const action = this.#menuRoleActions[this.#menuSelectedIndex];
-				if (!action) return;
+				if (!action || this.#isDefaultRoleActionOverContextLimit(action, selectedItem.model)) return;
 				this.#menuSelectedRole = action.role;
 				this.#menuStep = "thinking";
 				this.#menuSelectedIndex = this.#getThinkingPreselectIndex(action.role, selectedItem.model);

package/src/modes/components/omfg-panel.ts

@@ -117,7 +117,7 @@ export class OmfgPanelComponent extends Container {
 			case "saved":
 				return theme.fg(
 					"success",
-					`${theme.status.success} Registered live · ${replaceTabs(this.#savedPath ?? "saved")}`,
+					`${theme.status.success} Registered live · ${replaceTabs(this.#savedPath ?? "saved")} · Esc dismiss`,
 				);
 			case "rejected":
 				return theme.fg("warning", `${theme.status.warning} Not saved · Esc dismiss`);

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

@@ -454,8 +454,6 @@ export interface SessionSelectorOptions {
 	loadAllSessions?: () => Promise<SessionInfo[]>;
 	/** Preloaded all-projects list; cached so the first Tab toggle is instant. */
 	allSessions?: SessionInfo[];
-	/** Open directly in all-projects scope (e.g. the current folder has no sessions). */
-	startInAllScope?: boolean;
 	/**
 	 * Reads the live terminal height so the visible window fits the viewport.
 	 * Omitted only in tests; defaults to a conservative 24 rows.
@@ -493,11 +491,6 @@ export class SessionSelectorComponent extends Container {
 		this.#loadAllSessions = options.loadAllSessions;
 		this.#folderSessions = sessions;
 		this.#globalSessions = options.allSessions ?? null;
-		// Open in all-projects scope when asked and we already have that list
-		// (e.g. the current folder has no sessions to show).
-		const startAll = options.startInAllScope === true && this.#globalSessions !== null;
-		this.#scope = startAll ? "all" : "folder";
-		const initialSessions = startAll ? this.#globalSessions! : sessions;
 		// Add header
 		this.addChild(new Spacer(1));
 		this.#headerText = new Text(this.#headerLabel(), 1, 0);
@@ -506,8 +499,10 @@ export class SessionSelectorComponent extends Container {
 		this.addChild(new DynamicBorder());
 		this.addChild(new Spacer(1));
 		this.addChild(this.#messageContainer);
-		// Create session list
-		this.#sessionList = new SessionList(initialSessions, startAll, options.historyMatcher, options.getTerminalRows);
+		// Create session list in folder scope; the empty-state hint invites the
+		// user to Tab into all-projects rather than silently surfacing other
+		// projects' history (issue #3099).
+		this.#sessionList = new SessionList(sessions, false, options.historyMatcher, options.getTerminalRows);
 		this.#sessionList.onSelect = onSelect;
 		this.#sessionList.onCancel = onCancel;
 		this.#sessionList.onExit = onExit;

package/src/modes/components/snapcompact-shape-preview.ts

@@ -148,7 +148,7 @@ export class SnapcompactShapePreview implements Component {
 			while (normalize(text).length < capacity) {
 				text += ` ${PREVIEW_TEXT}`;
 			}
-			const frame = renderMany(text, { shape, frameSize: SRC_FRAME_PX, maxFrames: 1 })[0];
+			const frame = (await renderMany(text, { shape, frameSize: SRC_FRAME_PX, maxFrames: 1 }))[0];
 			if (!frame) throw new Error("empty sample frame");
 			const edgePx = SRC_FRAME_PX * ZOOM_SCALE;
 			const zoomed = await new Bun.Image(Buffer.from(frame.data, "base64"))