pi-bar 0.3.41 → 0.3.44

package/README.md

@@ -6,7 +6,7 @@
 **Never accidentally run Opus on a typo again.** pi-bar keeps your model, thinking level, context pressure, a live progress update, and any extension statuses visible in pi's footer.
 
 ```text
-claude-opus-4.7  ❯  think:med  ❯  2.6% / 1.0M  ❯  Reviewing package structure  ❯  plan:active ❯ queue:2
+claude-opus-4.7  ❯  think:med  ❯  2.6% / 1.0M  ❯  Reviewing package structure  ❯  Plan active  ❯  Queue: 2
 ```
 
 ![pi-bar with low context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.38/assets/screenshot-green.png)
@@ -35,6 +35,20 @@ If pi is already running after install, reload resources:
 /reload
 ```
 
+## Automatic layout
+
+The footer adapts to terminal width without extra configuration:
+
+- **Model, thinking level, and context percentage take priority.**
+- Separators have two spaces on each side by default, for a roomier display.
+- Progress text shrinks first. If space is still tight, separator padding reduces to one space per side before compacting content. CWD then compacts from its preferred path to `parent/project`, then `project`; context window size is omitted when needed. An enabled provider prefix can yield before the model name is clipped.
+- Optional token totals, cost, and cache-hit ratio yield whole under width pressure, before overflowing extension badges. Numeric metrics are never shown partially.
+- Extension badges stay in their published order. Badges that cannot fit are hidden whole, with `+N` showing how many are behind the overflow. Open `/bar status` to inspect their text and visibility by key.
+- On very narrow terminals, progress and CWD yield to core information. If even the core cannot fit, the model name is truncated first. At extreme widths, not every value or overflow count can remain visible.
+- Widening the terminal restores the full display. Thinking and context retain their semantic colors throughout.
+
+Existing visibility settings still apply. CWD, usage metrics, and the provider prefix are opt-in; the default footer is unchanged.
+
 ## Customization
 
 pi-bar works out of the box. Run `/bar` inside pi to choose which footer segments and extension statuses are shown:
@@ -43,7 +57,7 @@ pi-bar works out of the box. Run `/bar` inside pi to choose which footer segment
 /bar
 ```
 
-Toggle `Model`, `Thinking level`, `Context usage`, `Current directory`, `Progress update`, and `Extension statuses` between `shown` and `hidden`. If other extensions have published status badges, `/bar` also shows fine-grained `Status: <key>` rows plus a `New extension statuses` default. You can also use commands:
+Toggle `Model`, `Thinking level`, `Context usage`, `Cache hit ratio`, `Estimated session cost`, `Session token totals`, `Current directory`, `Progress update`, and `Extension statuses` between `shown` and `hidden`. `Show provider` controls the optional prefix inside the model segment. `Progress model` opens a searchable model picker. If other extensions have published status badges, `/bar` also shows fine-grained `Status: <key>` rows plus a `New extension statuses` default. You can also use commands:
 
 ```text
 /bar segments list
@@ -52,7 +66,9 @@ Toggle `Model`, `Thinking level`, `Context usage`, `Current directory`, `Progres
 /bar segments show thinking
 ```
 
-Allowed segments are `model`, `thinking`, `context`, `cwd`, `progress`, and `extensions`. The `cwd` segment is off by default. The `progress` segment stays hidden until pi-bar has a current update. The `extensions` segment stays hidden when no extension has set a status.
+Allowed segments are `model`, `thinking`, `context`, `cache_hit_ratio`, `cost`, `tokens`, `cwd`, `progress`, and `extensions`. The `cwd`, `cache_hit_ratio`, `cost`, and `tokens` segments are off by default. The `progress` segment stays hidden until pi-bar has a current update. The `extensions` segment stays hidden when no extension has set a status.
+
+Tab completes `/bar` subcommands, actions, segment names, known status keys, and configured progress-model IDs. Completion preserves preceding arguments, including comma-separated lists such as `/bar segments show model,ca`.
 
 You can also set startup defaults with environment variables before launching pi:
 
@@ -85,21 +101,83 @@ The cap must be an integer of at least 8; invalid values use 36. Very long direc
 
 This is Pi's session working directory (`ctx.cwd`), not a live shell directory: `cd` inside a tool command does not change it. Visibility persists through the existing `/bar` configuration.
 
+### Show the model provider
+
+Provider prefixes are hidden by default. Enable `Show provider` in `/bar`, or use:
+
+```text
+/bar provider show
+/bar provider hide
+/bar provider
+```
+
+The last command reports the current setting. The choice persists as `showProvider` in `~/.pi/agent/pi-bar.json`; an absent setting means `false`.
+
+```text
+claude-opus-4.7             # default
+anthropic/claude-opus-4.7   # direct provider, enabled
+openrouter/claude-opus-4.7  # routed provider, enabled
+```
+
+The prefix uses the actual model provider, not a namespace embedded in the model ID. It stays inside the model segment: hiding `model` hides both. Under width pressure, the prefix yields before clipping the model name and returns when space is available.
+
+### Show cache, cost, and token metrics
+
+Enable any of the optional metrics through `/bar` or the existing segment commands:
+
+```text
+/bar segments show cache_hit_ratio cost tokens
+```
+
+```text
+claude-opus-4.7  ❯  think:med  ❯  2.6% / 1.0M  ❯  CH:84%  ❯  ≈$0.123  ❯  ↑12k ↓3k
+```
+
+| Segment | Meaning |
+| --- | --- |
+| `cache_hit_ratio` | Latest active-branch assistant prompt's cache-read percentage: `cacheRead / (input + cacheRead + cacheWrite)`. Hidden when that response has no reported prompt usage. Restored on resume and `/tree`; tool, summary, and progress calls do not replace this value. |
+| `cost` | Estimated dollar cost for recorded usage in the current session file. `≈` means an estimate, **not an invoice**. |
+| `tokens` | Cumulative input (`↑`, including cache reads and writes) and output (`↓`, including reported reasoning tokens). These are usage totals, not current context size or tokens/sec. |
+
+Cost and token totals include assistant responses, usage reported by tools, compaction/branch summaries, and pi-bar progress calls. They include all branches in the current session file, so `/tree` does not erase prior spend; `/new` starts fresh. Both stay hidden until usage is available. A zero-cost response with token usage still shows `≈$0.000`.
+
+Progress usage is saved as numeric-only `pi-bar-progress-usage` custom entries, without prompts or response text. These entries survive reloads but are not sent to the main model. Older sessions may lack progress-call usage. Requests with no reported usage, including some failed/interrupted calls, cannot be counted.
+
+Prices come from the usage estimates Pi/providers report. Subscription allowances, invoices, and missing/custom model pricing can differ; a reported zero is not a billing guarantee. Metrics make no additional model requests. Usage is aggregated at lifecycle events, not by scanning history on every footer render.
+
 ### Configure live progress updates
 
 pi-bar shows a short, plain-English description of what pi is working on right now. It refreshes as pi works and resets when you switch branches in the session tree, so stale updates never follow you across tasks. Hide `Progress update` in `/bar`, run `/bar segments hide progress`, or set `PI_BAR_SHOW` without `progress` to disable it.
 
-Pick a specific model for the update by setting the env var or pi settings:
+**Pick a model interactively:** open `/bar`, select `Progress model` directly below `Progress update`, and press Enter. Type a provider or model ID (for example `gpt`), then press Enter to select. Esc cancels without changing the preference. The picker shows models with configured Pi credentials and an `Auto` option; it does not validate keys or make model requests.
+
+**Or use commands with Tab completion:**
+
+```text
+/bar progress-model
+/bar progress-model openai/gpt-4.1-mini
+/bar progress-model auto
+```
+
+The first command reports the effective preference. After `/bar progress-model `, Tab offers `auto` and models with configured Pi credentials. Search by provider or model fragment, such as `gpt` or `haiku`; completion inserts the full `provider/model` ID, including any nested namespace. Suggestions use the current local model catalog, without refreshing catalogs, resolving credentials, or making model requests. Unknown/unavailable model arguments leave the preference unchanged.
+
+The choice saves as `progressModel` in `~/.pi/agent/pi-bar.json` (or `PI_BAR_CONFIG`) for all projects. It applies to subsequent progress updates without `/reload`, cancels pending old-model updates, and leaves your main chat model and credentials unchanged. Choosing a model does not enable a hidden progress segment.
+
+`Auto` tries fast Codex models, then Anthropic Haiku. To use an OpenAI API key instead of a Codex subscription, choose an **`openai/...`** model explicitly, such as `openai/gpt-4.1-mini`. Progress uses that provider's normal Pi credentials; no separate pi-bar key is needed. Configured but revoked credentials can still fail.
+
+You can also set a model before launching Pi:
 
 ```bash
