pi-fancy-footer 1.2.0 → 1.3.0

package/README.md

@@ -15,7 +15,7 @@ pi install npm:pi-fancy-footer
 ## 📊 What it shows
 
 - Active model + thinking level
-- Provider quota status for OpenAI Codex
+- Provider quota status for OpenAI Codex and Claude models
 - Context window capacity and a mini gauge of remaining context
 - Total session cost
 - Repo / path, branch, commit, open PR number, unresolved PR review
@@ -71,7 +71,7 @@ Create `~/.pi/agent/fancy-footer.json`:
   "providerStatus": {
     "refreshMs": 60000,
     "cacheTtlMs": 60000,
-    "providers": ["openai-codex"],
+    "providers": ["openai-codex", "anthropic"],
     "display": "gauge",
     "showCredits": false,
     "showReset": false
@@ -125,7 +125,7 @@ Top-level settings:
 - `providerStatus`:
   - `refreshMs` - provider status refresh interval in milliseconds
   - `cacheTtlMs` - cache freshness window in milliseconds
-  - `providers` - supported provider adapters (`openai-codex`)
+  - `providers` - supported provider adapters (`openai-codex`, `anthropic`)
   - `display` - render quota windows as a mini `gauge` (default) or plain
     `text`
   - `showCredits` - include provider-specific credit balance when available
@@ -265,18 +265,24 @@ Notes:
 - `pull-request-ci-status` is icon-only and uses symbols for running / failed /
   okay status. By default it uses semantic colors (warning / error / success);
   set this widget's icon color to override them.
-- `provider-status` shows provider quota windows, currently for OpenAI Codex,
-  as battery-style mini gauges per window, e.g. `5h ▰▰▰▰▱ 80% 7d ▰▰▱▱▱ 38%`,
+- `provider-status` shows provider quota windows for OpenAI Codex and Claude
+  models as battery-style mini gauges per window, e.g.
+  `5h ▰▰▰▰▱ 80% 7d ▰▰▱▱▱ 38%`,
   where filled cells show the remaining quota and each window is colored by
   how close it is to exhaustion. The gauge spans `gaugeWidth` cells and
   reuses the configured `gaugeStyle` glyphs; set `providerStatus.display` to
   `text` for the
-  compact `5h:95% 7d:97%` form. It uses existing pi OpenAI Codex credentials from
-  `~/.pi/agent/auth.json`, falling back to Codex CLI credentials in
-  `~/.codex/auth.json`, and caches status under
-  `~/.cache/pi-fancy-footer/provider-status/`.
+  compact `5h:95% 7d:97%` form. Codex uses existing pi OpenAI Codex credentials
+  from `~/.pi/agent/auth.json`, falling back to Codex CLI credentials in
+  `~/.codex/auth.json`. Claude uses pi Anthropic OAuth credentials from
+  `~/.pi/agent/auth.json` and reads Claude.ai usage for the 5-hour and weekly
+  windows. Status is cached under `~/.cache/pi-fancy-footer/provider-status/`.
+  The widget is hidden when the active model selection is not backed by the
+  status provider.
 - `provider-status` also refreshes from `x-codex-*` provider response headers
-  when pi exposes them, avoiding a separate status request after provider calls.
+  when pi exposes them, avoiding a separate Codex status request after provider
+  calls. Claude status refreshes from the Claude.ai usage endpoint, not
+  provider response headers.
 - `iconFamily` lets you choose between `nerd`, `emoji`, `unicode`, and
   `ascii` palettes.
 - `nerd` keeps the original Nerd Font look. `emoji`, `unicode`, and `ascii`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fancy-footer",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "A fancy footer extension for pi",
   "type": "module",
   "peerDependencies": {

package/src/config.test.ts

@@ -10,6 +10,7 @@ test("footerConfigValidationErrors accepts a valid config", () => {
     footerConfigValidationErrors({
       gaugeStyle: "bars",
       gaugeWidth: 8,
+      providerStatus: { providers: ["openai-codex", "anthropic"] },
       widgets: { "context-bar": { row: 0 } },
     }),
     [],

package/src/provider-status.test.ts

@@ -7,6 +7,8 @@ import {
   buildProviderStatusGauge,
   collectProviderStatus,
   formatProviderStatusText,
+  isProviderStatusRelevantToModel,
+  normalizeClaudeUsageResponse,
   normalizeCodexUsageResponse,
   parseCodexRateLimitHeaders,
   providerStatusColor,
@@ -26,6 +28,10 @@ const providerStatusConfig: ProviderStatusConfigSnapshot = {
   showCredits: false,
   showReset: false,
 };
+const anthropicProviderStatusConfig: ProviderStatusConfigSnapshot = {
+  ...providerStatusConfig,
+  providers: ["anthropic"],
+};
 
 test("normalizeCodexUsageResponse extracts primary and secondary quota windows", () => {
   const snapshot = normalizeCodexUsageResponse(
@@ -63,6 +69,63 @@ test("normalizeCodexUsageResponse extracts primary and secondary quota windows",
   assert.equal(snapshot?.state, "ok");
 });
 
+test("normalizeClaudeUsageResponse extracts five-hour and weekly usage windows", () => {
+  const fiveHourReset = "2026-06-16T15:20:00.365459+00:00";
+  const weeklyReset = "2026-06-16T23:00:00.365483+00:00";
+  const snapshot = normalizeClaudeUsageResponse(
+    {
+      five_hour: {
+        utilization: 0,
+        resets_at: fiveHourReset,
+      },
+      seven_day: {
+        utilization: 8,
+        resets_at: weeklyReset,
+      },
+      seven_day_sonnet: {
+        utilization: 99,
+        resets_at: weeklyReset,
+      },
+      extra_usage: {
+        utilization: 75,
+      },
+    },
+    now,
+  );
+
+  assert.deepEqual(snapshot?.primary, {
+    label: "5h",
+    usedPercent: 0,
+    leftPercent: 100,
+    resetAt: Math.round(Date.parse(fiveHourReset) / 1000),
+  });
+  assert.deepEqual(snapshot?.secondary, {
+    label: "7d",
+    usedPercent: 8,
+    leftPercent: 92,
+    resetAt: Math.round(Date.parse(weeklyReset) / 1000),
+  });
+  assert.equal(snapshot?.provider, "anthropic");
+  assert.equal(snapshot?.state, "ok");
+});
+
+test("normalizeClaudeUsageResponse ignores responses without supported windows", () => {
+  assert.equal(
+    normalizeClaudeUsageResponse(
+      {
+        seven_day_sonnet: {
+          utilization: 10,
+        },
+        extra_usage: {
+          utilization: 20,
+        },
+      },
+      now,
+    ),
+    undefined,
+  );
+});
+
 test("parseCodexRateLimitHeaders accepts case-insensitive x-codex headers", () => {
   const snapshot = parseCodexRateLimitHeaders(
     {
@@ -137,6 +200,62 @@ test("formatProviderStatusText can show provider-specific credits without window
   );
 });
 
+test("isProviderStatusRelevantToModel limits Codex status to OpenAI-like models", () => {
+  assert.equal(
+    isProviderStatusRelevantToModel("openai-codex", {
+      provider: "anthropic",
+      id: "claude-sonnet-4",
+      name: "Claude Sonnet 4",
+    }),
+    false,
+  );
+  assert.equal(
+    isProviderStatusRelevantToModel("openai-codex", {
+      id: "gpt-5-codex",
+      name: "GPT-5 Codex",
+    }),
+    true,
+  );
+  assert.equal(
+    isProviderStatusRelevantToModel("openai-codex", {
+      provider: "openai",
+      id: "o3",
+    }),
+    true,
+  );
+  assert.equal(
+    isProviderStatusRelevantToModel("other-provider", {
+      id: "claude-sonnet-4",
+    }),
+    true,
+  );
+});
+
+test("isProviderStatusRelevantToModel limits Anthropic status to Claude-like models", () => {
+  assert.equal(
+    isProviderStatusRelevantToModel("anthropic", {
+      provider: "anthropic",
+      id: "claude-sonnet-4",
+      name: "Claude Sonnet 4",
+    }),
+    true,
+  );
+  assert.equal(
+    isProviderStatusRelevantToModel("anthropic", {
+      id: "claude-opus-4",
+    }),
+    true,
+  );
+  assert.equal(
+    isProviderStatusRelevantToModel("anthropic", {
+      provider: "openai",
+      id: "gpt-5-codex",
+    }),
+    false,
+  );
+  assert.equal(isProviderStatusRelevantToModel("anthropic", undefined), false);
+});
+
 test("providerStatusColor derives semantic color from status", () => {
   assert.equal(
     providerStatusColor(
@@ -233,6 +352,18 @@ test("updateProviderStatusFromHeaders honors disabled providers", async () => {
   assert.deepEqual(updated, []);
 });
 
+test("updateProviderStatusFromHeaders ignores Anthropic response headers", async () => {
+  const updated = await updateProviderStatusFromHeaders(
+    {
+      "anthropic-ratelimit-requests-remaining": "10",
+      "anthropic-ratelimit-tokens-remaining": "1000",
+    },
+    anthropicProviderStatusConfig,
+  );
+
+  assert.deepEqual(updated, []);
+});
+
 test("updateProviderStatusFromHeaders does not merge expired cached windows", async (t) => {
   const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
   t.after(async () => {

package/src/provider-status.ts

@@ -16,9 +16,15 @@ import {
 export const CODEX_USAGE_URL = "https://chatgpt.com/codex/settings/usage";
 const CODEX_USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
 const CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-const TOKEN_URL = "https://auth.openai.com/oauth/token";
+const CODEX_TOKEN_URL = "https://auth.openai.com/oauth/token";
 const CODEX_PRIMARY_WINDOW_LABEL = "5h";
 const CODEX_SECONDARY_WINDOW_LABEL = "7d";
+export const CLAUDE_USAGE_URL = "https://claude.ai/settings/usage";
+const CLAUDE_USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
+const CLAUDE_CLIENT_ID = "https://claude.ai/oauth/claude-code-client-metadata";
+const CLAUDE_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const CLAUDE_PRIMARY_WINDOW_LABEL = "5h";
+const CLAUDE_SECONDARY_WINDOW_LABEL = "7d";
 
 type HeaderLike = Record<string, string | number | boolean | undefined | null>;
 
@@ -41,10 +47,87 @@ const CODEX_SOURCE: ProviderStatusSource = {
   parseHeaders: parseCodexRateLimitHeaders,
 };
 
+const ANTHROPIC_SOURCE: ProviderStatusSource = {
+  id: "anthropic",
+  label: "Claude",
+  usageUrl: CLAUDE_USAGE_URL,
+  fetch: fetchClaudeProviderStatus,
+  parseHeaders: () => undefined,
+};
+
 export const PROVIDER_STATUS_SOURCES: readonly ProviderStatusSource[] = [
   CODEX_SOURCE,
+  ANTHROPIC_SOURCE,
 ];
 
+type ModelLike = {
+  id?: unknown;
+  name?: unknown;
+  displayName?: unknown;
+  provider?: unknown;
+  providerId?: unknown;
+};
+
+function modelValue(value: unknown): string {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+function looksLikeOpenAIModel(value: string): boolean {
+  if (!value) return false;
+
+  const normalized = value.replace(/[/_:\s]+/g, "-");
+  return (
+    normalized.includes("openai") ||
+    normalized.includes("codex") ||
+    normalized.includes("chatgpt") ||
+    /(^|-)gpt(?:[0-9-]|$)/.test(normalized) ||
+    /(^|-)o[134](?:-|$)/.test(normalized)
+  );
+}
+
+function looksLikeAnthropicModel(value: string): boolean {
+  if (!value) return false;
+
+  const normalized = value.replace(/[/_:\s]+/g, "-");
+  return (
+    normalized.includes("anthropic") ||
+    normalized.includes("claude") ||
+    /(^|-)(sonnet|opus|haiku)(?:-|$)/.test(normalized)
+  );
+}
+
+function looksLikeProviderModel(providerId: string, value: string): boolean {
+  if (providerId === CODEX_SOURCE.id) return looksLikeOpenAIModel(value);
+  if (providerId === ANTHROPIC_SOURCE.id) return looksLikeAnthropicModel(value);
+  return true;
+}
+
+export function isProviderStatusRelevantToModel(
+  providerId: string,
+  model: ModelLike | string | undefined,
+): boolean {
+  if (
+    providerId !== CODEX_SOURCE.id &&
+    providerId !== ANTHROPIC_SOURCE.id
+  ) {
+    return true;
+  }
+
+  if (typeof model === "string") {
+    return looksLikeProviderModel(providerId, modelValue(model));
+  }
+  if (!model) return false;
+
+  const provider = modelValue(model.provider) || modelValue(model.providerId);
+  if (provider) return looksLikeProviderModel(providerId, provider);
+
+  return [
+    modelValue(model.id),
+    modelValue(model.name),
+    modelValue(model.displayName),
+  ].some((value) => looksLikeProviderModel(providerId, value));
+}
+
 function enabledProviderStatusSources(
   config: Pick<ProviderStatusConfigSnapshot, "providers">,
 ): readonly ProviderStatusSource[] {
@@ -54,6 +137,7 @@ function enabledProviderStatusSources(
 }
 
 interface AuthCredentials {
+  provider: "openai-codex" | "anthropic";
   source: "pi" | "codex";
   path: string;
   accessToken: string;
@@ -260,6 +344,36 @@ export function normalizeCodexUsageResponse(
   };
 }
 
+export function normalizeClaudeUsageResponse(
+  value: unknown,
+  now = new Date(),
+): ProviderStatusSnapshot | undefined {
+  const obj = objectValue(value);
+  if (!obj) return undefined;
+
+  const primary = normalizeClaudeUsageWindow(
+    objectValue(obj.five_hour),
+    CLAUDE_PRIMARY_WINDOW_LABEL,
+    now,
+  );
+  const secondary = normalizeClaudeUsageWindow(
+    objectValue(obj.seven_day),
+    CLAUDE_SECONDARY_WINDOW_LABEL,
+    now,
+  );
+  if (!primary && !secondary) return undefined;
+
+  return {
+    provider: "anthropic",
+    source: "api",
+    fetchedAt: now.toISOString(),
+    state: computeProviderStatusState(primary, secondary),
+    ...(primary ? { primary } : {}),
+    ...(secondary ? { secondary } : {}),
+    url: CLAUDE_USAGE_URL,
+  };
+}
+
 export function isProviderStatusFresh(
   snapshot: ProviderStatusSnapshot | undefined,
   maxAgeMs: number,
@@ -274,7 +388,7 @@ export function isProviderStatusFresh(
 async function fetchCodexProviderStatus(
   _pi: ExtensionAPI,
 ): Promise<ProviderStatusSnapshot> {
-  let auth = await resolveAuth();
+  let auth = await resolveCodexAuth();
 
   for (let attempt = 0; attempt < 2; attempt++) {
     const response = await fetch(CODEX_USAGE_ENDPOINT, {
@@ -310,11 +424,57 @@ async function fetchCodexProviderStatus(
   throw new Error("Codex usage request failed after auth refresh");
 }
 
-async function resolveAuth(): Promise<AuthCredentials> {
-  const pi = await readAuthFile("pi", homePath(".pi/agent/auth.json"));
+async function fetchClaudeProviderStatus(
+  _pi: ExtensionAPI,
+): Promise<ProviderStatusSnapshot> {
+  let auth = await resolveClaudeAuth();
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const response = await fetch(CLAUDE_USAGE_ENDPOINT, {
+      headers: {
+        authorization: `Bearer ${auth.accessToken}`,
+        accept: "application/json",
+        "user-agent": "pi-fancy-footer",
+      },
+    });
+    const text = await response.text();
+
+    if (response.ok) {
+      const parsed = normalizeClaudeUsageResponse(JSON.parse(text));
+      if (parsed) return parsed;
+      throw new Error("Claude usage response did not contain quota data");
+    }
+
+    if (
+      (response.status === 401 || response.status === 403) &&
+      attempt === 0 &&
+      auth.refreshToken
+    ) {
+      auth = await refreshAuth(auth);
+      continue;
+    }
+
+    throw new Error(
+      `Claude usage request failed (${response.status}): ${text.slice(0, 500)}`,
+    );
+  }
+
+  throw new Error("Claude usage request failed after auth refresh");
+}
+
+async function resolveCodexAuth(): Promise<AuthCredentials> {
+  const pi = await readAuthFile(
+    "pi",
+    homePath(".pi/agent/auth.json"),
+    "openai-codex",
+  );
   if (pi) return refreshIfNeeded(pi);
 
-  const codex = await readAuthFile("codex", homePath(".codex/auth.json"));
+  const codex = await readAuthFile(
+    "codex",
+    homePath(".codex/auth.json"),
+    "openai-codex",
+  );
   if (codex) return refreshIfNeeded(codex);
 
   throw new Error(
@@ -322,6 +482,19 @@ async function resolveAuth(): Promise<AuthCredentials> {
   );
 }
 
+async function resolveClaudeAuth(): Promise<AuthCredentials> {
+  const pi = await readAuthFile(
+    "pi",
+    homePath(".pi/agent/auth.json"),
+    "anthropic",
+  );
+  if (pi) return refreshIfNeeded(pi);
+
+  throw new Error(
+    "No usable Anthropic OAuth credentials found. Run pi /login for Claude/Anthropic first.",
+  );
+}
+
 async function refreshIfNeeded(auth: AuthCredentials): Promise<AuthCredentials> {
   if (!auth.refreshToken || !auth.expiresAtMs) return auth;
   if (auth.expiresAtMs > Date.now() + 5 * 60 * 1000) return auth;
@@ -331,22 +504,38 @@ async function refreshIfNeeded(auth: AuthCredentials): Promise<AuthCredentials>
 async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
   if (!auth.refreshToken) return auth;
 
+  const refreshConfig =
+    auth.provider === "anthropic"
+      ? {
+          clientId: CLAUDE_CLIENT_ID,
+          tokenUrl: CLAUDE_TOKEN_URL,
+          label: "Anthropic",
+        }
+      : {
+          clientId: CODEX_CLIENT_ID,
+          tokenUrl: CODEX_TOKEN_URL,
+          label: "Codex",
+        };
   const body = new URLSearchParams({
     grant_type: "refresh_token",
     refresh_token: auth.refreshToken,
-    client_id: CODEX_CLIENT_ID,
+    client_id: refreshConfig.clientId,
   }).toString();
 
-  const result = await localRefresh(body);
+  const result = await localRefresh(body, refreshConfig.tokenUrl);
 
   if (result.code !== 0 || !result.stdout) {
-    throw new Error(result.stderr || "Failed to refresh Codex auth");
+    throw new Error(
+      result.stderr || `Failed to refresh ${refreshConfig.label} auth`,
+    );
   }
 
   const refreshed = JSON.parse(result.stdout) as Record<string, unknown>;
   const accessToken = stringValue(refreshed.access_token);
   if (!accessToken) {
-    throw new Error("Codex auth refresh did not return access_token");
+    throw new Error(
+      `${refreshConfig.label} auth refresh did not return access_token`,
+    );
   }
 
   const refreshToken = stringValue(refreshed.refresh_token) ?? auth.refreshToken;
@@ -365,9 +554,10 @@ async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
 
 async function localRefresh(
   body: string,
+  tokenUrl: string,
 ): Promise<{ code: number; stdout: string; stderr: string }> {
   try {
-    const response = await fetch(TOKEN_URL, {
+    const response = await fetch(tokenUrl, {
       method: "POST",
       headers: { "content-type": "application/x-www-form-urlencoded" },
       body,
@@ -387,12 +577,13 @@ async function localRefresh(
 async function readAuthFile(
   source: "pi" | "codex",
   path: string,
+  provider: AuthCredentials["provider"],
 ): Promise<AuthCredentials | undefined> {
   try {
     const raw = JSON.parse(await readFile(path, "utf8")) as unknown;
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
     return source === "pi"
-      ? parsePiAuth(raw as Record<string, unknown>, path)
+      ? parsePiAuth(raw as Record<string, unknown>, path, provider)
       : parseCodexAuth(raw as Record<string, unknown>, path);
   } catch {
     return undefined;
@@ -402,11 +593,13 @@ async function readAuthFile(
 function parsePiAuth(
   raw: Record<string, unknown>,
   path: string,
+  provider: AuthCredentials["provider"],
 ): AuthCredentials | undefined {
-  const entry = objectValue(raw["openai-codex"]);
+  const entry = objectValue(raw[provider]);
   const accessToken = stringValue(entry?.access);
   if (!accessToken) return undefined;
   return {
+    provider,
     source: "pi",
     path,
     accessToken,
@@ -431,6 +624,7 @@ function parseCodexAuth(
   const accessToken = stringValue(tokens?.access_token);
   if (!accessToken) return undefined;
   return {
+    provider: "openai-codex",
     source: "codex",
     path,
     accessToken,
@@ -451,11 +645,12 @@ async function persistAuth(auth: AuthCredentials): Promise<void> {
   >;
 
   if (auth.source === "pi") {
-    const entry = objectValue(raw["openai-codex"]);
+    const entry = objectValue(raw[auth.provider]);
     if (entry) {
       entry.access = auth.accessToken;
       if (auth.refreshToken) entry.refresh = auth.refreshToken;
       if (auth.expiresAtMs) entry.expires = auth.expiresAtMs;
+      if (auth.accountId) entry.accountId = auth.accountId;
     }
   } else {
     const tokens = objectValue(raw.tokens);
@@ -548,6 +743,25 @@ function normalizeApiWindow(
   return windowFromUsedPercent(label, usedPercent ?? 0, resetAt, now);
 }
 
+function normalizeClaudeUsageWindow(
+  value: Record<string, unknown> | undefined,
+  fallbackLabel: string,
+  now: Date,
+): ProviderStatusWindow | undefined {
+  if (!value) return undefined;
+  const usedPercent =
+    numberValue(value.utilization) ??
+    numberString(stringValue(value.utilization));
+  if (usedPercent === undefined) return undefined;
+
+  return windowFromUsedPercent(
+    fallbackLabel,
+    usedPercent,
+    resetAtFromTimestamp(stringValue(value.resets_at)),
+    now,
+  );
+}
+
 function windowLabelFromSeconds(seconds: number | undefined): string | undefined {
   if (seconds === undefined || seconds <= 0) return undefined;
   if (seconds % 86_400 === 0) return `${seconds / 86_400}d`;
@@ -600,6 +814,12 @@ function normalizeResetAt(value: number | undefined): number | undefined {
   return value > 10_000_000_000 ? Math.round(value / 1000) : value;
 }
 
+function resetAtFromTimestamp(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? Math.round(parsed / 1000) : undefined;
+}
+
 function providerStatusCachePath(providerId: string): string {
   const base =
     process.env.XDG_CACHE_HOME ||

package/src/render.test.ts

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { renderFooterLines } from "./render.ts";
+import {
+  DEFAULT_FOOTER_CONFIG,
+  EMPTY_GIT_INFO,
+  type FooterConfigSnapshot,
+  type ProviderStatusSnapshot,
+  type SessionUsageMetrics,
+} from "./shared.ts";
+
+const theme = {
+  fg: (_color: string, text: string) => text,
+};
+
+const usageMetrics: SessionUsageMetrics = {
+  latest: undefined,
+  totalCost: 0,
+};
+
+const providerStatus: ProviderStatusSnapshot = {
+  provider: "openai-codex",
+  source: "headers",
+  fetchedAt: "2026-05-06T10:00:00Z",
+  state: "ok",
+  primary: {
+    label: "5h",
+    leftPercent: 95,
+    usedPercent: 5,
+  },
+};
+
+const claudeProviderStatus: ProviderStatusSnapshot = {
+  provider: "anthropic",
+  source: "api",
+  fetchedAt: "2026-06-16T10:00:00Z",
+  state: "ok",
+  primary: {
+    label: "5h",
+    leftPercent: 100,
+    usedPercent: 0,
+  },
+  secondary: {
+    label: "7d",
+    leftPercent: 92,
+    usedPercent: 8,
+  },
+};
+
+const footerConfig: FooterConfigSnapshot = {
+  ...DEFAULT_FOOTER_CONFIG,
+  iconFamily: "ascii",
+  providerStatus: {
+    ...DEFAULT_FOOTER_CONFIG.providerStatus,
+    display: "text",
+  },
+  widgets: {
+    "context-bar": { enabled: false },
+    "context-capacity": { enabled: false },
+    location: { enabled: false },
+  },
+};
+
+function contextWithModel(model: { id: string; name: string; provider?: string }) {
+  return {
+    cwd: "/repo",
+    model,
+    getContextUsage: () => ({
+      contextWindow: 200_000,
+      tokens: 0,
+      percent: 0,
+    }),
+    sessionManager: {
+      getBranch: () => [],
+    },
+  };
+}
+
+test("renderFooterLines hides Codex provider status for non-OpenAI models", () => {
+  const lines = renderFooterLines(
+    120,
+    contextWithModel({
+      provider: "anthropic",
+      id: "claude-sonnet-4",
+      name: "Claude Sonnet 4",
+    }) as never,
+    EMPTY_GIT_INFO,
+    "off",
+    theme as never,
+    usageMetrics,
+    footerConfig,
+    [],
+    [providerStatus],
+  );
+
+  assert.doesNotMatch(lines.join("\n"), /5h:95%/);
+});
+
+test("renderFooterLines shows Codex provider status for OpenAI models", () => {
+  const lines = renderFooterLines(
+    120,
+    contextWithModel({
+      provider: "openai",
+      id: "gpt-5-codex",
+      name: "GPT-5 Codex",
+    }) as never,
+    EMPTY_GIT_INFO,
+    "off",
+    theme as never,
+    usageMetrics,
+    footerConfig,
+    [],
+    [providerStatus],
+  );
+
+  assert.match(lines.join("\n"), /5h:95%/);
+});
+
+test("renderFooterLines shows Anthropic provider status for Claude models", () => {
+  const lines = renderFooterLines(
+    120,
+    contextWithModel({
+      provider: "anthropic",
+      id: "claude-sonnet-4",
+      name: "Claude Sonnet 4",
+    }) as never,
+    EMPTY_GIT_INFO,
+    "off",
+    theme as never,
+    usageMetrics,
+    footerConfig,
+    [],
+    [claudeProviderStatus],
+  );
+
+  assert.match(lines.join("\n"), /5h:100% 7d:92%/);
+});
+
+test("renderFooterLines hides Anthropic provider status for OpenAI models", () => {
+  const lines = renderFooterLines(
+    120,
+    contextWithModel({
+      provider: "openai",
+      id: "gpt-5-codex",
+      name: "GPT-5 Codex",
+    }) as never,
+    EMPTY_GIT_INFO,
+    "off",
+    theme as never,
+    usageMetrics,
+    footerConfig,
+    [],
+    [claudeProviderStatus],
+  );
+
+  assert.doesNotMatch(lines.join("\n"), /5h:100%/);
+});

package/src/render.ts

@@ -49,6 +49,7 @@ import {
   buildProviderStatusGauge,
   formatProviderStatusReset,
   formatProviderStatusText,
+  isProviderStatusRelevantToModel,
   providerStatusColor,
 } from "./provider-status.ts";
 
@@ -917,6 +918,9 @@ export function renderFooterLines(
     usageMetrics,
     footerConfig.iconFamily,
   );
+  const activeProviderStatuses = providerStatuses.filter((snapshot) =>
+    isProviderStatusRelevantToModel(snapshot.provider, ctx.model),
+  );
   const renderCtx: WidgetRenderContext = {
     width,
     theme,
@@ -924,7 +928,7 @@ export function renderFooterLines(
     gaugeWidth: footerConfig.gaugeWidth,
     gaugeColors: footerConfig.gaugeColors,
     metrics,
-    providerStatuses,
+    providerStatuses: activeProviderStatuses,
     providerStatusConfig: footerConfig.providerStatus,
     defaultIconColor: footerConfig.defaultIconColor,
     defaultTextColor: footerConfig.defaultTextColor,

package/src/shared.ts

@@ -463,7 +463,10 @@ export interface FooterConfigSnapshot {
   extensionWidgets: Record<string, FooterWidgetConfigOverride>;
 }
 
-export const PROVIDER_STATUS_PROVIDER_IDS = ["openai-codex"] as const;
+export const PROVIDER_STATUS_PROVIDER_IDS = [
+  "openai-codex",
+  "anthropic",
+] as const;
 
 export type ProviderStatusProviderId =
   (typeof PROVIDER_STATUS_PROVIDER_IDS)[number];
@@ -484,7 +487,7 @@ export interface ProviderStatusConfigSnapshot {
 export const DEFAULT_PROVIDER_STATUS_CONFIG: ProviderStatusConfigSnapshot = {
   refreshMs: 60_000,
   cacheTtlMs: 60_000,
-  providers: ["openai-codex"],
+  providers: ["openai-codex", "anthropic"],
   display: "gauge",
   showCredits: false,
   showReset: false,