@hank-warren/pi-statusline 0.6.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @hank-warren/pi-statusline
 
+## 0.7.1
+
+### Patch Changes
+
+- 950c926: Tick the subscription usage meters on a clock instead of on turn boundaries. The tracker only refreshed from session start, the end of a turn, and a model switch, while the poll gate that spaces requests is host-wide and five minutes wide. The moment a meter actually moved was therefore the first turn in this session ending more than five minutes after any pi process on the host last polled that account — which made updates look arbitrary, and froze an idle session's numbers indefinitely while the five-hour window was visibly recovering.
+
+  `UsageTracker` now owns an unref'd ten-second tick, started with the footer and stopped with the footer, with the usage setting, or at session shutdown. Request volume is unchanged, because a throttled refresh already issues no request: it reads `auth.json` and the shared cache, publishes whatever another process has already fetched, finds the gate closed and returns. The tick costs two small local reads and buys the two things the turn-driven cadence could not — an idle session's meters keep moving, and a sibling process's fresh values are adopted within one tick rather than waiting for this session's next turn to end. The poll itself now also fires when the five-minute window opens rather than at the first turn to end after it.
+
+  Nothing about the meters' appearance, the poll interval, the rate-limit backoff or the shared cache format changes.
+
+## 0.7.0
+
+### Minor Changes
+
+- 70c8ef9: Add an optional provider segment. A new `Provider` toggle in `/statusline` renders the active model's provider id between the model and the directory (`claude-opus-5 | anthropic-team | pi-extensions:main | 0/1.0m`), so a `pi-multi-login` alias names the login actually spending — something a model id never carries. It is off by default, has its own colour role in every theme, and is omitted entirely when the model reports no provider.
+
 ## 0.6.0
 
 ### Minor Changes

package/README.md

@@ -10,7 +10,7 @@ gpt-5.6-sol | pi-extensions:main* ⇣1 | 40k/1.0m |  97·54  80
 
 ## What it shows
 
-- **Line 1** — active model ID, current directory basename and Git branch, current context usage/window, and subscription usage headroom (see below). A yellow `*` marks a dirty checkout and `⇣N` shows how many commits it is behind its locally known upstream ref. Unknown context usage is rendered as `?/<window>` until Pi can provide an estimate. Exceptional prompt-cache hits trigger the celebration described below.
+- **Line 1** — active model ID, optionally the provider of that model, current directory basename and Git branch, current context usage/window, and subscription usage headroom (see below). A yellow `*` marks a dirty checkout and `⇣N` shows how many commits it is behind its locally known upstream ref. Unknown context usage is rendered as `?/<window>` until Pi can provide an estimate. Exceptional prompt-cache hits trigger the celebration described below.
 - **Worktree lines** — when the session works in or sends tool calls into linked worktrees, one line shows the same branch/dirty/behind state for each worktree plus its associated PR number.
 - **Final line** — the full Pi session ID.
 
