agent-tank 0.9.9 → 0.9.11

package/CHANGELOG.md

@@ -0,0 +1,157 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.9.11] - 2026-09-29
+
+### Verified
+
+Verified with the following agent versions (versions checked on 2026-09-29):
+
+- Claude Code `2.1.284`
+- Antigravity CLI (`agy`) `1.2.12`
+- Codex CLI `0.158.0`
+
+### Added
+
+- Monitor multiple accounts from the same provider using the repeatable `--agent provider[:alias][=config-path]` flag or the config file's `agents` array, with separate config directories, dashboard labels, history, and refresh endpoints
+- Parse Codex model-specific rate-limit buckets alongside the main five-hour and weekly limits
+- Include absolute `resetsAt` timestamps and limit `cycle` identifiers in Antigravity usage entries
+
+### Changed
+
+- Replace Claude's `weeklySonnet` usage field with `weeklyFable` in PTY and OAuth API parsing, dashboard display, history, and pace calculations; API consumers using `weeklySonnet` must update to the new field
+
+### Fixed
+
+- Recover swallowed Claude `/usage` commands without interrupting partially rendered usage or an active refresh, and parse metadata correctly from compact `/status` output
+- Submit Codex slash commands through the newer command picker and accept weekly-only usage output without waiting for a missing five-hour limit
+- Initialize the Codex app-server JSON-RPC connection and parse its current rate-limit response, including used percentages, window durations, and Unix reset timestamps
+- Preserve Claude Fable allowances at zero usage and wait for delayed allowance rows before dismissing the usage dialog, while allowing accounts without Fable to complete
+- Parse Antigravity's `Refreshes in` reset countdowns, including lines with leftover terminal box borders, and use the correct weekly or five-hour window for pace calculations
+
+## [0.9.10] - 2026-06-15
+
+### Fixed
+
+- Recover Claude session usage from the `/usage` dialog even when its "Current session" row is captured mid-render in a corrupted state, instead of returning only weekly and Sonnet data (and timing out)
+- Stop treating a partial Claude rate limit (e.g. the per-model/Sonnet breakdown) as an error: keep the fresh session and weekly data, omit only the rate-limited section, and surface a rate-limit error only when no usable data is returned
+
+## [0.9.9] - 2026-06-15
+
+### Fixed
+
+- Parse the newer Antigravity "Models & Quota" usage screen, keeping each model group's weekly and five-hour limits as distinct, readable entries instead of collapsing them into two generic limits
+- Dismiss the Antigravity usage modal before re-running `/usage`, fixing refreshes that alternated between success and a 35s timeout on the reused session
+- Force-kill agent PTY processes that ignore `SIGTERM`/`SIGHUP` (e.g. `agy`, `codex`) so they no longer survive as orphaned processes after respawns or shutdown
+- Clean up agent processes on `SIGINT` and `SIGHUP` in addition to `SIGTERM`, so detached/background runs shut down cleanly
+
+## [0.9.8] - 2026-06-14
+
+### Added
+
+- Add `--background` (and `AGENT_TANK_BACKGROUND`) to start Agent Tank as a detached process that prints its PID and log path, then exits the parent command
+- Add `AGENT_TANK_BACKGROUND_LOG` to set the background child's stdout/stderr log path, and `AGENT_TANK_BACKGROUND_GRACE_MS` to configure the parent's startup grace period before reporting success
+- Warn at startup when other Agent Tank processes are already running, listing each PID with credential flags redacted, and including `kill` / `kill -9` instructions to stop them; the warning header is shown in bold red on an interactive terminal
+- Document running Agent Tank from source in the README (clone, install, run, flags, prerequisites)
+
+### Fixed
+
+- Harden the debug output dump on the status page so malformed agent output can't crash the process
+
+## [0.9.7] - 2026-06-05
+
+### Changed
+
+- Use chokidar polling for activity monitoring to reduce native watcher pressure on large CLI log trees
+- Replace Gemini CLI support with Antigravity CLI (`agy`) using the interactive `/usage` command
+
+### Fixed
+
+- Fix Claude Code PTY one-shot stats checks against Claude Code 2.1 compact usage output
+- Prevent Claude metadata fetch from crashing when the CLI exits before delayed PTY writes run
+- Dismiss Claude `/status` metadata dialogs before sending `/usage` so one-shot usage checks can complete
+- Parse compact Claude reset timestamps such as `Jun10,6pm(Europe/Berlin)`
+- Wait for Claude's separate weekly Sonnet usage section before completing `/usage` parsing
+
+## [0.9.5] - 2026-04-13
+
+### Added
+
+- Add a per-agent refresh cooldown with a default of 30 seconds, applied to manual refreshes, startup refreshes, and auto-refresh activity
+- Add `--refresh-cooldown` and `AGENT_TANK_REFRESH_COOLDOWN` to reconfigure or disable the refresh cooldown
+
+### Changed
+
+- Prefer Docker bridge gateway discovery via `docker network inspect`, falling back to local interface detection only when Docker is unavailable
+
+### Fixed
+
+- Stop interval-mode auto-refresh from bypassing the central refresh guard
+- Tighten Gemini CLI readiness detection so auth and agent-thinking screens are less likely to be misread as ready prompts
+
+## [0.9.4] - 2026-04-12
+
+### Added
+
+- Bind to the local Docker bridge by default when `--host` is omitted, so containers on the same host can reach Agent Tank without exposing it publicly
+- Add `--no-docker` and `AGENT_TANK_DOCKER` to disable Docker bridge binding explicitly
+
+### Fixed
+
+- Keep zero-usage reset times visible in the UI for Claude, Gemini, and Codex when reset information exists
+- Remove trailing slashes from startup banner status page URLs
+
+## [0.9.3] - 2026-04-11
+
+### Added
+
+- Add `--version` to the `agent-tank` CLI for quick version checks
+- Log PTY and JSON-RPC subprocess PIDs when agent processes start
+
+### Fixed
+
+- Make `Ctrl+C` exits immediate again by avoiding reliance on a JS `SIGINT` handler
+- Prevent shutdown races from respawning agent processes after teardown begins
+- Guard PTY refresh, metadata fetch, and keepalive paths against restart during shutdown
+
+## [0.9.2] - 2026-04-09
+
+### Fixed
+
+- Prevent Gemini agent crashes when the CLI process exits during authentication flows
+- Avoid sending `Escape` while Gemini OAuth authentication is in progress, which could cancel login
+- Improve Gemini trust prompt handling during command execution and slow startup scenarios
+- Detect Gemini CLI unauthenticated/setup screens and report them clearly instead of surfacing a generic timeout
+
+### Added
+
+- Regression tests covering Gemini shell null-safety during delayed callbacks
+- Gemini authentication-required status in the API response and a concise login instruction in the UI
+
+## [0.9.0] - 2024-01-20
+
+### Added
+
+- Initial release
+- Support for Claude Code CLI (`/usage` command)
+  - Session usage percentage
+  - Weekly usage (all models)
+  - Weekly usage (Sonnet only)
+  - Reset times
+- Support for Gemini CLI (`/stats` command)
+  - Per-model usage percentages
+  - Reset times for each model
+- Support for OpenAI Codex CLI (`/status` command)
+  - 5-hour limit percentage
+  - Weekly limit percentage
+  - Model and account info
+- Auto-discovery of installed LLM CLI tools
+- HTTP API with JSON responses
+- Built-in HTML status page dashboard
+- Refresh endpoints for on-demand updates
+- CORS support for cross-origin requests
+- Cursor position query response for Codex compatibility

