@latentminds/pi-quotas 0.2.3 → 0.2.6

package/README.md

@@ -1,12 +1,14 @@
 # @latentminds/pi-quotas
 
-Quota monitoring for the [Pi coding agent](https://github.com/mariozechner/pi). Shows remaining usage and rate limits for Anthropic, OpenAI Codex, GitHub Copilot, OpenRouter, and Synthetic — directly in your Pi session.
+Quota monitoring for Pi. Shows remaining usage and rate limits for Anthropic, OpenAI Codex, GitHub Copilot, OpenRouter, and Synthetic — directly in your Pi session.
 
 ## Screenshots
 
+
 | `/quotas` dashboard | Footer status |
-|---|---|
-| ![Quotas dashboard](docs/quotas-dashboard.png) | ![Footer status](docs/footer-status.png) |
+| ------------------- | ------------- |
+| Quotas dashboard    | Footer status |
+
 
 ## Install
 
@@ -31,15 +33,17 @@ pi -e npm:@latentminds/pi-quotas
 
 ## Commands
 
-| Command | Description |
-|---------|-------------|
-| `/quotas` | Combined quota dashboard for all providers |
-| `/anthropic:quotas` | Anthropic quotas only |
-| `/codex:quotas` | OpenAI Codex quotas only |
-| `/github:quotas` | GitHub Copilot quotas only |
-| `/openrouter:quotas` | OpenRouter quotas only |
-| `/synthetic:quotas` | Synthetic quotas only |
-| `/quotas:settings` | Toggle individual features on or off |
+
+| Command              | Description                                |
+| -------------------- | ------------------------------------------ |
+| `/quotas`            | Combined quota dashboard for all providers |
+| `/anthropic:quotas`  | Anthropic quotas only                      |
+| `/codex:quotas`      | OpenAI Codex quotas only                   |
+| `/github:quotas`     | GitHub Copilot quotas only                 |
+| `/openrouter:quotas` | OpenRouter quotas only                     |
+| `/synthetic:quotas`  | Synthetic quotas only                      |
+| `/quotas:settings`   | Toggle individual features on or off       |
+
 
 ## Features
 
@@ -58,22 +62,26 @@ Automatic notifications when projected usage is on track to exceed limits before
 ### Per-feature toggles
 
 Use `/quotas:settings` to enable or disable:
+
 - Combined `/quotas` command
 - Per-provider commands (`/anthropic:quotas`, `/codex:quotas`, `/github:quotas`, `/openrouter:quotas`, `/synthetic:quotas`)
 - Footer status widget
 - Quota warning notifications
+- **Defer to Synthetic** — when both pi-quotas and [pi-synthetic](https://www.npmjs.com/package/@aliou/pi-synthetic) are loaded, pi-quotas hides its own Synthetic footer to avoid showing duplicate quota information. Enabled by default; disable if you prefer to see both footers.
 
 Settings can be saved globally (`~/.pi/agent/extensions/quotas.json`) or per-project (`.pi/quotas.json`). Run `/reload` after changing command visibility.
 
 ## Supported providers
 
-| Provider | Windows | Details |
-|----------|---------|---------|
-| Anthropic | 5h, 7d, per-model 7d, extra usage | Utilization percentages; optional overage budget in local currency |
-| OpenAI Codex | 5h, 7d, credits, spend cap | Rate-limit percentages; credit balance; spend-cap reached/OK |
-| GitHub Copilot | Premium/chat/completions per month | Remaining/entitlement counts with overage indicators |
-| OpenRouter | Monthly budget, daily/weekly/monthly usage | USD spending tracking with cents precision; optional per-key budget limits; UTC-based period resets |
-| Synthetic | Subscription, search/hour, free tools, weekly tokens, 5h limit | Request counts and token budgets; rolling five-hour rate limit; weekly token regen |
+
+| Provider       | Windows                                                        | Details                                                                                             |
+| -------------- | -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Anthropic      | 5h, 7d, per-model 7d, extra usage                              | Utilization percentages; optional overage budget in local currency                                  |
+| OpenAI Codex   | 5h, 7d, credits, spend cap                                     | Rate-limit percentages; credit balance; spend-cap reached/OK                                        |
+| GitHub Copilot | Premium/chat/completions per month                             | Remaining/entitlement counts with overage indicators                                                |
+| OpenRouter     | Monthly budget, daily/weekly/monthly usage                     | USD spending tracking with cents precision; optional per-key budget limits; UTC-based period resets |
+| Synthetic      | Subscription, search/hour, free tools, weekly tokens, 5h limit | Request counts and token budgets; rolling five-hour rate limit; weekly token regen                  |
+
 
 ## Credentials
 
@@ -103,6 +111,3 @@ See [CHANGELOG.md](CHANGELOG.md) for release notes and recent changes.
 
 This project was inspired by [@aliou/pi-synthetic](https://www.npmjs.com/package/@aliou/pi-synthetic).
 
-<p align="center">
-  <img src="docs/latent-minds@2x.png" alt="Latent Minds" width="320" />
-</p>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latentminds/pi-quotas",
-  "version": "0.2.3",
+  "version": "0.2.6",
   "license": "MIT",
   "type": "module",
   "private": false,

package/src/config.ts

@@ -9,7 +9,8 @@ export type QuotasFeatureId =
   | "quotasCommand"
   | "providerCommands"
   | "usageStatus"
-  | "quotaWarnings";
+  | "quotaWarnings"
+  | "deferToSynthetic";
 
 export const QUOTAS_EXTENSIONS_REQUEST_EVENT =
   "quotas:extensions:request" as const;
@@ -28,6 +29,8 @@ export interface QuotasConfig {
   providerCommands?: boolean;
   usageStatus?: boolean;
   quotaWarnings?: boolean;
+  /** When true and pi-synthetic's usage footer is active, hide pi-quotas' Synthetic footer. */
+  deferToSynthetic?: boolean;
 }
 
 export interface ResolvedQuotasConfig {
@@ -36,6 +39,7 @@ export interface ResolvedQuotasConfig {
   providerCommands: boolean;
   usageStatus: boolean;
   quotaWarnings: boolean;
+  deferToSynthetic: boolean;
 }
 
 const DEFAULT_CONFIG: ResolvedQuotasConfig = {
@@ -44,6 +48,7 @@ const DEFAULT_CONFIG: ResolvedQuotasConfig = {
   providerCommands: true,
   usageStatus: true,
   quotaWarnings: true,
+  deferToSynthetic: true,
 };
 
 let pendingMigrationNotice = false;
@@ -79,6 +84,7 @@ class QuotasConfigStore {
       providerCommands: input?.providerCommands ?? DEFAULT_CONFIG.providerCommands,
       usageStatus: input?.usageStatus ?? DEFAULT_CONFIG.usageStatus,
       quotaWarnings: input?.quotaWarnings ?? DEFAULT_CONFIG.quotaWarnings,
+      deferToSynthetic: input?.deferToSynthetic ?? DEFAULT_CONFIG.deferToSynthetic,
     };
   }
 
@@ -164,6 +170,11 @@ const FEATURE_META: Array<{
     label: "Quota warnings",
     description: "Toggle projected-usage warning notifications",
   },
+  {
+    id: "deferToSynthetic",
+    label: "Defer to Synthetic",
+    description: "When pi-synthetic is loaded, hide pi-quotas' Synthetic footer to avoid duplicates",
+  },
 ];
 
 export function registerQuotasSettings(
@@ -205,11 +216,11 @@ export function registerQuotasSettings(
 
         const feature = FEATURE_META.find((item) => selected.startsWith(item.label));
         if (!feature) continue;
-        if (!getLoadedFeatures().has(feature.id)) {
+        if (feature.id !== "deferToSynthetic" && !getLoadedFeatures().has(feature.id)) {
           ctx.ui.notify(`${feature.label} is not loaded by Pi in this session.`, "warning");
           continue;
         }
-        draft[feature.id] = !draft[feature.id];
+        (draft as unknown as Record<string, boolean>)[feature.id] = !(draft as unknown as Record<string, boolean>)[feature.id];
       }
     },
   });

package/src/extensions/command-quotas/components/quotas-display.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from "vitest";
+import pkg from "../../../../package.json" with { type: "json" };
+import { QuotasComponent } from "./quotas-display.js";
+
+const ansi = {
+  accent: "\x1b[32m",
+  border: "\x1b[36m",
+  dim: "\x1b[2m",
+  error: "\x1b[31m",
+  muted: "\x1b[90m",
+  success: "\x1b[32m",
+  warning: "\x1b[33m",
+} as const;
+
+function fakeTheme() {
+  return {
+    bold: (text: string) => text,
+    fg: (color: keyof typeof ansi, text: string) => `${ansi[color] ?? ""}${text}\x1b[0m`,
+    getFgAnsi: (color: keyof typeof ansi) => ansi[color] ?? "",
+  };
+}
+
+function makeComponent(): QuotasComponent {
+  return new QuotasComponent(
+    fakeTheme() as any,
+    { requestRender: () => {} } as any,
+    "Quotas",
+    () => {},
+    () => {},
+  );
+}
+
+describe("QuotasComponent", () => {
+  it("renders the pi-quotas package version in the dashboard footer", () => {
+    const component = makeComponent();
+    component.setState({ type: "loaded", snapshots: [] });
+
+    expect(component.render(70).join("\n")).toContain(`pi-quotas v${pkg.version}`);
+  });
+
+  it("does not render an accent-colored pace marker inside filled warning bars", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-05-14T13:42:11Z"));
+
+    const component = makeComponent();
+    component.setState({
+      type: "loaded",
+      snapshots: [
+        {
+          provider: "github-copilot",
+          result: {
+            success: true,
+            data: {
+              provider: "github-copilot",
+              windows: [
+                {
+                  provider: "github-copilot",
+                  label: "Premium / month",
+                  usedPercent: 83,
+                  resetsAt: new Date("2026-06-01T10:00:00Z"),
+                  windowSeconds: 31 * 24 * 3600,
+                  usedValue: 249,
+                  limitValue: 300,
+                  showPace: true,
+                  nextLabel: "Resets",
+                  nextAmount: "overage allowed",
+                },
+              ],
+            },
+          },
+        },
+      ],
+    });
+
+    const output = component.render(70).join("\n");
+
+    expect(output).toContain("51/300 left");
+    expect(output).not.toContain(`${ansi.accent}|`);
+
+    vi.useRealTimers();
+  });
+
+  it("does not render a pace marker for zero-usage windows", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-05-14T13:49:29Z"));
+
+    const component = makeComponent();
+    component.setState({
+      type: "loaded",
+      snapshots: [
+        {
+          provider: "synthetic",
+          result: {
+            success: true,
+            data: {
+              provider: "synthetic",
+              windows: [
+                {
+                  provider: "synthetic",
+                  label: "Credits / week",
+                  usedPercent: 0,
+                  resetsAt: new Date("2026-05-14T16:40:29Z"),
+                  windowSeconds: 7 * 24 * 3600,
+                  usedValue: 0,
+                  limitValue: 24,
+                  isCurrency: true,
+                  showPace: true,
+                  nextLabel: "Next regen",
+                  nextAmount: "+$0.48",
+                },
+              ],
+            },
+          },
+        },
+      ],
+    });
+
+    const output = component.render(70).join("\n");
+
+    expect(output).toContain("$0.00 / $24.00");
+    expect(output).not.toContain("|");
+
+    vi.useRealTimers();
+  });
+});

