agent-fuel 0.2.0 → 0.4.0

package/README.md

@@ -6,20 +6,20 @@ A sleek, unified CLI dashboard to monitor your AI coding assistant quotas, credi
 
 ## 🚀 Installation & Running
 
-Install **Agent Fuel** globally on your system in one step:
+Install **Agent Fuel** globally:
 
 ```bash
 npm install -g agent-fuel
 ```
 
-Once installed, you can run the dashboard at any time from **any directory** on your machine by simply typing:
+Then run from any directory:
 
 ```bash
 agent-fuel
 ```
 
 ### Development Setup
-If you want to run or contribute to `agent-fuel` locally:
+
 ```bash
 git clone https://github.com/jperod/agent-fuel.git
 cd agent-fuel
@@ -32,63 +32,97 @@ npm link
 
 ## 💡 The Motivation
 
-AI coding assistants are now integral to developer workflows. Tools like **Claude Code**, **Codex CLI**, and **AGY (Google Antigravity CLI)** supercharge productivity but operate under tight, separate quota bounds. Whether it is a daily dollar limit, token ceilings, or monthly credits, developers are forced to jump through interactive prompts or scrape configuration screens just to answer a simple question:
+AI coding assistants are now integral to developer workflows. Tools like **Claude Code**, **Codex CLI**, and **AGY (Google Antigravity CLI)** supercharge productivity but operate under tight, separate quota bounds. Developers are forced to jump through interactive prompts or scrape configuration screens just to answer:
 
 > **"How much agent fuel do I have left before starting this massive refactor?"**
 
-Because each CLI exposes quota information differently (some via strict JSON, others through human-readable prompts, and some in local state files), there is no centralized way to monitor your resource consumption. 
-
-**Agent Fuel** solves this by acting as a lightweight, adapter-based abstraction layer that normalizes all coding agent quotas into a single metric: **Percent Remaining**.
+**Agent Fuel** solves this by acting as a lightweight, adapter-based abstraction layer that normalises all coding agent quotas into a single metric: **Percent Remaining**.
 
 ---
 
-## 🎯 The Idea
+## 🎯 How It Works
+
+`agent-fuel` is a tiny modern CLI built with TypeScript that:
 
-`agent-fuel` is a tiny, modern local CLI built with TypeScript that:
-1. **Dispatches Adapters**: Queries each configured AI coding tool (Claude Code, Codex, AGY) using native CLI calls, helper utilities (like `ccusage`), or local config parsing.
-2. **Normalizes Quota Models**: Standardizes diverse limits into a uniform percentage score (`0` to `100%`).
-3. **Renders an Elegant CLI Dashboard**: Displays a high-fidelity 3-bar ASCII progress dashboard directly in your terminal.
+1. **Dispatches Adapters concurrently** — all adapters run in parallel and each row is printed the moment its adapter resolves; you never wait for the slowest tool.
+2. **Normalises Quota Models** — standardises diverse limits into a uniform `0–100%` score.
+3. **Scrapes TUI output directly** — Codex and AGY quotas are read by spawning the real CLIs via `expect` and parsing terminal output, so the numbers match what the tools themselves show.
+4. **Caches AGY results** — AGY quota is cached for 5 minutes so repeated runs are instant (~1s).
+5. **Renders a clean dashboard** — colour-coded bars with reset times directly in your terminal.
 
 ### Project Architecture
 
 ```text
 agent-fuel/
   ├── src/
-  │   ├── index.ts          # CLI entry point
-  │   ├── render.ts         # Beautiful 3-bar dashboard renderer
+  │   ├── index.ts            # CLI entry point — runs all adapters concurrently
+  │   ├── render.ts           # Colour-coded bar dashboard renderer
   │   └── adapters/