-PI_BAR_PROGRESS_MODEL=anthropic/claude-haiku-4-5 pi
+PI_BAR_PROGRESS_MODEL=openai/gpt-4.1-mini pi
 ```
 
-Or in pi settings: `bar.progressModel`. Otherwise pi-bar picks a fast model you are already authenticated with.
+Preference order: `PI_BAR_PROGRESS_MODEL` → saved pi-bar `progressModel` → project Pi settings → global Pi settings → Auto. Within each Pi settings scope, `bar.progressModel` takes precedence over the legacy `progress.model` setting. A nonempty environment override makes both the picker and command read-only and suppresses model-value completion; unset it and restart Pi to choose another model. A saved `"auto"` explicitly enables automatic selection rather than falling back to Pi settings. Remove `progressModel` from the pi-bar config to use Pi settings again.
 
 ### Configure extension statuses
 
-Other pi extensions can publish small status badges. Pi-bar collects them into the `extensions` segment, strips embedded terminal colors, and separates each badge with the same `❯` divider used by other footer segments. Run `/bar` or `/bar status` inside pi to pick which ones to show:
+Other pi extensions can publish small status badges. Pi-bar displays their text as written, without prepending internal keys: `setStatus("mcp", "MCP: 2/2 servers")` appears as `MCP: 2/2 servers`, not `mcp:MCP: 2/2 servers`. Extensions should publish self-describing text; pi-bar does not guess labels for bare values.
+
+Pi-bar strips embedded terminal colors and control sequences, and separates each badge with the same `❯` divider used by other footer segments. Keys remain available for filtering and identification in `/bar`; selecting a status row shows its current sanitized text. Run `/bar` or `/bar status` inside pi to inspect statuses or pick which ones to show:
 
 ```text
 /bar status