package/src/extensions/command-quotas/components/quotas-display.ts

@@ -2,6 +2,7 @@ import type { Theme } from "@mariozechner/pi-coding-agent";
 import { DynamicBorder } from "@mariozechner/pi-coding-agent";
 import type { Component } from "@mariozechner/pi-tui";
 import { Loader, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import pkg from "../../../../package.json" with { type: "json" };
 import { PROVIDER_LABELS } from "../../../lib/quotas.js";
 import type { QuotasResult, SupportedQuotaProvider } from "../../../types/quotas.js";
 import {
@@ -19,10 +20,6 @@ type QuotasState =
   | { type: "loading" }
   | { type: "loaded"; snapshots: Snapshot[] };
 
-function fgAnsiToBg(fgAnsi: string): string {
-  return fgAnsi.split("[38;").join("[48;").replace(/\[3([0-9])m/g, "[4$1m");
-}
-
 function renderProgressBar(
   percent: number,
   width: number,
@@ -33,6 +30,7 @@ function renderProgressBar(
   const clamped = Math.max(0, Math.min(100, Math.round(percent)));
   const filled = Math.round((clamped / 100) * width);
   const showPace =
+    percent > 0 &&
     pacePercent !== null &&
     pacePercent !== undefined &&
     pacePercent >= 5 &&
@@ -44,11 +42,10 @@ function renderProgressBar(
   const parts: string[] = [];
   for (let idx = 0; idx < width; idx++) {
     if (paceIndex !== null && idx === paceIndex) {
-      const markerColor = idx < filled ? "accent" : fillColor;
       if (idx < filled) {
-        parts.push(`${fgAnsiToBg(theme.getFgAnsi(fillColor))}${theme.getFgAnsi(markerColor)}|${reset}`);
+        parts.push(theme.fg(fillColor, "█"));
       } else {
-        parts.push(theme.fg(markerColor, "|"));
+        parts.push(theme.fg(fillColor, "|"));
       }
     } else if (idx < filled) {
       parts.push(theme.fg(fillColor, "█"));
@@ -123,7 +120,7 @@ export class QuotasComponent implements Component {
     }
 
     lines.push("");
-    lines.push(this.theme.fg("dim", "  r to refresh  q/Esc to close"));
+    lines.push(this.theme.fg("dim", `  pi-quotas v${pkg.version}  ·  r to refresh  q/Esc to close`));
     lines.push(...border.render(width));
     return lines;
   }

package/src/extensions/quota-warnings/index.ts

@@ -85,6 +85,12 @@ export default async function (pi: ExtensionAPI) {
     ctx.ui.notify(`${providerName} quota warning:\n${lines.join("\n")}`, level);
   }
 
+  function scheduleCheck(ctx: ExtensionContext, onlyNew: boolean): void {
+    void check(ctx, onlyNew).catch(() => {
+      // Quota warnings are opportunistic; never let a failed quota check block Pi events.
+    });
+  }
+
   pi.events.on(QUOTAS_CONFIG_UPDATED_EVENT, (data: unknown) => {
     enabled = (data as QuotasConfigUpdatedPayload).config.quotaWarnings;
     if (!enabled) {
@@ -93,21 +99,21 @@ export default async function (pi: ExtensionAPI) {
     }
     if (currentContext) {
       clearAlertState();
-      void check(currentContext, false);
+      scheduleCheck(currentContext, false);
     }
   });
 
-  pi.on("session_start", async (_event, ctx) => {
+  pi.on("session_start", (_event, ctx) => {
     currentContext = ctx;
     clearAlertState();
     if (!enabled) return;
-    await check(ctx, false);
+    scheduleCheck(ctx, false);
   });
 
-  pi.on("turn_end", async (_event, ctx) => {
+  pi.on("turn_end", (_event, ctx) => {
     currentContext = ctx;
     if (!enabled) return;
-    await check(ctx, true);
+    scheduleCheck(ctx, true);
   });
 
   pi.on("model_select", async (_event, ctx) => {

package/src/extensions/usage-status/format-status.ts

@@ -37,6 +37,11 @@ const SHORT_LABELS: Record<string, string> = {
   "Daily": "daily",
   "Weekly": "weekly",
   "Monthly": "monthly",
+  // Synthetic labels (match pi-synthetic extension)
+  "Credits / week": "week",
+  "Requests / 5h": "5h",
+  "Search / hour": "search",
+  "Free Tool Calls / day": "tools",
 };
 
 /**
@@ -68,8 +73,19 @@ export function formatWindowStatus(theme: ThemeLike, w: WindowStatus): string {
   const labelColor = isAtRisk ? color : "dim";
   const labelText = theme.fg(labelColor, `${short}:`);
 
+  // Synthetic windows always use compact "remaining%" format
+  // to match the pi-synthetic extension display
+  const SYNTHETIC_LABELS = new Set([
+    "Credits / week", "Requests / 5h", "Search / hour", "Free Tool Calls / day",
+  ]);
+  const isSynthetic = SYNTHETIC_LABELS.has(w.label);
+
   let valueText: string;
-  if (w.label === "Spend cap") {
+  if (isSynthetic) {
+    // Compact format matching pi-synthetic: just remaining%
+    const remaining = Math.max(0, Math.min(100, Math.round(100 - w.usedPercent)));
+    valueText = theme.fg(color, `${remaining}%`);
+  } else if (w.label === "Spend cap") {
     valueText = theme.fg(color, w.limited ? "REACHED" : "OK");
   } else if (w.isCurrency && w.usedValue != null && w.limitValue != null) {
     // Tracking-only windows have limitValue=0, show just usage

package/src/extensions/usage-status/index.ts

@@ -9,6 +9,12 @@ import {
   type QuotasConfigUpdatedPayload,
   configLoader,
 } from "../../config.js";
+
+/** Event emitted by pi-synthetic when its usage-status extension registers. */
+const SYNTHETIC_EXTENSIONS_REGISTER_EVENT = "synthetic:extensions:register";
+interface SyntheticExtensionsRegisterPayload {
+  feature: string;
+}
 import {
   fetchProviderQuotas,
   isSupportedProvider,
@@ -152,44 +158,86 @@ export default async function (pi: ExtensionAPI) {
   await configLoader.load();
   const refresher = createStatusRefresher();
   let enabled = configLoader.getConfig().usageStatus;
+  let deferToSynthetic = configLoader.getConfig().deferToSynthetic;
   let currentContext: ExtensionContext | undefined;
 
+  /** Whether pi-synthetic's usage footer is active in this session. */
+  let syntheticUsageActive = false;
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, (data: unknown) => {
+    const { feature } = data as SyntheticExtensionsRegisterPayload;
+    if (feature === "usageStatus") {
+      syntheticUsageActive = true;
+      // If currently showing synthetic data, clear our footer
+      if (currentContext && enabled && deferToSynthetic && currentContext.model?.provider === "synthetic") {
+        currentContext.ui.setStatus(EXTENSION_ID, undefined);
+        refresher.stop();
+      }
+    }
+  });
+
+  function scheduleRefresh(ctx: ExtensionContext): void {
+    void refresher.refreshFor(ctx).catch(() => {
+      if (ctx.hasUI) ctx.ui.setStatus(EXTENSION_ID, ctx.ui.theme.fg("warning", "usage unavailable"));
+    });
+  }
+
   pi.events.on(QUOTAS_CONFIG_UPDATED_EVENT, (data: unknown) => {
-    enabled = (data as QuotasConfigUpdatedPayload).config.usageStatus;
+    const config = (data as QuotasConfigUpdatedPayload).config;
+    enabled = config.usageStatus;
+    deferToSynthetic = config.deferToSynthetic;
     if (!enabled) {
       refresher.stop(currentContext);
       return;
     }
     if (currentContext) {
       refresher.start();
-      void refresher.refreshFor(currentContext);
+      scheduleRefresh(currentContext);
     }
   });
 
-  pi.on("session_start", async (_event, ctx) => {
+  /**
+   * Whether to suppress our footer because pi-synthetic is showing
+   * the same data for the Synthetic provider.
+   */
+  function shouldDeferToSynthetic(provider: string | undefined): boolean {
+    return deferToSynthetic && syntheticUsageActive && provider === "synthetic";
+  }
+
+  pi.on("session_start", (_event, ctx) => {
     currentContext = ctx;
     if (!enabled) return;
+    if (shouldDeferToSynthetic(ctx.model?.provider)) {
+      ctx.ui.setStatus(EXTENSION_ID, undefined);
+      return;
+    }
     refresher.start();
-    await refresher.refreshFor(ctx);
+    scheduleRefresh(ctx);
   });
 
-  pi.on("turn_end", async (_event, ctx) => {
+  pi.on("turn_end", (_event, ctx) => {
     currentContext = ctx;
     if (!enabled) return;
-    await refresher.refreshFor(ctx);
+    if (shouldDeferToSynthetic(ctx.model?.provider)) return;
+    scheduleRefresh(ctx);
   });
 
-  pi.on("model_select", async (_event, ctx) => {
+  pi.on("model_select", (_event, ctx) => {
     currentContext = ctx;
     if (!enabled) {
       refresher.stop(ctx);
       return;
     }
-    await refresher.refreshFor(ctx);
+    if (shouldDeferToSynthetic(ctx.model?.provider)) {
+      ctx.ui.setStatus(EXTENSION_ID, undefined);
+      return;
+    }
+    scheduleRefresh(ctx);
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {
     currentContext = undefined;
+    syntheticUsageActive = false;
     refresher.stop(ctx);
   });
 

package/src/providers/fetch.test.ts

@@ -1,7 +1,9 @@
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   fetchAnthropicQuotasWithToken,
   fetchCodexQuotasWithToken,
+  fetchGitHubCopilotQuotas,
   fetchGitHubCopilotQuotasWithToken,
   fetchOpenRouterQuotasWithToken,
 } from "./fetch.js";
@@ -135,6 +137,44 @@ describe("fetchGitHubCopilotQuotasWithToken", () => {
     expect(result.success).toBe(true);
     expect(globalThis.fetch).toHaveBeenCalledTimes(2);
   });
+
+  it("uses the stored GitHub OAuth refresh token for Pi 0.74 Copilot quota checks", async () => {
+    const auth = AuthStorage.inMemory({
+      "github-copilot": {
+        type: "oauth",
+        refresh: "ghu-refresh-token",
+        access: "tid=abc;proxy-ep=proxy.individual.githubcopilot.com;exp=1778611280",
+        expires: Date.now() + 60_000,
+      },
+    });
+
+    globalThis.fetch = vi.fn(async (_url, init) => {
+      const authorization = new Headers(init?.headers).get("authorization");
+      if (authorization === "Bearer ghu-refresh-token") {
+        return new Response(
+          JSON.stringify({
+            quota_reset_date: "2026-05-01T00:00:00Z",
+            quota_snapshots: {
+              premium_interactions: { entitlement: 300, remaining: 210 },
+            },
+          }),
+          { status: 200 },
+        );
+      }
+      return new Response(JSON.stringify({ message: "Bad credentials" }), { status: 401 });
+    }) as any;
+
+    const result = await fetchGitHubCopilotQuotas(auth);
+
+    expect(result.success).toBe(true);
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "https://api.github.com/copilot_internal/user",
+      expect.objectContaining({
+        headers: expect.objectContaining({ Authorization: "Bearer ghu-refresh-token" }),
+      }),
+    );
+  });
 });
 
 describe("fetchOpenRouterQuotasWithToken", () => {

package/src/providers/fetch.ts

@@ -179,6 +179,32 @@ async function tryGitHubUserEndpoint(
   );
 }
 
+function githubOAuthToken(authStorage: AuthStorage): string | undefined {
+  // Pi's GitHub Copilot OAuth credential stores the GitHub OAuth token in
+  // `refresh`; `access` is a Copilot proxy token (tid=...;proxy-ep=...) that
+  // is valid for model calls but rejected by api.github.com quota endpoints.
+  const credential = authStorage.get("github-copilot") as any;
+  if (credential?.type !== "oauth") return undefined;
+  return typeof credential.refresh === "string" && credential.refresh.length > 0
+    ? credential.refresh
+    : undefined;
+}
+
+async function fetchGitHubCopilotQuotasWithGitHubToken(
+  githubToken: string | undefined,
+  signal?: AbortSignal,
+): Promise<QuotasResult> {
+  if (!githubToken) return failure("No GitHub Copilot OAuth token found", "config");
+
+  const bearerUsage = await tryGitHubUserEndpoint(`Bearer ${githubToken}`, signal);
+  if (bearerUsage.ok) return success("github-copilot", parseGitHubCopilotUsage(bearerUsage.data));
+
+  const tokenUsage = await tryGitHubUserEndpoint(`token ${githubToken}`, signal);
+  if (tokenUsage.ok) return success("github-copilot", parseGitHubCopilotUsage(tokenUsage.data));
+
+  return failure(bearerUsage.message, bearerUsage.kind);
+}
+
 export async function fetchGitHubCopilotQuotasWithToken(
   accessToken: string | undefined,
   signal?: AbortSignal,
@@ -234,6 +260,18 @@ export async function fetchGitHubCopilotQuotas(
   authStorage: AuthStorage,
   signal?: AbortSignal,
 ): Promise<QuotasResult> {
+  const oauthResult = await fetchGitHubCopilotQuotasWithGitHubToken(
+    githubOAuthToken(authStorage),
+    signal,
+  );
+  if (
+    oauthResult.success ||
+    oauthResult.error.kind === "cancelled" ||
+    oauthResult.error.kind === "timeout"
+  ) {
+    return oauthResult;
+  }
+
   return fetchGitHubCopilotQuotasWithToken(
     await providerAccessToken(authStorage, "github-copilot"),
     signal,

package/src/providers/parse.test.ts

@@ -3,6 +3,7 @@ import { parseAnthropicUsage } from "./providers.js";
 import { parseCodexUsage } from "./providers.js";
 import { parseGitHubCopilotUsage } from "./providers.js";
 import { parseOpenRouterUsage } from "./providers.js";
+import { parseSyntheticUsage } from "./providers.js";
 
 describe("parseAnthropicUsage", () => {
   it("maps oauth usage response into quota windows", () => {
@@ -410,3 +411,133 @@ describe("parseOpenRouterUsage", () => {
     expect(windows.find((w) => w.label === "Monthly")).toBeDefined();
   });
 });
+
+describe("parseSyntheticUsage", () => {
+  it("parses a full API response with all windows", () => {
+    const windows = parseSyntheticUsage({
+      subscription: {
+        limit: 500,
+        requests: 0,
+        renewsAt: "2026-05-06T12:27:17.097Z",
+      },
+      search: {
+        hourly: {
+          limit: 250,
+          requests: 30,
+          renewsAt: "2026-05-06T08:27:17.097Z",
+        },
+      },
+      freeToolCalls: {
+        limit: 0,
+        requests: 0,
+        renewsAt: "2026-05-07T07:27:17.102Z",
+      },
+      weeklyTokenLimit: {
+        nextRegenAt: "2026-05-06T09:44:14.000Z",
+        percentRemaining: 96.39,
+        maxCredits: "$24.00",
+        remainingCredits: "$23.13",
+        nextRegenCredits: "$0.48",
+      },
+      rollingFiveHourLimit: {
+        nextTickAt: "2026-05-06T07:27:51.000Z",
+        tickPercent: 0.05,
+        remaining: 420,
+        max: 500,
+        limited: false,
+      },
+    });
+
+    // subscription is NOT a window (matching pi-synthetic extension)
+    expect(windows.find((w) => w.label === "Subscription")).toBeUndefined();
+
+    // weeklyTokenLimit: 100 - 96.39 = ~3.61%
+    const credits = windows.find((w) => w.label === "Credits / week");
+    expect(credits).toBeDefined();
+    expect(credits!.usedPercent).toBeCloseTo(3.61, 1);
+    expect(credits!.isCurrency).toBe(true);
+    expect(credits!.limitValue).toBe(24);
+    expect(credits!.usedValue).toBeCloseTo(0.87, 1);
+    expect(credits!.paceScale).toBe(1 / 7);
+    expect(credits!.nextAmount).toBe("+$0.48");
+
+    // rollingFiveHourLimit: (500-420)/500 = 16%
+    const fiveHour = windows.find((w) => w.label === "Requests / 5h");
+    expect(fiveHour).toBeDefined();
+    expect(fiveHour!.usedPercent).toBe(16);
+    expect(fiveHour!.usedValue).toBe(80);
+    expect(fiveHour!.limitValue).toBe(500);
+    expect(fiveHour!.limited).toBe(false);
+
+    // search hourly
+    const search = windows.find((w) => w.label === "Search / hour");
+    expect(search).toBeDefined();
+    expect(search!.usedPercent).toBeCloseTo(12, 0);
+    expect(search!.usedValue).toBe(30);
+    expect(search!.limitValue).toBe(250);
+
+    // freeToolCalls with limit=0 is NOT shown
+    expect(windows.find((w) => w.label === "Free Tool Calls / day")).toBeUndefined();
+  });
+
+  it("shows freeToolCalls when limit > 0", () => {
+    const windows = parseSyntheticUsage({
+      weeklyTokenLimit: {
+        nextRegenAt: "2026-05-06T09:44:14.000Z",
+        percentRemaining: 50,
+        maxCredits: "$10.00",
+        remainingCredits: "$5.00",
+        nextRegenCredits: "$0.50",
+      },
+      freeToolCalls: {
+        limit: 100,
+        requests: 25,
+        renewsAt: "2026-05-07T07:27:17.102Z",
+      },
+    });
+
+    const tools = windows.find((w) => w.label === "Free Tool Calls / day");
+    expect(tools).toBeDefined();
+    expect(tools!.usedPercent).toBe(25);
+  });
+
+  it("parses currency strings like $24.00 correctly", () => {
+    const windows = parseSyntheticUsage({
+      weeklyTokenLimit: {
+        nextRegenAt: "2026-05-06T09:44:14.000Z",
+        percentRemaining: 75,
+        maxCredits: "$1,234.56",
+        remainingCredits: "$925.92",
+        nextRegenCredits: "$12.34",
+      },
+    });
+
+    const credits = windows.find((w) => w.label === "Credits / week");
+    expect(credits).toBeDefined();
+    expect(credits!.limitValue).toBe(1234.56);
+    expect(credits!.usedValue).toBeCloseTo(308.64, 1);
+    expect(credits!.usedPercent).toBe(25); // 100 - 75
+  });
+
+  it("handles limited state", () => {
+    const windows = parseSyntheticUsage({
+      rollingFiveHourLimit: {
+        nextTickAt: "2026-05-06T07:27:51.000Z",
+        tickPercent: 100,
+        remaining: 0,
+        max: 500,
+        limited: true,
+      },
+    });
+
+    const fiveHour = windows.find((w) => w.label === "Requests / 5h");
+    expect(fiveHour).toBeDefined();
+    expect(fiveHour!.usedPercent).toBe(100);
+    expect(fiveHour!.limited).toBe(true);
+  });
+
+  it("returns empty array when no data", () => {
+    const windows = parseSyntheticUsage({});
+    expect(windows).toHaveLength(0);
+  });
+});

package/src/providers/providers.ts

@@ -353,26 +353,55 @@ export function parseOpenRouterUsage(data: any): QuotaWindow[] {
   return windows;
 }
 
+/** Parse currency strings like "$24.00" to a number */
+function parseCurrency(value: string): number {
+  const n = Number(value.replace(/[^0-9.-]/g, ""));
+  return Number.isFinite(n) ? n : 0;
+}
+
 export function parseSyntheticUsage(data: any): QuotaWindow[] {
   const windows: QuotaWindow[] = [];
 
-  // Subscription (requests)
-  if (data?.subscription) {
+  // Weekly token/credit limit (primary window for paid plans)
+  if (data?.weeklyTokenLimit) {
+    const { weeklyTokenLimit } = data.weeklyTokenLimit;
+    const limitValue = parseCurrency(data.weeklyTokenLimit.maxCredits);
+    const remainingValue = parseCurrency(data.weeklyTokenLimit.remainingCredits);
     windows.push({
       provider: "synthetic",
-      label: "Subscription",
-      usedPercent: safePercent(data.subscription.requests, data.subscription.limit),
-      resetsAt: parseDateish(data.subscription.renewsAt),
-      windowSeconds: 30 * 24 * 60 * 60,
-      usedValue: data.subscription.requests,
-      limitValue: data.subscription.limit,
+      label: "Credits / week",
+      usedPercent: Math.max(0, Math.min(100, 100 - data.weeklyTokenLimit.percentRemaining)),
+      resetsAt: parseDateish(data.weeklyTokenLimit.nextRegenAt),
+      windowSeconds: 24 * 60 * 60,
+      usedValue: limitValue - remainingValue,
+      limitValue,
+      isCurrency: true,
       showPace: true,
-      nextLabel: "Resets",
+      paceScale: 1 / 7,
+      nextAmount: `+${data.weeklyTokenLimit.nextRegenCredits}`,
+      nextLabel: "Next regen",
+    });
+  }
+
+  // Rolling 5-hour request limit
+  if (data?.rollingFiveHourLimit && data.rollingFiveHourLimit.max > 0) {
+    const used = data.rollingFiveHourLimit.max - data.rollingFiveHourLimit.remaining;
+    windows.push({
+      provider: "synthetic",
+      label: "Requests / 5h",
+      usedPercent: safePercent(used, data.rollingFiveHourLimit.max),
+      resetsAt: parseDateish(data.rollingFiveHourLimit.nextTickAt),
+      windowSeconds: 5 * 60 * 60,
+      usedValue: Math.round(used),
+      limitValue: data.rollingFiveHourLimit.max,
+      showPace: false,
+      limited: data.rollingFiveHourLimit.limited,
+      nextLabel: data.rollingFiveHourLimit.limited ? "Limited" : "Resets",
     });
   }
 
-  // Search hourly
-  if (data?.search?.hourly) {
+  // Search hourly (only if limit > 0)
+  if (data?.search?.hourly?.limit && data.search.hourly.limit > 0) {
     windows.push({
       provider: "synthetic",
       label: "Search / hour",
@@ -381,59 +410,27 @@ export function parseSyntheticUsage(data: any): QuotaWindow[] {
       windowSeconds: 60 * 60,
       usedValue: data.search.hourly.requests,
       limitValue: data.search.hourly.limit,
-      showPace: false,
+      showPace: true,
+      paceScale: 1,
       nextLabel: "Resets",
     });
   }
 
-  // Free tool calls
-  if (data?.freeToolCalls) {
+  // Free tool calls (only if limit > 0)
+  if (data?.freeToolCalls?.limit && data.freeToolCalls.limit > 0) {
     windows.push({
       provider: "synthetic",
-      label: "Free Tools",
+      label: "Free Tool Calls / day",
       usedPercent: safePercent(data.freeToolCalls.requests, data.freeToolCalls.limit),
       resetsAt: parseDateish(data.freeToolCalls.renewsAt),
-      windowSeconds: 30 * 24 * 60 * 60,
+      windowSeconds: 24 * 60 * 60,
       usedValue: data.freeToolCalls.requests,
       limitValue: data.freeToolCalls.limit,
       showPace: true,
+      paceScale: 1,
       nextLabel: "Resets",
     });
   }
 
-  // Weekly token limit
-  if (data?.weeklyTokenLimit) {
-    const maxCredits = parseFloat(data.weeklyTokenLimit.maxCredits) || 0;
-    const remainingCredits = parseFloat(data.weeklyTokenLimit.remainingCredits) || 0;
-    windows.push({
-      provider: "synthetic",
-      label: "Weekly Tokens",
-      usedPercent: data.weeklyTokenLimit.percentRemaining ?? safePercent(remainingCredits, maxCredits),
-      resetsAt: parseDateish(data.weeklyTokenLimit.nextRegenAt),
-      windowSeconds: 7 * 24 * 60 * 60,
-      usedValue: maxCredits - remainingCredits,
-      limitValue: maxCredits,
-      isCurrency: true,
-      showPace: true,
-      nextLabel: "Regen",
-    });
-  }
-
-  // Rolling 5-hour limit
-  if (data?.rollingFiveHourLimit) {
-    windows.push({
-      provider: "synthetic",
-      label: "5h Limit",
-      usedPercent: data.rollingFiveHourLimit.tickPercent,
-      resetsAt: parseDateish(data.rollingFiveHourLimit.nextTickAt),
-      windowSeconds: 5 * 60 * 60,
-      usedValue: data.rollingFiveHourLimit.max - data.rollingFiveHourLimit.remaining,
-      limitValue: data.rollingFiveHourLimit.max,
-      limited: data.rollingFiveHourLimit.limited,
-      showPace: false,
-      nextLabel: data.rollingFiveHourLimit.limited ? "Limited" : "Resets",
-    });
-  }
-
   return windows;
 }

package/src/utils/quotas-severity.test.ts

@@ -74,13 +74,33 @@ describe("assessWindow", () => {
     expect(assessWindow(w).severity).toBe("critical");
   });
 
+  it("warns for pace-aware windows once absolute usage reaches 80%", () => {
+    const now = Date.now();
+    const monthSeconds = 31 * 24 * 3600;
+    const w = makeWindow({
+      provider: "github-copilot",
+      label: "Premium / month",
+      usedPercent: 83,
+      usedValue: 249,
+      limitValue: 300,
+      showPace: true,
+      windowSeconds: monthSeconds,
+      // Screenshot repro: 51/300 left with reset in about 428h35m in a 31-day
+      // monthly window. Dynamic pace alone projects just under warning, but
+      // only 17% remains, so low-quota color should still be amber.
+      resetsAt: new Date(now + ((428 * 60 + 35) * 60 * 1000)),
+    });
+
+    expect(assessWindow(w).severity).toBe("warning");
+  });
+
   it("returns warning when projected exceeds dynamic warn threshold", () => {
     const w = makeWindow({
-      usedPercent: 95,
+      usedPercent: 79,
       showPace: true,
       paceScale: 1,
       windowSeconds: 3600,
-      resetsAt: new Date(Date.now() + 1800 * 1000),
+      resetsAt: new Date(Date.now() + 2520 * 1000),
     });
     expect(assessWindow(w).severity).toBe("warning");
   });

package/src/utils/quotas-severity.ts

@@ -53,11 +53,24 @@ export function getProjectedPercent(
   return Math.max(0, (usedPercent / effectivePace) * 100);
 }
 
+function absoluteUsageSeverity(window: QuotaWindow, percent: number): RiskSeverity {
+  if (window.limited || percent >= 100) return "critical";
+  if (percent >= 90) return "high";
+  if (percent >= 80) return "warning";
+  return "none";
+}
+
+function maxSeverity(a: RiskSeverity, b: RiskSeverity): RiskSeverity {
+  const order: RiskSeverity[] = ["none", "warning", "high", "critical"];
+  return order[Math.max(order.indexOf(a), order.indexOf(b))] ?? "none";
+}
+
 export function assessWindow(window: QuotaWindow): RiskAssessment {
   const rawPace = window.showPace ? getPacePercent(window) : null;
   const pacePercent =
     rawPace !== null ? rawPace * (window.paceScale ?? 1) : null;
   const projectedPercent = getProjectedPercent(window.usedPercent, pacePercent);
+  const absoluteSeverity = absoluteUsageSeverity(window, window.usedPercent);
 
   let progress: number | null = null;
   if (pacePercent !== null) progress = pacePercent / 100;
@@ -70,10 +83,7 @@ export function assessWindow(window: QuotaWindow): RiskAssessment {
   };
 
   if (progress === null) {
-    let severity: RiskSeverity = "none";
-    if (window.limited || projectedPercent >= 100) severity = "critical";
-    else if (projectedPercent >= 90) severity = "high";
-    else if (projectedPercent >= 80) severity = "warning";
+    const severity = absoluteUsageSeverity(window, projectedPercent);
 
     return {
       ...base,
@@ -121,7 +131,7 @@ export function assessWindow(window: QuotaWindow): RiskAssessment {
     warnProjectedPercent,
     highProjectedPercent,
     criticalProjectedPercent,
-    severity,
+    severity: maxSeverity(severity, absoluteSeverity),
   };
 }