@oh-my-pi/pi-tui 18.4.0 → 18.4.1

package/src/components/image.ts

@@ -3,6 +3,7 @@ import {
 	getCellDimensions,
 	getImageDimensions,
 	type ImageDimensions,
+	ImageProtocol,
 	imageFallback,
 	renderImage,
 	TERMINAL,
@@ -765,6 +766,13 @@ export class Image implements Component {
 		// toward (and are demoted by) the budget; without a protocol every image is
 		// already text.
 		const suppressed = hasProtocol && this.#budget !== undefined ? this.#budget.observe(this.#imageId ?? 0) : false;
+		// Only Kitty images with a budget id transmit their data separately from
+		// the placement; a pending re-transmit (after a purge or history clear)
+		// must rebuild the lines. SIXEL and iTerm2 carry the image inside the line
+		// itself and never register a transmit, so gating their cache on it would
+		// re-encode the full image on every render pass.
+		const imageId = this.#imageId;
+		const transmitsSeparately = imageProtocol === ImageProtocol.Kitty && imageId != null;
 
 		if (
 			this.#cachedLines &&
@@ -774,7 +782,7 @@ export class Image implements Component {
 			this.#cachedCellWidthPx === cellDimensions.widthPx &&
 			this.#cachedCellHeightPx === cellDimensions.heightPx &&
 			this.#cachedKittyUnicodePlaceholders === kittyUnicodePlaceholders &&
-			(this.#imageId == null || this.#budget?.shouldTransmit(this.#imageId) !== true)
+			(!transmitsSeparately || this.#budget?.shouldTransmit(imageId) !== true)
 		) {
 			return this.#cachedLines;
 		}
@@ -787,7 +795,7 @@ export class Image implements Component {
 		if (hasProtocol && !suppressed) {
 			// Transmit the data once (keyed by id); thereafter renderImage returns
 			// just the placement, so repaints never re-send the base64.
-			const needsTransmit = this.#imageId != null && (this.#budget?.shouldTransmit(this.#imageId) ?? false);
+			const needsTransmit = transmitsSeparately && (this.#budget?.shouldTransmit(imageId) ?? false);
 			const result = renderImage(this.#base64Data, this.#dimensions, {
 				maxWidthCells: maxWidth,
 				maxHeightCells: this.#options.maxHeightCells,

package/src/overlays/agents-hub.ts

@@ -81,7 +81,7 @@ interface SidebarEntry extends HubSidebarEntry<"all" | "source" | "new" | "separ
 type ListRow = { kind: "agent"; agent: HubAgent } | { kind: "new" };
 
 /** The per-agent knob a strip or the model browser is editing. */
-type PropertyKind = "model" | "prewalk" | "advisor";
+export type PropertyKind = "model" | "prewalk" | "advisor";
 
 type StripChip = HubStripChip<
 	| { kind: "toggle" }
@@ -110,8 +110,10 @@ export interface AgentsHubDeps {
 	resolvePatterns: (patterns: string[]) => string | undefined;
 	effectivePrewalkPattern: (agent: HubAgent) => string | undefined;
 	effectiveAdvisorPattern: (agent: HubAgent) => string | undefined;
-	setDisabledAgents: (names: string[]) => void;
-	setOverrides: (property: PropertyKind, overrides: Record<string, string>) => void;
+	/** Persist one agent's enabled state; other agents are untouched. */
+	setAgentDisabled: (name: string, options: { disabled: boolean }) => void;
+	/** Persist one agent's override for `property`; `undefined` clears it. Other agents are untouched. */
+	setAgentOverride: (property: PropertyKind, name: string, value: string | undefined) => void;
 	generateAgent: (description: string, onText: (text: string) => void) => Promise<string>;
 	saveAgent: (scope: "project" | "user", spec: GeneratedAgentSpec) => Promise<string>;
 }
@@ -341,24 +343,11 @@ export class AgentsHubComponent implements Component {
 
 	#toggleAgent(agent: HubAgent): void {
 		agent.disabled = !agent.disabled;
-		const disabled = this.#allAgents
-			.filter(entry => entry.disabled)
-			.map(entry => entry.name)
-			.sort((a, b) => a.localeCompare(b));
-		this.#deps.setDisabledAgents(disabled);
+		this.#deps.setAgentDisabled(agent.name, { disabled: agent.disabled });
 		this.#notice = `${agent.name} ${agent.disabled ? "disabled" : "enabled"}`;
 		this.#tui.requestRender();
 	}
 
-	#persistRecord(property: PropertyKind): void {
-		const overrides: Record<string, string> = {};
-		for (const agent of this.#allAgents) {
-			const value = this.#overrideFor(agent, property)?.trim();
-			if (value) overrides[agent.name] = value;
-		}
-		this.#deps.setOverrides(property, overrides);
-	}
-
 	#overrideFor(agent: HubAgent, property: PropertyKind): string | undefined {
 		switch (property) {
 			case "model":
@@ -383,7 +372,7 @@ export class AgentsHubComponent implements Component {
 				agent.advisorOverride = trimmed;
 				break;
 		}
-		this.#persistRecord(property);
+		this.#deps.setAgentOverride(property, agent.name, trimmed);
 		this.#notice = this.#describeProperty(agent, property);
 		this.#tui.requestRender();
 	}

package/src/overlays/copy-selector.ts

@@ -18,12 +18,12 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { type Component, matchesKey, routeSgrMouseInput, type TUI, truncateToWidth, visibleWidth } from "../index";
 import type { MessageRenderer } from "../chat/extension-types";
 import {
-	isUserRequestEntry,
+	recentTranscriptEntries,
+	type SessionMessageEntryLike as SessionMessageEntry,
 	type TranscriptEntryLike as TranscriptEntry,
 	transcriptEntryMessage,
 	userTurnDraft,
 } from "../chat/transcript-entry";
-import type { SessionMessageEntryLike as SessionMessageEntry } from "../chat/transcript-entry";
 import { expandKeyHint, replaceTabs } from "../render/render-utils";
 import { formatKeyHint } from "../app-keybindings";
 import { editorKey, editorKeys } from "../chrome/keybinding-hints";
@@ -92,13 +92,6 @@ export interface CopyBlock {
 const BLOCK_PREVIEW_LINES = 12;
 /** The copy picker's outline stroke — green, distinct from the rewind selector's accent. */
 const OUTLINE_COLOR: ThemeColor = "success";
-/**
- * Entries replayed when the picker opens. Replaying a long session's whole
- * branch costs seconds before the first frame (one component built and
- * rendered per entry), and the clipboard target is almost always recent, so
- * the picker starts at this tail and loads the rest on demand (`a`).
- */
-const INITIAL_ENTRIES = 600;
 
 /** A clickable control on a block caption, in composed-column columns. */
 interface ControlRegion {
@@ -132,7 +125,7 @@ export class CopySelectorComponent implements Component {
 		private readonly deps: CopySelectorDeps,
 	) {
 		this.#entries = entries;
-		const tail = recentEntries(entries, INITIAL_ENTRIES);
+		const tail = recentTranscriptEntries(entries);
 		this.#truncated = tail.length < entries.length;
 		this.#builder = this.#replay(tail);
 		this.#selected = Math.max(0, this.#targets.length - 1);
@@ -478,27 +471,6 @@ export class CopySelectorComponent implements Component {
 	}
 }
 
-/**
- * The trailing slice starting at the last turn initiator at or before
- * `entries.length - limit`: a user message, or a custom message that starts
- * a user-attributed turn (a directly invoked `/skill:` prompt, a collab peer's
- * prompt), the same boundary `ChatTranscriptBuilder` uses.
- *
- * The cut has to land on a turn boundary: the builder drops a tool result
- * whose initiating call was sliced away, so a tail beginning mid-turn renders
- * without its command — and a tail of nothing but orphaned results would
- * leave the picker with no target at all. Scanning backwards keeps the whole
- * final turn instead, and a branch whose last turn is itself longer than
- * `limit` replays in full.
- */
-function recentEntries(entries: TranscriptEntry[], limit: number): TranscriptEntry[] {
-	if (entries.length <= limit) return entries;
-	for (let index = entries.length - limit; index > 0; index--) {
-		if (isUserRequestEntry(entries[index]!)) return entries.slice(index);
-	}
-	return entries;
-}
-
 /** Raw multi-line text of a user message (string or text blocks). */
 function rawUserText(message: Extract<SessionMessageEntry["message"], { role: "user" }>): string {
 	if (typeof message.content === "string") return message.content;

package/src/overlays/model-hub.ts

@@ -984,7 +984,11 @@ export class ModelHubComponent implements Component {
 		);
 	}
 
-	/** Persist `role → item`, preserving a still-supported thinking level, then open the thinking strip. */
+	/**
+	 * Persist `role → item`, preserving a still-supported thinking level, then
+	 * open the thinking strip — skipped for models with no reasoning surface,
+	 * where every chip would be a no-op ({@link #thinkingOptionsFor}).
+	 */
 	#assignRole(item: ModelBrowserItem, role: string, returnToRoles: boolean, scope?: ModelRoleSelectionScope): void {
 		if (this.#settings.modelRoleStorage === "project" && scope === undefined) {
 			this.#openScopeStrip(item, role, returnToRoles);
@@ -1003,6 +1007,13 @@ export class ModelHubComponent implements Component {
 		const result = this.#callbacks.onAssign(item.model, role, level, item.selector, scope);
 		this.#finishAssignment(result, () => {
 			this.#refreshAfterMutation();
+			if (supported.length === 0) {
+				if (returnToRoles) {
+					this.#setActiveEntry("roles");
+					this.#focus = "list";
+				}
+				return;
+			}
 			this.#openThinkingStrip(item, role, returnToRoles, scope, level);
 		});
 	}
@@ -1019,10 +1030,39 @@ export class ModelHubComponent implements Component {
 		this.#refreshAfterMutation();
 	}
 
+	/**
+	 * Thinking levels a role assignment can actually apply. A model that does
+	 * not reason gets none: no request path sends reasoning for it, and
+	 * `applyAutoThinkingLevel` early-returns on `!model.reasoning`, so
+	 * `inherit`/`off`/`auto` would all be no-ops. Reasoners without an effort
+	 * dial (`thinking: undefined`, e.g. `xai/grok-code-fast-1`) keep the three
+	 * always-on levels — their thinking is real, only the ladder is absent.
+	 */
 	#thinkingOptionsFor(model: Model): ConfiguredThinkingLevel[] {
+		if (!model.reasoning) return [];
 		return [ThinkingLevel.Inherit, ThinkingLevel.Off, AUTO_THINKING, ...getSupportedEfforts(model)];
 	}
 
+	/**
+	 * Resolve what `t` on a role row would edit: the role's model in its
+	 * persisted scope. Undefined when the role is unassigned or its model has
+	 * no thinking levels to offer, which makes both `t` and its footer hint
+	 * inert — the same rule wildcard fallback rows follow.
+	 */
+	#roleThinkingTarget(role: string): { item: ModelBrowserItem; scope?: ModelRoleSelectionScope } | undefined {
+		const assignment = this.#roles[role];
+		if (!assignment) return undefined;
+		const source =
+			this.#settings.modelRoleStorage === "project" ? this.#settings.getModelRoleSource(role) : "default";
+		const scope = source === "project" || source === "global" ? source : undefined;
+		const model = scope ? this.#roleForScope(role, scope).model : assignment.model;
+		if (!model || this.#thinkingOptionsFor(model).length === 0) return undefined;
+		return {
+			item: { provider: model.provider, id: model.id, model, selector: `${model.provider}/${model.id}` },
+			scope,
+		};
+	}
+
 	/** Offer only the roles this model can actually fill (chat roles for chat models, `web` for search runners, …). */
 	#openRoleStrip(item: ModelBrowserItem): void {
 		const chips: StripChip[] = [];
@@ -1821,20 +1861,9 @@ export class ModelHubComponent implements Component {
 			return;
 		}
 		if (printable === "t") {
-			const assignment = role ? this.#roles[role] : undefined;
-			if (role && assignment) {
-				const source =
-					this.#settings.modelRoleStorage === "project" ? this.#settings.getModelRoleSource(role) : "default";
-				const scope = source === "project" || source === "global" ? source : undefined;
-				const scopedModel = scope ? this.#roleForScope(role, scope).model : assignment.model;
-				if (!scopedModel) return;
-				const item: ModelBrowserItem = {
-					provider: scopedModel.provider,
-					id: scopedModel.id,
-					model: scopedModel,
-					selector: `${scopedModel.provider}/${scopedModel.id}`,
-				};
-				this.#openThinkingStrip(item, role, true, scope);
+			if (role) {
+				const target = this.#roleThinkingTarget(role);
+				if (target) this.#openThinkingStrip(target.item, role, true, target.scope);
 			} else if (row?.kind === "fallback") {
 				this.#openFallbackThinkingStrip(row);
 			}
@@ -2338,7 +2367,11 @@ export class ModelHubComponent implements Component {
 			if (row?.kind === "newFallback") {
 				return `${upDown} rows · ${enter} new model/provider fallback chain · ${left} providers`;
 			}
-			return `${upDown} rows · ${enter} pick · ${formatKeyHint("f")} fallback · ${formatKeyHint("x")} clear · ${formatKeyHint("t")} thinking · ${formatKeyHint("c")} cycle · [/] reorder · ${formatKeyHint("n")} new`;
+			// Same rule as fallback rows: advertise `t` only where a strip would
+			// open — an assigned role whose model has thinking levels to offer.
+			const editable = row?.kind === "role" && this.#roleThinkingTarget(row.role) !== undefined;
+			const thinking = editable ? ` · ${formatKeyHint("t")} thinking` : "";
+			return `${upDown} rows · ${enter} pick · ${formatKeyHint("f")} fallback · ${formatKeyHint("x")} clear${thinking} · ${formatKeyHint("c")} cycle · [/] reorder · ${formatKeyHint("n")} new`;
 		}
 		if (entry.kind === "provider" && entry.locked) {
 			return entry.oauth

package/src/overlays/rewind-selector.ts

@@ -21,8 +21,8 @@
  * active column when a strip is open), Left/Right slide between branch
  * variants at a fork and jump between user turns elsewhere, `f` opens a
  * filter (typing narrows the current path to matching items; Esc leaves the
- * filter with the selection kept), Enter rewinds to the outlined item, Esc
- * cancels.
+ * filter with the selection kept), Enter rewinds to the outlined item, A loads
+ * earlier turns without changing selection, Esc cancels.
  */
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import {
@@ -36,7 +36,7 @@ import {
 	truncateToWidth,
 } from "../index";
 import type { MessageRenderer } from "../chat/extension-types";
-import type { TranscriptEntryLike as TranscriptEntry } from "../chat/transcript-entry";
+import { recentTranscriptEntries, type TranscriptEntryLike as TranscriptEntry } from "../chat/transcript-entry";
 import { theme } from "../theme/theme";
 import { matchesAppToolsExpand, matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../keybinding-matchers";
 import { ChatTranscriptBuilder } from "../chat/chat-transcript-builder";
@@ -116,6 +116,10 @@ export class RewindSelectorComponent implements Component {
 	#slide: { from: number; to: number; startedAt: number } | undefined;
 	#slideTimer: NodeJS.Timeout | undefined;
 
+	/** Whole branch; the selector may currently replay only its tail. */
+	#entries: TranscriptEntry[];
+	/** True while older history is still unreplayed. */
+	#truncated = false;
 	/** Filter query while the filter prompt is open; undefined shows the full transcript. */
 	#filter: string | undefined;
 	/** Main transcript rows from the last frame; the filter matches what is on screen. */
@@ -127,8 +131,10 @@ export class RewindSelectorComponent implements Component {
 		entries: TranscriptEntry[],
 		private readonly deps: RewindSelectorDeps,
 	) {
-		this.#builder = this.#newBuilder();
-		this.#targets = appendOutlineEntries(this.#builder, entries);
+		this.#entries = entries;
+		const tail = recentTranscriptEntries(entries);
+		this.#truncated = tail.length < entries.length;
+		this.#builder = this.#replay(tail);
 		this.#selected = Math.max(0, this.#targets.length - 1);
 		this.#browser = new TranscriptBrowser({
 			getHeight: () => this.deps.ui.terminal?.rows || process.stdout.rows || 40,
@@ -142,7 +148,7 @@ export class RewindSelectorComponent implements Component {
 	}
 
 	#newBuilder(): ChatTranscriptBuilder {
-		return new ChatTranscriptBuilder({
+		const builder = new ChatTranscriptBuilder({
 			ui: this.deps.ui,
 			getTool: this.deps.getTool,
 			isBuiltInTool: this.deps.isBuiltInTool,
@@ -153,6 +159,30 @@ export class RewindSelectorComponent implements Component {
 			linkTargets: this.deps.linkTargets,
 			requestRender: this.deps.requestRender,
 		});
+		builder.setExpanded(this.#expanded);
+		return builder;
+	}
+
+	/** Build a transcript for `entries` and adopt its targets. */
+	#replay(entries: TranscriptEntry[]): ChatTranscriptBuilder {
+		const builder = this.#newBuilder();
+		this.#targets = appendOutlineEntries(builder, entries);
+		return builder;
+	}
+
+	/** Replay the whole branch, keeping the main outline on the same turn. */
+	#loadFullHistory(): void {
+		if (!this.#truncated) return;
+		const selectedId = this.#targets[this.#selected]?.turnId;
+		const previous = this.#builder;
+		this.#builder = this.#replay(this.#entries);
+		previous.dispose();
+		this.#truncated = false;
+		this.#mainVisible = undefined;
+		this.#mainRows = [];
+		const restored = selectedId ? this.#targets.findIndex(target => target.turnId === selectedId) : -1;
+		this.#selected = restored >= 0 ? restored : Math.max(0, this.#targets.length - 1);
+		this.deps.requestRender();
 	}
 
 	invalidate(): void {
@@ -186,7 +216,6 @@ export class RewindSelectorComponent implements Component {
 		for (const sibling of this.deps.siblingPaths(target.turnId)) {
 			if (sibling.entries.length === 0) continue;
 			const builder = this.#newBuilder();
-			builder.setExpanded(this.#expanded);
 			const targets = appendOutlineEntries(builder, sibling.entries);
 			const firstUser = sibling.entries.find(isUserTurnEntry);
 			const label = (firstUser && userTurnLabel(firstUser)) || sibling.rootId;
@@ -257,6 +286,8 @@ export class RewindSelectorComponent implements Component {
 			return;
 		}
 		if (matchesKey(data, "f")) {
+			// The filter must search the whole branch, not just the startup tail.
+			this.#loadFullHistory();
 			this.#filter = "";
 			this.#activeVariant = 0;
 			this.#siblingSelected = 0;
@@ -291,6 +322,10 @@ export class RewindSelectorComponent implements Component {
 			}
 			return;
 		}
+		if (data === "a" || data === "A") {
+			this.#loadFullHistory();
+			return;
+		}
 		if (matchesKey(data, "enter") || matchesKey(data, "return") || data === "\n") {
 			const target = this.#outlinedTarget();
 			if (target) this.deps.onSelect(target.entryId);
@@ -384,15 +419,19 @@ export class RewindSelectorComponent implements Component {
 
 	/**
 	 * Visible main-path target indices whose rendered text contains every
-	 * whitespace-separated query word as a whole word (case-insensitive: `ls`
-	 * matches `ls -la` but not `tools`); all visible targets for an empty query.
+	 * whitespace-separated Latin query word as a whole word (case-insensitive:
+	 * `ls` matches `ls -la` but not `tools`). Other scripts match substrings so
+	 * a Chinese query can find text inside a sentence without spaces.
+	 * All visible targets match an empty query.
 	 * Matching the rendered rows keeps results honest: collapsed tool output
 	 * only matches once Ctrl+O expands it.
 	 */
 	#filterMatches(): number[] {
 		const words = (this.#filter ?? "").toLowerCase().split(/\s+/).filter(Boolean);
-		const patterns = words.map(
-			word => new RegExp(`(?<![\\p{L}\\p{N}_])${RegExp.escape(word)}(?![\\p{L}\\p{N}_])`, "u"),
+		const patterns = words.map(word =>
+			/^[\p{Script=Latin}\p{N}_]+$/u.test(word)
+				? new RegExp(`(?<![\\p{L}\\p{N}_])${RegExp.escape(word)}(?![\\p{L}\\p{N}_])`, "u")
+				: new RegExp(RegExp.escape(word), "u"),
 		);
 		const matches: number[] = [];
 		for (let index = 0; index < this.#targets.length; index++) {
@@ -492,7 +531,7 @@ export class RewindSelectorComponent implements Component {
 		const upDown = editorKeys("tui.select.up", "tui.select.down");
 		const leftRight = formatKeyHints(["left", "right"]);
 		const lateral = columns.length > 0 ? `${leftRight} branches` : `${leftRight} user turns`;
-		const keys = `${upDown} step  ${lateral}  ${formatKeyHint("f")} filter  ${formatKeyHint("enter")} rewind  ${expandKeyHint()} expand  ${editorKey("tui.select.cancel")} cancel`;
+		const keys = `${upDown} step  ${lateral}  ${formatKeyHint("f")} filter  ${formatKeyHint("enter")} rewind  ${this.#truncated ? `${formatKeyHint("a")} earlier turns  ` : ""}${expandKeyHint()} expand  ${editorKey("tui.select.cancel")} cancel`;
 		return {
 			header: [this.#header()],
 			body: {

package/src/overlays/usage-dashboard.ts

@@ -67,12 +67,19 @@ export interface CardWindowRow {
 	usedText?: string;
 }
 
+/** A connected account whose usage lookup produced no attributable report. */
+export interface UnavailableUsageAccount {
+	provider: string;
+	label: string;
+}
+
 /** Compact per-provider summary backing one card in the subscriptions grid. */
 export interface ProviderCard {
 	provider: string;
 	name: string;
-	/** Number of accounts reporting for this provider. */
+	/** Number of represented accounts, including unavailable usage lookups. */
 	accounts: number;
+	unavailableAccounts: string[];
 	/** Window rows sorted most-pressing first. */
 	windows: CardWindowRow[];
 	/** True when every account reports no limits (e.g. enterprise plans). */
@@ -104,6 +111,15 @@ function aggregateStatus(limits: readonly { status?: UsageLimit["status"] }[]):
 	return "unknown";
 }
 
+/**
+ * Card status when some connected accounts reported no usage: the missing
+ * report raises the card to a warning but never hides an exhausted quota.
+ */
+function statusWithUnavailableAccounts(windows: readonly { status?: UsageLimit["status"] }[]): UsageLimit["status"] {
+	if (windows.length === 0) return "unknown";
+	return aggregateStatus(windows) === "exhausted" ? "exhausted" : "warning";
+}
+
 /** Fraction below which a window counts as untouched (renders as 100% free). */
 const IDLE_FRACTION = 0.005;
 /**
@@ -129,7 +145,11 @@ function compactWindowTag(window: NonNullable<UsageLimit["window"]>): string {
  * most-used account's reset countdown. Cards sort most-pressing first so
  * what's burning is on top-left; fully idle providers collapse into a tick.
  */
-export function buildProviderCards(reports: UsageReport[], nowMs: number): ProviderCard[] {
+export function buildProviderCards(
+	reports: UsageReport[],
+	nowMs: number,
+	unavailableAccounts: readonly UnavailableUsageAccount[] = [],
+): ProviderCard[] {
 	const displayReports = collapseSharedUsageReports(reports);
 	const grouped = new Map<string, UsageReport[]>();
 	for (const report of displayReports) {
@@ -137,9 +157,15 @@ export function buildProviderCards(reports: UsageReport[], nowMs: number): Provi
 		list.push(report);
 		grouped.set(report.provider, list);
 	}
+	for (const account of unavailableAccounts) {
+		if (!grouped.has(account.provider)) grouped.set(account.provider, []);
+	}
 
 	const cards: ProviderCard[] = [];
 	for (const [provider, providerReports] of grouped) {
+		const unavailable = unavailableAccounts
+			.filter(account => account.provider === provider)
+			.map(account => account.label);
 		const buckets = new Map<string, { label: string; limits: UsageLimit[] }>();
 		for (const report of providerReports) {
 			for (const limit of report.limits) {
@@ -220,10 +246,12 @@ export function buildProviderCards(reports: UsageReport[], nowMs: number): Provi
 		cards.push({
 			provider,
 			name: formatProviderName(provider),
-			accounts: providerReports.length,
+			accounts: providerReports.length + unavailable.length,
+			unavailableAccounts: unavailable,
 			windows,
-			unlimited: windows.length === 0,
+			unlimited: windows.length === 0 && unavailable.length === 0,
 			idle:
+				unavailable.length === 0 &&
 				!resetCredits &&
 				daybreakAccounts.length === 0 &&
 				windows.every(window => window.fraction !== undefined && window.fraction < IDLE_FRACTION),
@@ -328,6 +356,7 @@ export function buildHeatmapLayout(points: DailyActivityPoint[], weeks: number,
 /** Callbacks and data sources for {@link UsageDashboardComponent}. */
 export interface UsageDashboardOptions {
 	reports: UsageReport[];
+	unavailableAccounts?: readonly UnavailableUsageAccount[];
 	/**
 	 * Full classic `/usage` report for the expanded detail view; re-invoked per
 	 * terminal width.
@@ -395,7 +424,7 @@ export class UsageDashboardComponent implements Component {
 		ensureThemeSync();
 		this.#options = options;
 		this.#nowMs = Date.now();
-		this.#cards = buildProviderCards(options.reports, this.#nowMs);
+		this.#cards = buildProviderCards(options.reports, this.#nowMs, options.unavailableAccounts);
 		this.#panel = new OverlayPanel("Usage");
 		this.#header = new PanelRows();
 		this.#header.setHeight(1);
@@ -464,7 +493,12 @@ export class UsageDashboardComponent implements Component {
 
 	#renderCardLines(card: ProviderCard, width: number, labels: string[][], layout: CardRowLayout): string[] {
 		const lines: string[] = [];
-		const cardStatus = card.unlimited ? "ok" : aggregateStatus(card.windows);
+		const cardStatus =
+			card.unavailableAccounts.length > 0
+				? statusWithUnavailableAccounts(card.windows)
+				: card.unlimited
+					? "ok"
+					: aggregateStatus(card.windows);
 		const accountsText = card.accounts > 1 ? theme.fg("dim", `${card.accounts} accts`) : "";
 		const titleBudget = width - 2 - visibleWidth(accountsText) - (accountsText ? 1 : 0);
 		const title = theme.bold(truncateToWidth(card.name, Math.max(4, titleBudget)));
@@ -495,6 +529,13 @@ export class UsageDashboardComponent implements Component {
 			}
 		}
 
+		for (const account of card.unavailableAccounts) {
+			const text = sanitizeDisplayLine(`${account} — usage unavailable`);
+			for (const line of wrapTextWithAnsi(text, Math.max(1, width - 2))) {
+				lines.push(`  ${theme.fg("dim", line)}`);
+			}
+		}
+
 		if (card.unlimited) {
 			lines.push(`  ${theme.fg("dim", "no limits")}`);
 			return lines;