@@ -130,7 +208,7 @@ npm test
 npm run check
 ```
 
-Tests cover path formatting, terminal safety, width limits, and segment visibility/persistence. Test configuration mirrors Pi's `pi-ai/compat` loader alias; runtime dependencies remain optional peers supplied by Pi.
+Tests cover path formatting, display-ready statuses, responsive layout, all 512 segment visibility combinations, terminal safety, ANSI/Unicode widths, provider settings, progress-model selection, command completion, usage accounting, progress-call persistence, session/tree lifecycle, and config persistence. Test configuration mirrors Pi's `pi-ai/compat` loader alias; runtime dependencies remain optional peers supplied by Pi.
 
 ## Security note
 

package/extensions/status-footer.ts

@@ -2,7 +2,7 @@
  * pi-bar — footer / statusline extension.
  *
  * Replaces pi's built-in footer with left-aligned segments:
- *   <model> ❯ think:<level> ❯ <context% / window> ❯ [cwd] ❯ <progress> ❯ <extensions>
+ *   <model> ❯ think:<level> ❯ <context% / window> ❯ [metrics] ❯ [cwd] ❯ <progress> ❯ <extensions>
  *
  * Example:
  *   claude-opus-4.7  ❯  think:med  ❯  2.6% / 1.0M  ❯  Reviewing package structure
@@ -21,7 +21,7 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, posix, win32 } from "node:path";
-import { complete, type UserMessage } from "@earendil-works/pi-ai";
+import { complete, type Usage, type UserMessage } from "@earendil-works/pi-ai";
 import {
 	getSettingsListTheme,
 	SettingsManager,
@@ -31,13 +31,15 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
 	Container,
+	type AutocompleteItem,
 	type SettingItem,
 	SettingsList,
 	truncateToWidth,
 	visibleWidth,
 } from "@earendil-works/pi-tui";
+import { FooterUsageTracker, hasUsage, PROGRESS_USAGE_ENTRY_TYPE, totalsFromUsage } from "./usage.js";
 
-type SegmentName = "model" | "thinking" | "context" | "cwd" | "progress" | "extensions";
+type SegmentName = "model" | "thinking" | "context" | "cache_hit_ratio" | "cost" | "tokens" | "cwd" | "progress" | "extensions";
 type StatusFilter =
 	| { mode: "all"; hidden: Set<string> }
 	| { mode: "only"; shown: Set<string> };
@@ -47,6 +49,8 @@ type SerializedStatusFilter =
 type GlobalBarConfig = {
 	statusFilter?: SerializedStatusFilter;
 	segments?: SegmentName[];
+	showProvider?: boolean;
+	progressModel?: string;
 };
 type ProgressActivityType =
 	| "user_message"
@@ -120,6 +124,9 @@ const ALL_SEGMENTS: readonly SegmentName[] = [
 	"model",
 	"thinking",
 	"context",
+	"cache_hit_ratio",
+	"cost",
+	"tokens",
 	"cwd",
 	"progress",
 	"extensions",
@@ -128,6 +135,9 @@ const SEGMENT_LABELS: Record<SegmentName, string> = {
 	model: "Model",
 	thinking: "Thinking level",
 	context: "Context usage",
+	cache_hit_ratio: "Cache hit ratio",
+	cost: "Estimated session cost",
+	tokens: "Session token totals",
 	cwd: "Current directory",
 	progress: "Progress update",
 	extensions: "Extension statuses",
@@ -136,7 +146,6 @@ const DEFAULT_WARNING_THRESHOLD = 70;
 const DEFAULT_ERROR_THRESHOLD = 90;
 
 const SEGMENT_SEPARATOR = "❯";
-const EXTENSION_STATUS_SEPARATOR = SEGMENT_SEPARATOR;
 
 function formatTokens(n: number): string {
 	if (n >= 1_000_000) {
@@ -150,10 +159,17 @@ function formatTokens(n: number): string {
 	return `${n}`;
 }
 
-function formatModelName(id: string | undefined): string {
+export function formatModelName(
+	model: { id: string; provider?: string } | undefined,
+	showProvider = false,
+): string {
+	const id = stripTerminalControls(model?.id ?? "");
 	if (!id) return "no-model";
-	const base = id.includes("/") ? (id.split("/").pop() ?? id) : id;
-	return base.replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "");
+	const base = id.split("/").filter(Boolean).at(-1) ?? id;
+	const name = base.replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "");
+	// The namespace in a model ID is not necessarily its routing provider.
+	const provider = stripTerminalControls(model?.provider ?? "");
+	return showProvider && provider ? `${provider}/${name}` : name;
 }
 
 const DEFAULT_CWD_MAX_WIDTH = 36;
@@ -195,6 +211,117 @@ export function formatCwd(
 	return truncateToWidth(compact, maxWidth);
 }
 
+/** Preferred directory display, then parent/project, then project only. */
+export function cwdVariants(
+	cwd: string,
+	home = homedir(),
+	maxWidth = DEFAULT_CWD_MAX_WIDTH,
+	paths = process.platform === "win32" ? win32 : posix,
+): string[] {
+	const safeCwd = stripTerminalControls(cwd);
+	const leaf = paths.basename(safeCwd);
+	const parent = paths.basename(paths.dirname(safeCwd));
+	return [
+		formatCwd(cwd, home, maxWidth, paths),
+		...[parent && leaf ? `${parent}${paths.sep}${leaf}` : leaf, leaf]
+			.filter(Boolean)
+			.map((text) => truncateToWidth(stripTerminalControls(text), maxWidth, "…")),
+	].map(stripTerminalControls);
+}
+
+export type FooterSegment = {
+	name: SegmentName;
+	text: string;
+	/** Shorter, already styled representations, in preference order. */
+	alternatives?: readonly string[];
+};
+
+/** Pure, column-aware layout. The divider may be styled but has no padding. Never split a status badge. */
+export function layoutFooter(
+	segments: readonly FooterSegment[],
+	badges: readonly string[],
+	width: number,
+	divider = SEGMENT_SEPARATOR,
+): string {
+	if (!Number.isFinite(width) || width <= 0) return "";
+	width = Math.floor(width);
+	let separator = `  ${divider}  `;
+	const items = segments.map((segment) => ({ ...segment }));
+	const extensions = items.find((item) => item.name === "extensions");
+	let shownBadges = badges.length;
+	const updateBadges = () => {
+		if (!extensions) return;
+		const hidden = badges.length - shownBadges;
+		extensions.text = [...badges.slice(0, shownBadges), ...(hidden ? [`+${hidden}`] : [])].join(separator);
+	};
+	updateBadges();
+	const line = () => items.map((item) => item.text).filter(Boolean).join(separator);
+	const overflow = () => visibleWidth(line()) - width;
+	const progress = items.find((item) => item.name === "progress");
+	if (progress && overflow() > 0) {
+		const currentWidth = visibleWidth(progress.text);
+		// Keep a short activity fragment while trying the other compact forms.
+		const minimumWidth = Math.min(12, width);
+		const progressWidth = Math.min(currentWidth, Math.max(minimumWidth, currentWidth - overflow()));
+		progress.text = truncateToWidth(progress.text, progressWidth, "…");
+	}
+	// Keep the roomy default while progress alone can absorb width pressure.
+	// Tighten gaps before compacting paths/context or overflowing whole badges.
+	if (overflow() > 0) {
+		separator = ` ${divider} `;
+		updateBadges();
+	}
+	for (const name of ["cwd", "context", "thinking", "model"] as const) {
+		const item = items.find((item) => item.name === name);
+		if (!item) continue;
+		for (const alternative of item.alternatives ?? []) {
+			if (overflow() <= 0) break;
+			if (visibleWidth(alternative) < visibleWidth(item.text)) item.text = alternative;
+		}
+	}
+	// Optional metrics yield whole, never leaving a misleading partial number.
+	for (const name of ["tokens", "cost", "cache_hit_ratio"] as const) {
+		if (overflow() <= 0) break;
+		const item = items.find((item) => item.name === name);
+		if (item) item.text = "";
+	}
+	while (extensions && shownBadges > 0 && overflow() > 0) {
+		shownBadges--;
+		updateBadges();
+	}
+	// On very narrow terminals, remove optional content before clipping identity.
+	for (const name of ["progress", "cwd", "extensions"] as const) {
+		if (overflow() <= 0) break;
+		const item = items.find((item) => item.name === name);
+		if (item) {
+			item.text = name === "cwd"
+				? truncateToWidth(item.text, Math.max(0, visibleWidth(item.text) - overflow()), "…")
+				: "";
+		}
+	}
+	const model = items.find((item) => item.name === "model");
+	if (model && overflow() > 0) {
+		model.text = truncateToWidth(model.text, Math.max(0, visibleWidth(model.text) - overflow()), "…");
+	}
+	// Whole-badge overflow can free more space than needed. Use that space rather
+	// than leaving unnecessarily compact context, paths, or progress on screen.
+	for (const name of ["model", "context", "thinking", "cwd", "progress"] as const) {
+		const item = items.find((item) => item.name === name);
+		const original = segments.find((segment) => segment.name === name);
+		if (!item?.text || !original) continue;
+		const budget = visibleWidth(item.text) - overflow();
+		if (name === "progress") {
+			item.text = truncateToWidth(original.text, Math.max(0, budget), "…");
+		} else {
+			const preferred = [original.text, ...(original.alternatives ?? [])]
+				.find((text) => visibleWidth(text) <= budget);
+			if (preferred !== undefined) item.text = preferred;
+		}
+	}
+	// A terminal narrower than thinking + context cannot show every core value.
+	return truncateToWidth(line(), width, "…");
+}
+
 function thinkingColor(level: string): ThemeColor {
 	switch (level) {
 		case "off":
@@ -276,7 +403,7 @@ function parseThresholds(): { warningThreshold: number; errorThreshold: number }
 
 function parseProgressModelSpec(value: string): ProgressModelPreference | undefined {
 	const trimmed = value.trim();
-	if (!trimmed || trimmed === "auto") return undefined;
+	if (!trimmed || trimmed === "auto" || /[\s\x00-\x1f\x7f-\x9f]/u.test(trimmed)) return undefined;
 	const separator = trimmed.indexOf("/");
 	if (separator <= 0 || separator === trimmed.length - 1) return undefined;
 	return { provider: trimmed.slice(0, separator), id: trimmed.slice(separator + 1) };
@@ -298,10 +425,14 @@ function settingsModelValue(settings: Record<string, unknown>): string | undefin
 	return undefined;
 }
 
-function resolveProgressModelPreference(cwd: string): ProgressModelPreference | undefined {
+export function resolveProgressModelPreference(cwd: string): ProgressModelPreference | undefined {
 	const envModel = process.env.PI_BAR_PROGRESS_MODEL;
 	if (envModel) return parseProgressModelSpec(envModel);
 
+	// An explicit /bar choice wins over legacy Pi settings, including "auto".
+	const savedModel = readGlobalConfig().progressModel;
+	if (savedModel !== undefined) return parseProgressModelSpec(savedModel);
+
 	const settings = SettingsManager.create(cwd);
 	const projectModel = settingsModelValue(
 		settings.getProjectSettings() as Record<string, unknown>,
@@ -324,8 +455,64 @@ const FAST_PROGRESS_MODELS: readonly ProgressModelPreference[] = [
 	{ provider: "anthropic", id: "claude-haiku-4-5-20251001" },
 ];
 
-function formatProgressModelKey(model: ProgressModelPreference): string {
-	return `${model.provider}/${model.id}`;
+function formatProgressModelKey(model: ProgressModelPreference | undefined): string {
+	return model ? `${model.provider}/${model.id}` : "auto";
+}
+
+function parseSerializedProgressModel(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	if (value.trim() === "auto") return "auto";
+	const model = parseProgressModelSpec(value);
+	return model ? formatProgressModelKey(model) : undefined;
+}
+
+function createProgressModelPicker(
+	ctx: ExtensionContext,
+	currentValue: string,
+	done: (value?: string) => void,
+): SettingsList {
+	// Availability is a local snapshot of configured credentials, not a key
+	// validation request. Never resolve or display credentials in this UI.
+	const choices = new Map<string, SettingItem>();
+	for (const model of ctx.modelRegistry.getAvailable()) {
+		const key = formatProgressModelKey(model);
+		if (parseSerializedProgressModel(key) !== key) continue;
+		choices.set(key, {
+			id: key,
+			label: key,
+			currentValue: key === currentValue ? "selected" : "",
+			description: `${key} — ${stripTerminalControls(model.name)}. Uses this provider's Pi credentials.`,
+			values: ["selected"],
+		});
+	}
+	const items: SettingItem[] = [{
+		id: "auto",
+		label: "Auto",
+		currentValue: currentValue === "auto" ? "selected" : "",
+		description: choices.size > 0
+			? "Try fast Codex models, then Anthropic Haiku. Choose an openai/ model explicitly to use an OpenAI API key."
+			: "No models with configured credentials. Use /login, then reopen this picker.",
+		values: ["selected"],
+	}];
+	if (currentValue !== "auto" && !choices.has(currentValue)) {
+		items.push({
+			id: currentValue,
+			label: stripTerminalControls(currentValue),
+			currentValue: "unavailable",
+			description: "Current preference is not in Pi's available models. Use /login or choose another model.",
+		});
+	}
+	items.push(...[...choices.values()].sort((a, b) => a.id.localeCompare(b.id)));
+	const picker = new SettingsList(
+		items,
+		Math.min(items.length + 2, 14),
+		getSettingsListTheme(),
+		(id) => done(id),
+		() => done(),
+		{ enableSearch: true },
+	);
+	picker.selectItem(currentValue);
+	return picker;
 }
 
 async function getModelAuth(
@@ -703,12 +890,19 @@ class FooterProgressEngine {
 	private normalCheckpointTimer?: ReturnType<typeof setTimeout>;
 	private normalCheckpointBurstStartedAt?: number;
 
-	constructor(private readonly requestRender: () => void) {}
+	constructor(
+		private readonly requestRender: () => void,
+		private readonly createUsageRecorder: (ctx: ExtensionContext) => (usage: Usage) => void,
+	) {}
 
 	text(): string | null {
 		return this.currentText;
 	}
 
+	modelKey(): string {
+		return formatProgressModelKey(this.configuredModel);
+	}
+
 	startSession(cwd: string): void {
 		this.configuredModel = resolveProgressModelPreference(cwd);
 		this.facts.resetConversation();
@@ -954,6 +1148,7 @@ class FooterProgressEngine {
 
 			abortController = new AbortController();
 			this.abortController = abortController;
+			const recordUsage = this.createUsageRecorder(ctx);
 			const response = await complete(
 				auth.model,
 				{ systemPrompt: checkpointSystemPrompt(job), messages: [prompt] },
@@ -967,6 +1162,9 @@ class FooterProgressEngine {
 					signal: abortController.signal,
 				},
 			);
+			// A superseded/aborted request can still report billed usage. Account for
+			// it even when its text must no longer be displayed.
+			recordUsage(response.usage);
 			if (!this.isCurrentJob(job) || response.stopReason !== "stop") return;
 
 			const rawText = extractTextContent(response.content) ?? "";
@@ -1566,7 +1764,7 @@ function shouldShowStatus(key: string, filter: StatusFilter): boolean {
 	return !filter.hidden.has(key);
 }
 
-function formatExtensionStatuses(
+export function formatExtensionStatuses(
 	statuses: ReadonlyMap<string, string>,
 	filter: StatusFilter,
 	seenStatusKeys: Set<string>,
@@ -1577,9 +1775,7 @@ function formatExtensionStatuses(
 			seenStatusKeys.add(key);
 			return shouldShowStatus(key, filter);
 		})
-		.map(([key, text]) =>
-			`${stripTerminalControls(key)}:${stripTerminalControls(text)}`,
-		);
+		.map(([, text]) => stripTerminalControls(text));
 
 	return parts.length > 0 ? parts : null;
 }
@@ -1652,6 +1848,8 @@ function readGlobalConfig(): GlobalBarConfig {
 		return {
 			statusFilter: statusFilter ? serializeStatusFilter(statusFilter) : undefined,
 			segments: parseSerializedSegments(data.segments) ?? undefined,
+			showProvider: typeof data.showProvider === "boolean" ? data.showProvider : undefined,
+			progressModel: parseSerializedProgressModel(data.progressModel),
 		};
 	} catch {
 		return {};
@@ -1684,6 +1882,68 @@ function writeGlobalSegments(segments: readonly SegmentName[]): void {
 	writeGlobalConfig({ ...existing, segments: serializeSegments(segments) });
 }
 
+/** Pi replaces the entire argument prefix, not just its last word. */
+export function completeBarArguments(
+	prefix: string,
+	knownStatusKeys: readonly string[] = [],
+	progressModelKeys: readonly string[] = [],
+): AutocompleteItem[] | null {
+	const words = prefix.trimStart().split(/\s+/);
+	let fragment = words.at(-1) ?? "";
+	let stem = prefix.slice(0, prefix.length - fragment.length);
+	let candidates: readonly string[];
+	let selected: string[] = [];
+	let segmentValues = false;
+	let modelValues = false;
+	const section = words[0];
+	const segmentSection = section === "segments" || section === "segment" || section === "footer";
+	const statusSection = section === "status" || section === "statuses";
+
+	if (words.length === 1) {
+		candidates = ["config", "segments", "status", "provider", "progress-model", "list"];
+	} else if (words.length === 2 && (segmentSection || statusSection)) {
+		candidates = ["list", "all", "none", "only", "show", "hide", "config"];
+	} else if (words.length === 2 && section === "provider") {
+		candidates = ["show", "hide"];
+	} else if (words.length === 2 && section === "progress-model") {
+		modelValues = true;
+		candidates = ["auto", ...[...new Set(progressModelKeys.filter(
+			(key) => typeof key === "string" && key !== "auto" && parseSerializedProgressModel(key) === key,
+		))].sort()];
+	} else if ((segmentSection || statusSection) && ["only", "show", "hide"].includes(words[1])) {
+		const comma = fragment.lastIndexOf(",");
+		const priorValues = fragment.slice(0, comma + 1);
+		stem += priorValues;
+		fragment = fragment.slice(comma + 1);
+		selected = [...words.slice(2, -1), priorValues].join(" ").split(/[\s,]+/).filter(Boolean);
+		segmentValues = segmentSection;
+		// Keys containing delimiters/controls are still configurable in the UI,
+		// but cannot be represented safely by the existing command grammar.
+		candidates = segmentSection ? ALL_SEGMENTS : [...new Set(knownStatusKeys)].filter(
+			(key) => typeof key === "string" && key.length > 0 && !/[\s,\x00-\x1f\x7f-\x9f]/u.test(key),
+		).sort();
+	} else {
+		return null;
+	}
+
+	const normalize = (value: string) => segmentValues || modelValues ? value.toLowerCase() : value;
+	const used = new Set(selected.map(normalize));
+	const query = normalize(fragment);
+	const matches = candidates
+		.filter((value) => {
+			const normalized = normalize(value);
+			return (modelValues ? normalized.includes(query) : normalized.startsWith(query)) && !used.has(normalized);
+		})
+		.map((value) => ({
+			value: `${stem}${value}`,
+			label: value,
+			description: segmentValues && isSegmentName(value) ? SEGMENT_LABELS[value]
+				: modelValues ? value === "auto" ? "Automatic fast-model selection" : "Progress model"
+				: undefined,
+		}));
+	return matches.length > 0 ? matches : null;
+}
+
 function getKnownStatusKeys(filter: StatusFilter, seenStatusKeys: Set<string>): string[] {
 	const keys = new Set(seenStatusKeys);
 	if (filter.mode === "only") {
@@ -1698,9 +1958,36 @@ export default function (pi: ExtensionAPI) {
 	let requestRender: (() => void) | undefined;
 	let statusFilter: StatusFilter = { mode: "all", hidden: new Set() };
 	let visibleSegments: SegmentName[] = readGlobalSegments() ?? DEFAULT_SEGMENTS;
+	let showProvider = readGlobalConfig().showProvider ?? false;
 	const seenStatusKeys = new Set<string>();
+	let currentStatuses: ReadonlyMap<string, string> = new Map();
+	let completionModelRegistry: ExtensionContext["modelRegistry"] | undefined;
+	const statusDescription = (key: string) =>
+		stripTerminalControls(currentStatuses.get(key) ?? "") || "No current status text";
 	const refresh = () => requestRender?.();
-	const progress = new FooterProgressEngine(refresh);
+	const usageTracker = new FooterUsageTracker();
+	const syncUsage = (ctx: ExtensionContext, restoreBranch = false) => {
+		usageTracker.syncEntries(ctx.sessionManager.getEntries());
+		if (restoreBranch) usageTracker.restoreBranch(ctx.sessionManager.getBranch());
+	};
+	let sessionEpoch = 0;
+	let sessionOpen = false;
+	const progress = new FooterProgressEngine(refresh, (ctx) => {
+		const epoch = sessionEpoch;
+		return (usage) => {
+			// Never append a late response into a replacement/reloaded session.
+			if (!sessionOpen || epoch !== sessionEpoch) return;
+			const totals = totalsFromUsage(usage);
+			if (!hasUsage(totals)) return;
+			try {
+				pi.appendEntry(PROGRESS_USAGE_ENTRY_TYPE, totals);
+				syncUsage(ctx);
+				refresh();
+			} catch {
+				// Usage persistence is best effort; do not discard a valid progress update.
+			}
+		};
+	});
 	const restoreStatusFilter = (ctx: ExtensionContext) => {
 		let restoredFilter = readGlobalStatusFilter();
 		if (!restoredFilter) {
@@ -1716,6 +2003,29 @@ export default function (pi: ExtensionAPI) {
 		writeGlobalStatusFilter(statusFilter);
 		refresh();
 	};
+	const setShowProvider = (value: boolean) => {
+		showProvider = value;
+		writeGlobalConfig({ ...readGlobalConfig(), showProvider });
+		refresh();
+	};
+	const setProgressModel = (value: string, ctx: ExtensionContext): boolean => {
+		if (process.env.PI_BAR_PROGRESS_MODEL) {
+			ctx.ui.notify("Progress model is controlled by PI_BAR_PROGRESS_MODEL. Unset it and restart Pi to choose here.", "warning");
+			return false;
+		}
+		const model = parseSerializedProgressModel(value);
+		if (!model) return false;
+		try {
+			writeGlobalConfig({ ...readGlobalConfig(), progressModel: model });
+		} catch {
+			ctx.ui.notify("Could not save the progress model. Check pi-bar config file permissions; selection unchanged.", "error");
+			return false;
+		}
+		// Reset/cancel old-provider jobs, but do not enable a hidden segment.
+		if (visibleSegments.includes("progress") && model !== progress.modelKey()) progress.startSession(ctx.cwd);
+		refresh();
+		return true;
+	};
 	const setVisibleSegments = (segments: readonly SegmentName[], ctx?: ExtensionContext) => {
 		const previousProgressVisible = visibleSegments.includes("progress");
 		visibleSegments = serializeSegments(segments);
@@ -1726,6 +2036,10 @@ export default function (pi: ExtensionAPI) {
 		refresh();
 	};
 	const openSegmentConfigurator = async (ctx: ExtensionContext) => {
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify("/bar configuration requires TUI mode", "warning");
+			return;
+		}
 		await ctx.ui.custom((tui, theme, _kb, done) => {
 			const knownStatusKeys = getKnownStatusKeys(statusFilter, seenStatusKeys);
 			const segmentVisibility = new Map(
@@ -1765,13 +2079,27 @@ export default function (pi: ExtensionAPI) {
 				persistStatusFilter();
 			};
 
-			const segmentItems: SettingItem[] = ALL_SEGMENTS.map((segment): SettingItem => ({
-				id: `segment:${segment}`,
-				label: SEGMENT_LABELS[segment],
-				description: "Footer segment visibility",
-				currentValue: segmentVisibility.get(segment) ? "shown" : "hidden",
-				values: ["shown", "hidden"],
-			}));
+			const segmentItems: SettingItem[] = ALL_SEGMENTS.flatMap((segment): SettingItem[] => {
+				const visibilityItem: SettingItem = {
+					id: `segment:${segment}`,
+					label: SEGMENT_LABELS[segment],
+					description: "Footer segment visibility",
+					currentValue: segmentVisibility.get(segment) ? "shown" : "hidden",
+					values: ["shown", "hidden"],
+				};
+				if (segment !== "progress") return [visibilityItem];
+				return [visibilityItem, {
+					id: "progress-model",
+					label: "Progress model",
+					description: process.env.PI_BAR_PROGRESS_MODEL
+						? "Controlled by PI_BAR_PROGRESS_MODEL (read-only). Unset it and restart Pi to choose here."
+						: "Choose Auto or search models with configured Pi credentials. Saved for all projects; changes only progress updates.",
+					currentValue: formatProgressModelKey(resolveProgressModelPreference(ctx.cwd)),
+					submenu: process.env.PI_BAR_PROGRESS_MODEL
+						? undefined
+						: (currentValue, close) => createProgressModelPicker(ctx, currentValue, close),
+				}];
+			});
 			const statusItems: SettingItem[] = knownStatusKeys.length > 0
 				? [
 					{
@@ -1783,26 +2111,36 @@ export default function (pi: ExtensionAPI) {
 					},
 					...knownStatusKeys.map((key): SettingItem => ({
 						id: `status:${key}`,
-						label: `Status: ${key}`,
-						description: "Extension status visibility",
+						label: `Status: ${stripTerminalControls(key)}`,
+						description: statusDescription(key),
 						currentValue: statusVisibility.get(key) ? "shown" : "hidden",
 						values: ["shown", "hidden"],
 					})),
 				]
 				: [];
-			const items: SettingItem[] = [...segmentItems, ...statusItems];
+			const items: SettingItem[] = [
+				...segmentItems,
+				{
+					id: "show-provider",
+					label: "Show provider",
+					description: "Provider prefix inside the model segment (hidden by default)",
+					currentValue: showProvider ? "shown" : "hidden",
+					values: ["shown", "hidden"],
+				},
+				...statusItems,
+			];
 
 			const container = new Container();
 			container.addChild(
 				new (class {
 					render(_width: number) {
 						return [
-							theme.fg("accent", theme.bold("pi-bar visibility")),
+							theme.fg("accent", theme.bold("pi-bar configuration")),
 							theme.fg(
 								"dim",
 								knownStatusKeys.length > 0
-									? "Footer segments + extension statuses · Enter/Space toggles · Esc closes"
-									: "Footer segments · no extension statuses seen yet · Esc closes",
+									? "Footer settings + extension statuses · Enter/Space changes · Esc closes"
+									: "Footer settings · Enter/Space changes · Esc closes",
 							),
 							"",
 						];
@@ -1816,6 +2154,15 @@ export default function (pi: ExtensionAPI) {
 				Math.min(items.length + 2, 18),
 				getSettingsListTheme(),
 				(id, newValue) => {
+					if (id === "progress-model") {
+						setProgressModel(newValue, ctx);
+						settingsList.updateValue(id, formatProgressModelKey(resolveProgressModelPreference(ctx.cwd)));
+						return;
+					}
+					if (id === "show-provider") {
+						setShowProvider(newValue === "shown");
+						return;
+					}
 					if (id.startsWith("segment:")) {
 						const segment = id.slice("segment:".length);
 						if (!isSegmentName(segment)) return;
@@ -1843,7 +2190,7 @@ export default function (pi: ExtensionAPI) {
 
 			return {
 				render(width: number) {
-					return container.render(width);
+					return container.render(Math.max(8, width)).map((line) => truncateToWidth(line, Math.max(0, width)));
 				},
 				invalidate() {
 					container.invalidate();
@@ -1899,8 +2246,8 @@ export default function (pi: ExtensionAPI) {
 				},
 				...knownStatusKeys.map((key): SettingItem => ({
 					id: key,
-					label: key,
-					description: "Extension status visibility",
+					label: stripTerminalControls(key),
+					description: statusDescription(key),
 					currentValue: statusVisibility.get(key) ? "shown" : "hidden",
 					values: ["shown", "hidden"],
 				})),
@@ -1954,7 +2301,17 @@ export default function (pi: ExtensionAPI) {
 	};
 
 	pi.registerCommand("bar", {
-		description: "Configure pi-bar footer visibility",
+		description: "Configure pi-bar footer",
+		getArgumentCompletions: (prefix) => {
+			let modelKeys: string[] = [];
+			if (/^\s*progress-model\s+\S*$/.test(prefix)) {
+				if (!sessionOpen || process.env.PI_BAR_PROGRESS_MODEL) return null;
+				// Read current local availability only for model arguments, never
+				// refresh catalogs or resolve credentials while the user types.
+				modelKeys = completionModelRegistry?.getAvailable().map(formatProgressModelKey) ?? [];
+			}
+			return completeBarArguments(prefix, getKnownStatusKeys(statusFilter, seenStatusKeys), modelKeys);
+		},
 		handler: async (args, ctx) => {
 			const [section, action, ...rest] = args.trim().split(/\s+/).filter(Boolean);
 			if (!section || section === "config" || section === "configure" || section === "edit") {
@@ -1966,6 +2323,38 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
+			if (section === "progress-model") {
+				if (!action) {
+					const value = formatProgressModelKey(resolveProgressModelPreference(ctx.cwd));
+					const override = process.env.PI_BAR_PROGRESS_MODEL ? " (PI_BAR_PROGRESS_MODEL, read-only)" : "";
+					ctx.ui.notify(`pi-bar progress model: ${value}${override}`, "info");
+					return;
+				}
+				const model = parseSerializedProgressModel(action);
+				if (rest.length > 0 || !model) {
+					ctx.ui.notify("Usage: /bar progress-model [auto|provider/model]", "warning");
+					return;
+				}
+				if (!process.env.PI_BAR_PROGRESS_MODEL && model !== "auto" && !ctx.modelRegistry.getAvailable().some(
+					(available) => formatProgressModelKey(available) === model,
+				)) {
+					ctx.ui.notify("Progress model unavailable. Use /login or choose a configured model with Tab.", "warning");
+					return;
+				}
+				if (setProgressModel(model, ctx)) ctx.ui.notify(`pi-bar progress model: ${model}`, "info");
+				return;
+			}
+
+			if (section === "provider") {
+				if (rest.length > 0 || (action !== undefined && action !== "show" && action !== "hide")) {
+					ctx.ui.notify("Usage: /bar provider [show|hide]", "warning");
+					return;
+				}
+				if (action) setShowProvider(action === "show");
+				ctx.ui.notify(`pi-bar provider prefix: ${showProvider ? "shown" : "hidden"}`, "info");
+				return;
+			}
+
 			if (section === "segment" || section === "segments" || section === "footer") {
 				const segments = splitSegmentNames(rest.join(" "));
 				if ((action === "only" || action === "show" || action === "hide") && segments.length === 0) {
@@ -2077,7 +2466,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			ctx.ui.notify(
-				"Usage: /bar [config] or /bar segments [list|all|none|only <segments>|show <segments>|hide <segments>] or /bar status [list|all|none|only <keys>|show <keys>|hide <keys>]",
+				"Usage: /bar [config] or /bar segments [list|all|none|only <segments>|show <segments>|hide <segments>] or /bar status [list|all|none|only <keys>|show <keys>|hide <keys>] or /bar provider [show|hide] or /bar progress-model [auto|provider/model]",
 				"warning",
 			);
 		},
@@ -2085,7 +2474,11 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("model_select", async () => refresh());
 	pi.on("thinking_level_select", async () => refresh());
-	pi.on("turn_end", async () => refresh());
+	// message_end runs before persistence and allows later handlers to replace
+	// usage. Read finalized entries at the synchronized lifecycle boundaries.
+	pi.on("turn_end", async (_event, ctx) => { syncUsage(ctx); refresh(); });
+	pi.on("agent_end", async (_event, ctx) => { syncUsage(ctx); refresh(); });
+	pi.on("session_compact", async (_event, ctx) => { syncUsage(ctx); refresh(); });
 	pi.on("before_agent_start", async (event, ctx) => {
 		if (visibleSegments.includes("progress")) progress.recordUserMessage(ctx, event.prompt);
 	});
@@ -2093,7 +2486,9 @@ export default function (pi: ExtensionAPI) {
 		if (visibleSegments.includes("progress")) progress.recordAssistantUpdate(ctx, event.message);
 	});
 	pi.on("tool_call", async (event, ctx) => {
+		syncUsage(ctx);
 		if (visibleSegments.includes("progress")) progress.recordToolCall(ctx, event);
+		refresh();
 	});
 	pi.on("tool_result", async (event, ctx) => {
 		if (visibleSegments.includes("progress")) progress.recordToolResult(ctx, event);
@@ -2109,11 +2504,21 @@ export default function (pi: ExtensionAPI) {
 		if (visibleSegments.includes("progress")) progress.startSession(ctx.cwd);
 		else progress.shutdown();
 		restoreStatusFilter(ctx);
+		showProvider = readGlobalConfig().showProvider ?? false;
+		syncUsage(ctx, true);
 		refresh();
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		sessionEpoch++;
+		sessionOpen = true;
+		completionModelRegistry = ctx.modelRegistry;
+		usageTracker.reset();
+		syncUsage(ctx, true);
+		currentStatuses = new Map();
+		seenStatusKeys.clear();
 		visibleSegments = readGlobalSegments() ?? DEFAULT_SEGMENTS;
+		showProvider = readGlobalConfig().showProvider ?? false;
 		if (visibleSegments.includes("progress")) progress.startSession(ctx.cwd);
 		else progress.shutdown();
 		restoreStatusFilter(ctx);
@@ -2132,10 +2537,13 @@ export default function (pi: ExtensionAPI) {
 				},
 				invalidate() {},
 				render(width: number): string[] {
-					const modelName = formatModelName(ctx.model?.id);
+					const modelName = formatModelName(ctx.model, showProvider);
+					const metrics = usageTracker.snapshot();
+					const reportedUsage = hasUsage(metrics);
 					const thinkingLevel = String(pi.getThinkingLevel());
+					currentStatuses = footerData?.getExtensionStatuses?.() ?? new Map();
 					const extensionStatusParts = formatExtensionStatuses(
-						footerData?.getExtensionStatuses?.() ?? new Map(),
+						currentStatuses,
 						statusFilter,
 						seenStatusKeys,
 					);
@@ -2151,35 +2559,50 @@ export default function (pi: ExtensionAPI) {
 						: "—";
 					const progressText = progress.text();
 
-					const extensionStatuses = extensionStatusParts
-						? extensionStatusParts
-							.map((part) => theme.fg("text", part))
-							.join(` ${theme.fg("dim", EXTENSION_STATUS_SEPARATOR)} `)
-						: null;
-					const segmentRenderers: Record<SegmentName, string | null> = {
-						model: theme.fg("accent", modelName),
-						thinking: theme.fg(thinkingColor(thinkingLevel), `think:${thinkingLevel}`),
-						context: theme.fg(contextSegmentColor, contextText),
-						cwd: visibleSegments.includes("cwd")
-							? theme.fg("accent", formatCwd(ctx.cwd, homedir(), Math.min(cwdWidth, width)))
-							: null,
-						progress: progressText ? theme.fg("text", progressText) : null,
-						extensions: extensionStatuses,
+					const directories = visibleSegments.includes("cwd")
+						? cwdVariants(ctx.cwd, homedir(), cwdWidth).map((text) => theme.fg("accent", text))
+						: [];
+					const contextCompact = usage
+						? usage.percent !== null ? `${usage.percent.toFixed(1)}%` : "—%"
+						: "—";
+					const shortThinking = thinkingLevel === "medium" ? "med" : thinkingLevel === "minimal" ? "min" : thinkingLevel;
+					const renderers: Record<SegmentName, Omit<FooterSegment, "name">> = {
+						model: {
+							text: theme.fg("accent", modelName),
+							alternatives: showProvider ? [theme.fg("accent", formatModelName(ctx.model))] : [],
+						},
+						thinking: {
+							text: theme.fg(thinkingColor(thinkingLevel), `think:${thinkingLevel}`),
+							alternatives: [theme.fg(thinkingColor(thinkingLevel), `think:${shortThinking}`)],
+						},
+						context: {
+							text: theme.fg(contextSegmentColor, contextText),
+							alternatives: [theme.fg(contextSegmentColor, contextCompact)],
+						},
+						cache_hit_ratio: {
+							text: metrics.cacheHitRate === null ? "" : theme.fg("muted", `CH:${metrics.cacheHitRate.toFixed(1).replace(/\.0$/, "")}%`),
+						},
+						cost: { text: reportedUsage ? theme.fg("muted", `≈$${metrics.cost.toFixed(3)}`) : "" },
+						tokens: { text: reportedUsage ? theme.fg("muted", `↑${formatTokens(metrics.input)} ↓${formatTokens(metrics.output)}`) : "" },
+						cwd: { text: directories[0] ?? "", alternatives: directories.slice(1) },
+						progress: { text: progressText ? theme.fg("text", progressText) : "" },
+						extensions: { text: "" },
 					};
-
-					const separator = `  ${theme.fg("dim", SEGMENT_SEPARATOR)}  `;
-					const line = visibleSegments
-						.map((segment) => segmentRenderers[segment])
-						.filter((segment): segment is string => segment !== null)
-						.join(separator);
-
-					return [truncateToWidth(line, width)];
+					return [layoutFooter(
+						visibleSegments.map((name) => ({ name, ...renderers[name] })),
+						(extensionStatusParts ?? []).map((part) => theme.fg("text", part)),
+						width,
+						theme.fg("dim", SEGMENT_SEPARATOR),
+					)];
 				},
 			};
 		});
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
+		sessionOpen = false;
+		completionModelRegistry = undefined;
+		sessionEpoch++;
 		progress.shutdown();
 		if (ctx.hasUI) ctx.ui.setFooter(undefined);
 	});

package/extensions/usage.ts

@@ -0,0 +1,108 @@
+import type { Usage } from "@earendil-works/pi-ai";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+
+/** Numeric-only entries; never add progress prompts or responses to session context. */
+export const PROGRESS_USAGE_ENTRY_TYPE = "pi-bar-progress-usage";
+
+export type UsageTotals = {
+	/** All prompt tokens, including cache reads and writes. */
+	input: number;
+	/** Includes reasoning tokens when reported as part of output. */
+	output: number;
+	/** Reported/catalog dollar estimate, not an invoice. */
+	cost: number;
+};
+
+function nonNegative(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+
+export function totalsFromUsage(usage: Partial<Usage> | undefined): UsageTotals {
+	return {
+		input: nonNegative(usage?.input) + nonNegative(usage?.cacheRead) + nonNegative(usage?.cacheWrite),
+		output: nonNegative(usage?.output),
+		cost: nonNegative(usage?.cost?.total),
+	};
+}
+
+export function hasUsage(totals: UsageTotals): boolean {
+	return totals.input > 0 || totals.output > 0 || totals.cost > 0;
+}
+
+export function promptCacheHitRate(usage: Partial<Usage> | undefined): number | null {
+	const promptTokens = totalsFromUsage(usage).input;
+	return promptTokens > 0 && Number.isFinite(promptTokens)
+		? (nonNegative(usage?.cacheRead) / promptTokens) * 100
+		: null;
+}
+
+function totalsFromEntry(entry: SessionEntry): UsageTotals {
+	if (entry.type === "message" && (entry.message.role === "assistant" || entry.message.role === "toolResult")) {
+		return totalsFromUsage(entry.message.usage);
+	}
+	if (entry.type === "compaction" || entry.type === "branch_summary") {
+		return totalsFromUsage(entry.usage);
+	}
+	if (entry.type === "custom" && entry.customType === PROGRESS_USAGE_ENTRY_TYPE) {
+		const data = entry.data as Partial<UsageTotals> | undefined;
+		if (data && [data.input, data.output, data.cost].every(
+			(value) => typeof value === "number" && Number.isFinite(value) && value >= 0,
+		)) {
+			return { input: data.input!, output: data.output!, cost: data.cost! };
+		}
+	}
+	return { input: 0, output: 0, cost: 0 };
+}
+
+/**
+ * Totals cover the entire session file, including abandoned branches. Cache hit
+ * rate follows the active branch instead. Consume persisted entries after Pi's
+ * message_end hooks finish, so later extensions' usage corrections are honored.
+ * Rendering only reads a snapshot; it never walks session history.
+ */
+export class FooterUsageTracker {
+	private totals: UsageTotals = { input: 0, output: 0, cost: 0 };
+	private cacheHitRate: number | null = null;
+	private cursor = 0;
+	private lastEntryId: string | undefined;
+
+	reset(): void {
+		this.totals = { input: 0, output: 0, cost: 0 };
+		this.cacheHitRate = null;
+		this.cursor = 0;
+		this.lastEntryId = undefined;
+	}
+
+	syncEntries(entries: readonly SessionEntry[]): void {
+		// Session replacement or a rewritten prefix requires a fresh snapshot.
+		if (entries.length < this.cursor || (this.cursor > 0 && entries[this.cursor - 1]?.id !== this.lastEntryId)) {
+			this.reset();
+		}
+		for (; this.cursor < entries.length; this.cursor++) {
+			const entry = entries[this.cursor];
+			const totals = totalsFromEntry(entry);
+			this.totals.input += totals.input;
+			this.totals.output += totals.output;
+			this.totals.cost += totals.cost;
+			if (entry.type === "message" && entry.message.role === "assistant") {
+				this.cacheHitRate = promptCacheHitRate(entry.message.usage);
+			}
+		}
+		this.lastEntryId = entries.at(-1)?.id;
+	}
+
+	restoreBranch(branch: readonly SessionEntry[]): void {
+		this.cacheHitRate = null;
+		for (let index = branch.length - 1; index >= 0; index--) {
+			const entry = branch[index];
+			if (entry.type === "message" && entry.message.role === "assistant") {
+				this.cacheHitRate = promptCacheHitRate(entry.message.usage);
+				break;
+			}
+		}
+	}
+
+	snapshot(): UsageTotals & { cacheHitRate: number | null } {
+		return { ...this.totals, cacheHitRate: this.cacheHitRate };
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bar",
-  "version": "0.3.41",
+  "version": "0.3.44",
   "description": "Pi footer/statusline showing active model, thinking level, context pressure, live progress updates, and extension statuses.",
   "type": "module",
   "keywords": [