package/README.md

@@ -170,7 +170,7 @@ agent-tank --refresh-cooldown 60
 
 | Agent | Method | Metrics |
 |---|---|---|
-| Claude | PTY `/usage` or Anthropic OAuth API | Current session, weekly all-models, weekly Sonnet-only |
+| Claude | PTY `/usage` or Anthropic OAuth API | Current session, weekly all-models, weekly Fable allowance (Max accounts only) |
 | Antigravity | PTY `/usage` | Per-model quota availability and reset windows when reported |
 | Codex | JSON-RPC preferred, PTY fallback | 5-hour limits, weekly limits, model/account info |
 
@@ -237,6 +237,7 @@ Options:
   --claude              Enable Claude monitoring
   --agy                 Enable Antigravity monitoring
   --codex               Enable Codex monitoring
+  --agent <spec>        Add an account as provider[:alias][=config-path] (repeatable)
   --port <port>         HTTP server port (default: 3456)
   --host <host>         Bind address (default: 127.0.0.1 + Docker bridge when available)
   --docker              Enable Docker bridge bind when --host is omitted (default: true)
@@ -293,11 +294,32 @@ three exceptions: `--no-background`, `--once`, and `--json` suppress
 
 ### Config File
 
+Use the `agents` array to monitor multiple accounts, including multiple accounts
+from the same provider. Each entry accepts a `provider`, an optional unique `id`
+and display `alias`, and an optional `configPath` directory:
+
 ```json
 {
-  "claude": true,
-  "agy": true,
-  "codex": false,
+  "agents": [
+    {
+      "provider": "codex",
+      "id": "work",
+      "alias": "Work",
+      "configPath": "/srv/accounts/codex-work"
+    },
+    {
+      "provider": "codex",
+      "id": "personal",
+      "alias": "Personal",
+      "configPath": "/srv/accounts/codex-personal"
+    },
+    {
+      "provider": "claude",
+      "id": "client-a",
+      "alias": "Client A",
+      "configPath": "./accounts/claude-client-a"
+    }
+  ],
   "port": 8080,
   "dockerAccess": true,
   "claudeApi": false,
@@ -318,12 +340,32 @@ three exceptions: `--no-background`, `--once`, and `--json` suppress
 }
 ```
 