-  │       ├── claude.ts     # Adapter for Claude Code (ccusage blocks)
-  │       ├── codex.ts      # Adapter for Codex (ccusage codex session)
-  │       └── agy.ts        # Adapter for AGY (Antigravity history & model config parser)
+  │       ├── index.ts        # Shared UsageSnapshot type & QuotaAdapter interface
+  │       ├── claude.ts       # Claude Code (via ccusage blocks)
+  │       ├── codex.ts        # Codex CLI (expect TUI scrape; ccusage as fallback estimate)
+  │       └── agy.ts          # AGY — split into Gemini + Other buckets
   ├── package.json
   └── README.md
 ```
 
-### High-Fidelity API Type Shape
+### Type Shape
 
 ```typescript
 type UsageSnapshot = {
-  tool: 'codex' | 'claude-code' | 'agy';
-  remainingPercent: number | null; // Unified 0-100 scale
+  tool: 'codex' | 'claude-code' | 'agy-gemini' | 'agy-other';
+  remainingPercent: number | null;   // Unified 0–100 scale
   usedPercent?: number | null;
   resetAt?: string | null;
-  source: 'official-cli' | 'ccusage' | 'local-state' | 'provider-api' | 'unknown';
+  source: 'official-cli' | 'ccusage' | 'local-state' | 'provider-api' | 'cache' | 'unknown';
   raw?: unknown;
 };
 ```
 
 ---
 
-## 📊 Terminal Dashboard Preview
+## 📊 Terminal Dashboard
 
-Running `agent-fuel` will immediately output a clean, colored visual summary of your current agent capacity:
-
-```text
+```
 ⚡️ Agent Fuel - CLI Quota Monitor
 
-Codex        [██████████████████████████████]  99% remaining (resets 01:49 PM)
-Claude Code  [█████████████████████████░░░░░]  83% remaining (resets 01:00 PM)
-AGY          [██████████████████░░░░░░░░░░░░]  60% remaining (resets 01:57 PM) [Gemini 3.5 Flash (High)]
+Claude Code   [███████████████████░░░░░░░░░░░]  64% remaining (resets 01:00 PM)
+Codex         [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░]   0% remaining (resets in 4h 33m)
+AGY Gemini    [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░]   0% remaining (resets in 3h 16m) [Gemini 3.5 Flash (Medium)]
+AGY Other     [██████████████████░░░░░░░░░░░░]  60% remaining (resets in 4h 47m) [Claude Sonnet 4.6 (Thinking)]
+
+agent-fuel v0.3.0
 ```
 
+Rows appear as each adapter resolves — Claude Code (instant) prints first, Codex and AGY follow as their TUI scrapes complete.
+
+**AGY Gemini** shows the worst-case remaining across all `Gemini *` model tiers.  
+**AGY Other** shows the worst-case across Claude and other non-Gemini models.  
+**Codex** row tagged `[~est]` when quota has not been reached and the percentage is estimated from local session cost data (see fallback note below).
+
+---
+
+## ⚙️ Environment Overrides
+
+| Variable | Default | Description |
+|---|---|---|
+| `AGENT_FUEL_CLAUDE_BUDGET` | `20.0` | Claude Code rolling budget in USD |
+| `AGENT_FUEL_CODEX_BUDGET` | `20.0` | **Fallback estimate only** — Codex rolling budget in USD |
+
+> **Note on `AGENT_FUEL_CODEX_BUDGET`:** Codex quota is read directly from the Codex TUI via `expect` scraping. This variable is only used as a rough fallback estimate (shown as `[~est]`) when the TUI reports no quota warning and a percentage cannot be determined. It is a guess based on local session cost data — not an official Codex quota signal. The TUI scrape is always preferred.
+
+---
+
+## 📦 Changelog
+
+### v0.3.0
+- **Codex TUI scrape**: replaced inaccurate `ccusage` cost estimate with an `expect` wrapper that reads the real Codex quota warning (`"Individual quota reached. Resets in Xh Ym"`) — same pattern as AGY. `ccusage` kept as a labelled `[~est]` fallback when quota has not yet been exhausted.
+- **Streaming render with fixed order**: placeholder rows print immediately; each bar overwrites in-place as its adapter resolves. Row order is always `Claude Code → Codex → AGY Gemini → AGY Other`.
+- **AGY split view**: Gemini and non-Gemini (Claude, etc.) quota buckets shown as separate rows
+- **5-minute disk cache** for AGY quota — repeated runs complete in ~1s instead of ~20s
+- Output size cap, typed `any` removal, env validation hardening
 
+### v0.2.x
+- AGY quota now scraped live from `agy /usage` panel via `expect` wrapper (zero token cost)
+- Claude Code budget corrected to $20 rolling limit
+- Replaced token-consuming `claude -p` calls with offline `ccusage` scraping

package/dist/adapters/agy.d.ts