@@ -22,7 +22,7 @@ Colors come from a selectable [theme](#themes), with context warning thresholds.
 
 - **Theme** — the color palette, cycled with Enter or Space. See [Themes](#themes).
 - **Cache celebration** — `off` or one of five badge animations, cycled with Enter or Space and previewed live in the statusline below. See [Animation styles](#animation-styles).
-- **Model**, **Directory & git**, **Context**, **Subscription usage**, **Worktree line**, **Session ID line** — `on`/`off`, cycled with Enter or Space. Disabled segments are dropped from line 1 without leaving a stray ` | ` separator; hiding the worktree line also stops its `git`/`gh` polling, and hiding usage stops the usage poller. With every element off the footer collapses to a single blank row.
+- **Model**, **Provider**, **Directory & git**, **Context**, **Subscription usage**, **Worktree line**, **Session ID line** — `on`/`off`, cycled with Enter or Space. **Provider** is the only one that starts `off`; it shows the provider id exactly as Pi reports it, so a [pi-multi-login](../pi-multi-login) alias renders as `anthropic-team` and names the login actually spending — something a model id like `claude-opus-5` never carries. With no model, or a model reporting no provider, the segment is simply absent. Disabled segments are dropped from line 1 without leaving a stray ` | ` separator; hiding the worktree line also stops its `git`/`gh` polling, and hiding usage stops the usage poller. With every element off the footer collapses to a single blank row.
 - **Worktree root** — the directory whose immediate children are tracked as session worktrees (default `~/repos/worktrees`). `~` and `$HOME` are expanded; a relative path is rejected and the previous value kept.
 - **Repo aliases** — short display names for repositories on the worktree line. Enter edits the selected `repo → alias` pair, `d` deletes it, and `Add alias…` creates one from a `repo=alias` line.
 
@@ -75,7 +75,7 @@ When Pi's `~/.pi/agent/auth.json` contains OAuth credentials for Anthropic (Clau
 
 Numbers are colored by remaining headroom: green above 60, yellow 41–60, orange 16–40, red at 15 and below.
 
-Usage is fetched from the providers' own usage endpoints with Pi's stored tokens — read-only; tokens are never refreshed or written. Fetches happen on session start and after each turn, throttled to at most once every five minutes (the Anthropic usage endpoint rate-limits aggressively), and are strictly best-effort: on any failure the last-known value is kept, and providers without credentials (or before the first successful fetch) are simply omitted, leaving the statusline exactly as before. While a provider that *does* have credentials still has no value, the throttle drops to 30 seconds — Pi only refreshes an expired OAuth access token when that provider is first used, so a session starting with a stale Anthropic token would otherwise show no Claude meter for a full interval.
+Usage is fetched from the providers' own usage endpoints with Pi's stored tokens — read-only; tokens are never refreshed or written. Fetches are driven by session start, each turn, and a ten-second tick while the footer is mounted, throttled to at most once every five minutes (the Anthropic usage endpoint rate-limits aggressively), and are strictly best-effort: on any failure the last-known value is kept, and providers without credentials (or before the first successful fetch) are simply omitted, leaving the statusline exactly as before. While a provider that *does* have credentials still has no value, the throttle drops to 30 seconds — Pi only refreshes an expired OAuth access token when that provider is first used, so a session starting with a stale Anthropic token would otherwise show no Claude meter for a full interval.
 
 ### Which account each meter shows
 
@@ -87,6 +87,8 @@ When [`@hank-warren/pi-multi-login`](../pi-multi-login/README.md) has registered
 
 Polling is host-wide, not per-session. Usage percentages describe the account rather than the session, and a busy machine runs dozens of pi processes, so every process shares `~/.pi/agent/statusline-usage.json`, written atomically via a temp file and rename. It is keyed by **credential id**, one entry per account, each holding that account's last good values plus the time its last poll was *started*. A session adopts the cached values for its selected accounts on first refresh — so the meters are populated before it has issued a single request, and switching back to an account polled earlier repaints with no request at all — and only polls an account whose timestamp is older than the interval. Keying by account rather than by provider family is what lets two sessions on two different Anthropic logins coexist: keyed by family, each looked like an account switch to the other, so they evicted each other's values and re-polled every cycle.
 
+The ten-second tick does not increase request volume; it only stops the meters from being pinned to turn boundaries. A throttled refresh issues no request at all — it reads `auth.json` and the shared cache, publishes whatever another process has already fetched, finds the poll gate closed and returns — so the tick costs two small local reads and buys the two things the previous turn-driven cadence could not: an **idle** session's meters keep moving (quota recovers on a wall clock, not on your turns), and a sibling process's fresh values are adopted within one tick instead of waiting for this session's next turn to end. It also means the poll itself happens when the five-minute window opens rather than at the first turn that ends after it. The tick is `unref`ed, runs only in TUI mode, and stops with the footer — so turning the usage segment off still stops all polling.
+
 Cache entries stay compatible in both directions: a Codex entry written by a statusline older than 0.6.0 carries no 5-hour value, so a newer one renders it as a single weekly number until its own next poll fills the second slot, and an older reader ignores the extra value entirely.
 
 An account answering `429` is parked for fifteen minutes (tracked per account, so a rate-limited Anthropic never stops codex from updating) and stops counting as pending, since retrying harder is what earns the rate limit in the first place. Every cache entry is keyed to a fingerprint (a sha256 prefix, never the token itself) of the credential that fetched it: switching accounts — or rotating a token — discards that entry's numbers and backoff and polls immediately, so an exhausted old account's meters never masquerade as the new account's. A logged-out account fails the same check, so the file garbage-collects itself.

package/index.ts

@@ -40,6 +40,8 @@ import {
 
 export interface StatuslineData {
 	model: string;
+	/** Provider id of the active model; absent when there is no model. */
+	provider?: string;
 	cwd: string;
 	cwdGit: GitRepositoryStatus | null;
 	contextTokens: number | null;
@@ -177,6 +179,9 @@ export function renderStatusline(
 	const usageSegment = settings.showUsage && data.usage ? renderUsageSegment(data.usage, palette) : undefined;
 	const segments = [
 		settings.showModel ? styled(palette.model, data.model) : undefined,
+		// No provider is a missing segment, not a placeholder: the model id already
+		// says "no-model" in that state, and a second one would only add noise.
+		settings.showProvider && data.provider ? styled(palette.provider, data.provider) : undefined,
 		settings.showDirectory
 			? data.cwdGit
 				? renderRepository(data.cwd, data.cwdGit, palette)
@@ -299,7 +304,13 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 		} else if (!previous.showWorktrees || !tracker || previous.worktreeRoot !== next.worktreeRoot) {
 			resetTracker(ctx);
 		}
-		if (next.showUsage && !previous.showUsage) runInBackground(usageTracker.refresh());
+		if (next.showUsage && !previous.showUsage) {
+			runInBackground(usageTracker.refresh());
+			usageTracker.start();
+		} else if (!next.showUsage && previous.showUsage) {
+			// A hidden meter must not keep polling, matching the worktree line above.
+			usageTracker.stop();
+		}
 		if (!next.showCacheCelebration) cacheCelebration.dispose();
 		// Dropping a row leaves a stale one behind in fullscreen mode.
 		if (previous.showSessionId !== next.showSessionId || previous.showWorktrees !== next.showWorktrees) {
@@ -401,6 +412,10 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 			// Fullscreen mode never repaints unchanged rows; the session id line is
 			// static, so it needs periodic forced redraws to shed stale cells.
 			fullRedraw.attach(tui);
+			// The meters are wall-clock quantities, not per-turn ones: an idle session
+			// still needs them to move, and a sibling process's poll is worth adopting
+			// before the next turn ends.
+			if (settings.showUsage) usageTracker.start();
 			const stopBranchUpdates = footerData.onBranchChange(() => {
 				runInBackground(refreshCwdStatus(ctx));
 				tui.requestRender();
@@ -412,6 +427,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 					cacheCelebration.dispose();
 					celebrationPreview.dispose();
 					fullRedraw.detach();
+					usageTracker.stop();
 					requestRender = undefined;
 				},
 				invalidate(): void {},
@@ -424,6 +440,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 						renderStatusline(
 							{
 								model,
+								provider: ctx.model?.provider,
 								cwd,
 								cwdGit,
 								contextTokens: usage?.tokens ?? null,
@@ -473,6 +490,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 	pi.on("session_shutdown", () => {
 		cacheCelebration.dispose();
 		fullRedraw.detach();
+		usageTracker.stop();
 		tracker?.dispose();
 		tracker = undefined;
 		cwdStatusAbort?.abort();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-statusline",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Compact Pi footer statusline with Git/worktree context, token usage, and neon celebrations for exceptional prompt-cache hits.",
   "type": "module",
   "keywords": [

package/settings-menu.ts

@@ -32,6 +32,7 @@ export interface BooleanRow {
 /** Toggle rows, in statusline render order. */
 export const BOOLEAN_ROWS: readonly BooleanRow[] = [
 	{ id: "showModel", label: "Model", description: "Show the active model id." },
+	{ id: "showProvider", label: "Provider", description: "Show the provider of the active model." },
 	{ id: "showDirectory", label: "Directory & git", description: "Show the working directory and its git branch." },
 	{ id: "showContext", label: "Context", description: "Show context tokens used against the window." },
 	{ id: "showUsage", label: "Subscription usage", description: "Show Claude/Codex remaining-headroom meters." },

package/settings.ts

@@ -12,6 +12,7 @@ import { DEFAULT_THEME, isThemeName, type StatuslineThemeName } from "./themes.t
 /** Toggle keys, in the order the `/statusline` menu lists them. */
 export const BOOLEAN_SETTING_KEYS = [
 	"showModel",
+	"showProvider",
 	"showDirectory",
 	"showContext",
 	"showUsage",
@@ -40,6 +41,8 @@ export function defaultWorktreeRoot(home: string = homedir()): string {
 export function defaultSettings(home: string = homedir()): StatuslineSettings {
 	return {
 		showModel: true,
+		// Opt-in: the provider is redundant for anyone with a single login per family.
+		showProvider: false,
 		showDirectory: true,
 		showContext: true,
 		showUsage: true,

package/themes.ts

@@ -5,6 +5,8 @@
 export interface StatuslinePalette {
 	/** Active model id. */
 	model: string;
+	/** Provider id of the active model. */
+	provider: string;
 	/** Repository and directory names. */
 	path: string;
 	/** Git branch names. */
@@ -35,6 +37,7 @@ const rgb = (hex: string): string => {
 /** The palette this package shipped before themes existed. */
 const DEFAULT: StatuslinePalette = {
 	model: rgb("#0099ff"),
+	provider: rgb("#7aa2c8"),
 	path: rgb("#dcdcdc"),
 	branch: rgb("#56b6c2"),
 	text: rgb("#dcdcdc"),
@@ -50,6 +53,7 @@ const DEFAULT: StatuslinePalette = {
 /** Dracula, with the pink branch colour from Hank's Herdr sidebar config. */
 const DRACULA: StatuslinePalette = {
 	model: rgb("#bd93f9"),
+	provider: rgb("#9580c9"),
 	path: rgb("#f8f8f2"),
 	branch: rgb("#ff79c6"),
 	text: rgb("#f8f8f2"),
@@ -64,6 +68,7 @@ const DRACULA: StatuslinePalette = {
 
 const GITHUB_DARK: StatuslinePalette = {
 	model: rgb("#58a6ff"),
+	provider: rgb("#6e8bb5"),
 	path: rgb("#c9d1d9"),
 	branch: rgb("#39c5cf"),
 	text: rgb("#c9d1d9"),
@@ -78,6 +83,7 @@ const GITHUB_DARK: StatuslinePalette = {
 
 const CATPPUCCIN_MOCHA: StatuslinePalette = {
 	model: rgb("#cba6f7"),
+	provider: rgb("#a58fc4"),
 	path: rgb("#cdd6f4"),
 	branch: rgb("#89dceb"),
 	text: rgb("#cdd6f4"),
@@ -93,6 +99,7 @@ const CATPPUCCIN_MOCHA: StatuslinePalette = {
 /** No colour at all: white text, dimmed punctuation, a grey badge flash. */
 const WHITE: StatuslinePalette = {
 	model: rgb("#ffffff"),
+	provider: rgb("#ffffff"),
 	path: rgb("#ffffff"),
 	branch: rgb("#ffffff"),
 	text: rgb("#ffffff"),

package/usage.ts

@@ -35,6 +35,17 @@ export const USAGE_RETRY_INTERVAL_MS = 30_000;
  * a break rather than that we are racing ourselves.
  */
 export const USAGE_RATE_LIMIT_BACKOFF_MS = 15 * 60_000;
+/**
+ * How often a bound tracker calls itself. This is deliberately far shorter than
+ * the poll interval, because a throttled `refresh()` issues no request at all:
+ * it reads auth.json and the shared cache, publishes whatever another process
+ * has already fetched, finds the poll gate closed, and returns. So the tick
+ * costs two small local reads and buys two things the previous turn-driven
+ * cadence could not — an idle session's meters keep moving, and a sibling
+ * process's fresh values appear within one tick instead of at the next turn.
+ * Request volume is unchanged: both throttles still gate every fetch.
+ */
+export const USAGE_TICK_INTERVAL_MS = 10_000;
 const FETCH_TIMEOUT_MS = 10_000;
 const ONE_DAY_SECONDS = 86_400;
 
@@ -150,6 +161,20 @@ export interface UsageTrackerOptions {
 	now?: () => number;
 	/** Provider id of the session's main model; selects which account is polled. */
 	activeProvider?: string;
+	tickIntervalMs?: number;
+	schedule?: (callback: () => void, intervalMs: number) => unknown;
+	cancel?: (handle: unknown) => void;
+}
+
+function defaultSchedule(callback: () => void, intervalMs: number): unknown {
+	const timer = setInterval(callback, intervalMs);
+	// A usage meter is cosmetic; it must never hold the process open at exit.
+	(timer as { unref?: () => void }).unref?.();
+	return timer;
+}
+
+function defaultCancel(handle: unknown): void {
+	clearInterval(handle as ReturnType<typeof setInterval>);
 }
 
 type ProviderKey = "claude" | "codex";
@@ -323,6 +348,10 @@ export class UsageTracker {
 	private readonly rateLimited = new Set<ProviderKey>();
 	private lastAttempt: Record<string, number> = {};
 	private inFlight: Promise<void> | undefined;
+	private readonly tickIntervalMs: number;
+	private readonly schedule: (callback: () => void, intervalMs: number) => unknown;
+	private readonly cancel: (handle: unknown) => void;
+	private tickHandle: unknown;
 
 	constructor(options: UsageTrackerOptions = {}) {
 		this.authPath = options.authPath ?? join(homedir(), ".pi", "agent", "auth.json");
@@ -331,12 +360,34 @@ export class UsageTracker {
 		this.onChange = options.onChange;
 		this.now = options.now ?? Date.now;
 		this.activeProvider = options.activeProvider;
+		this.tickIntervalMs = options.tickIntervalMs ?? USAGE_TICK_INTERVAL_MS;
+		this.schedule = options.schedule ?? defaultSchedule;
+		this.cancel = options.cancel ?? defaultCancel;
 	}
 
 	snapshot(): UsageSnapshot {
 		return this.current;
 	}
 
+	/**
+	 * Begin ticking. Idempotent, so the caller may start from whichever lifecycle
+	 * event happens first without tracking whether it already did.
+	 */
+	start(): void {
+		if (this.tickHandle !== undefined) return;
+		this.tickHandle = this.schedule(() => {
+			// refresh() swallows its own failures and no-ops while one is in flight.
+			void this.refresh();
+		}, this.tickIntervalMs);
+	}
+
+	/** Stop ticking. Safe to call when never started, and leaves values in place. */
+	stop(): void {
+		if (this.tickHandle === undefined) return;
+		this.cancel(this.tickHandle);
+		this.tickHandle = undefined;
+	}
+
 	/**
 	 * Point the meters at the session's main model. A switch between two accounts
 	 * in the same family changes which one is displayed; the next refresh adopts