+Relative account paths are resolved relative to the JSON config file, and `~/`
+paths are expanded to the current user's home directory. The path
+is passed to the provider CLI as its config home: `CLAUDE_CONFIG_DIR` for Claude,
+`CODEX_HOME` for Codex, and `GEMINI_CLI_HOME` for Antigravity. Legacy top-level
+settings such as `"claude": true` remain supported for single default accounts.
+
 Run with:
 
 ```bash
 agent-tank -c config.json
 ```
 
+The same setup can be supplied directly on the command line. Repeat `--agent`
+once per account:
+
+```bash
+agent-tank \
+  --agent codex:work=/srv/accounts/codex-work \
+  --agent codex:personal=/srv/accounts/codex-personal
+```
+
+The `id` (or CLI alias after `:`) is the key returned by `/status` and is used
+by account-specific status, history, and refresh endpoints. IDs may contain
+letters, numbers, dots, underscores, and hyphens. If both `id` and `alias` are
+set in JSON, `id` is the API key and `alias` is the dashboard label.
+
 ## Antigravity
 
 Antigravity support uses the `agy` CLI and reads the interactive `/usage` output.
@@ -337,6 +379,25 @@ agent-tank --agy
 agent-tank --agy --once --json
 ```
 
+Each entry in `usage.models` reports the quota left, the countdown Antigravity
+displays (`Resets in` on older builds, `Refreshes in` on the grouped
+`Models & Quota` screen), the absolute instant that countdown points at, and the
+cycle the limit belongs to. A limit showing `Quota available` has no pending
+reset, so its reset fields are `null`.
+
+```json
+{
+  "model": "Gemini · Five Hour Limit Remaining",
+  "usageLeft": 90.31,
+  "percentUsed": 9.7,
+  "resetsIn": "58m",
+  "resetsInSeconds": 3480,
+  "resetsAt": "2026-09-23T11:52:00.000Z",
+  "cycle": "fiveHour",
+  "group": "Gemini"
+}
+```
+
 ## HTTP API
 
 ### Endpoints
@@ -345,12 +406,12 @@ agent-tank --agy --once --json
 |---|---|---|
 | GET | `/` | HTML status page |
 | GET | `/status` | JSON status for all agents |
-| GET | `/status/:agent` | JSON status for one agent |
+| GET | `/status/:id` | JSON status for one configured account |
 | GET | `/config` | Auto-refresh and history config |
 | GET | `/history` | History summary |
-| GET | `/history/:agent` | History for one agent |
+| GET | `/history/:id` | History for one configured account |
 | POST | `/refresh` | Refresh all agents |
-| POST | `/refresh/:agent` | Refresh one agent |
+| POST | `/refresh/:id` | Refresh one configured account |
 
 ### Example `GET /status`
 
@@ -358,6 +419,9 @@ agent-tank --agy --once --json
 {
   "claude": {
     "name": "claude",
+    "id": "claude",
+    "alias": null,
+    "provider": "claude",
     "usage": {
       "session": {
         "label": "Current session",
@@ -372,6 +436,13 @@ agent-tank --agy --once --json
         "resetsAt": "Mar 13, 3am (Europe/London)",
         "resetsIn": "4d 5h",
         "resetsInSeconds": 364364
+      },
+      "weeklyFable": {
+        "label": "Current week (Fable)",
+        "percent": 82,
+        "resetsAt": "Mar 13, 3am (Europe/London)",
+        "resetsIn": "4d 5h",
+        "resetsInSeconds": 364364
       }
     },
     "metadata": {
@@ -570,7 +641,11 @@ codex --version
 const { AgentTank } = require('agent-tank');
 
 const watcher = new AgentTank({
-  agents: ['claude', 'agy'],
+  agents: [
+    { provider: 'codex', id: 'work', configPath: '/srv/accounts/codex-work' },
+    { provider: 'codex', id: 'personal', configPath: '/srv/accounts/codex-personal' },
+    'agy'
+  ],
   port: 3456,
   autoDiscover: true
 });
@@ -580,7 +655,7 @@ await watcher.start();
 const status = watcher.getStatus();
 console.log(status);
 
-await watcher.refreshAgent('claude');
+await watcher.refreshAgent('work');
 
 watcher.stop();
 ```

