@jameslovespancakes/pi-plus 1.0.17 → 1.0.18

package/README.md

@@ -73,6 +73,14 @@ Your live quota, always in the footer:
 With more than two accounts only the two most recently used are listed, so the
 footer stays a fixed height however many you pool.
 
+The right-hand column follows the model in use. It shows Codex by default and
+swaps to Gemini while a `gemini/*` model is selected: one bar per quota family
+(Flash, Pro, and Claude or GPT-OSS), pooled across your Gemini accounts, with
+the active family highlighted. Whether a family resets weekly or every five
+hours depends on the account's plan; the reset time shows which. Kimi and Grok
+publish no usage endpoint, so their column shows only the last rate-limit
+reading, if any.
+
 Account and routing commands are provider-agnostic. Sequential routing uses
 account order; quota-aware routing uses reported capacity and fairly probes
 accounts whose provider does not publish quota headers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jameslovespancakes/pi-plus",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "type": "module",
   "description": "pi and more",
   "license": "MIT",

package/src/core/anthropic/quota.ts

@@ -61,12 +61,16 @@ export function parseQuota(body: any, now = Date.now()): QuotaSnapshot {
     };
   };
 
+  // `limits` also restates the session and weekly windows (`kind: session`,
+  // `weekly_all`) with no scope. Only model-scoped entries are extra limits;
+  // keeping the others filed the 5h and 7d windows a second time as "scoped".
   const scoped = (Array.isArray(body?.limits) ? body.limits : [])
     .map((limit: any) => {
+      const name = limit?.scope?.model?.display_name;
       const used = pct(limit?.percent);
-      if (used === undefined) return undefined;
+      if (typeof name !== "string" || !name || used === undefined) return undefined;
       return {
-        id: String(limit?.scope?.model?.display_name ?? limit?.id ?? "scoped").toLowerCase(),
+        id: name.toLowerCase(),
         usedPercent: used,
         remainingPercent: 100 - used,
         resetsAt: typeof limit?.resets_at === "string" ? limit.resets_at : undefined,

package/src/core/gemini/client.ts

@@ -154,6 +154,45 @@ export async function fetchUserEmail(token: string, signal?: AbortSignal): Promi
   }
 }
 
+/** One `retrieveUserQuota` bucket: a runtime model's remaining share of its window. */
+export interface QuotaBucket {
+  modelId: string;
+  /** 0..1 of the window left. */
+  remainingFraction: number;
+  /** ISO time the window resets; absent for buckets with no window. */
+  resetTime?: string;
+}
+
+/**
+ * The account's quota, one bucket per runtime model id. Endpoints are tried in
+ * order and the first answer wins: quota is per account, not per endpoint.
+ * Throws only when no endpoint answered at all.
+ */
+export async function fetchUserQuota(
+  token: string,
+  projectId: string,
+  signal?: AbortSignal,
+): Promise<QuotaBucket[]> {
+  for (const endpoint of GEMINI_ENDPOINTS) {
+    const answer = await postJson(endpoint, "retrieveUserQuota", token, { project: projectId }, signal);
+    if (!isRecord(answer)) continue;
+    const buckets = Array.isArray(answer.buckets) ? answer.buckets : [];
+    return buckets.flatMap((bucket): QuotaBucket[] => {
+      if (!isRecord(bucket) || typeof bucket.modelId !== "string") return [];
+      // proto3 JSON omits zero values, so an exhausted bucket arrives with no
+      // `remainingFraction` at all. Absent means empty, not unknown.
+      const fraction = bucket.remainingFraction === undefined ? 0 : Number(bucket.remainingFraction);
+      if (!Number.isFinite(fraction)) return [];
+      return [{
+        modelId: bucket.modelId,
+        remainingFraction: Math.min(1, Math.max(0, fraction)),
+        ...(typeof bucket.resetTime === "string" && bucket.resetTime && { resetTime: bucket.resetTime }),
+      }];
+    });
+  }
+  throw new Error("Gemini did not return quota from any endpoint.");
+}
+
 /** One entry of `fetchAvailableModels`, keyed by its runtime model id. */
 export interface RuntimeModelInfo {
   isInternal?: boolean;

package/src/core/gemini/quota.ts

@@ -0,0 +1,58 @@
+import type { QuotaBucket } from "./client.ts";
+
+/**
+ * Gemini quota, grouped the way the backend pools it.
+ *
+ * `retrieveUserQuota` answers per runtime model id (`gemini-3.8-flash-high`,
+ * `gemini-pro-agent`, `claude-opus-4-6-thinking`, …), but the ids of one
+ * family draw on one shared allowance: every Flash variant reports the same
+ * fraction and reset, as does every Pro variant. The window differs by plan —
+ * a paid account resets weekly, a free one every five hours — so the bars are
+ * labelled by family and the reset time says which window it is.
+ */
+
+export const GEMINI_QUOTA_FAMILIES = ["Flash", "Pro", "Claude", "GPT"] as const;
+export type GeminiQuotaFamily = typeof GEMINI_QUOTA_FAMILIES[number];
+
+/**
+ * The family a public or runtime model id draws quota from. Undefined for ids
+ * that are not agent models (tab completion, image, the `-lite` helpers the
+ * client uses for commit messages and search), so they never skew a family.
+ */
+export function geminiQuotaFamily(modelId: string | undefined): GeminiQuotaFamily | undefined {
+  const id = (modelId ?? "").toLowerCase();
+  if (id.startsWith("claude-")) return "Claude";
+  if (id.startsWith("gpt-oss")) return "GPT";
+  if (!id.startsWith("gemini-") || /image|lite/.test(id)) return undefined;
+  if (/(^|-)pro(-|$)/.test(id)) return "Pro";
+  if (/(^|-)flash(-|$)/.test(id)) return "Flash";
+  return undefined;
+}
+
+export interface GeminiFamilyQuota {
+  family: GeminiQuotaFamily;
+  /** Percent left, 0..100. */
+  remaining: number;
+  resetAt?: number;
+}
+
+/**
+ * One figure per family: the most depleted bucket in it, so a variant that
+ * has run dry is never hidden behind a sibling that has not.
+ */
+export function summarizeGeminiQuota(buckets: readonly QuotaBucket[]): GeminiFamilyQuota[] {
+  const byFamily = new Map<GeminiQuotaFamily, GeminiFamilyQuota>();
+  for (const bucket of buckets) {
+    const family = geminiQuotaFamily(bucket.modelId);
+    if (!family) continue;
+    const remaining = bucket.remainingFraction * 100;
+    const parsed = bucket.resetTime ? Date.parse(bucket.resetTime) : Number.NaN;
+    const resetAt = Number.isFinite(parsed) ? parsed : undefined;
+    const current = byFamily.get(family);
+    const lower = !current || remaining < current.remaining;
+    const sooner = current && remaining === current.remaining
+      && resetAt !== undefined && (current.resetAt === undefined || resetAt < current.resetAt);
+    if (lower || sooner) byFamily.set(family, { family, remaining, ...(resetAt !== undefined && { resetAt }) });
+  }
+  return GEMINI_QUOTA_FAMILIES.flatMap((family) => byFamily.get(family) ?? []);
+}

package/src/core/quota/pool.ts

@@ -19,6 +19,16 @@ export type UsageRow = {
  */
 export const CLAUDE_FRESH_MS = 12 * 60_000;
 export const isClaudeAccount = (row: UsageRow) => row.group.startsWith("Claude ") && !row.group.startsWith("Claude pool ×");
+export const isGeminiAccount = (row: UsageRow) => row.group.startsWith("Gemini ");
+
+/**
+ * Pooled providers with no usage endpoint, and the group their header-observed
+ * rate-limit reading is filed under. Their bars can only show what responses said.
+ */
+export const OBSERVED_PROVIDERS: ReadonlyArray<readonly [providerId: string, group: string]> = [
+  ["kimi-coding", "Kimi"],
+  ["xai", "Grok"],
+];
 export const isFresh = (row: UsageRow, now = Date.now()) => !row.stale && !!row.checkedAt
   && now - row.checkedAt < CLAUDE_FRESH_MS && (!row.resetAt || row.resetAt > now);
 
@@ -26,7 +36,19 @@ export const isFresh = (row: UsageRow, now = Date.now()) => !row.stale && !!row.
  * Without published capacities this is explicitly an equal-account estimate.
  */
 export function combinedWindow(rows: UsageRow[], label: string, expected: number, now = Date.now(), allowPartial = false) {
-  const matching = rows.filter((r) => isClaudeAccount(r) && r.label === label && isFresh(r, now));
+  return pooledWindow(rows, label, expected, isClaudeAccount, now, allowPartial);
+}
+
+/** {@link combinedWindow} for any pooled provider's account rows. */
+export function pooledWindow(
+  rows: UsageRow[],
+  label: string,
+  expected: number,
+  isMember: (row: UsageRow) => boolean,
+  now = Date.now(),
+  allowPartial = false,
+) {
+  const matching = rows.filter((r) => isMember(r) && r.label === label && isFresh(r, now));
   const partial = matching.length !== expected;
   if (!expected || !matching.length || (partial && !allowPartial)) return undefined;
   const weighted = matching.every((r) => typeof r.capacity === "number" && r.capacity > 0);

package/src/core/quota/usage-source.ts

@@ -1,13 +1,19 @@
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { loadOAuthPool, saveOAuthAccount, sharedOAuthPoolStore, type PooledOAuthAccount } from "../accounts/oauth-pool.ts";
+import { refreshAbortSignal, type AccountQuotaState } from "../accounts/routing.ts";
+import { anthropicAccountIdentity, cachedAnthropicAccountIdentity } from "../anthropic/identity.ts";
 import { loadAccounts, saveAccount, type Account as AnthropicAccount } from "../anthropic/store.ts";
 import { refreshToken } from "../anthropic/oauth.ts";
-import { loadCodexAccounts } from "../codex/store.ts";
-import type { UsageRow } from "./pool.ts";
+import { claimsOf } from "../codex/store.ts";
+import { fetchUserQuota } from "../gemini/client.ts";
+import { credentialEmail } from "../gemini/credentials.ts";
+import { geminiOAuth, requestProjectId } from "../gemini/oauth.ts";
+import { summarizeGeminiQuota } from "../gemini/quota.ts";
+import { agentPath, readJson } from "../store.ts";
+import { CLAUDE_FRESH_MS, OBSERVED_PROVIDERS, type UsageRow } from "./pool.ts";
 
 /**
- * Fetches subscription quota from the Claude and Codex endpoints.
+ * Fetches subscription quota from the Claude, Codex and Gemini endpoints, and
+ * reports what response headers showed for providers with no usage endpoint.
  *
  * Pure data access: no pi imports, no module-level mutable state, no rendering.
  * Everything here returns values so it can be tested without a live agent.
@@ -19,10 +25,67 @@ const TIMEOUT_MS = 10_000;
 export interface SourceResult {
   rows: UsageRow[];
   errors: string[];
+  /** Claude account groups expected to report. */
   groups: string[];
+  /** Gemini account groups expected to report. */
+  geminiGroups: string[];
   codexPlan?: string;
 }
 
+/** Reads a provider's credential as pi stores it (pi's `readStoredCredential`). */
+export type CredentialReader = (providerId: string) => unknown;
+
+export interface SourceOptions {
+  /**
+   * How the primary (pi-owned) credential is read. It must be read as stored:
+   * `modelRegistry.getProviderAuth()` returns whatever account *routing*
+   * picked, which can be a pooled one, so figures labelled as the primary
+   * account could silently belong to another.
+   */
+  readCredential?: CredentialReader;
+}
+
+/** Fallback when pi's reader was not supplied: the same file pi reads. */
+function readAuthFile(providerId: string): unknown {
+  return readJson<Record<string, unknown>>(agentPath("auth.json"), {})[providerId];
+}
+
+interface StoredOAuth {
+  type: "oauth";
+  access: string;
+  refresh: string;
+  expires: number;
+  [key: string]: unknown;
+}
+
+function usableOAuth(value: unknown, now = Date.now()): value is StoredOAuth {
+  const credential = value as Partial<StoredOAuth> | undefined;
+  return credential?.type === "oauth"
+    && typeof credential.access === "string" && credential.access.length > 0
+    && (typeof credential.expires !== "number" || credential.expires > now + 60_000);
+}
+
+/**
+ * The provider's primary OAuth credential, or undefined when pi holds none
+ * (not logged in, or an API key, which has no subscription quota).
+ *
+ * An expiring credential is refreshed by pi itself (`getProviderAuth`
+ * refreshes and persists before it routes) and then read back, so rotating
+ * refresh tokens are only ever spent by pi.
+ */
+async function primaryOAuth(ctx: any, providerId: string, read: CredentialReader): Promise<StoredOAuth | undefined> {
+  const stored = read(providerId) as { type?: unknown } | undefined;
+  if (stored?.type !== "oauth") return undefined;
+  if (usableOAuth(stored)) return stored;
+
+  await ctx?.modelRegistry?.getProviderAuth?.(providerId);
+  const refreshed = read(providerId);
+  if (usableOAuth(refreshed)) return refreshed;
+  throw new Error(`login expired, run /login ${providerId}`);
+}
+
+const errorText = (error: unknown) => error instanceof Error ? error.message : String(error);
+
 function pct(value: unknown): number | undefined {
   if (value == null || typeof value === "boolean" || (typeof value === "string" && !value.trim())) return undefined;
   const n = typeof value === "number" ? value : Number(value);
@@ -60,14 +123,16 @@ async function claudeUsage(group: string, token: string): Promise<{ rows: UsageR
   };
   push("5h", body.five_hour);
   push("7d", body.seven_day);
-  push("7d Opus", body.seven_day_opus ?? body.seven_day_omelette);
-  push("7d Sonnet", body.seven_day_sonnet);
+  // Scoped labels are lower case in every source (the stored snapshot keeps
+  // lower-cased ids), or one limit pools as two half-reported windows.
+  push("7d opus", body.seven_day_opus ?? body.seven_day_omelette);
+  push("7d sonnet", body.seven_day_sonnet);
 
   for (const limit of Array.isArray(body.limits) ? body.limits : []) {
     const scoped = limit?.scope?.model?.display_name;
     const used = pct(limit?.percent);
-    if (!scoped || used === undefined) continue;
-    const label = `7d ${scoped}`;
+    if (typeof scoped !== "string" || !scoped || used === undefined) continue;
+    const label = `7d ${scoped.toLowerCase()}`;
     if (rows.some((row) => row.label === label)) continue;
     rows.push({ group, label, remaining: 100 - used, resetAt: resetToMs(limit?.resets_at) });
   }
@@ -131,33 +196,59 @@ function rowsFromSnapshot(group: string, quota: any): UsageRow[] | undefined {
   push("5h", quota.five_hour);
   push("7d", quota.seven_day);
   for (const scoped of Array.isArray(quota.scoped) ? quota.scoped : []) {
-    if (typeof scoped?.remainingPercent !== "number" || !scoped?.id) continue;
-    push(`7d ${scoped.id}`, scoped);
+    if (typeof scoped?.remainingPercent !== "number" || typeof scoped?.id !== "string" || !scoped.id) continue;
+    // Snapshots written before the fix restate the 5h/7d windows as "scoped".
+    if (scoped.id === "scoped") continue;
+    push(`7d ${scoped.id.toLowerCase()}`, scoped);
   }
   return rows.length ? rows : undefined;
 }
 
-export async function fetchClaudeRows(ctx: any): Promise<{ rows: UsageRow[]; errors: string[]; groups: string[] }> {
+const claudeGroup = (account: AnthropicAccount) => `Claude ${account.label ?? account.id.slice(0, 8)}`;
+
+export async function fetchClaudeRows(
+  ctx: any,
+  options: SourceOptions = {},
+): Promise<{ rows: UsageRow[]; errors: string[]; groups: string[] }> {
+  const read = options.readCredential ?? readAuthFile;
   const rows: UsageRow[] = [];
   const errors: string[] = [];
   const accounts: Array<{ group: string; token?: string; account?: AnthropicAccount }> = [];
+  const groups = new Set<string>();
 
+  let sidecars: AnthropicAccount[] = [];
   try {
-    const token = (await ctx.modelRegistry.getProviderAuth("anthropic"))?.auth?.apiKey;
-    if (token) accounts.push({ group: "Claude Personal", token });
-    else errors.push("Claude Personal: not logged in");
+    sidecars = (loadAccounts()?.accounts ?? []).filter((account) => account.type === "oauth" && account.enabled !== false);
   } catch (error) {
-    errors.push(`Claude Personal: ${error instanceof Error ? error.message : String(error)}`);
+    errors.push(`Claude accounts: ${errorText(error)}`);
   }
+  const taken = new Set(sidecars.map(claudeGroup));
+  const primaryGroup = taken.has("Claude Personal") ? "Claude Primary" : "Claude Personal";
 
   try {
-    const storage = loadAccounts();
-    for (const account of storage?.accounts ?? []) {
-      if (account.type !== "oauth" || account.enabled === false) continue;
-      accounts.push({ group: `Claude ${account.label ?? account.id.slice(0, 8)}`, account });
+    const primary = await primaryOAuth(ctx, "anthropic", read);
+    if (!primary) {
+      errors.push(`${primaryGroup}: not logged in`);
+    } else {
+      // pi's own login is often the same Claude account as a pooled one.
+      // Counting it twice filed every window twice and marked the pool partial.
+      const identity = cachedAnthropicAccountIdentity(primary.access)
+        ?? await anthropicAccountIdentity(primary.access).catch(() => undefined);
+      const twin = identity ? sidecars.find((account) => account.identity === identity) : undefined;
+      if (!twin) {
+        accounts.push({ group: primaryGroup, token: primary.access });
+        groups.add(primaryGroup);
+      }
     }
   } catch (error) {
-    errors.push(`Claude accounts: ${error instanceof Error ? error.message : String(error)}`);
+    // Logged in but unreadable: still an account the pool expects.
+    groups.add(primaryGroup);
+    errors.push(`${primaryGroup}: ${errorText(error)}`);
+  }
+
+  for (const account of sidecars) {
+    accounts.push({ group: claudeGroup(account), account });
+    groups.add(claudeGroup(account));
   }
 
   for (const entry of accounts) {
@@ -185,35 +276,30 @@ export async function fetchClaudeRows(ctx: any): Promise<{ rows: UsageRow[]; err
     }
   }
 
-  return { rows, errors, groups: [...new Set(["Claude Personal", ...accounts.map((entry) => entry.group)])] };
+  return { rows, errors, groups: [...groups] };
 }
 
-function codexAccountId(): string | undefined {
-  // Prefer an enabled account from our own pool, so /usage reflects the
-  // accounts /accounts manages rather than only pi's single credential.
-  try {
-    const pooled = loadCodexAccounts().accounts.find((a) => a.enabled !== false && a.accountId);
-    if (pooled?.accountId) return pooled.accountId;
-  } catch { /* fall through */ }
-  try {
-    const auth = JSON.parse(readFileSync(join(homedir(), ".pi", "agent", "auth.json"), "utf8"));
-    const credential = auth["openai-codex"];
-    if (credential?.accountId) return credential.accountId;
-    if (credential?.account_id) return credential.account_id;
-  } catch { /* fall through */ }
-  try {
-    const codex = JSON.parse(readFileSync(join(homedir(), ".codex", "auth.json"), "utf8"));
-    return codex?.tokens?.account_id ?? codex?.tokens?.accountId;
-  } catch {
-    return undefined;
+/**
+ * The ChatGPT account the token belongs to. It must come from the same
+ * credential: an id taken from a pooled account while the token is pi's
+ * primary asks the endpoint about one account on behalf of another.
+ */
+function codexAccountId(credential: StoredOAuth): string | undefined {
+  for (const value of [credential.accountId, credential.account_id, claimsOf(credential.access).accountId]) {
+    if (typeof value === "string" && value) return value;
   }
+  return undefined;
 }
 
-export async function fetchCodexRows(ctx: any): Promise<{ rows: UsageRow[]; error?: string; plan?: string }> {
+export async function fetchCodexRows(
+  ctx: any,
+  options: SourceOptions = {},
+): Promise<{ rows: UsageRow[]; error?: string; plan?: string }> {
   try {
-    const token = (await ctx.modelRegistry.getProviderAuth("openai-codex"))?.auth?.apiKey;
-    const accountId = codexAccountId();
-    if (!token) return { rows: [], error: "Codex: not logged in" };
+    const primary = await primaryOAuth(ctx, "openai-codex", options.readCredential ?? readAuthFile);
+    if (!primary) return { rows: [], error: "Codex: not logged in" };
+    const token = primary.access;
+    const accountId = codexAccountId(primary);
     if (!accountId) return { rows: [], error: "Codex: no ChatGPT account id" };
 
     const response = await fetch("https://chatgpt.com/backend-api/wham/usage", {
@@ -277,13 +363,150 @@ export async function fetchCodexRows(ctx: any): Promise<{ rows: UsageRow[]; erro
   }
 }
 
+const GEMINI = "gemini";
+const GEMINI_PRIMARY_GROUP = "Gemini Primary";
+
+/** A pooled Gemini account with a live token, refreshed and saved if it had lapsed. */
+async function freshGeminiAccount(account: PooledOAuthAccount): Promise<PooledOAuthAccount> {
+  if (account.expires > Date.now() + 60_000) return account;
+  // Google does not rotate refresh tokens on use, so a refresh racing the
+  // serving path's own is harmless: both tokens stay valid.
+  const credential = await geminiOAuth.refresh(account, refreshAbortSignal());
+  const updated = { ...account, ...credential };
+  saveOAuthAccount(GEMINI, updated);
+  return updated;
+}
+
+/**
+ * Gemini quota per account from `retrieveUserQuota`, one row per model
+ * family (Flash, Pro, Claude, GPT). Silent when no Gemini account exists.
+ */
+export async function fetchGeminiRows(
+  ctx: any,
+  options: SourceOptions = {},
+): Promise<{ rows: UsageRow[]; errors: string[]; groups: string[] }> {
+  const errors: string[] = [];
+  const accounts: Array<{ group: string; credential?: StoredOAuth; account?: PooledOAuthAccount }> = [];
+  const groups: string[] = [];
+  const emails = new Set<string>();
+
+  try {
+    const primary = await primaryOAuth(ctx, GEMINI, options.readCredential ?? readAuthFile);
+    if (primary) {
+      accounts.push({ group: GEMINI_PRIMARY_GROUP, credential: primary });
+      const email = credentialEmail(primary as any);
+      if (email) emails.add(email.toLowerCase());
+    }
+  } catch (error) {
+    groups.push(GEMINI_PRIMARY_GROUP);
+    errors.push(`${GEMINI_PRIMARY_GROUP}: ${errorText(error)}`);
+  }
+
+  try {
+    for (const account of loadOAuthPool(GEMINI).accounts) {
+      if (account.enabled === false || !account.access) continue;
+      // The same Google account signed in twice has one allowance, not two.
+      const email = credentialEmail(account)?.toLowerCase();
+      if (email && emails.has(email)) continue;
+      if (email) emails.add(email);
+      let group = `Gemini ${account.label || email || account.id.slice(0, 8)}`;
+      if (accounts.some((entry) => entry.group === group)) group = `${group} ${account.id.slice(0, 4)}`;
+      accounts.push({ group, account });
+    }
+  } catch (error) {
+    errors.push(`Gemini accounts: ${errorText(error)}`);
+  }
+
+  const results = await Promise.all(accounts.map(async (entry): Promise<{ rows: UsageRow[]; error?: string }> => {
+    try {
+      const credential = entry.account ? await freshGeminiAccount(entry.account) : entry.credential!;
+      const buckets = await fetchUserQuota(
+        credential.access,
+        requestProjectId(credential as any),
+        AbortSignal.timeout(TIMEOUT_MS),
+      );
+      const checkedAt = Date.now();
+      const rows = summarizeGeminiQuota(buckets).map((family): UsageRow => ({
+        group: entry.group,
+        label: family.family,
+        remaining: family.remaining,
+        resetAt: family.resetAt,
+        checkedAt,
+      }));
+      return rows.length ? { rows } : { rows, error: `${entry.group}: quota unavailable` };
+    } catch (error) {
+      const message = errorText(error);
+      return {
+        rows: [],
+        error: /invalid_grant/i.test(message)
+          ? `${entry.group}: login expired, run ${entry.account
+            ? `/accounts reauth gemini ${entry.account.label || entry.account.id}`
+            : "/login gemini"}`
+          : `${entry.group}: ${message}`,
+      };
+    }
+  }));
+
+  return {
+    rows: results.flatMap((result) => result.rows),
+    errors: [...errors, ...results.flatMap((result) => result.error ?? [])],
+    groups: [...groups, ...accounts.map((entry) => entry.group)],
+  };
+}
+
+function observedRemaining(quota: AccountQuotaState, now: number): number | undefined {
+  // A 429 reading means nothing once its block has cleared.
+  if (quota.blockedUntil !== undefined) return quota.blockedUntil > now ? 0 : undefined;
+  return quota.remainingPercent;
+}
+
+/**
+ * What response headers last said for providers without a usage endpoint:
+ * the account routing can still use most. A rate-limit reading, not a
+ * subscription allowance, so it is labelled "rate" and dropped once old.
+ */
+export function observedRows(now = Date.now()): UsageRow[] {
+  return OBSERVED_PROVIDERS.flatMap(([providerId, group]): UsageRow[] => {
+    let quotas: AccountQuotaState[] = [];
+    try {
+      const store = sharedOAuthPoolStore(providerId);
+      quotas = [
+        store.primaryQuota(),
+        ...store.load().accounts.filter((account) => account.enabled !== false).map((account) => account.quota),
+      ].filter((quota): quota is AccountQuotaState => !!quota);
+    } catch {
+      return [];
+    }
+
+    const current = quotas.filter((quota) => observedRemaining(quota, now) !== undefined
+      && ((quota.blockedUntil ?? 0) > now || now - quota.checkedAt < CLAUDE_FRESH_MS));
+    if (current.length === 0) return [];
+    const best = current.reduce((left, right) =>
+      observedRemaining(right, now)! > observedRemaining(left, now)! ? right : left);
+    const blocked = (best.blockedUntil ?? 0) > now;
+    return [{
+      group,
+      label: "rate",
+      remaining: observedRemaining(best, now)!,
+      resetAt: blocked ? best.blockedUntil : best.resetAt,
+      // A live block stays current until it clears, however old the reading.
+      checkedAt: blocked ? now : best.checkedAt,
+    }];
+  });
+}
+
 /** One full poll of every configured subscription source. */
-export async function fetchAll(ctx: any): Promise<SourceResult> {
-  const [claude, codex] = await Promise.all([fetchClaudeRows(ctx), fetchCodexRows(ctx)]);
+export async function fetchAll(ctx: any, options: SourceOptions = {}): Promise<SourceResult> {
+  const [claude, codex, gemini] = await Promise.all([
+    fetchClaudeRows(ctx, options),
+    fetchCodexRows(ctx, options),
+    fetchGeminiRows(ctx, options),
+  ]);
   return {
-    rows: [...claude.rows, ...codex.rows],
-    errors: [...claude.errors, codex.error].filter((error): error is string => !!error),
+    rows: [...claude.rows, ...codex.rows, ...gemini.rows, ...observedRows()],
+    errors: [...claude.errors, codex.error, ...gemini.errors].filter((error): error is string => !!error),
     groups: claude.groups,
+    geminiGroups: gemini.groups,
     codexPlan: codex.plan,
   };
 }

package/src/domains/models/catalog-tool.ts

@@ -13,6 +13,8 @@ import {
   refreshQuality,
 } from "../../core/catalog/quality.ts";
 import { ensureFresh, usageState } from "../../services/usage-service.ts";
+import { geminiQuotaFamily } from "../../core/gemini/quota.ts";
+import { combinedWindow, isGeminiAccount, pooledWindow } from "../../core/quota/pool.ts";
 import { env, isFromProcessEnv, maskSecret, setEnv } from "../../core/env.ts";
 import { fitId } from "../../ui/format.ts";
 
@@ -53,14 +55,24 @@ interface Entry {
   efficiency: { intelligencePerDollar?: number; codingPerDollar?: number; agenticPerDollar?: number };
 }
 
-function quotaFor(provider: string): number | undefined {
-  const rows = usageState().rows;
-  const match = provider === "anthropic"
-    ? rows.find((row) => row.group.includes("pool") && row.label === "5h")
-      ?? rows.find((row) => row.group.startsWith("Claude ") && row.label === "5h")
-    : provider === "openai-codex"
-      ? rows.find((row) => row.group === "Codex" && row.label === "weekly")
-      : undefined;
+function quotaFor(provider: string, modelId: string): number | undefined {
+  const state = usageState();
+  const rows = state.rows;
+  if (provider === "anthropic") {
+    // The pool's figure, not whichever account happens to be listed first.
+    const pool = combinedWindow(rows, "5h", state.accounts, Date.now(), true);
+    return pool ? Math.round(pool.remaining) : undefined;
+  }
+  if (provider === "gemini") {
+    // Gemini pools per model family, so the figure depends on the model.
+    const family = geminiQuotaFamily(modelId);
+    const expected = state.geminiAccounts || new Set(rows.filter(isGeminiAccount).map((row) => row.group)).size;
+    const pool = family ? pooledWindow(rows, family, expected, isGeminiAccount, Date.now(), true) : undefined;
+    return pool ? Math.round(pool.remaining) : undefined;
+  }
+  const match = provider === "openai-codex"
+    ? rows.find((row) => row.group === "Codex" && row.label === "weekly")
+    : undefined;
   return match ? Math.round(match.remaining) : undefined;
 }
 
@@ -76,7 +88,7 @@ function buildEntry(model: any): Entry {
     id: `${model.provider}/${model.id}`,
     provider: model.provider,
     billing: SUBSCRIPTION_PROVIDERS.has(model.provider) ? "subscription" : "metered",
-    quotaLeftPercent: quotaFor(model.provider),
+    quotaLeftPercent: quotaFor(model.provider, model.id),
     contextWindow: model.contextWindow,
     maxTokens: model.maxTokens,
     reasoning: !!model.reasoning,

package/src/domains/subscriptions/footer.ts

@@ -1,6 +1,14 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { readStoredCredential, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { refreshUsage, startPolling, stopPolling, subscribe, usageState } from "../../services/usage-service.ts";
+import { isGeminiAccount } from "../../core/quota/pool.ts";
+import {
+  configureUsageSources,
+  refreshUsage,
+  startPolling,
+  stopPolling,
+  subscribe,
+  usageState,
+} from "../../services/usage-service.ts";
 import { renderUsageLines, usageSummaryText } from "../../ui/usage-bars.ts";
 import { formatTokens, sanitize } from "../../ui/format.ts";
 
@@ -48,7 +56,23 @@ function usageSignature(entries: any[]): string {
   return [entries.length, last?.id, usage?.input, usage?.output, usage?.cacheRead, usage?.cacheWrite, usage?.cost?.total].join(":");
 }
 
+/**
+ * True when the column the footer shows for `provider` has nothing to draw
+ * yet, e.g. right after a first `/login gemini`. Waiting for the next poll
+ * would leave the swapped-in column empty for minutes.
+ */
+function columnIsEmpty(provider: string | undefined): boolean {
+  const rows = usageState().rows;
+  if (provider === "gemini") return !rows.some(isGeminiAccount);
+  if (provider === "openai-codex") return !rows.some((row) => row.group === "Codex");
+  return false;
+}
+
 export function registerFooter(pi: ExtensionAPI): void {
+  // The primary account's quota must be read from pi's store as-is; the
+  // registry would hand back whichever pooled account routing picked.
+  configureUsageSources({ readCredential: (providerId) => readStoredCredential(providerId) });
+
   let showUsage = true;
   let requestRender: (() => void) | undefined;
   let unsubscribe: (() => void) | undefined;
@@ -137,12 +161,8 @@ export function registerFooter(pi: ExtensionAPI): void {
           }
 
           if (showUsage) {
-            lines.push(...renderUsageLines(
-              usageState(),
-              theme,
-              width,
-              model?.provider === "anthropic" ? model.id : undefined,
-            ));
+            // The right-hand column follows the provider in use.
+            lines.push(...renderUsageLines(usageState(), theme, width, { provider: model?.provider, modelId: model?.id }));
           }
 
           // Final safety net: never emit a line wider than the terminal.
@@ -159,9 +179,11 @@ export function registerFooter(pi: ExtensionAPI): void {
     startPolling(ctx);
   });
 
-  pi.on("model_select", async (_event, ctx) => {
+  pi.on("model_select", async (event, ctx) => {
     apply(ctx);
     requestRender?.();
+    // The swap itself is immediate; fetch only if the new column has no figures.
+    if (ctx.hasUI && showUsage && columnIsEmpty(event.model?.provider)) void refreshUsage(ctx, true);
   });
 
   pi.on("agent_settled", async (_event, ctx) => {

package/src/services/usage-service.ts

@@ -1,6 +1,6 @@
 import { agentPath, readJson, writeJson } from "../core/store.ts";
-import { isClaudeAccount, type UsageRow } from "../core/quota/pool.ts";
-import { fetchAll } from "../core/quota/usage-source.ts";
+import { isClaudeAccount, isGeminiAccount, type UsageRow } from "../core/quota/pool.ts";
+import { fetchAll, type SourceOptions } from "../core/quota/usage-source.ts";
 
 /** Shared subscription-usage cache and poller. */
 
@@ -14,14 +14,23 @@ export interface UsageState {
   errors: string[];
   updatedAt?: number;
   loading: boolean;
+  /** Claude accounts expected to report. */
   accounts: number;
+  /** Gemini accounts expected to report. */
+  geminiAccounts?: number;
   codexPlan?: string;
   /** Last observed quota drop for each account group. */
   lastUsedAt?: Record<string, number>;
 }
 
-const state: UsageState = { rows: [], errors: [], loading: true, accounts: 0, lastUsedAt: {} };
+const state: UsageState = { rows: [], errors: [], loading: true, accounts: 0, geminiAccounts: 0, lastUsedAt: {} };
 const listeners = new Set<() => void>();
+let sourceOptions: SourceOptions = {};
+
+/** Supplies host services the sources need, such as pi's credential reader. */
+export function configureUsageSources(options: SourceOptions): void {
+  sourceOptions = { ...sourceOptions, ...options };
+}
 
 let nextAllowedFetch = 0;
 let inFlight: Promise<void> | undefined;
@@ -39,6 +48,7 @@ function loadCache(): void {
   if (Date.now() - cached.updatedAt > CACHE_MAX_AGE_MS) return;
   state.rows = cached.rows.filter((row) => !row.group.startsWith("Claude pool ×"));
   state.accounts = cached.accounts ?? 0;
+  state.geminiAccounts = cached.geminiAccounts ?? 0;
   state.codexPlan = cached.codexPlan;
   state.updatedAt = cached.updatedAt;
   state.lastUsedAt = cached.lastUsedAt ?? {};
@@ -49,6 +59,7 @@ function saveCache(): void {
   writeJson(cachePath(), {
     rows: state.rows,
     accounts: state.accounts,
+    geminiAccounts: state.geminiAccounts,
     codexPlan: state.codexPlan,
     updatedAt: state.updatedAt,
     lastUsedAt: state.lastUsedAt,
@@ -107,20 +118,24 @@ export async function refreshUsage(ctx: any, force = false): Promise<void> {
 
   inFlight = (async () => {
     try {
-      const result = await fetchAll(ctx);
+      const result = await fetchAll(ctx, sourceOptions);
       const rateLimited = result.errors.some((error) => error.includes("429"));
       recordUsageDrops(result.rows);
 
-      // Per-account merge: groups that failed this cycle keep their last figures.
+      // Per-account merge: accounts that failed this cycle keep their last
+      // figures, marked stale. Removed accounts and header-observed readings
+      // (which lapse by design) are not kept.
       const freshGroups = new Set(result.rows.map((row) => row.group));
+      const expected = new Set([...result.groups, ...result.geminiGroups]);
       const retained = state.rows
         .filter((row) => !row.group.startsWith("Claude pool ×")
           && !freshGroups.has(row.group)
-          && (!isClaudeAccount(row) || result.groups.includes(row.group)))
+          && (isClaudeAccount(row) || isGeminiAccount(row) ? expected.has(row.group) : row.group === "Codex"))
         .map((row) => ({ ...row, stale: true }));
 
       state.rows = [...result.rows, ...retained];
       state.accounts = result.groups.length;
+      state.geminiAccounts = result.geminiGroups.length;
       state.updatedAt = Date.now(); // poll time only; rows retain their own checkedAt
       state.errors = result.errors;
       if (result.codexPlan !== undefined) state.codexPlan = result.codexPlan;

package/src/ui/usage-bars.ts

@@ -1,14 +1,34 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { combinedWindow, isClaudeAccount, poolAvailability, scopedLabels, type UsageRow } from "../core/quota/pool.ts";
+import { geminiQuotaFamily, GEMINI_QUOTA_FAMILIES } from "../core/gemini/quota.ts";
+import {
+  combinedWindow,
+  isClaudeAccount,
+  isFresh,
+  isGeminiAccount,
+  OBSERVED_PROVIDERS,
+  poolAvailability,
+  pooledWindow,
+  scopedLabels,
+  type UsageRow,
+} from "../core/quota/pool.ts";
 import type { UsageState } from "../services/usage-service.ts";
 import { formatReset, formatShortReset, hasTruecolor, levelColor, themeLevel } from "./format.ts";
 
 /**
- * Renders the Claude/Codex quota bars. Takes state as an argument rather than
- * importing the service, so the renderer stays a pure function of its input.
+ * Renders the quota bars: Claude on the left, and on the right the provider in
+ * use: Gemini, Kimi or Grok while one of their models is selected, Codex
+ * otherwise. Takes state as an argument rather than importing the service, so
+ * the renderer stays a pure function of its input.
  */
 
-type Cell = { label: string; remaining?: number; resetAt?: number; partial?: boolean };
+type Cell = { label: string; remaining?: number; resetAt?: number; partial?: boolean; active?: boolean };
+type Column = { title: string; cells: Cell[] };
+
+/** The session's current model; its provider picks the right-hand column. */
+export interface ActiveModel {
+  provider?: string;
+  modelId?: string;
+}
 
 function pooled(state: UsageState, label: string): Cell | undefined {
   return combinedWindow(state.rows, label, state.accounts, Date.now(), true);
@@ -19,6 +39,11 @@ function codexCell(state: UsageState, display: string, match: (label: string) =>
   return row ? { label: display, remaining: row.remaining, resetAt: row.resetAt } : { label: display };
 }
 
+/** Gemini accounts the pool expects, falling back to those that reported. */
+function geminiExpected(state: UsageState): number {
+  return state.geminiAccounts || new Set(state.rows.filter(isGeminiAccount).map((row) => row.group)).size;
+}
+
 /**
  * Turns a scoped limit id into something that fits the label column.
  *
@@ -33,7 +58,7 @@ function scopedDisplayName(label: string): string {
   return family.charAt(0).toUpperCase() + family.slice(1);
 }
 
-function buildColumns(state: UsageState, modelId?: string): { claude: Cell[]; codex: Cell[] } {
+function claudeColumn(state: UsageState, modelId?: string): Column {
   // Three fixed tiers, so the block keeps its shape whether or not a scoped
   // limit is currently reported.
   const scoped = scopedLabels(state.rows, modelId)[0];
@@ -41,18 +66,76 @@ function buildColumns(state: UsageState, modelId?: string): { claude: Cell[]; co
     ? { ...(pooled(state, scoped) ?? { label: scoped }), label: scopedDisplayName(scoped) }
     : { label: "Fable" };
 
-  const claude: Cell[] = [
+  const cells: Cell[] = [
     { ...(pooled(state, "5h") ?? { label: "5h" }), label: "5h" },
     { ...(pooled(state, "7d") ?? { label: "7d" }), label: "weekly" },
     scopedCell,
   ];
 
+  const availability = poolAvailability(state.rows, state.accounts, modelId);
+  const status = availability.ready
+    ? `${availability.ready}/${availability.total} ready`
+    : availability.unknown ? "unknown/stale" : "exhausted";
+  return { title: `Claude Σ${state.accounts} · ${status}`, cells };
+}
+
+function codexColumn(state: UsageState): Column {
   // Codex reports only the two windows; it has no scoped equivalent.
-  const codex: Cell[] = [
+  const cells: Cell[] = [
     codexCell(state, "5h", (label) => label === "5h") ?? { label: "5h" },
     codexCell(state, "weekly", (label) => label === "weekly") ?? { label: "weekly" },
   ];
-  return { claude, codex };
+  return { title: state.codexPlan ? `Codex · ${state.codexPlan}` : "Codex", cells };
+}
+
+/**
+ * Gemini pools quota per model family, so each bar is a family. The third is
+ * whichever third-party family is in use (Claude unless GPT-OSS is), and the
+ * active family's label is highlighted.
+ */
+function geminiColumn(state: UsageState, modelId?: string): Column {
+  const expected = geminiExpected(state);
+  const active = geminiQuotaFamily(modelId);
+  const labels = ["Flash", "Pro", active === "GPT" ? "GPT" : "Claude"];
+  const cells: Cell[] = labels.map((label) => ({
+    ...(pooledWindow(state.rows, label, expected, isGeminiAccount, Date.now(), true) ?? {}),
+    label,
+    active: label === active,
+  }));
+
+  let title = expected > 1 ? `Gemini Σ${expected}` : "Gemini";
+  if (active && expected > 0) {
+    // Ready = can serve the active model now: its family has quota left.
+    const groups = [...new Set(state.rows.filter(isGeminiAccount).map((row) => row.group))];
+    let ready = 0;
+    let unknown = Math.max(0, expected - groups.length);
+    for (const group of groups) {
+      const row = state.rows.find((candidate) => candidate.group === group && candidate.label === active);
+      if (!row || !isFresh(row)) unknown++;
+      else if (row.remaining > 0) ready++;
+    }
+    title += ` · ${ready ? `${ready}/${expected} ready` : unknown ? "unknown/stale" : "exhausted"}`;
+  }
+  return { title, cells };
+}
+
+/** Providers with no usage endpoint: the last rate-limit reading, if any. */
+function observedColumn(state: UsageState, group: string): Column {
+  const row = state.rows.find((candidate) => candidate.group === group && candidate.label === "rate");
+  return row
+    ? { title: group, cells: [{ label: "rate", remaining: row.remaining, resetAt: row.resetAt }] }
+    : { title: `${group} · usage not reported`, cells: [] };
+}
+
+/** The right-hand column: the active provider's, else Codex. */
+function sideColumn(state: UsageState, active?: ActiveModel): Column {
+  if (active?.provider === "gemini") return geminiColumn(state, active.modelId);
+  if (active?.provider === "openai-codex") return codexColumn(state);
+  const observed = OBSERVED_PROVIDERS.find(([providerId]) => providerId === active?.provider);
+  if (observed) return observedColumn(state, observed[1]);
+  // Nothing more specific in use: Codex, unless only Gemini has figures.
+  const codex = state.rows.some((row) => row.group === "Codex");
+  return !codex && state.rows.some(isGeminiAccount) ? geminiColumn(state) : codexColumn(state);
 }
 
 /** `Work 61% · Personal 88%`. Empty when there is nothing extra to say. */
@@ -77,13 +160,13 @@ function renderAccountSummary(state: UsageState, cellWidth: number): string | un
 }
 
 function renderCell(theme: any, cell: Cell, labelWidth: number, cellWidth: number): string {
-  const label = cell.label.slice(0, labelWidth).padEnd(labelWidth);
+  const label = theme.fg(cell.active ? "accent" : "muted", cell.label.slice(0, labelWidth).padEnd(labelWidth));
   const reset = formatShortReset(cell.resetAt);
   const resetWidth = 4;
   const barWidth = Math.max(4, cellWidth - labelWidth - 6 - resetWidth - 3);
 
   if (cell.remaining === undefined) {
-    return `${theme.fg("muted", label)} ${theme.fg("dim", "·".repeat(barWidth))} ${theme.fg("dim", "  n/a")}${" ".repeat(resetWidth + 1)}`;
+    return `${label} ${theme.fg("dim", "·".repeat(barWidth))} ${theme.fg("dim", "  n/a")}${" ".repeat(resetWidth + 1)}`;
   }
 
   const filled = Math.round((cell.remaining / 100) * barWidth);
@@ -102,10 +185,10 @@ function renderCell(theme: any, cell: Cell, labelWidth: number, cellWidth: numbe
     percent = theme.fg(color, percentText);
   }
 
-  return `${theme.fg("muted", label)} ${bar} ${percent} ${theme.fg("dim", reset.padEnd(resetWidth))}`;
+  return `${label} ${bar} ${percent} ${theme.fg("dim", reset.padEnd(resetWidth))}`;
 }
 
-export function renderUsageLines(state: UsageState, theme: any, width: number, modelId?: string): string[] {
+export function renderUsageLines(state: UsageState, theme: any, width: number, active?: ActiveModel): string[] {
   if (state.loading) return [theme.fg("dim", "  usage: loading…")];
   if (state.rows.length === 0) {
     if (state.errors.length > 0) return state.errors.map((error) => theme.fg("warning", `  ${error}`));
@@ -115,18 +198,15 @@ export function renderUsageLines(state: UsageState, theme: any, width: number, m
   const gap = 3;
   const cellWidth = Math.max(22, Math.floor((width - 2 - gap) / 2));
   const labelWidth = 6;
-  const { claude, codex } = buildColumns(state, modelId);
-  const availability = poolAvailability(state.rows, state.accounts, modelId);
-  const status = availability.ready
-    ? `${availability.ready}/${availability.total} ready`
-    : availability.unknown ? "unknown/stale" : "exhausted";
-  const claudeTitle = `Claude Σ${state.accounts} · ${status}`;
-  const codexTitle = state.codexPlan ? `Codex · ${state.codexPlan}` : "Codex";
-  const lines = [`  ${theme.fg("accent", claudeTitle.padEnd(cellWidth))}${" ".repeat(gap)}${theme.fg("accent", codexTitle)}`];
-
-  for (let index = 0; index < Math.max(claude.length, codex.length); index += 1) {
-    const left = claude[index] ? renderCell(theme, claude[index], labelWidth, cellWidth) : " ".repeat(cellWidth);
-    const right = codex[index] ? renderCell(theme, codex[index], labelWidth, cellWidth) : "";
+  // Claude's scoped limit follows the model only while Anthropic serves it;
+  // the same Claude id through Gemini draws on Gemini's quota instead.
+  const claude = claudeColumn(state, active?.provider === "anthropic" ? active.modelId : undefined);
+  const side = sideColumn(state, active);
+  const lines = [`  ${theme.fg("accent", claude.title.padEnd(cellWidth))}${" ".repeat(gap)}${theme.fg("accent", side.title)}`];
+
+  for (let index = 0; index < Math.max(claude.cells.length, side.cells.length); index += 1) {
+    const left = claude.cells[index] ? renderCell(theme, claude.cells[index], labelWidth, cellWidth) : " ".repeat(cellWidth);
+    const right = side.cells[index] ? renderCell(theme, side.cells[index], labelWidth, cellWidth) : "";
     lines.push(`  ${left}${" ".repeat(gap)}${right}`);
   }
 
@@ -146,7 +226,15 @@ export function usageSummaryText(state: UsageState): string {
       ? `${pool.partial ? "~" : ""}${Math.round(pool.remaining)}% left${pool.partial ? " (partial: reporting accounts only)" : ""} ${formatReset(pool.resetAt)}`
       : "unknown/stale"}`;
   });
-  const summary = [...combined, ...state.rows.map(
+  // Gemini's combined figures only add information with more than one account.
+  const geminiAccounts = geminiExpected(state);
+  const gemini = geminiAccounts > 1 ? GEMINI_QUOTA_FAMILIES.flatMap((label) => {
+    const pool = pooledWindow(state.rows, label, geminiAccounts, isGeminiAccount, Date.now(), true);
+    return pool
+      ? [`Gemini combined ${label}: ${pool.partial ? "~" : ""}${Math.round(pool.remaining)}% left ${formatReset(pool.resetAt)}`.trim()]
+      : [];
+  }) : [];
+  const summary = [...combined, ...gemini, ...state.rows.map(
     (row: UsageRow) => `${row.group} ${row.label}: ${Math.round(row.remaining)}% left ${formatReset(row.resetAt)}${row.stale ? " (stale)" : ""}`.trim(),
   )];
   return [...summary, ...state.errors].join("\n") || "No usage data";