@@ -1,6 +1,4 @@
 import { QuotaAdapter, UsageSnapshot } from './index.js';
 export declare class AgyQuotaAdapter implements QuotaAdapter {
-    private configDir;
-    constructor();
-    fetchSnapshot(): Promise<UsageSnapshot>;
+    fetchSnapshots(): Promise<UsageSnapshot[]>;
 }

package/dist/adapters/agy.js

@@ -1,104 +1,171 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-export class AgyQuotaAdapter {
-    configDir;
-    constructor() {
-        // Default to the standard AGY CLI config directory
-        this.configDir = path.join(os.homedir(), '.gemini/antigravity-cli');
+import { TuiScraper } from '../tmux.js';
+const CACHE_PATH = path.join(os.homedir(), '.gemini/antigravity-cli/.agent-fuel-quota-cache.json');
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+// ── Scraping ───────────────────────────────────────────────────────────────
+async function sleep(ms) {
+    return new Promise(res => setTimeout(res, ms));
+}
+/**
+ * Launches `agy` in a tmux session, opens the `/usage` panel, waits for
+ * the Model Quota list to render, then returns clean rendered screen text.
+ */
+async function runAgyUsage() {
+    const tui = new TuiScraper('agy');
+    try {
+        tui.start();
+        // Wait for AGY main menu ready
+        await tui.waitFor(/for shortcuts/, 20_000);
+        // Navigate to /usage panel
+        tui.send('/usage');
+        await tui.waitFor(/Model Quota/, 10_000);
+        // Brief pause for all model rows to finish rendering
+        await sleep(500);
+        return tui.capture();
     }
-    async fetchSnapshot() {
-        try {
-            const settingsPath = path.join(this.configDir, 'settings.json');
-            const historyPath = path.join(this.configDir, 'history.jsonl');
-            let activeModel = 'Gemini 3.5 Flash';
-            // 1. Read active model from settings.json if it exists
-            try {
-                const settingsContent = await fs.readFile(settingsPath, 'utf-8');
-                const settings = JSON.parse(settingsContent);
-                if (settings && settings.model) {
-                    activeModel = settings.model;
+    finally {
+        tui.kill();
+    }
+}
+// ── Parsing ────────────────────────────────────────────────────────────────
+/**
+ * Parse the Model Quota panel into an array of entries.
+ *
+ * Panel format (tmux rendered — no ANSI codes):
+ *
+ *   └ Model Quota
+ *
+ *     Gemini 3.5 Flash (High)
+ *     ░░░░░░░░░░░ ... 20%
+ *     Refreshes in 3h 28m
+ *
+ *     Claude Sonnet 4.6 (Thinking)
+ *     ███████████ ... 100%
+ *     Quota available
+ */
+function parseQuotaPanel(raw) {
+    // tmux capture-pane returns clean rendered text — no ANSI stripping needed
+    const lines = raw.split(/\r?\n/);
+    const results = [];
+    const headerIdx = lines.findIndex(l => l.includes('Model Quota'));
+    if (headerIdx === -1)
+        return results;
+    const panelLines = lines.slice(headerIdx + 1);
+    let i = 0;
+    while (i < panelLines.length) {
+        const line = panelLines[i].trim();
+        const isModelName = line.length > 0 &&
+            !line.startsWith('░') && !line.startsWith('█') &&
+            !line.startsWith('↑') && !line.startsWith('(') &&
+            !line.startsWith('┘') && !line.startsWith('└') &&
+            !line.startsWith('?') && !line.startsWith('esc') &&
+            !/^\d+%/.test(line) &&
+            !line.includes('Refreshes') && !line.includes('Quota available') &&
+            !line.includes('──');
+        if (isModelName) {
+            let barLine = null;
+            let refreshLine = null;
+            let j = i + 1;
+            while (j < panelLines.length) {
+                const candidate = panelLines[j].trim();
+                if (candidate.length === 0) {
+                    j++;
+                    continue;
                 }
-            }
-            catch {
-                // Fallback to default model name if reading or parsing settings failed
-            }
-            // 2. Read history.jsonl to detect active prompts within the rolling 5-hour window
-            let todayPromptsCount = 0;
-            let latestPromptTimestamp = null;
-            const fiveHoursAgo = Date.now() - 5 * 60 * 60 * 1000;
-            try {
-                const historyContent = await fs.readFile(historyPath, 'utf-8');
-                const historyLines = historyContent.trim().split('\n');
-                for (const line of historyLines) {
-                    if (!line.trim())
-                        continue;
-                    const entry = JSON.parse(line);
-                    if (entry && entry.timestamp) {
-                        // Check if the prompt falls within the 5-hour rolling window
-                        if (entry.timestamp >= fiveHoursAgo) {
-                            todayPromptsCount++;
-                            if (!latestPromptTimestamp || entry.timestamp > latestPromptTimestamp) {
-                                latestPromptTimestamp = entry.timestamp;
-                            }
-                        }
-                    }
+                if (barLine === null && (candidate.includes('░') || candidate.includes('█') || /^\d+%/.test(candidate))) {
+                    barLine = candidate;
+                    j++;
+                    continue;
                 }
-            }
-            catch {
-                // Fallback if reading or parsing history failed (e.g. file doesn't exist)
-            }
-            // 3. Calculate remaining percent based on active usage and model tier
-            // Support dynamic overrides using AGENT_FUEL_AGY_PERCENT environment variable
-            let remainingPercent = 100;
-            const isProModel = activeModel.toLowerCase().includes('pro');
-            let calculatedPercent = 100;
-            if (isProModel) {
-                // Pro models: limit is 10 prompts, steps of 2 prompts (each step is 20%)
-                calculatedPercent = Math.max(0, 100 - (Math.floor(todayPromptsCount / 2) * 20));
-            }
-            else {
-                // Flash models: limit is 25 prompts, steps of 5 prompts (each step is 20%)
-                calculatedPercent = Math.max(0, 100 - (Math.floor(todayPromptsCount / 5) * 20));
-            }
-            if (process.env.AGENT_FUEL_AGY_PERCENT) {
-                const envVal = Number(process.env.AGENT_FUEL_AGY_PERCENT);
-                remainingPercent = !isNaN(envVal) ? Math.max(0, Math.min(100, envVal)) : calculatedPercent;
-            }
-            else {
-                remainingPercent = calculatedPercent;
-            }
-            // 4. Calculate rolling reset time (5 hours rolling or resets in 4h 37m from latest prompt, giving ~01:30 PM resets)
-            let resetAt = null;
-            if (latestPromptTimestamp) {
-                try {
-                    const lastActivityDate = new Date(latestPromptTimestamp);
-                    // Roll forward 5 hours (refreshes in ~4h 37m from active run)
-                    const resetDate = new Date(lastActivityDate.getTime() + 5 * 60 * 60 * 1000);
-                    resetAt = resetDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                if (barLine !== null && (candidate.includes('Refreshes') || candidate.includes('Quota available'))) {
+                    const m = candidate.match(/(Refreshes in [^\r\n]+|Quota available)/);
+                    refreshLine = m ? m[1] : candidate;
+                    j++;
                 }
-                catch {
-                    resetAt = null;
+                break;
+            }
+            if (barLine !== null) {
+                const percentMatch = barLine.match(/(\d+)%/);
+                if (percentMatch) {
+                    results.push({ model: line, percent: parseInt(percentMatch[1], 10), refreshLine });
                 }
             }
-            return {
-                tool: 'agy',
-                remainingPercent,
-                usedPercent: 100 - remainingPercent,
-                resetAt,
-                source: 'local-state',
-                raw: { activeModel, todayPromptsCount }
-            };
+            i = j;
+        }
+        else {
+            i++;
+        }
+    }
+    return results;
+}
+// ── Cache helpers ──────────────────────────────────────────────────────────
+async function readCache() {
+    try {
+        return JSON.parse(await fs.readFile(CACHE_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(entries) {
+    try {
+        await fs.writeFile(CACHE_PATH, JSON.stringify({ fetchedAt: Date.now(), entries }), 'utf-8');
+    }
+    catch { /* non-fatal */ }
+}
+// ── Bucket aggregation ────────────────────────────────────────────────────
+function buildSnapshots(entries, fromCache) {
+    const source = fromCache ? 'cache' : 'official-cli';
+    const geminiEntries = entries.filter(e => /gemini/i.test(e.model));
+    const otherEntries = entries.filter(e => !/gemini/i.test(e.model));
+    function worstCase(bucket, tool) {
+        if (bucket.length === 0) {
+            return { tool, remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown' };
+        }
+        const worst = bucket.reduce((a, b) => a.percent <= b.percent ? a : b);
+        return {
+            tool,
+            remainingPercent: worst.percent,
+            usedPercent: 100 - worst.percent,
+            resetAt: worst.refreshLine ?? null,
+            source,
+            raw: { matchedModel: worst.model, allModels: bucket.map(e => `${e.model}: ${e.percent}%`) },
+        };
+    }
+    return [
+        worstCase(geminiEntries, 'agy-gemini'),
+        worstCase(otherEntries, 'agy-other'),
+    ];
+}
+// ── Adapter ───────────────────────────────────────────────────────────────
+export class AgyQuotaAdapter {
+    async fetchSnapshots() {
+        // Fast path: serve from cache if fresh enough
+        const cached = await readCache();
+        if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+            return buildSnapshots(cached.entries, true);
+        }
+        // Slow path: spawn agy via tmux, scrape the quota panel
+        try {
+            const raw = await runAgyUsage();
+            const entries = parseQuotaPanel(raw);
+            if (entries.length > 0) {
+                await writeCache(entries);
+                return buildSnapshots(entries, false);
+            }
+            return [
+                { tool: 'agy-gemini', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown' },
+                { tool: 'agy-other', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown' },
+            ];
         }
         catch (error) {
-            return {
-                tool: 'agy',
-                remainingPercent: null,
-                usedPercent: null,
-                resetAt: null,
-                source: 'unknown',
-                raw: error instanceof Error ? error.message : String(error)
-            };
+            const msg = error instanceof Error ? error.message : String(error);
+            return [
+                { tool: 'agy-gemini', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown', raw: msg },
+                { tool: 'agy-other', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown', raw: msg },
+            ];
         }
     }
 }

package/dist/adapters/claude.d.ts

@@ -1,6 +1,5 @@
 import { QuotaAdapter, UsageSnapshot } from './index.js';
 export declare class ClaudeQuotaAdapter implements QuotaAdapter {
-    private budgetLimit;
-    constructor();
-    fetchSnapshot(): Promise<UsageSnapshot>;
+    fetchSnapshots(): Promise<UsageSnapshot[]>;
+    private _fetch;
 }

package/dist/adapters/claude.js

@@ -1,72 +1,87 @@
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-const execAsync = promisify(exec);
+import { TuiScraper } from '../tmux.js';
+import { debug } from '../debug.js';
+// ── TUI scraper ────────────────────────────────────────────────────────────
+async function sleep(ms) {
+    return new Promise(res => setTimeout(res, ms));
+}
+/**
+ * Launches `claude` in a tmux session, opens /status, navigates to the
+ * Status tab (which shows real quota usage bars), and returns the captured
+ * screen text.
+ *
+ * The Status tab renders persistently (not transient), so regular
+ * capture-pane is sufficient — no pipe-pane needed.
+ */
+async function runClaudeScrape() {
+    const tui = new TuiScraper('claude');
+    try {
+        tui.start();
+        // Wait for TUI ready — welcome banner or prompt hint visible
+        await tui.waitFor(/Welcome back|Try "/i, 15_000, 0);
+        // Open the /status panel
+        tui.send('/status');
+        // Wait for the status panel tabs to appear
+        await tui.waitFor(/Settings\s+Status/i, 10_000, 0);
+        // Navigate to the Status tab (second tab after Settings)
+        tui.sendKey('Tab');
+        await sleep(300);
+        tui.sendKey('Tab');
+        // Wait for the usage bars — shows "XX% used"
+        return await tui.waitFor(/\d+%\s+used/i, 8_000, 0);
+    }
+    finally {
+        tui.kill();
+    }
+}
+function parseScrapeOutput(screen) {
+    debug('claude:parse', `screen length: ${screen.length}`);
+    debug('claude:parse', 'screen', screen);
+    // Match "XX% used" occurrences in order:
+    // First = current session (5h block), second = current week
+    const usedMatches = [...screen.matchAll(/(\d+)%\s+used/gi)];
+    debug('claude:parse', `found ${usedMatches.length} "% used" matches`);
+    const sessionUsedPct = usedMatches[0] ? parseInt(usedMatches[0][1], 10) : null;
+    const weeklyUsedPct = usedMatches[1] ? parseInt(usedMatches[1][1], 10) : null;
+    // Reset time: "Resets H:MMam" or "Resets May 30 at 6am" — grab the first occurrence
+    const resetMatch = screen.match(/Resets\s+([^\n\r]+)/i);
+    const sessionResetAt = resetMatch ? resetMatch[1].trim() : null;
+    debug('claude:parse', 'result', { sessionUsedPct, sessionResetAt, weeklyUsedPct });
+    return { sessionUsedPct, sessionResetAt, weeklyUsedPct };
+}
+// ── Adapter ────────────────────────────────────────────────────────────────
 export class ClaudeQuotaAdapter {
-    budgetLimit;
-    constructor() {
-        // Default to $10.00 for the rolling 5-hour window, allow env override
-        this.budgetLimit = Number(process.env.AGENT_FUEL_CLAUDE_BUDGET) || 10.0;
+    async fetchSnapshots() {
+        return [await this._fetch()];
     }
-    async fetchSnapshot() {
+    async _fetch() {
+        const unknown = () => ({
+            tool: 'claude-code',
+            remainingPercent: null,
+            usedPercent: null,
+            resetAt: null,
+            source: 'unknown',
+        });
+        debug('claude:fetch', 'starting TUI scrape via tmux');
         try {
-            // Execute ccusage to get billing block information in JSON format
-            // We run npx --no-install first to see if it's already cached/available, otherwise fall back to regular npx
-            let stdout;
-            try {
-                const result = await execAsync('npx --no-install ccusage blocks --json');
-                stdout = result.stdout;
-            }
-            catch {
-                throw new Error('ccusage package is not installed or available locally. Please run "npm install -g ccusage" to use this tool.');
-            }
-            const data = JSON.parse(stdout);
-            const blocks = data && Array.isArray(data.blocks) ? data.blocks : data;
-            if (!blocks || !Array.isArray(blocks)) {
-                throw new Error('Invalid JSON format returned from ccusage blocks');
-            }
-            // Find the active billing block
-            const activeBlock = blocks.find((block) => block.isActive === true);
-            if (!activeBlock) {
+            const screen = await runClaudeScrape();
+            const result = parseScrapeOutput(screen);
+            if (result.sessionUsedPct !== null) {
+                const remainingPercent = Math.max(0, 100 - result.sessionUsedPct);
+                debug('claude:fetch', `parsed Usage tab → ${result.sessionUsedPct}% used (${remainingPercent}% remaining)`);
                 return {
                     tool: 'claude-code',
-                    remainingPercent: null,
-                    usedPercent: null,
-                    resetAt: null,
-                    source: 'unknown'
+                    remainingPercent,
+                    usedPercent: result.sessionUsedPct,
+                    resetAt: result.sessionResetAt,
+                    source: 'official-cli',
                 };
             }
-            const cost = activeBlock.costUSD || 0.0;
-            const usedPercent = (cost / this.budgetLimit) * 100;
-            const remainingPercent = Math.max(0, Math.min(100, Math.round(100 - usedPercent)));
-            let resetAt = null;
-            if (activeBlock.endTime) {
-                try {
-                    const endDate = new Date(activeBlock.endTime);
-                    resetAt = endDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-                }
-                catch {
-                    resetAt = activeBlock.endTime;
-                }
-            }
-            return {
-                tool: 'claude-code',
-                remainingPercent,
-                usedPercent: Math.round(usedPercent),
-                resetAt,
-                source: 'ccusage',
-                raw: activeBlock
-            };
+            debug('claude:fetch', 'parse failed → unknown');
+            return unknown();
         }
-        catch (error) {
-            // Fallback in case of execution errors
-            return {
-                tool: 'claude-code',
-                remainingPercent: null,
-                usedPercent: null,
-                resetAt: null,
-                source: 'unknown',
-                raw: error instanceof Error ? error.message : String(error)
-            };
+        catch (err) {
+            debug('claude:fetch', 'caught error', String(err));
+            return unknown();
         }
     }
 }

package/dist/adapters/codex.d.ts

@@ -1,6 +1,7 @@
 import { QuotaAdapter, UsageSnapshot } from './index.js';
 export declare class CodexQuotaAdapter implements QuotaAdapter {
-    private budgetLimit;
+    private readonly budgetLimit;
     constructor();
-    fetchSnapshot(): Promise<UsageSnapshot>;
+    fetchSnapshots(): Promise<UsageSnapshot[]>;
+    private _fetch;
 }