package/bin/agent-tank.js

@@ -10,12 +10,14 @@ const {
   spawnBackgroundProcess,
   warnAboutRunningProcesses,
 } = require('../src/cli-background.js');
+const { normalizeAgentSpecs, parseAgentOption } = require('../src/agent-config.js');
 const pkg = require('../package.json');
 
 const options = {
   claude: { type: 'boolean', default: false },
   agy: { type: 'boolean', default: false },
   codex: { type: 'boolean', default: false },
+  agent: { type: 'string', multiple: true, default: [] },
   'claude-api': { type: 'boolean', default: false },
   port: { type: 'string', default: '3456' },
   host: { type: 'string' },
@@ -76,6 +78,7 @@ Options:
   --claude              Enable Claude monitoring
   --agy                 Enable Antigravity monitoring
   --codex               Enable Codex monitoring
+  --agent <spec>        Add an account as provider[:alias][=config-path] (repeatable)
   --claude-api          Use direct Anthropic API for Claude usage (faster, 60s refresh)
   --port <port>         HTTP server port (default: 3456)
   --host <host>         Bind address (default: 127.0.0.1 + Docker bridge when available)
@@ -131,6 +134,7 @@ Examples:
   agent-tank                          # Auto-discover and monitor all available
   agent-tank --background             # Start in the background and print the PID
   agent-tank --claude --agy           # Monitor specific agents
+  agent-tank --agent codex:work=/srv/codex-work --agent codex:personal=/srv/codex-personal
   agent-tank --port 8080              # Use custom port
   agent-tank --host 0.0.0.0           # Expose on all interfaces
   agent-tank --no-docker              # Bind localhost only when host is omitted
@@ -152,12 +156,12 @@ Examples:
 HTTP Endpoints:
   GET /              Status page (HTML)
   GET /status        All agent statuses (JSON)
-  GET /status/:agent Status for specific agent (JSON)
+  GET /status/:id    Status for a specific agent account (JSON)
   GET /config        Auto-refresh and history configuration (JSON)
   GET /history       Usage history statistics (JSON)
-  GET /history/:agent Usage history for specific agent (JSON)
+  GET /history/:id   Usage history for a specific agent account (JSON)
   POST /refresh      Trigger refresh for all agents
-  POST /refresh/:agent Trigger refresh for specific agent
+  POST /refresh/:id  Trigger refresh for a specific agent account
 `);
 }
 
@@ -207,9 +211,12 @@ async function main() {
 
   // Load config file if specified
   let config = {};
+  let configBaseDir = process.cwd();
   if (values.config) {
     try {
-      config = require(require('path').resolve(values.config));
+      const configPath = require('path').resolve(values.config);
+      config = require(configPath);
+      configBaseDir = require('path').dirname(configPath);
     } catch (err) {
       exitWithCode(1, `Failed to load config file: ${err.message}`);
       return;
@@ -217,10 +224,21 @@ async function main() {
   }
 
   // Merge CLI options with config (env vars > CLI flags > config file)
-  const agents = [];
-  if (values.claude || config.claude) agents.push('claude');
-  if (values.agy || config.agy) agents.push('agy');
-  if (values.codex || config.codex) agents.push('codex');
+  let agents;
+  try {
+    const configAgents = config.agents == null
+      ? []
+      : normalizeAgentSpecs(config.agents, { baseDir: configBaseDir });
+    const cliAgents = normalizeAgentSpecs(values.agent.map(parseAgentOption));
+    const legacyAgents = [];
+    if (values.claude || config.claude) legacyAgents.push('claude');
+    if (values.agy || config.agy) legacyAgents.push('agy');
+    if (values.codex || config.codex) legacyAgents.push('codex');
+    agents = normalizeAgentSpecs([...configAgents, ...cliAgents, ...legacyAgents]);
+  } catch (err) {
+    exitWithCode(1, `Invalid agent configuration: ${err.message}`);
+    return;
+  }
 
   const auth = {
     user: process.env.AGENT_TANK_USER || values['auth-user'] || config.auth?.user,

package/favicon.svg

@@ -0,0 +1,7 @@
+<svg viewBox="0 0 24 24" fill="none" stroke="#48bb78" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" xmlns="http://www.w3.org/2000/svg">
+  <rect width="24" height="24" rx="5" fill="#0d1117" stroke="none"/>
+  <path d="M6 4v12a4 4 0 0 0 4 4h4a4 4 0 0 0 4-4V4"/>
+  <line x1="6" y1="4" x2="18" y2="4"/>
+  <line x1="8" y1="8" x2="16" y2="8" opacity="0.3"/>
+  <line x1="8" y1="12" x2="16" y2="12" opacity="0.3"/>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-tank",
-  "version": "0.9.9",
+  "version": "0.9.11",
   "description": "Monitor and query usage limits for LLM CLI tools (Claude, Antigravity, Codex) via HTTP API",
   "main": "src/index.js",
   "bin": {
@@ -61,6 +61,8 @@
     "bin/",
     "src/",
     "media/",
+    "favicon.svg",
+    "CHANGELOG.md",
     "LICENSE",
     "README.md"
   ]

package/src/activity-monitor.js

@@ -29,6 +29,11 @@ const DEFAULT_LOG_DIRECTORIES = {
   ],
 };
 
+function getAgentLogDirectories(provider, configPath = null) {
+  if (configPath) return [configPath];
+  return DEFAULT_LOG_DIRECTORIES[provider] || [];
+}
+
 function normalizeFilename(filename) {
   return String(filename || '').replace(/\\/g, '/');
 }
@@ -320,4 +325,4 @@ class ActivityMonitor {
   }
 }
 
-module.exports = { ActivityMonitor, DEFAULT_LOG_DIRECTORIES };
+module.exports = { ActivityMonitor, DEFAULT_LOG_DIRECTORIES, getAgentLogDirectories };

package/src/agent-config.js

@@ -0,0 +1,105 @@
+/* eslint-disable complexity -- Validation keeps all supported agent config forms in one place. */
+
+const path = require('node:path');
+const os = require('node:os');
+
+const SUPPORTED_PROVIDERS = new Set(['claude', 'agy', 'codex']);
+const AGENT_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+
+function resolveConfigPath(configPath, baseDir) {
+  if (configPath === '~') return os.homedir();
+  if (configPath.startsWith('~/') || configPath.startsWith('~\\')) {
+    return path.resolve(os.homedir(), configPath.slice(2));
+  }
+  return path.resolve(baseDir, configPath);
+}
+
+function parseAgentOption(value) {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new Error('Agent option must be a non-empty string');
+  }
+
+  const equalsIndex = value.indexOf('=');
+  const identity = (equalsIndex === -1 ? value : value.slice(0, equalsIndex)).trim();
+  const configPath = equalsIndex === -1 ? null : value.slice(equalsIndex + 1).trim();
+  const colonIndex = identity.indexOf(':');
+  const provider = (colonIndex === -1 ? identity : identity.slice(0, colonIndex)).trim();
+  const alias = colonIndex === -1 ? null : identity.slice(colonIndex + 1).trim();
+
+  if (equalsIndex !== -1 && !configPath) {
+    throw new Error(`Agent option "${value}" has an empty config path`);
+  }
+  if (colonIndex !== -1 && !alias) {
+    throw new Error(`Agent option "${value}" has an empty alias`);
+  }
+
+  return {
+    provider,
+    ...(alias && { id: alias, alias }),
+    ...(configPath && { configPath }),
+  };
+}
+
+function normalizeAgentSpec(entry, baseDir) {
+  const raw = typeof entry === 'string' ? { provider: entry } : entry;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new Error('Each agent must be a provider name or an agent configuration object');
+  }
+
+  const provider = String(raw.provider || raw.name || '').trim().toLowerCase();
+  if (!SUPPORTED_PROVIDERS.has(provider)) {
+    throw new Error(`Unsupported agent provider: ${provider || '(missing)'}`);
+  }
+
+  const explicitId = raw.id == null ? null : String(raw.id).trim();
+  const alias = raw.alias == null ? null : String(raw.alias).trim();
+  const id = explicitId || alias || provider;
+  if (!AGENT_ID_PATTERN.test(id)) {
+    throw new Error(`Invalid agent id "${id}"; use letters, numbers, dots, underscores, or hyphens`);
+  }
+  if (raw.alias != null && !alias) {
+    throw new Error(`Alias for agent "${id}" must not be empty`);
+  }
+
+  const rawConfigPath = raw.configPath ?? raw.path ?? null;
+  let configPath = null;
+  if (rawConfigPath != null) {
+    if (typeof rawConfigPath !== 'string' || !rawConfigPath.trim()) {
+      throw new Error(`Config path for agent "${id}" must be a non-empty string`);
+    }
+    configPath = resolveConfigPath(rawConfigPath.trim(), baseDir);
+  }
+
+  return {
+    provider,
+    id,
+    alias: alias || (id !== provider ? id : null),
+    configPath,
+  };
+}
+
+function normalizeAgentSpecs(entries, options = {}) {
+  if (!Array.isArray(entries)) {
+    throw new Error('agents must be an array');
+  }
+
+  const baseDir = options.baseDir || process.cwd();
+  const normalized = entries.map(entry => normalizeAgentSpec(entry, baseDir));
+  const ids = new Set();
+
+  for (const spec of normalized) {
+    if (ids.has(spec.id)) {
+      throw new Error(`Duplicate agent id "${spec.id}"; give each account a unique id or alias`);
+    }
+    ids.add(spec.id);
+  }
+
+  return normalized;
+}
+
+module.exports = {
+  AGENT_ID_PATTERN,
+  SUPPORTED_PROVIDERS,
+  normalizeAgentSpecs,
+  parseAgentOption,
+};

package/src/agents/agy.js

@@ -8,8 +8,15 @@ class AgyAgent extends BaseAgent {
   // "Models & Quota" screen reported by recent Antigravity CLI builds.
   static QUOTA_HEADER = /Models?\s*&?\s*Quota/i;
 
-  constructor() {
+  // Antigravity words its countdown line differently across builds: older
+  // screens say "Resets in 3h 15m", the grouped "Models & Quota" screen says
+  // "Refreshes in 160h 12m". A fully replenished limit renders "Quota
+  // available" instead, which carries no countdown and yields a null reset.
+  static RESET_LINE = /^(?:resets?|refresh(?:es)?|renew(?:s|als)?)\s*(?:in|at)?\s*([0-9dhm\s]+)?/i;
+
+  constructor(options = {}) {
     super('agy', 'agy', ['--dangerously-skip-permissions']);
+    this.configPath = options.configPath || null;
     this._aboutSent = false;
   }
 
@@ -20,11 +27,13 @@ class AgyAgent extends BaseAgent {
   getEnv() {
     // Use xterm-256color for proper terminal support
     // Antigravity CLI needs good terminal emulation for its TUI
-    return {
+    const env = {
       ...process.env,
       TERM: 'xterm-256color',
       COLORTERM: 'truecolor',
     };
+    if (this.configPath) env.GEMINI_CLI_HOME = this.configPath;
+    return env;
   }
 
   _hasReadyPrompt(output) {
@@ -203,9 +212,35 @@ class AgyAgent extends BaseAgent {
       .join(' ');
   }
 
+  // Read the countdown line that follows a limit's percentage bar. Returns
+  // nulls when the limit is fully replenished ("Quota available") or the line
+  // is something else entirely.
+  _parseResetLine(line) {
+    // A redrawn frame can leave box borders on the line, so normalise before
+    // matching the countdown's leading keyword.
+    const resetMatch = this.stripBoxChars(line || '').match(AgyAgent.RESET_LINE);
+    const resetsIn = resetMatch?.[1]?.trim() || null;
+    const resetsInSeconds = resetsIn ? this.parseDurationToSeconds(resetsIn) : null;
+    // The countdown goes stale as soon as it is stored, so also record the
+    // absolute instant it refers to.
+    const resetsAt = resetsInSeconds == null
+      ? null
+      : new Date(Date.now() + resetsInSeconds * 1000).toISOString();
+    return { resetsIn, resetsInSeconds, resetsAt };
+  }
+
+  // Map an Antigravity limit label to the cycle its countdown belongs to, so
+  // pace math compares usage against the right window. A weekly limit reports
+  // "Refreshes in 160h 12m", which is nonsense against a 24h cycle.
+  _cycleTypeFor(label) {
+    if (/\bweek(?:ly)?\b/i.test(label)) return 'weekly';
+    if (/\b(?:five|5)[\s-]?hour\b/i.test(label)) return 'fiveHour';
+    return 'sessionAgy';
+  }
+
   // Calculate pace data for a model entry when reset timing is available.
-  _addPaceData(entry, resetsInSeconds) {
-    const cycleDuration = CYCLE_DURATIONS.sessionAgy;
+  _addPaceData(entry, resetsInSeconds, cycleType = 'sessionAgy') {
+    const cycleDuration = CYCLE_DURATIONS[cycleType];
     if (!cycleDuration || resetsInSeconds == null) return;
     const paceData = calculatePace({ usagePercent: entry.percentUsed, resetsInSeconds, cycleDurationSeconds: cycleDuration });
     if (paceData) entry.pace = paceData;
@@ -265,6 +300,11 @@ class AgyAgent extends BaseAgent {
       if (!/[A-Za-z]/.test(line) || /\d+\s*%/.test(line)) {
         continue;
       }
+      // A countdown line ("Refreshes in 58m") belongs to the entry above it and
+      // is never a model label of its own.
+      if (AgyAgent.RESET_LINE.test(line)) {
+        continue;
+      }
 
       const percentLine = lines[i + 1] || '';
       const percentMatch = percentLine.match(/(\d+(?:\.\d+)?)\s*%/);
@@ -274,10 +314,7 @@ class AgyAgent extends BaseAgent {
 
       const usageLeft = parseFloat(percentMatch[1]);
       const percentUsed = Number((100 - usageLeft).toFixed(1));
-      const resetLine = lines[i + 2] || '';
-      const resetMatch = resetLine.match(/(?:resets?|available)\s*(?:in|at)?\s*([0-9dhm\s]+)?/i);
-      const resetsIn = resetMatch?.[1]?.trim() || null;
-      const resetsInSeconds = resetsIn ? this.parseDurationToSeconds(resetsIn) : null;
+      const reset = this._parseResetLine(lines[i + 2]);
 
       // Qualify shared limit labels with their group so entries from different
       // groups stay distinct; per-model labels are already unique on their own.
@@ -287,9 +324,10 @@ class AgyAgent extends BaseAgent {
         : line;
 
       if (!usage.models.find(m => m.model === modelName)) {
-        const modelEntry = { model: modelName, usageLeft, percentUsed, resetsIn, resetsInSeconds };
+        const cycle = this._cycleTypeFor(line);
+        const modelEntry = { model: modelName, usageLeft, percentUsed, ...reset, cycle };
         if (currentGroup) modelEntry.group = currentGroup;
-        this._addPaceData(modelEntry, resetsInSeconds);
+        this._addPaceData(modelEntry, reset.resetsInSeconds, cycle);
         usage.models.push(modelEntry);
       }
     }