shariq-pi-extensions 0.2.1 → 0.2.2

package/README.md

@@ -22,7 +22,7 @@ Run `/reload` in an existing Pi session after installation; new sessions load th
 
 The package contains:
 
-- Antigravity provider
+- Antigravity OAuth provider with multi-account quota-aware rotation and `/antigravity` dashboard
 - structured user questions
 - managed background terminals
 - copy-all transcript support

package/docs/EXTENSIONS.md

@@ -6,7 +6,7 @@ Last verified: 2026-08-20
 
 ### [Antigravity Provider](../extensions/antigravity-provider/README.md)
 
-Registers the `antigravity` provider and `/login antigravity` flow for supported Google Antigravity models. Use `/antigravity.doctor` to inspect non-secret provider status. Credentials remain in Pi auth storage.
+Registers the `antigravity` provider and `/login antigravity` flow for supported Google Antigravity models. Repeating login adds or updates accounts in the secure `<agent-dir>/antigravity/accounts.json` pool. Requests use quota-aware least-recently-used balancing, rotate before streaming on account-specific auth/rate/quota/capacity failures, honor known reset times, and refresh stored OAuth tokens. `/antigravity` shows account state and live model quotas and can enable or disable accounts; `/antigravity.doctor` reports sanitized provider and rotation diagnostics.
 
 ### [Cursor provider](../extensions/cursor-provider/README.md)
 

package/extensions/antigravity-provider/README.md

@@ -4,11 +4,14 @@ Local persistent Pi provider for Google Antigravity-compatible models.
 
 - Package module: `extensions/antigravity-provider/`
 - Provider id: `antigravity`
-- Login command: `/login antigravity`
+- Login command: `/login antigravity` (repeat once per Google account)
+- Account and quota dashboard: `/antigravity`
 - Doctor command: `/antigravity.doctor`
 
 The provider includes an IPv4 OAuth token-exchange fallback for Node environments where the default request fails. Its deterministic catalog follows Antigravity CLI 1.1.13 model identifiers and runtime behavior.
 
+Successful logins are added to `<agent-dir>/antigravity/accounts.json`, written with owner-only permissions. Existing Pi OAuth credentials are migrated into that pool without exposing token values. Requests select the least recently used eligible account, skip disabled/cooling/exhausted accounts, refresh expiring OAuth tokens, and rotate to another account when an auth, rate, quota, or capacity failure occurs before response streaming begins. Cached per-model remaining quota and reset times guide selection; `/antigravity` refreshes the authoritative catalog and can reversibly enable or disable accounts.
+
 Current public model IDs:
 - `antigravity/gemini-3.7-flash`
 - `antigravity/gemini-3.6-flash`

package/extensions/antigravity-provider/antigravity/accounts.ts

