gentle-pi 3.7.0 → 4.0.0

package/lib/shell-sidebar-layout.ts

@@ -1,7 +1,9 @@
 import { ScrollView, VStack, visibleWidth, type Component, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { sidebarState, type SidebarRail } from "./shell-sidebar.ts";
 import type { ShellBarTheme } from "./shell-bar.ts";
+import { CARD_STYLE, cardStyle, type CardStyle } from "./shell-card.ts";
 import { renderSidebarBanner } from "./shell-sidebar-banner.ts";
+import type { Density, HeaderPlacement, StatusPlacement } from "./visual-customization-policy.ts";
 
 export const SIDEBAR_BREAKPOINT = 140;
 const RAIL_WIDTH = 50;
@@ -12,6 +14,8 @@ const RAIL_PADDING = 1;
 // the card instead of touching the terminal edge.
 const HEADER_RIGHT_INSET = RAIL_PADDING + 1;
 const GAP = 3;
+/** Right-edge columns the painting rail takes from the editor column; published as `railColumns`. */
+export const SIDEBAR_RAIL_COLUMNS = RAIL_WIDTH + GAP;
 // Experimental Pi 0.85.1 internals. Only the fullscreen layout tree is adapted;
 // regular mode keeps native scrollback and the original bottom components.
 const NODE = Symbol.for("@earendil-works/pi-tui/layout-node");
@@ -27,6 +31,8 @@ type PreparedRail = {
 	revision: number;
 	width: number;
 	mode: string | undefined;
+	headerPlacement: HeaderPlacement;
+	cardStyle: CardStyle;
 	root: LayoutRoot;
 	theme: ShellBarTheme;
 	parts: Array<[string, SidebarRail]>;
@@ -68,8 +74,28 @@ function railDigest(rail: SidebarRail): string | undefined {
 	}
 }
 
+export const STATUS_OWNER = { HEADER: "header", BOTTOM: "bottom" } as const;
+export type StatusOwner = (typeof STATUS_OWNER)[keyof typeof STATUS_OWNER];
+export interface StatusOwnerInput {
+	mode: string | undefined;
+	columns: number;
+	statusPlacement: StatusPlacement;
+	headerPlacement: HeaderPlacement;
+}
+
+/**
+ * Which single status row owns a narrow fullscreen terminal, so the header and
+ * the bottom bar never both paint there. A configured top header wins;
+ * otherwise the bottom bar does, unless Status is hidden and the below-input
+ * header is all that is left. Wide and regular layouts keep their own rules.
+ */
+export function narrowStatusOwner(input: StatusOwnerInput): StatusOwner | undefined {
+	if (input.mode !== "fullscreen" || input.columns >= SIDEBAR_BREAKPOINT) return undefined;
+	return input.headerPlacement === "top" || input.statusPlacement === "hidden" ? STATUS_OWNER.HEADER : STATUS_OWNER.BOTTOM;
+}
+
 /** Installs the fullscreen rail: wraps the host layout root with the [rail, transcript] hstack and returns a disposer restoring the original layout. */
-export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
+export function installSidebar(tui: TUI, theme: ShellBarTheme, placement: () => StatusPlacement = () => "auto", headerPlacement: () => HeaderPlacement = () => "top", density: () => Density = () => "comfortable"): () => void {
 	if (!tui.terminal) return () => {};
 	const host = tui as Host;
 	const state = sidebarState(tui);
@@ -89,7 +115,17 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 	// revision counter, exactly like the whole-rail memo already did.
 	const sectionCache = new Map<string, SectionCacheEntry>();
 	state.active = false;
-	state.ownsHost = () => !stopped && host.mode === "fullscreen" && !!host.layoutRoot && roots.has(host.layoutRoot);
+	// Hidden removes Status everywhere, including regular mode where the rail
+	// never mounts, so it is published independently of the fullscreen layout.
+	state.statusHidden = () => !stopped && placement() === "hidden";
+	// A narrow top header is the only status row there. Whether it paints comes
+	// from the last layout pass (a blank or failed header never swallows the
+	// bottom bar); the geometry is read live so a resize applies before the next pass.
+	const headerOwnsStatus = () => !stopped && !failed && headerLines.length > 0 && headerPlacement() === "top" &&
+		narrowStatusOwner({ mode: host.mode, columns: tui.terminal.columns, statusPlacement: placement(), headerPlacement: headerPlacement() }) === STATUS_OWNER.HEADER;
+	state.headerOwnsStatus = headerOwnsStatus;
+	state.railColumns = SIDEBAR_RAIL_COLUMNS;
+	state.ownsHost = () => !stopped && host.mode === "fullscreen" && tui.terminal.columns >= SIDEBAR_BREAKPOINT && (placement() === "auto" || placement() === "right") && !!host.layoutRoot && roots.has(host.layoutRoot);
 	const rail: Component = {
 		render: () => railLines,
 		invalidate() {
@@ -156,14 +192,30 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 	};
 	const prepare = (width: number, root: LayoutRoot): boolean => {
 		state.active = false;
-		if (stopped || failed || host.mode !== "fullscreen" || width < SIDEBAR_BREAKPOINT) {
+		if (stopped || failed || host.mode !== "fullscreen") {
 			prepared = undefined;
+			headerLines = [];
 			return false;
 		}
+		const railEligible = width >= SIDEBAR_BREAKPOINT && placement() !== "bottom" && placement() !== "hidden";
+		if (!railEligible) {
+			prepared = undefined;
+			try {
+				const headerPart = state.parts.get("header");
+				headerLines = headerPlacement() === "top" && headerPart
+					? [...(headerPart.render(Math.max(0, width)) ?? [])] : [];
+				if (!headerLines.some((line) => line.trim() !== "")) headerLines = [];
+			} catch {
+				failed = true;
+				headerLines = [];
+			}
+			return false;
+		}
+		const style = cardStyle();
 		const parts = [...state.parts.entries()];
 		const digests = parts.map(([, rail]) => railDigest(rail));
 		const unchanged = prepared?.revision === cache.revision &&
-			prepared.width === width && prepared.mode === host.mode && prepared.root === root && prepared.theme === theme &&
+			prepared.width === width && prepared.mode === host.mode && prepared.headerPlacement === headerPlacement() && prepared.cardStyle === style && prepared.root === root && prepared.theme === theme &&
 			prepared.parts.length === parts.length && prepared.parts.every(([key, part], index) => parts[index]?.[0] === key && parts[index]?.[1] === part) &&
 			prepared.digests.length === digests.length && prepared.digests.every((digest, index) => digest === digests[index]);
 		if (unchanged) {
@@ -179,7 +231,7 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 			const preparedHeaderLines = [...(headerPart?.render(Math.max(0, width - HEADER_RIGHT_INSET)) ?? [])];
 			const headerActive = headerPart !== undefined && preparedHeaderLines.some((line) => line.trim() !== "");
 			const contentWidth = scroll.getContentWidth(RAIL_WIDTH);
-			const sections = ["footer", "agents", "todo"].map((key) => {
+			const sections = ["footer", "agents", "todo"].filter((key) => key !== "todo" || state.visibility?.todo !== false).map((key) => {
 				const component = state.parts.get(key);
 				if (!component) {
 					sectionCache.delete(key);
@@ -204,23 +256,23 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 			railLines = [];
 			if (sections.length && branding.length) {
 				railLines.push(...branding.map((line) => " ".repeat(RAIL_PADDING) + line + " ".repeat(RAIL_PADDING)));
-			} else if (sections.length && headerActive) {
-				// The banner used to hold the first card off the top; the header
-				// took its place, so keep one blank row between them.
+			} else if (sections.length && headerActive && density() === "comfortable" && style === CARD_STYLE.NEON) {
+				// Preserve neon's header gap. Float's painted top padding starts
+				// on the same body row as the transcript, without an external gap.
 				railLines.push("");
 			}
 			for (const section of sections) {
 				// One blank row separates a section from the banner or the
-				// previous section; the header gap above is not a section.
-				if (hits.length > 0 || branding.length > 0) railLines.push("");
+				// previous section; neon's header gap above is not a section.
+				if ((hits.length > 0 || branding.length > 0) && density() === "comfortable") railLines.push("");
 				const startY = railLines.length;
 				railLines.push(...section.lines.map((line) => " ".repeat(RAIL_PADDING) + line + " ".repeat(RAIL_PADDING)));
 				hits.push({ key: section.key, component: section.component, startY, height: section.lines.length, width: contentWidth - RAIL_PADDING * 2 });
 			}
 			// Height is owned by the native ScrollView, never by the transcript.
 			const active = railLines.length > 0 && railLines.every((line) => visibleWidth(line) <= contentWidth);
-			headerLines = active && headerActive ? preparedHeaderLines : [];
-			prepared = { revision: cache.revision, width, mode: host.mode, root, theme, parts, digests, contentWidth, active, lines: railLines, hits, headerLines, headerActive: headerLines.length > 0 };
+			headerLines = headerActive && headerPlacement() === "top" ? preparedHeaderLines : [];
+			prepared = { revision: cache.revision, width, mode: host.mode, headerPlacement: headerPlacement(), cardStyle: style, root, theme, parts, digests, contentWidth, active, lines: railLines, hits, headerLines, headerActive: headerLines.length > 0 };
 			state.active = active;
 			return active;
 		} catch {
@@ -264,6 +316,11 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 				}
 				return { ...node, entries: entries.map((entry, index) => index === entries.length - 1 ? { ...entry, component: wrapped! } : entry) };
 			};
+			// Without a rail the native layout stays in place; a hidden Status, or a
+			// narrow top header owning it, only frees the footer's reserved dock row,
+			// exactly as the rail does.
+			const nativeLayout = () => placement() === "hidden" || headerOwnsStatus() ? reclaimFooterRow(original.call(root)) : original.call(root);
+			const nativeHost = { render: () => [], invalidate() {}, [NODE]: nativeLayout };
 			const left = { render: () => [], invalidate() {}, [NODE]: () => reclaimFooterRow(original.call(root)) };
 			// Stable component wrapping the [left, scroll] hstack behind its own
 			// NODE, exactly like `left` wraps the native transcript: the header
@@ -278,10 +335,17 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme): () => void {
 				] }),
 			};
 			const replacement = () => {
-				if (!prepare(tui.terminal.columns, root)) return original.call(root);
+				if (!prepare(tui.terminal.columns, root)) {
+					if (failed || stopped || host.mode !== "fullscreen") return original.call(root);
+					if (!headerLines.length) return nativeLayout();
+					return { type: "vstack", gap: 0, align: "stretch", entries: [
+						{ component: header, basis: "auto", grow: 0, shrink: 0, minSize: 1 },
+						{ component: nativeHost, basis: 0, grow: 1, shrink: 1, minSize: 1 },
+					] };
+				}
 				const current = prepared!;
 				if (current.presentation?.scrollTop === scroll.scrollTop) return current.presentation.output;
-				const output: LayoutNode = current.headerActive
+				const output: LayoutNode = current.headerActive && headerPlacement() !== "below-input"
 					? { type: "vstack", gap: 0, align: "stretch", entries: [
 						{ component: header, basis: "auto", grow: 0, shrink: 0, minSize: 1 },
 						{ component: hstackHost, basis: 0, grow: 1, shrink: 1, minSize: 1 },

package/lib/shell-sidebar.ts

@@ -3,9 +3,23 @@ import type { Component, TUI } from "@earendil-works/pi-tui";
 // Store on the terminal, not a module singleton: extension loaders may isolate
 // modules, while Pi keeps this terminal across regular/fullscreen transitions.
 const STATE = Symbol.for("gentle-pi.experimental-sidebar.state");
+/** In-process notification after a visual preference is persisted. */
+export const VISUAL_SETTINGS_CHANGED = "gentle-pi.visual-settings-changed";
 export interface SidebarState {
 	active: boolean;
+	visibility?: { todo?: boolean };
 	ownsHost?: () => boolean;
+	/**
+	 * Columns the fullscreen rail reserves at the right edge (rail plus gap)
+	 * while `active && ownsHost()`. Overlays read it to stay inside the editor
+	 * column (the prompt-history picker's right margin) without importing
+	 * gentle-shell.
+	 */
+	railColumns?: number;
+	/** True while Status placement is "hidden": the bottom Status bar paints nothing at any width or mode. */
+	statusHidden?: () => boolean;
+	/** True while a painting top header is the only status row of a narrow fullscreen terminal: the bottom Status bar steps aside. */
+	headerOwnsStatus?: () => boolean;
 	parts: Map<string, SidebarRail>;
 }
 
@@ -32,7 +46,7 @@ export function sidebarPart<T extends Component & { dispose?(): void }>(tui: TUI
 	state.parts.set(key, rail);
 	return {
 		...bottom,
-		render: (width: number) => state.active && state.ownsHost?.() ? [] : bottom.render(width),
+		render: (width: number) => (key === "todo" && state.visibility?.todo === false) || (key === "footer" && (state.statusHidden?.() || state.headerOwnsStatus?.())) || (state.active && state.ownsHost?.()) ? [] : bottom.render(width),
 		dispose() {
 			if (state.parts.get(key) === rail) state.parts.delete(key);
 			bottom.dispose?.();

package/lib/shell-todo.ts

@@ -1,5 +1,5 @@
 import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { CARD_TONE, cardInnerWidth, renderCard, type CardTheme } from "./shell-card.ts";
+import { CARD_TONE, panelHeaderRow, panelInnerWidth, renderCard, type CardTheme, type CardTone } from "./shell-card.ts";
 import { sanitizeTerminalText } from "./terminal-theme.ts";
 import { paintHoverable } from "./shell-hover.ts";
 
@@ -244,11 +244,11 @@ export function todoPromptBlock(state: TodoState, stale: number): string | undef
 	].join("\n") + staleLine;
 }
 
-function taskRow(task: TodoTask, theme: TodoTheme, width: number): string {
+function taskRow(task: TodoTask, theme: TodoTheme, inner: number): string {
 	if (task.status === TODO_STATUS.DONE) {
 		// Wrap before applying SGR 9: every physical title closes its own style
 		// before renderCard adds padding and rails.
-		return wrapTextWithAnsi(task.title, Math.max(1, cardInnerWidth(width) - 2))
+		return wrapTextWithAnsi(task.title, Math.max(1, inner - 2))
 			.map((line, index) => `${index === 0 ? theme.fg(GLYPH_ROLE[task.status], STATUS_GLYPH[task.status]) : " "} ${theme.fg(STATUS_ROLE[task.status], theme.strikethrough(line))}`)
 			.join("\n");
 	}
@@ -259,27 +259,32 @@ function taskRow(task: TodoTask, theme: TodoTheme, width: number): string {
 
 // Long lists keep the card short: done tasks fold into "✓ N done" and the
 // open ones fill the remaining rows, with a trailing count for the rest.
-function bodyRows(state: TodoState, theme: TodoTheme, width: number): string[] {
-	if (state.tasks.length <= ROW_CAP) return state.tasks.map((task) => taskRow(task, theme, width));
+function bodyRows(state: TodoState, theme: TodoTheme, inner: number): string[] {
+	if (state.tasks.length <= ROW_CAP) return state.tasks.map((task) => taskRow(task, theme, inner));
 	const { done } = todoSummary(state);
 	const open = state.tasks.filter((task) => task.status !== TODO_STATUS.DONE);
 	const rows: string[] = [];
 	if (done > 0) rows.push(`${theme.fg(GLYPH_ROLE[TODO_STATUS.DONE], STATUS_GLYPH[TODO_STATUS.DONE])} ${theme.fg(NOTE_ROLE, `${done} done`)}`);
 	const room = ROW_CAP - rows.length - (open.length > ROW_CAP - rows.length ? 1 : 0);
-	for (const task of open.slice(0, room)) rows.push(taskRow(task, theme, width));
+	for (const task of open.slice(0, room)) rows.push(taskRow(task, theme, inner));
 	if (open.length > room) rows.push(theme.fg(NOTE_ROLE, `… ${open.length - room} more`));
 	return rows;
 }
 
-function collapsedRow(state: TodoState, theme: TodoTheme, width: number): string {
+function collapsedRow(state: TodoState, theme: TodoTheme, inner: number): string {
 	const active = state.tasks.find((task) => task.status === TODO_STATUS.IN_PROGRESS);
-	if (active) return taskRow(active, theme, width);
+	if (active) return taskRow(active, theme, inner);
 	const pending = state.tasks.find((task) => task.status === TODO_STATUS.PENDING);
-	if (pending) return taskRow(pending, theme, width);
+	if (pending) return taskRow(pending, theme, inner);
 	const { open } = todoSummary(state);
 	return `${theme.fg(GLYPH_ROLE[TODO_STATUS.PENDING], STATUS_GLYPH[TODO_STATUS.PENDING])} ${theme.fg(NOTE_ROLE, `${open} open`)}`;
 }
 
+/** The tone the Todos card renders in: warning once the list went stale, info otherwise. */
+export function todoCardTone(staleTurns: number): CardTone {
+	return staleTurns >= STALE_AFTER_TURNS ? CARD_TONE.WARNING : CARD_TONE.INFO;
+}
+
 export function renderTodoCard(state: TodoState, theme: TodoTheme, width: number, options: TodoRenderOptions): string[] {
 	if (state.tasks.length === 0) return [];
 	const { done, total } = todoSummary(state);
@@ -288,16 +293,21 @@ export function renderTodoCard(state: TodoState, theme: TodoTheme, width: number
 	const actionLabel = action[0]!.toUpperCase() + action.slice(1);
 	const icon = options.collapsed ? "▸" : "▾";
 	const control = `${icon} ${width >= 28 ? actionLabel : ""}`.trimEnd();
-	const hint = options.collapseKey ? `${options.collapseKey} ${action}` : undefined;
-	const rows = options.collapsed ? [collapsedRow(state, theme, width)] : options.scrollable ? state.tasks.map((task) => taskRow(task, theme, width)) : bodyRows(state, theme, width);
+	const tone = todoCardTone(options.staleTurns);
+	const hint = options.collapseKey
+		? panelHeaderRow(theme, width, tone) ? options.collapseKey : `${options.collapseKey} ${action}`
+		: undefined;
+	// Content columns of the card body in the active style (float is narrower).
+	const inner = panelInnerWidth(theme, width, tone);
+	const rows = options.collapsed ? [collapsedRow(state, theme, inner)] : options.scrollable ? state.tasks.map((task) => taskRow(task, theme, inner)) : bodyRows(state, theme, inner);
 	const body = stale ? [theme.fg(NOTE_ROLE, `stale · ${options.staleTurns} turns`), ...rows] : rows;
 	// The clickable control paints the shared hover role while hovered --
 	// same treatment every other clickable surface uses -- instead of its
 	// ordinary accent role.
 	return renderCard(
-		{ title: `Todos ${paintHoverable(theme, control, options.hovered, "accent")}`, subtitle: `${done} of ${total}`, body, tone: stale ? CARD_TONE.WARNING : CARD_TONE.INFO, glyph: TODO_GLYPH },
+		{ title: `Todos ${paintHoverable(theme, control, options.hovered, "accent")}`, subtitle: `${done} of ${total}`, body, tone, glyph: TODO_GLYPH },
 		theme,
 		width,
-		{ expanded: true, hint },
+		{ expanded: true, hint, panel: true },
 	);
 }

package/lib/shell-usage-view.ts

@@ -1,5 +1,5 @@
 import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
-import { renderUsagePanel, type ActiveProvider, type UsageSourceRegistry, type UsageStore, type UsageTheme } from "./shell-usage.ts";
+import { renderUsagePanel, type ActiveProvider, type UsagePanelScope, type UsageSourceRegistry, type UsageStore, type UsageTheme } from "./shell-usage.ts";
 import { paintHoverable } from "./shell-hover.ts";
 
 // Gentle Shell subscriptions overlay: a framed panel over the usage store.
@@ -12,6 +12,10 @@ export interface UsageViewDeps {
 	// Optional: lets the panel resolve the pending note of a provider whose
 	// usage source was registered at runtime instead of built in.
 	registry?(): UsageSourceRegistry | undefined;
+	// Optional: the targeted routing scope. Without it the panel draws every
+	// provider the store holds; with it, exactly the targeted providers, in
+	// scope order, explaining the ones without data.
+	scope?(): UsagePanelScope | undefined;
 	onRefresh(): Promise<void>;
 	onClose(): void;
 	requestRender(): void;
@@ -80,8 +84,9 @@ export class UsageView {
 	// A failing usage fetch is the store's problem to report (its rows already
 	// carry the last error); the panel only clears its "refreshing" state. The
 	// rejection must never leave this method: an unhandled rejection is fatal
-	// to the whole shell on current Node.
-	private refresh(): void {
+	// to the whole shell on current Node. Public so the overlay can dispatch
+	// its opening refresh instead of making the open wait for it.
+	refresh(): void {
 		if (this.refreshing) return;
 		this.refreshing = true;
 		this.deps.requestRender();
@@ -101,7 +106,7 @@ export class UsageView {
 		const inner = width - 2;
 		const title = this.refreshing ? REFRESHING : TITLE;
 		const top = theme.fg(FRAME_ROLE, "╭─ ") + theme.fg(TITLE_ROLE, title) + theme.fg(FRAME_ROLE, ` ${rule(inner - visibleWidth(title) - 3)}╮`);
-		const body = renderUsagePanel(this.store.all(), theme, inner - 2, this.deps.now(), this.deps.active(), this.deps.registry?.()).map(
+		const body = renderUsagePanel(this.store.all(), theme, inner - 2, this.deps.now(), this.deps.active(), this.deps.registry?.(), this.deps.scope?.()).map(
 			(line) => `${theme.fg(FRAME_ROLE, "│")} ${fit(line, inner - 2)} ${theme.fg(FRAME_ROLE, "│")}`,
 		);
 		const hints = KEYS.map(([key, label]) => ({ key, label, text: `${key} ${label}`, action: (key === "r" ? "refresh" : "close") as HintAction }));

package/lib/shell-usage.ts

@@ -1,4 +1,5 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import { parseModelRef } from "./agents-config.ts";
 import { paintGauge } from "./shell-gauge.ts";
 
 // Gentle Shell subscription usage: the rate-limit windows each connected
@@ -125,6 +126,10 @@ const PENDING_NOTE: Record<string, string> = {
 };
 const UNSUPPORTED_NOTE = "no subscription usage for this provider";
 const ACTIVE_MARK = "✿";
+// What a targeted provider with no snapshot says after a refresh actually ran
+// and answered nothing. Generic on purpose: it names no endpoint, key, or
+// account detail, exactly like the other notes here.
+export const USAGE_FETCH_FAILED_NOTE = "fetch failed · r to retry";
 
 export interface ActiveProvider {
 	provider: string;
@@ -289,7 +294,7 @@ export function parseCodexUsage(payload: unknown, now: number): ProviderUsage {
 	return { provider: CODEX_PROVIDER, plan: typeof raw.plan_type === "string" ? raw.plan_type : undefined, limits, fetchedAt: now };
 }
 
-function headerWindow(headers: Record<string, string>, kind: "primary" | "secondary", now: number): UsageWindow | undefined {
+function headerWindow(headers: Record<string, string>, kind: "primary" | "secondary"): UsageWindow | undefined {
 	const used = Number.parseFloat(headers[`${HEADER_PREFIX}${kind}-used-percent`] ?? "");
 	if (!Number.isFinite(used)) return undefined;
 	const minutes = Number.parseInt(headers[`${HEADER_PREFIX}${kind}-window-minutes`] ?? "", 10);
@@ -299,7 +304,7 @@ function headerWindow(headers: Record<string, string>, kind: "primary" | "second
 }
 
 export function parseCodexHeaders(headers: Record<string, string>, now: number): ProviderUsage | undefined {
-	const windows = [headerWindow(headers, "primary", now), headerWindow(headers, "secondary", now)].filter((window): window is UsageWindow => window !== undefined);
+	const windows = [headerWindow(headers, "primary"), headerWindow(headers, "secondary")].filter((window): window is UsageWindow => window !== undefined);
 	if (windows.length === 0) return undefined;
 	const reached = headers[`${HEADER_PREFIX}rate-limit-reached-type`];
 	return { provider: CODEX_PROVIDER, plan: undefined, limits: [{ name: CODEX_MAIN_LIMIT, windows, limitReached: Boolean(reached) }], fetchedAt: now };
@@ -527,18 +532,66 @@ function updatedAgo(fetchedAt: number, now: number): string {
 	return minutes < 1 ? "updated just now" : `updated ${minutes}m ago`;
 }
 
+// The providers one refresh targets: the session's own provider first, then
+// every provider the active profile's subagent routing names, deduplicated in
+// first-seen order. A qualified ref ("provider/id") resolves directly; a bare
+// model id resolves through the registry callback only when that callback can
+// name exactly one provider, so an ambiguous or unknown ref never guesses one
+// and is dropped instead.
+export function usageScopeProviders(
+	mainProvider: string | undefined,
+	routingModels: ReadonlyArray<string | undefined> | undefined,
+	resolveBareModel?: (modelId: string) => string | undefined,
+): string[] {
+	const providers = new Set<string>();
+	if (mainProvider) providers.add(mainProvider);
+	for (const model of routingModels ?? []) {
+		const ref = parseModelRef(model);
+		if (!ref) continue;
+		const provider = ref.provider ?? resolveBareModel?.(ref.id);
+		if (provider) providers.add(provider);
+	}
+	return [...providers];
+}
+
+// The current routing scope the panel draws: which providers are targeted, and
+// which of them failed their latest settled refresh. A provider recorded
+// earlier but no longer targeted is simply absent — it is not current scope.
+export interface UsagePanelScope {
+	providers: readonly string[];
+	// Actual failures only: a refresh that settled without a snapshot. A
+	// provider still fetching is never in here, so an in-flight refresh cannot
+	// read as failed, and a successful refresh removes the provider again.
+	failed: ReadonlySet<string>;
+}
+
 // The active provider comes first, marked with the petal, and explains
 // itself when it has no data yet. Other providers seen this session follow.
-export function renderUsagePanel(usages: ProviderUsage[], theme: UsageTheme, width: number, now: number, active?: ActiveProvider, registry?: UsageSourceRegistry): string[] {
+// With a scope, the panel draws exactly the targeted providers in scope order:
+// one with no snapshot explains itself (its latest refresh failed, or its
+// pending note otherwise), one whose latest refresh failed after a good
+// snapshot keeps that snapshot and says so beside it, and a provider recorded
+// under a previous profile's routing is never presented as current scope after
+// a profile switch.
+export function renderUsagePanel(usages: ProviderUsage[], theme: UsageTheme, width: number, now: number, active?: ActiveProvider, registry?: UsageSourceRegistry, scope?: UsagePanelScope): string[] {
 	const activeUsage = active ? usages.find((usage) => usage.provider === active.provider) : undefined;
-	const others = usages.filter((usage) => usage !== activeUsage);
-	if (!active && usages.length === 0) return [truncateToWidth(USAGE_EMPTY_MESSAGE, width, "…")];
+	const byProvider = new Map(usages.map((usage) => [usage.provider, usage] as const));
+	const rows = scope
+		? scope.providers.map((provider) => ({ provider, usage: byProvider.get(provider) }))
+		: [...(active ? [{ provider: active.provider, usage: activeUsage }] : []), ...usages.filter((usage) => usage !== activeUsage).map((usage) => ({ provider: usage.provider, usage }))];
+	if (rows.length === 0) return [truncateToWidth(USAGE_EMPTY_MESSAGE, width, "…")];
 	const lines: string[] = [];
-	if (active && !activeUsage) {
-		lines.push(`${theme.fg(ROLE.LIMIT, ACTIVE_MARK)} ${theme.fg(ROLE.PROVIDER, active.provider)} ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.RESET, providerNote(active.provider, registry))}`);
-	}
-	for (const usage of [...(activeUsage ? [activeUsage] : []), ...others]) {
-		const mark = usage === activeUsage ? `${theme.fg(ROLE.LIMIT, ACTIVE_MARK)} ` : "";
+	for (const row of rows) {
+		const mark = active?.provider === row.provider ? `${theme.fg(ROLE.LIMIT, ACTIVE_MARK)} ` : "";
+		if (!row.usage) {
+			// A settled refresh that answered nothing is a failure; a provider
+			// whose usage arrives with responses (Anthropic) or that has not
+			// failed keeps its pending note.
+			const note = scope?.failed.has(row.provider) ? USAGE_FETCH_FAILED_NOTE : providerNote(row.provider, registry);
+			lines.push(`${mark}${theme.fg(ROLE.PROVIDER, row.provider)} ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.RESET, note)}`);
+			continue;
+		}
+		const usage = row.usage;
 		const plan = usage.plan ? ` ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.PLAN, usage.plan)}` : "";
 		lines.push(`${mark}${theme.fg(ROLE.PROVIDER, usage.provider)}${plan} ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.RESET, updatedAgo(usage.fetchedAt, now))}`);
 		// One row per window: the limit name, its meter, its percentage and the reset
@@ -555,6 +608,9 @@ export function renderUsagePanel(usages: ProviderUsage[], theme: UsageTheme, wid
 			const tail = reset.length > 0 ? ` ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.RESET, reset)}` : "";
 			lines.push(`  ${theme.fg(ROLE.LABEL, row.name.padEnd(nameWidth))} ${paintMeter(row.window.usedPercent, PANEL_METER_CELLS, theme)} ${theme.fg(ROLE.PERCENT, percent)}${tail}`);
 		}
+		// A failure after a good snapshot never hides either fact: the last good
+		// snapshot stays on its rows and the failed refresh says so beside it.
+		if (scope?.failed.has(row.provider)) lines.push(`  ${theme.fg(ROLE.RESET, USAGE_FETCH_FAILED_NOTE)}`);
 	}
 	return lines.map((line) => truncateToWidth(line, width, "…"));
 }