@@ -0,0 +1,343 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { OAuthCredentials } from "./oauth.ts";
+import { ANTIGRAVITY_ROUTING } from "./models.ts";
+
+export const ANTIGRAVITY_STATE_DIR = path.join(getAgentDir(), "antigravity");
+export const ANTIGRAVITY_ACCOUNTS_PATH = path.join(ANTIGRAVITY_STATE_DIR, "accounts.json");
+
+const AUTH_COOLDOWN_MS = 24 * 60 * 60 * 1_000;
+const RATE_COOLDOWN_MS = 30 * 60 * 1_000;
+const CAPACITY_COOLDOWN_MS = 60 * 1_000;
+const REFRESH_SKEW_MS = 60 * 1_000;
+
+export type AntigravityQuotaGroup = "gemini" | "non-gemini";
+
+export interface AntigravityQuotaEntry {
+  modelId: string;
+  displayName?: string;
+  group: AntigravityQuotaGroup;
+  remainingFraction: number;
+  resetTime?: string;
+}
+
+export interface AntigravityAccount {
+  id: string;
+  email?: string;
+  refresh: string;
+  access: string;
+  expires: number;
+  projectId: string;
+  disabled?: boolean;
+  addedAt: number;
+  lastUsedAt?: number;
+  cooldownUntil?: number;
+  cooldownReason?: "auth" | "rate" | "quota" | "capacity";
+  lastError?: string;
+  quota?: AntigravityQuotaEntry[];
+  quotaUpdatedAt?: number;
+  quotaError?: string;
+}
+
+interface AntigravityAccountFile {
+  version: 1;
+  accounts: AntigravityAccount[];
+}
+
+export interface AntigravityAccountStatus extends AntigravityAccount {
+  active: boolean;
+}
+
+function finiteNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function credentialId(refresh: string, email?: string): string {
+  return createHash("sha256").update(refresh || email || "antigravity").digest("hex").slice(0, 20);
+}
+
+function normalizeAccount(value: unknown): AntigravityAccount | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const raw = value as Record<string, unknown>;
+  if (typeof raw.refresh !== "string" || !raw.refresh) return undefined;
+  if (typeof raw.access !== "string") return undefined;
+  const projectId = typeof raw.projectId === "string" ? raw.projectId : "";
+  if (!projectId) return undefined;
+  const email = typeof raw.email === "string" && raw.email ? raw.email : undefined;
+  const quota = Array.isArray(raw.quota)
+    ? raw.quota.flatMap((item): AntigravityQuotaEntry[] => {
+        if (!item || typeof item !== "object") return [];
+        const entry = item as Record<string, unknown>;
+        if (typeof entry.modelId !== "string") return [];
+        if (entry.group !== "gemini" && entry.group !== "non-gemini") return [];
+        const remainingFraction = finiteNumber(entry.remainingFraction);
+        if (remainingFraction === undefined) return [];
+        return [{
+          modelId: entry.modelId,
+          displayName: typeof entry.displayName === "string" ? entry.displayName : undefined,
+          group: entry.group,
+          remainingFraction: Math.max(0, Math.min(1, remainingFraction)),
+          resetTime: typeof entry.resetTime === "string" ? entry.resetTime : undefined,
+        }];
+      })
+    : undefined;
+  return {
+    id: typeof raw.id === "string" && raw.id ? raw.id : credentialId(raw.refresh, email),
+    email,
+    refresh: raw.refresh,
+    access: raw.access,
+    expires: finiteNumber(raw.expires) ?? 0,
+    projectId,
+    disabled: raw.disabled === true,
+    addedAt: finiteNumber(raw.addedAt) ?? Date.now(),
+    lastUsedAt: finiteNumber(raw.lastUsedAt),
+    cooldownUntil: finiteNumber(raw.cooldownUntil),
+    cooldownReason: raw.cooldownReason === "auth" || raw.cooldownReason === "rate" || raw.cooldownReason === "quota" || raw.cooldownReason === "capacity" ? raw.cooldownReason : undefined,
+    lastError: typeof raw.lastError === "string" ? raw.lastError.slice(0, 300) : undefined,
+    quota,
+    quotaUpdatedAt: finiteNumber(raw.quotaUpdatedAt),
+    quotaError: typeof raw.quotaError === "string" ? raw.quotaError.slice(0, 300) : undefined,
+  };
+}
+
+export function loadAntigravityAccounts(): AntigravityAccount[] {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(ANTIGRAVITY_ACCOUNTS_PATH, "utf8")) as Partial<AntigravityAccountFile>;
+    return Array.isArray(parsed.accounts)
+      ? parsed.accounts.map(normalizeAccount).filter((account): account is AntigravityAccount => Boolean(account))
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+function saveAntigravityAccounts(accounts: AntigravityAccount[]) {
+  fs.mkdirSync(ANTIGRAVITY_STATE_DIR, { recursive: true, mode: 0o700 });
+  fs.chmodSync(ANTIGRAVITY_STATE_DIR, 0o700);
+  const temporary = `${ANTIGRAVITY_ACCOUNTS_PATH}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify({ version: 1, accounts }, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, ANTIGRAVITY_ACCOUNTS_PATH);
+  fs.chmodSync(ANTIGRAVITY_ACCOUNTS_PATH, 0o600);
+}
+
+function replaceAccount(id: string, update: (account: AntigravityAccount) => AntigravityAccount) {
+  const accounts = loadAntigravityAccounts();
+  const index = accounts.findIndex((account) => account.id === id);
+  if (index < 0) return undefined;
+  const next = update(accounts[index]!);
+  accounts[index] = next;
+  saveAntigravityAccounts(accounts);
+  return next;
+}
+
+export function upsertAntigravityAccount(
+  credentials: OAuthCredentials,
+  options: { clearCooldown?: boolean } = {},
+): AntigravityAccount {
+  const id = credentialId(credentials.refresh, credentials.email);
+  const accounts = loadAntigravityAccounts();
+  const index = accounts.findIndex((account) => account.id === id || Boolean(credentials.email && account.email === credentials.email));
+  const existing = index >= 0 ? accounts[index] : undefined;
+  const account: AntigravityAccount = {
+    ...existing,
+    id,
+    email: credentials.email || existing?.email,
+    refresh: credentials.refresh,
+    access: credentials.access,
+    expires: credentials.expires,
+    projectId: credentials.projectId || existing?.projectId || "",
+    addedAt: existing?.addedAt ?? Date.now(),
+    disabled: existing?.disabled ?? false,
+    cooldownUntil: options.clearCooldown ? undefined : existing?.cooldownUntil,
+    cooldownReason: options.clearCooldown ? undefined : existing?.cooldownReason,
+    lastError: options.clearCooldown ? undefined : existing?.lastError,
+  };
+  if (index >= 0) accounts[index] = account;
+  else accounts.push(account);
+  saveAntigravityAccounts(accounts);
+  return account;
+}
+
+export function setAntigravityAccountEnabled(id: string, enabled: boolean) {
+  return replaceAccount(id, (account) => ({
+    ...account,
+    disabled: !enabled,
+    ...(enabled ? { cooldownUntil: undefined, cooldownReason: undefined, lastError: undefined } : {}),
+  }));
+}
+
+export function removeAntigravityAccount(id: string) {
+  const accounts = loadAntigravityAccounts();
+  const next = accounts.filter((account) => account.id !== id);
+  if (next.length === accounts.length) return false;
+  saveAntigravityAccounts(next);
+  return true;
+}
+
+function quotaGroupForModel(modelId: string): AntigravityQuotaGroup {
+  return modelId.startsWith("gemini-") ? "gemini" : "non-gemini";
+}
+
+function resetAt(entry: AntigravityQuotaEntry | undefined): number | undefined {
+  if (!entry?.resetTime) return undefined;
+  const value = Date.parse(entry.resetTime);
+  return Number.isFinite(value) ? value : undefined;
+}
+
+export function quotaForModel(account: AntigravityAccount, modelId: string) {
+  const group = quotaGroupForModel(modelId);
+  const routing = ANTIGRAVITY_ROUTING[modelId];
+  const relatedIds = new Set([
+    modelId,
+    routing?.off,
+    routing?.defaultRequestId,
+    ...Object.values(routing?.routing ?? {}),
+  ].filter((value): value is string => typeof value === "string"));
+  const related = account.quota?.filter((entry) =>
+    relatedIds.has(entry.modelId) || entry.modelId.startsWith(`${modelId}-`)
+  ) ?? [];
+  if (related.length) return related.sort((left, right) => left.remainingFraction - right.remainingFraction)[0];
+  const grouped = account.quota?.filter((entry) => entry.group === group) ?? [];
+  return grouped.sort((left, right) => left.remainingFraction - right.remainingFraction)[0];
+}
+
+export function eligibleAntigravityAccounts(
+  accounts: AntigravityAccount[],
+  modelId: string,
+  now = Date.now(),
+) {
+  return accounts
+    .filter((account) => {
+      if (account.disabled) return false;
+      if (account.cooldownUntil && account.cooldownUntil > now) return false;
+      const quota = quotaForModel(account, modelId);
+      const reset = resetAt(quota);
+      return !(quota && quota.remainingFraction <= 0 && reset && reset > now);
+    })
+    .sort((left, right) => (left.lastUsedAt ?? 0) - (right.lastUsedAt ?? 0));
+}
+
+export function selectAntigravityAccounts(modelId: string, now = Date.now()) {
+  return eligibleAntigravityAccounts(loadAntigravityAccounts(), modelId, now);
+}
+
+export function markAntigravityAccountUsed(id: string) {
+  return replaceAccount(id, (account) => ({ ...account, lastUsedAt: Date.now() }));
+}
+
+function parseRetryAfter(message: string, now = Date.now()): number | undefined {
+  const iso = message.match(/(?:reset(?:s| time)?(?: at| in)?|retry after)[^\n]*?(\d{4}-\d{2}-\d{2}T[^\s,;]+)/i)?.[1];
+  if (iso) {
+    const parsed = Date.parse(iso);
+    if (Number.isFinite(parsed) && parsed > now) return parsed;
+  }
+  const duration = message.match(/(?:reset(?:s)? in|retry after)\s*(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+(?:\.\d+)?)s)?/i);
+  if (!duration) return undefined;
+  const milliseconds = ((Number(duration[1] || 0) * 3600) + (Number(duration[2] || 0) * 60) + Number(duration[3] || 0)) * 1_000;
+  return milliseconds > 0 ? now + milliseconds : undefined;
+}
+
+export function classifyAntigravityFailure(message: string, modelId: string, account?: AntigravityAccount) {
+  const lower = message.toLowerCase();
+  const now = Date.now();
+  if (/\b401\b/.test(lower) || lower.includes("invalid_grant") || lower.includes("login expired") || lower.includes("credentials are invalid")) {
+    return { reason: "auth" as const, until: now + AUTH_COOLDOWN_MS };
+  }
+  if (/\b429\b/.test(lower) || lower.includes("rate limit") || lower.includes("quota reached") || lower.includes("resource exhausted")) {
+    const quotaReset = resetAt(account ? quotaForModel(account, modelId) : undefined);
+    const explicitReset = parseRetryAfter(message, now);
+    return {
+      reason: lower.includes("quota") || lower.includes("exhaust") ? "quota" as const : "rate" as const,
+      until: explicitReset || (quotaReset && quotaReset > now ? quotaReset : now + RATE_COOLDOWN_MS),
+    };
+  }
+  if (/\b503\b/.test(lower) || /\b529\b/.test(lower) || lower.includes("capacity") || lower.includes("overloaded")) {
+    return { reason: "capacity" as const, until: now + CAPACITY_COOLDOWN_MS };
+  }
+  return undefined;
+}
+
+export function markAntigravityAccountFailure(id: string, modelId: string, message: string) {
+  const account = loadAntigravityAccounts().find((entry) => entry.id === id);
+  const failure = classifyAntigravityFailure(message, modelId, account);
+  if (!failure) return false;
+  replaceAccount(id, (current) => ({
+    ...current,
+    cooldownUntil: failure.until,
+    cooldownReason: failure.reason,
+    lastError: message.slice(0, 300),
+    lastUsedAt: Date.now(),
+  }));
+  return true;
+}
+
+export function updateAntigravityAccountQuota(id: string, quota: AntigravityQuotaEntry[] | undefined, error?: string) {
+  return replaceAccount(id, (account) => ({
+    ...account,
+    ...(quota ? { quota, quotaUpdatedAt: Date.now(), quotaError: undefined } : { quotaError: error?.slice(0, 300) }),
+  }));
+}
+
+export function parseAntigravityQuota(value: unknown): AntigravityQuotaEntry[] {
+  const entries: AntigravityQuotaEntry[] = [];
+  const seen = new Set<string>();
+  const visit = (node: unknown, keyHint?: string) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    const raw = node as Record<string, unknown>;
+    const quota = raw.quotaInfo && typeof raw.quotaInfo === "object" ? raw.quotaInfo as Record<string, unknown> : raw;
+    const remaining = finiteNumber(quota.remainingFraction);
+    const modelId = [raw.modelId, raw.id, raw.name, raw.model, keyHint].find((item): item is string => typeof item === "string" && /gemini|claude|gpt-oss/i.test(item));
+    if (modelId && remaining !== undefined) {
+      const normalized = modelId.replace(/^models\//, "");
+      if (!seen.has(normalized)) {
+        seen.add(normalized);
+        entries.push({
+          modelId: normalized,
+          displayName: typeof raw.displayName === "string" ? raw.displayName : typeof raw.label === "string" ? raw.label : undefined,
+          group: normalized.startsWith("gemini-") ? "gemini" : "non-gemini",
+          remainingFraction: Math.max(0, Math.min(1, remaining)),
+          resetTime: typeof quota.resetTime === "string" ? quota.resetTime : undefined,
+        });
+      }
+    }
+    for (const [key, child] of Object.entries(raw)) {
+      if (child && typeof child === "object") visit(child, key);
+    }
+  };
+  visit(value);
+  return entries;
+}
+
+const refreshes = new Map<string, Promise<AntigravityAccount>>();
+
+export function resolveAntigravityAccount(
+  account: AntigravityAccount,
+  refresh: (credentials: OAuthCredentials) => Promise<OAuthCredentials>,
+  now = Date.now(),
+): Promise<AntigravityAccount> {
+  if (account.access && account.expires > now + REFRESH_SKEW_MS) return Promise.resolve(account);
+  const existing = refreshes.get(account.id);
+  if (existing) return existing;
+  const pending = refresh({
+    refresh: account.refresh,
+    access: account.access,
+    expires: account.expires,
+    projectId: account.projectId,
+    email: account.email,
+  }).then(upsertAntigravityAccount).finally(() => refreshes.delete(account.id));
+  refreshes.set(account.id, pending);
+  return pending;
+}
+
+export function antigravityAccountStatuses(now = Date.now()): AntigravityAccountStatus[] {
+  return loadAntigravityAccounts().map((account) => ({
+    ...account,
+    active: !account.disabled && !(account.cooldownUntil && account.cooldownUntil > now),
+  }));
+}

package/extensions/antigravity-provider/antigravity/cloud-code-assist.ts

@@ -19,9 +19,20 @@ import {
 	jsonOrTextError,
 	loadCodeAssist,
 	fetchAvailableRuntimeModel,
+	refreshAntigravityToken,
 	DEFAULT_PROJECT_ID,
 } from "./oauth.ts";
 import { getAntigravityRequestModelId, PROVIDER_ID } from "./models.ts";
+import {
+	classifyAntigravityFailure,
+	loadAntigravityAccounts,
+	markAntigravityAccountFailure,
+	markAntigravityAccountUsed,
+	resolveAntigravityAccount,
+	selectAntigravityAccounts,
+	type AntigravityAccount,
+} from "./accounts.ts";
+import { refreshAntigravityQuotas } from "./quotas.ts";
 
 const ANTIGRAVITY_SYSTEM_INSTRUCTION =
 	"You are Antigravity, a powerful agentic AI coding assistant designed by Google DeepMind. " +
@@ -435,7 +446,7 @@ async function streamResponse(response: Response, stream: AssistantMessageEventS
 	return hasContent;
 }
 
-export function streamAntigravity(model: any, context: any, options?: any): any {
+function streamAntigravitySingle(model: any, context: any, options?: any): any {
 	const stream = createAssistantMessageEventStream();
 	void (async () => {
 		const output = createOutput(model);
@@ -517,3 +528,83 @@ export function streamAntigravity(model: any, context: any, options?: any): any
 	})();
 	return stream;
 }
+
+function antigravityErrorEvent(model: any, message: string) {
+	const output = createOutput(model);
+	output.stopReason = "error";
+	output.errorMessage = message;
+	return { type: "error" as const, reason: "error" as const, error: output };
+}
+
+function antigravityEventError(event: any): string | undefined {
+	if (event?.type !== "error") return undefined;
+	return event.error?.errorMessage || event.error?.message || event.reason;
+}
+
+export function streamAntigravity(model: any, context: any, options?: any): any {
+	const stream = createAssistantMessageEventStream();
+	void (async () => {
+		const stored = loadAntigravityAccounts();
+		const selected = selectAntigravityAccounts(model.id);
+		const candidates: Array<AntigravityAccount | undefined> = stored.length ? selected : [undefined];
+		if (!candidates.length) {
+			stream.push(antigravityErrorEvent(model, `No Antigravity account has available ${model.id} quota. Open /antigravity to refresh quotas or enable an account.`));
+			stream.end();
+			return;
+		}
+
+		let lastError = "No Antigravity account completed the request.";
+		for (const candidate of candidates) {
+			if (options?.signal?.aborted) throw options.signal.reason ?? new Error("Request was aborted");
+			let account = candidate;
+			let apiKey = options?.apiKey;
+			try {
+				if (account) {
+					account = await resolveAntigravityAccount(account, refreshAntigravityToken);
+					apiKey = JSON.stringify({ token: account.access, projectId: account.projectId });
+				}
+			} catch (error) {
+				lastError = safeError(error);
+				if (account) markAntigravityAccountFailure(account.id, model.id, lastError);
+				continue;
+			}
+
+			const inner = streamAntigravitySingle(model, context, { ...options, apiKey });
+			const buffered: any[] = [];
+			let started = false;
+			let rotate = false;
+			for await (const event of inner as AsyncIterable<any>) {
+				const error = antigravityEventError(event);
+				if (error && !started && account) {
+					lastError = error;
+					const retryable = Boolean(classifyAntigravityFailure(error, model.id, account));
+					if (retryable) {
+						markAntigravityAccountFailure(account.id, model.id, error);
+						void refreshAntigravityQuotas({ force: true, signal: options?.signal }).catch(() => {});
+						rotate = true;
+						break;
+					}
+				}
+				if (!started && event?.type === "start") {
+					started = true;
+					if (account) markAntigravityAccountUsed(account.id);
+					for (const pending of buffered) stream.push(pending);
+					buffered.length = 0;
+				}
+				if (started || event?.type === "error") stream.push(event);
+				else buffered.push(event);
+			}
+			if (rotate) continue;
+			for (const pending of buffered) stream.push(pending);
+			stream.end();
+			return;
+		}
+
+		stream.push(antigravityErrorEvent(model, `All configured Antigravity accounts are cooling down, exhausted, or failed. Last error: ${lastError}`));
+		stream.end();
+	})().catch((error) => {
+		stream.push(antigravityErrorEvent(model, safeError(error)));
+		stream.end();
+	});
+	return stream;
+}

package/extensions/antigravity-provider/antigravity/dashboard.ts

@@ -0,0 +1,248 @@
+import type { ExtensionContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { frameBottom, frameTop, joinSides, meter, oneLine, padLine, stateLabel } from "../../shared/tui-dashboard.ts";
+import type { AntigravityAccountStatus, AntigravityQuotaEntry } from "./accounts.ts";
+
+export interface AntigravityDashboardSnapshot {
+  authentication: string;
+  modelCount: number;
+  accounts: AntigravityAccountStatus[];
+  warning?: string;
+}
+
+type Theme = ExtensionContext["ui"]["theme"];
+
+function remaining(value: number) {
+  return `${Math.round(Math.max(0, Math.min(1, value)) * 100)}%`;
+}
+
+function until(timestamp: number | string | undefined) {
+  const value = typeof timestamp === "number" ? timestamp : timestamp ? Date.parse(timestamp) : Number.NaN;
+  if (!Number.isFinite(value) || value <= Date.now()) return "now";
+  const seconds = Math.max(0, Math.round((value - Date.now()) / 1_000));
+  const days = Math.floor(seconds / 86_400);
+  const hours = Math.floor((seconds % 86_400) / 3_600);
+  const minutes = Math.floor((seconds % 3_600) / 60);
+  if (days) return `${days}d ${hours}h`;
+  if (hours) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+
+function groupQuota(quota: AntigravityQuotaEntry[] | undefined, group: "gemini" | "non-gemini") {
+  return (quota ?? []).filter((entry) => entry.group === group).sort((left, right) => left.remainingFraction - right.remainingFraction);
+}
+
+function accountState(account: AntigravityAccountStatus) {
+  if (account.disabled) return "disabled";
+  if (account.cooldownUntil && account.cooldownUntil > Date.now()) return account.cooldownReason === "auth" ? "auth cooldown" : "cooldown";
+  const quota = account.quota ?? [];
+  if (quota.length && quota.every((entry) => entry.remainingFraction <= 0 && (!entry.resetTime || Date.parse(entry.resetTime) > Date.now()))) return "exhausted";
+  if (account.quotaError && !quota.length) return "refresh error";
+  return quota.length ? "ready" : "not refreshed";
+}
+
+function stateColor(state: string) {
+  if (state === "ready") return "success" as const;
+  if (state === "not refreshed" || state === "disabled") return "muted" as const;
+  if (state === "refresh error" || state === "auth cooldown") return "error" as const;
+  return "warning" as const;
+}
+
+function compactGroup(label: string, entries: AntigravityQuotaEntry[]) {
+  if (!entries.length) return `${label}: unavailable`;
+  const worst = entries[0]!;
+  return `${label}: ${remaining(worst.remainingFraction)} remaining${worst.resetTime ? ` · resets ${until(worst.resetTime)}` : ""}`;
+}
+
+export class AntigravityDashboard implements Component {
+  private selected = 0;
+  private refreshing = false;
+  private closed = false;
+  private readonly tui: TUI;
+  private readonly theme: Theme;
+  private readonly keys: KeybindingsManager;
+  private snapshot: AntigravityDashboardSnapshot;
+  private readonly refreshData: (force: boolean) => Promise<AntigravityDashboardSnapshot>;
+  private readonly toggleAccount: (id: string, enabled: boolean) => Promise<AntigravityDashboardSnapshot>;
+  private readonly done: () => void;
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    keys: KeybindingsManager,
+    snapshot: AntigravityDashboardSnapshot,
+    refreshData: (force: boolean) => Promise<AntigravityDashboardSnapshot>,
+    toggleAccount: (id: string, enabled: boolean) => Promise<AntigravityDashboardSnapshot>,
+    done: () => void,
+  ) {
+    this.tui = tui;
+    this.theme = theme;
+    this.keys = keys;
+    this.snapshot = snapshot;
+    this.refreshData = refreshData;
+    this.toggleAccount = toggleAccount;
+    this.done = done;
+  }
+
+  startRefresh(force: boolean) {
+    if (this.refreshing || this.closed) return;
+    this.refreshing = true;
+    this.tui.requestRender();
+    void this.refreshData(force)
+      .then((snapshot) => this.replaceSnapshot(snapshot))
+      .catch((error) => {
+        if (!this.closed) this.snapshot = { ...this.snapshot, warning: `Refresh failed: ${error instanceof Error ? error.message : String(error)}` };
+      })
+      .finally(() => {
+        if (!this.closed) {
+          this.refreshing = false;
+          this.tui.requestRender();
+        }
+      });
+  }
+
+  private replaceSnapshot(snapshot: AntigravityDashboardSnapshot) {
+    if (this.closed) return;
+    const id = this.snapshot.accounts[this.selected]?.id;
+    this.snapshot = snapshot;
+    const index = id ? snapshot.accounts.findIndex((account) => account.id === id) : -1;
+    this.selected = index >= 0 ? index : Math.min(this.selected, Math.max(0, snapshot.accounts.length - 1));
+  }
+
+  dispose() { this.closed = true; }
+  invalidate() {}
+
+  handleInput(data: string) {
+    const accounts = this.snapshot.accounts;
+    if (this.keys.matches(data, "tui.select.cancel")) {
+      this.closed = true;
+      this.done();
+      return;
+    }
+    if (this.keys.matches(data, "tui.select.up") || data === "k") {
+      if (accounts.length) this.selected = (this.selected - 1 + accounts.length) % accounts.length;
+    } else if (this.keys.matches(data, "tui.select.down") || data === "j") {
+      if (accounts.length) this.selected = (this.selected + 1) % accounts.length;
+    } else if (data === "r") {
+      this.startRefresh(true);
+    } else if (data === "d" && accounts[this.selected] && !this.refreshing) {
+      const account = accounts[this.selected]!;
+      this.refreshing = true;
+      void this.toggleAccount(account.id, account.disabled === true)
+        .then((snapshot) => this.replaceSnapshot(snapshot))
+        .catch((error) => {
+          if (!this.closed) this.snapshot = { ...this.snapshot, warning: error instanceof Error ? error.message : String(error) };
+        })
+        .finally(() => {
+          if (!this.closed) {
+            this.refreshing = false;
+            this.tui.requestRender();
+          }
+        });
+    }
+    this.tui.requestRender();
+  }
+
+  render(width: number) {
+    const rows = this.tui.terminal.rows || 30;
+    const bodyHeight = Math.max(8, rows - 7);
+    const accounts = this.snapshot.accounts;
+    this.selected = Math.min(this.selected, Math.max(0, accounts.length - 1));
+    const selected = accounts[this.selected];
+    const active = accounts.filter((account) => account.active).length;
+    const right = this.refreshing
+      ? this.theme.fg("warning", "refreshing…")
+      : this.snapshot.warning
+        ? this.theme.fg("warning", oneLine(this.snapshot.warning))
+        : this.theme.fg("muted", `${active}/${accounts.length} active · ${this.snapshot.modelCount} models`);
+    const title = `  ${this.theme.fg("accent", this.theme.bold("◆ ANTIGRAVITY"))} ${this.theme.fg("dim", `· ${this.snapshot.authentication}`)}`;
+    const lines = width >= 64
+      ? [joinSides(title, `${right}  `, width)]
+      : [truncateToWidth(title, width, ""), truncateToWidth(`  ${right}`, width, "")];
+    lines.push(frameTop(this.theme, width, `ACCOUNTS ${accounts.length} · QUOTA REMAINING`));
+    const inner = Math.max(1, width - 2);
+    if (width >= 104 && selected) {
+      const leftWidth = Math.max(46, Math.floor((inner - 1) * 0.45));
+      const rightWidth = Math.max(24, inner - leftWidth - 1);
+      const list = this.renderAccounts(leftWidth, bodyHeight, true);
+      const detail = this.renderDetail(selected, rightWidth, bodyHeight);
+      for (let row = 0; row < bodyHeight; row++) {
+        lines.push(this.theme.fg("border", "│") + padLine(list[row] ?? "", leftWidth) + this.theme.fg("borderMuted", "│") + padLine(detail[row] ?? "", rightWidth) + this.theme.fg("border", "│"));
+      }
+    } else {
+      const list = this.renderAccounts(inner, bodyHeight, false);
+      for (let row = 0; row < bodyHeight; row++) lines.push(this.theme.fg("border", "│") + padLine(list[row] ?? "", inner) + this.theme.fg("border", "│"));
+    }
+    lines.push(frameBottom(this.theme, width));
+    lines.push(truncateToWidth(`${this.theme.fg("accent", "  ↑↓ / j k")} ${this.theme.fg("dim", "select")}  ${this.theme.fg("accent", "r")} ${this.theme.fg("dim", "refresh")}  ${this.theme.fg("accent", "d")} ${this.theme.fg("dim", "enable/disable")}  ${this.theme.fg("accent", "esc")} ${this.theme.fg("dim", "close")}`, width, ""));
+    return lines.map((line) => truncateToWidth(line, width, ""));
+  }
+
+  private renderAccounts(width: number, height: number, compact: boolean) {
+    const accounts = this.snapshot.accounts;
+    if (!accounts.length) return [this.theme.fg("muted", " No Antigravity accounts saved."), this.theme.fg("dim", " Run /login antigravity once per Google account.")];
+    const rowsPerAccount = compact ? 1 : 4;
+    const visibleCount = Math.max(1, Math.floor(height / rowsPerAccount));
+    const start = Math.min(Math.max(0, this.selected - Math.floor(visibleCount / 2)), Math.max(0, accounts.length - visibleCount));
+    const lines: string[] = [];
+    for (const [offset, account] of accounts.slice(start, start + visibleCount).entries()) {
+      const index = start + offset;
+      const selected = index === this.selected;
+      const state = accountState(account);
+      const marker = selected ? this.theme.fg("accent", "◆") : " ";
+      const title = this.theme.fg(selected ? "accent" : "text", oneLine(account.email || `account-${account.id.slice(0, 6)}`));
+      const first = joinSides(` ${marker} ${title}`, `${stateLabel(this.theme, stateColor(state), state)} `, width);
+      lines.push(selected ? this.theme.bg("selectedBg", padLine(first, width)) : first);
+      if (!compact) {
+        lines.push(`   ${this.theme.fg("muted", compactGroup("Gemini", groupQuota(account.quota, "gemini")))}`);
+        lines.push(`   ${this.theme.fg("muted", compactGroup("Claude / GPT", groupQuota(account.quota, "non-gemini")))}`);
+        lines.push("");
+      }
+    }
+    return lines.slice(0, height);
+  }
+
+  private renderDetail(account: AntigravityAccountStatus, width: number, height: number) {
+    const state = accountState(account);
+    const lines = [
+      ` ${stateLabel(this.theme, stateColor(state), state)} ${this.theme.fg("accent", this.theme.bold(oneLine(account.email || `account-${account.id.slice(0, 6)}`)))}`,
+      ` ${this.theme.fg("dim", account.quotaUpdatedAt ? `quota updated ${until(account.quotaUpdatedAt + 15 * 60 * 1_000)} refresh window` : "quota has not been refreshed")}`,
+    ];
+    if (account.cooldownUntil && account.cooldownUntil > Date.now()) lines.push(` ${this.theme.fg("warning", `${account.cooldownReason || "rotation"} cooldown · ${until(account.cooldownUntil)}`)}`);
+    if (account.quotaError) lines.push(` ${this.theme.fg("error", oneLine(account.quotaError))}`);
+    if (account.lastError) lines.push(` ${this.theme.fg("warning", oneLine(account.lastError))}`);
+    lines.push("", ...this.renderQuotaGroup("Gemini", groupQuota(account.quota, "gemini"), width));
+    lines.push("", ...this.renderQuotaGroup("Claude / GPT-OSS", groupQuota(account.quota, "non-gemini"), width));
+    if (account.lastUsedAt) lines.push("", ` ${this.theme.fg("muted", "LAST USED")} ${this.theme.fg("text", new Date(account.lastUsedAt).toLocaleString())}`);
+    return lines.slice(0, height);
+  }
+
+  private renderQuotaGroup(name: string, entries: AntigravityQuotaEntry[], width: number) {
+    const lines = [` ${this.theme.fg("accent", this.theme.bold(`${name.toUpperCase()} · REMAINING`))}`];
+    if (!entries.length) return [...lines, ` ${this.theme.fg("muted", "Unavailable")}`];
+    const meterWidth = Math.max(10, width - 29);
+    for (const entry of entries.slice(0, 8)) {
+      const percent = entry.remainingFraction * 100;
+      const color = percent <= 0 ? "error" : percent <= 15 ? "warning" : "active";
+      const label = oneLine(entry.displayName || entry.modelId).slice(0, 16).padEnd(16);
+      lines.push(` ${this.theme.fg("muted", label)} ${meter(this.theme, percent, 100, meterWidth, color)} ${this.theme.fg("text", remaining(entry.remainingFraction))}${entry.resetTime ? ` ${this.theme.fg("dim", until(entry.resetTime))}` : ""}`);
+    }
+    return lines;
+  }
+}
+
+export async function openAntigravityDashboard(
+  ctx: ExtensionContext,
+  initial: AntigravityDashboardSnapshot,
+  refresh: (force: boolean) => Promise<AntigravityDashboardSnapshot>,
+  toggle: (id: string, enabled: boolean) => Promise<AntigravityDashboardSnapshot>,
+) {
+  await ctx.ui.custom<void>(
+    (tui, theme, keys, done) => {
+      const dashboard = new AntigravityDashboard(tui, theme, keys, initial, refresh, toggle, () => done(undefined));
+      queueMicrotask(() => dashboard.startRefresh(false));
+      return dashboard;
+    },
+    { overlay: true, overlayOptions: { anchor: "center", width: "100%", maxHeight: "100%" } },
+  );
+}

package/extensions/antigravity-provider/antigravity/index.ts

@@ -1,4 +1,8 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	readStoredCredential,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import {
 	PROVIDER_ID,
 	PROVIDER_NAME,
@@ -18,8 +22,43 @@ import {
 	DEFAULT_ENDPOINT,
 } from "./oauth.ts";
 import { streamAntigravity } from "./cloud-code-assist.ts";
+import {
+	antigravityAccountStatuses,
+	setAntigravityAccountEnabled,
+	upsertAntigravityAccount,
+} from "./accounts.ts";
+import { refreshAntigravityQuotas } from "./quotas.ts";
+import {
+	openAntigravityDashboard,
+	type AntigravityDashboardSnapshot,
+} from "./dashboard.ts";
 
 export default function antigravityProviderExtension(pi: ExtensionAPI) {
+	const dashboardSnapshot = (ctx: ExtensionContext): AntigravityDashboardSnapshot => {
+		const auth = ctx.modelRegistry.getProviderAuthStatus(PROVIDER_ID);
+		return {
+			authentication: auth.configured ? auth.source || auth.label || "configured" : "not authenticated",
+			modelCount: ANTIGRAVITY_MODELS.length,
+			accounts: antigravityAccountStatuses(),
+		};
+	};
+
+	const migrateStoredCredential = () => {
+		try {
+			const credential = readStoredCredential(PROVIDER_ID) as any;
+			if (credential?.type !== "oauth" || typeof credential.refresh !== "string" || typeof credential.access !== "string") return;
+			upsertAntigravityAccount({
+				refresh: credential.refresh,
+				access: credential.access,
+				expires: typeof credential.expires === "number" ? credential.expires : 0,
+				projectId: typeof credential.projectId === "string" ? credential.projectId : undefined,
+				email: typeof credential.email === "string" ? credential.email : undefined,
+			});
+		} catch {
+			// A malformed or unavailable Pi credential must not block extension startup.
+		}
+	};
+
 	pi.registerProvider(PROVIDER_ID, {
 		name: PROVIDER_NAME,
 		baseUrl: DEFAULT_ENDPOINT,
@@ -34,9 +73,43 @@ export default function antigravityProviderExtension(pi: ExtensionAPI) {
 		streamSimple: streamAntigravity,
 	} as any);
 
+	pi.on("session_start", (_event, ctx) => {
+		(ctx.modelRegistry as any).authStorage?.reload?.();
+		migrateStoredCredential();
+		void refreshAntigravityQuotas({ signal: ctx.signal }).catch(() => {
+			// Cached quota state remains available; /antigravity reports refresh failures.
+		});
+	});
+
+	pi.on("agent_end", (_event, ctx) => {
+		if (ctx.model?.provider !== PROVIDER_ID) return;
+		void refreshAntigravityQuotas({ signal: ctx.signal }).catch(() => {});
+	});
+
+	pi.registerCommand("antigravity", {
+		description: "Open Antigravity accounts, rotation, and quota dashboard",
+		handler: async (_args, ctx) => {
+			migrateStoredCredential();
+			await openAntigravityDashboard(
+				ctx,
+				dashboardSnapshot(ctx),
+				async (force) => {
+					await refreshAntigravityQuotas({ force, signal: ctx.signal });
+					return dashboardSnapshot(ctx);
+				},
+				async (id, enabled) => {
+					setAntigravityAccountEnabled(id, enabled);
+					if (enabled) await refreshAntigravityQuotas({ force: true, signal: ctx.signal });
+					return dashboardSnapshot(ctx);
+				},
+			);
+		},
+	});
+
 	pi.registerCommand("antigravity.doctor", {
 		description: "Show sanitized Antigravity provider diagnostics",
 		handler: async (_args, ctx) => {
+			const accounts = antigravityAccountStatuses();
 			const lines = [
 				`provider=${PROVIDER_ID}`,
 				`lastResolvedRuntimeModel=${lastResolvedRuntimeModel || "none"}`,
@@ -48,6 +121,9 @@ export default function antigravityProviderExtension(pi: ExtensionAPI) {
 				`lastError=${lastError || "none"}`,
 				"transport=native-streamSimple",
 				"runtimeCli=not-used",
+				`accountsConfigured=${accounts.length}`,
+				`accountsActive=${accounts.filter((account) => account.active).length}`,
+				"rotation=quota-aware-lru",
 			];
 			const text = lines.join("\n");
 			if (ctx.hasUI) ctx.ui.notify(`Antigravity doctor\n${text}`, "info");

package/extensions/antigravity-provider/antigravity/oauth.ts

@@ -320,6 +320,32 @@ function findDynamicModel(value: any, requestedId: string): DynamicModelInfo | u
 	return undefined;
 }
 
+export async function fetchAntigravityQuotaCatalog(token: string, projectId: string, signal?: AbortSignal): Promise<unknown> {
+	let lastFailure = "Antigravity quota catalog is unavailable.";
+	const bodies = [{}, { cloudaicompanionProject: projectId }, { project: projectId }];
+	for (const endpoint of endpointCandidates()) {
+		for (const candidateBody of bodies) {
+			try {
+				const res = await fetch(`${endpoint}/v1internal:fetchAvailableModels`, {
+					method: "POST",
+					headers: antigravityHeaders(token),
+					body: JSON.stringify(candidateBody),
+					signal: boundedFetchSignal(signal),
+				});
+				lastStatus = res.status;
+				lastEndpoint = endpoint;
+				if (res.ok) return await res.json();
+				lastFailure = `HTTP ${res.status}: ${jsonOrTextError(await res.text())}`;
+			} catch (error) {
+				if (signal?.aborted) throw error;
+				lastFailure = safeError(error);
+				lastError = lastFailure;
+			}
+		}
+	}
+	throw new Error(lastFailure);
+}
+
 export async function fetchAvailableRuntimeModel(token: string, projectId: string, requestedRuntimeModel: string, signal?: AbortSignal): Promise<DynamicModelInfo | undefined> {
 	const bodies = [{}, { cloudaicompanionProject: projectId }, { project: projectId }];
 	for (const endpoint of endpointCandidates()) {
@@ -463,13 +489,16 @@ export async function loginAntigravity(callbacks: OAuthCallbacks): Promise<OAuth
 		if (!tokenData.refresh_token) throw new Error("No refresh token received. Re-run /login antigravity and allow offline access.");
 
 		const [email, discoveredProject] = await Promise.all([getUserEmail(tokenData.access_token), loadCodeAssist(tokenData.access_token)]);
-		return {
+		const credentials = {
 			refresh: tokenData.refresh_token,
 			access: tokenData.access_token,
 			expires: Date.now() + tokenData.expires_in * 1000 - 5 * 60 * 1000,
 			projectId: discoveredProject || DEFAULT_PROJECT_ID,
 			email,
 		};
+		const { upsertAntigravityAccount } = await import("./accounts.ts");
+		upsertAntigravityAccount(credentials, { clearCooldown: true });
+		return credentials;
 	} finally {
 		server.close();
 	}
@@ -485,13 +514,16 @@ export async function refreshAntigravityToken(credentials: OAuthCredentials): Pr
 	if (!response.ok) throw new Error(`Antigravity token refresh failed: ${await response.text()}`);
 	const data = (await response.json()) as { access_token: string; expires_in: number; refresh_token?: string };
 	const discoveredProject = await loadCodeAssist(data.access_token);
-	return {
+	const refreshed = {
 		...credentials,
 		refresh: data.refresh_token || credentials.refresh,
 		access: data.access_token,
 		expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000,
 		projectId: discoveredProject || credentials.projectId || DEFAULT_PROJECT_ID,
 	};
+	const { upsertAntigravityAccount } = await import("./accounts.ts");
+	upsertAntigravityAccount(refreshed);
+	return refreshed;
 }
 
 export function getApiKey(credentials: OAuthCredentials): string {

package/extensions/antigravity-provider/antigravity/quotas.ts

@@ -0,0 +1,40 @@
+import {
+  antigravityAccountStatuses,
+  parseAntigravityQuota,
+  resolveAntigravityAccount,
+  updateAntigravityAccountQuota,
+  type AntigravityAccountStatus,
+} from "./accounts.ts";
+import {
+  fetchAntigravityQuotaCatalog,
+  refreshAntigravityToken,
+} from "./oauth.ts";
+
+export const ANTIGRAVITY_QUOTA_TTL_MS = 15 * 60 * 1_000;
+let refreshPromise: Promise<AntigravityAccountStatus[]> | undefined;
+
+export function refreshAntigravityQuotas(options: { force?: boolean; signal?: AbortSignal } = {}) {
+  if (refreshPromise) return refreshPromise;
+  refreshPromise = (async () => {
+    const now = Date.now();
+    const accounts = antigravityAccountStatuses(now);
+    for (const account of accounts) {
+      if (account.disabled) continue;
+      if (!options.force && account.quotaUpdatedAt && now - account.quotaUpdatedAt < ANTIGRAVITY_QUOTA_TTL_MS) continue;
+      try {
+        const resolved = await resolveAntigravityAccount(account, refreshAntigravityToken, now);
+        const catalog = await fetchAntigravityQuotaCatalog(resolved.access, resolved.projectId, options.signal);
+        const quota = parseAntigravityQuota(catalog);
+        if (!quota.length) throw new Error("Antigravity returned no recognizable quota entries.");
+        updateAntigravityAccountQuota(resolved.id, quota);
+      } catch (error) {
+        if (options.signal?.aborted) throw error;
+        updateAntigravityAccountQuota(account.id, undefined, error instanceof Error ? error.message : String(error));
+      }
+    }
+    return antigravityAccountStatuses();
+  })().finally(() => {
+    refreshPromise = undefined;
+  });
+  return refreshPromise;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shariq-pi-extensions",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Cross-platform extension suite for the Pi coding agent.",
   "license": "MIT",
   "author": "Shariq Riaz",