@prplkane/roundtable 0.0.0-stage → 0.6.3

package/src/adapters/errors.js

@@ -0,0 +1,69 @@
+// What went wrong with a CLI call, in a word the engine and the board can act on:
+//
+//   quota    the account's limit is used up: no point calling this pool again this debate
+//   auth     not logged in, or the login expired: same
+//   missing  the CLI is not installed: same
+//   network  the service could not be reached: worth one retry
+//   timeout  the call ran past its time
+//   killed   stopped by the human, the wall clock or a shutdown
+//   policy   the provider boundary could not be trusted: stop this seat for the review
+//   other    anything else: the seat fails for the round, as before
+//
+// classifyError({ message, stdout, stderr, code, label }, now) -> { kind, message, resetsAt, detail }
+// Pure: tested on captured CLI text. `message` is the plain sentence for the board; `detail` keeps
+// the CLI's own words.
+
+const QUOTA = /usage limit|limit reached|hit your (?:usage )?limit|rate[- ]?limit|quota|too many requests|\b429\b|out of credits|insufficient credits|credit balance/i;
+const AUTH = /not logged in|please (?:run )?\/?login|log ?in (?:again|required|first)|unauthori[sz]ed|\b401\b|invalid api key|authentication (?:failed|required|error)|session expired|token (?:has )?expired|re-?authenticate/i;
+const NETWORK = /ENOTFOUND|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang up|fetch failed|getaddrinfo|network (?:error|is unreachable)|connection (?:error|reset|refused)|\b50[234]\b|overloaded|\b529\b|service unavailable/i;
+const LOGIN = { claude: 'claude /login', codex: 'codex login', antigravity: 'agy (sign in in a terminal)' };
+
+const MONTHS = { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 };
+
+// When the limit lifts, if the CLI says: "try again at Oct 27th, 2026 12:51 PM" (codex), or a
+// trailing "|<epoch seconds>" (claude). Milliseconds, or null.
+export function resetTime(text, now = Date.now()) {
+  const epoch = /\|(\d{10})\b/.exec(text);
+  if (epoch) return Number(epoch[1]) * 1000;
+  const m = /(?:try again|resets?|available again)\s+(?:at|on)?\s*([A-Z][a-z]{2})[a-z]*\.?\s+(\d{1,2})(?:st|nd|rd|th)?,?\s*(\d{4})?,?\s*(?:at\s*)?(\d{1,2}):(\d{2})\s*([AP]M)?/i.exec(text);
+  if (!m) return null;
+  const month = MONTHS[m[1].toLowerCase()];
+  if (month == null) return null;
+  let hour = Number(m[4]) % 12;
+  if (m[6]?.toUpperCase() === 'PM') hour += 12; else if (!m[6]) hour = Number(m[4]);
+  const year = m[3] ? Number(m[3]) : new Date(now).getFullYear();
+  return new Date(year, month, Number(m[2]), hour, Number(m[5])).getTime();
+}
+
+const when = (ms) => new Date(ms).toLocaleString('en-GB', { day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' });
+
+export function classifyError({ message = '', stdout = '', stderr = '', code = null, label = 'The CLI' } = {}, now = Date.now()) {
+  // the CLI's own last words carry the reason; the wrapper's message frames it
+  const text = [message, stderr, stdout.split(/\r?\n/).filter((l) => /error|fail|limit|login|denied|quota/i.test(l)).slice(-3).join('\n')].join('\n');
+  const detail = String(message).slice(0, 600);
+  if (code === 'RESEARCH_LIMIT') return { kind: 'budget', message: 'The reported search-operation limit was exceeded. Research stopped before discussion.', resetsAt: null, detail };
+  if (code === 'RESEARCH_INVALID') return { kind: 'format', message: 'Research did not produce usable web evidence. Discussion was not started; check the research details before trying again.', resetsAt: null, detail };
+  if (code === 'TOOL_POLICY') return { kind: 'policy', message: 'Provider tool policy rejected this call. This seat is stopped for the review.', resetsAt: null, detail };
+  if (code === 'PROVIDER_PROTOCOL') return { kind: 'policy', message: 'Provider output could not be validated. This seat is stopped for the review.', resetsAt: null, detail };
+  if (code === 'OUTPUT_LIMIT') return { kind: 'policy', message: 'Provider output exceeded the local size limit. This seat is stopped for the review.', resetsAt: null, detail };
+  if (code === 'ISOLATION_REQUIRED') return { kind: 'policy', message: 'Antigravity cannot disable all shared customizations or MCP discovery. Enable Allow limited isolation explicitly, or choose another provider.', resetsAt: null, detail };
+  if (code === 'TERMS_ACK_REQUIRED') return { kind: 'policy', message: `${label} was not called: its maker says wrapping it in third-party applications is unsupported on some plans and can put the account at risk. Acknowledge its notice from a ${label} card on the setup screen, or choose another provider.`, resetsAt: null, detail };
+  if (/unknown (?:option|argument)|unexpected argument|unrecognized (?:option|argument)/i.test(text)) return { kind: 'compatibility', message: `${label} does not support a required CLI option. Update the CLI; Roundtable will not retry with weaker restrictions.`, resetsAt: null, detail };
+  if (code === 'ENOENT' || /not found on PATH/i.test(text)) return { kind: 'missing', message: `${label} CLI not found on this machine.`, resetsAt: null, detail };
+  if (code === 'KILLED') return { kind: 'killed', message: 'Stopped before it answered.', resetsAt: null, detail };
+  if (code === 'TIMEOUT') return { kind: 'timeout', message: `${label} did not answer in time.`, resetsAt: null, detail };
+  if (code === 'STALL') return { kind: 'timeout', message: `${label}'s web search stalled: no progress for ${detail.match(/\d+ s/)?.[0] || 'a while'}.`, resetsAt: null, detail };
+  if (code === 'CLI_FAILURE' && /idle timeout|timeout waiting for (?:SSE|stream)/i.test(text)) return {
+    kind: 'timeout', message: `${label}'s provider connection stalled before completion.`, resetsAt: null, detail,
+  };
+  if (QUOTA.test(text)) {
+    const resetsAt = resetTime(text, now);
+    return { kind: 'quota', message: `${label}: usage limit reached${resetsAt ? `, resets ${when(resetsAt)}` : ''}.`, resetsAt, detail };
+  }
+  if (AUTH.test(text)) return { kind: 'auth', message: `${label}: not logged in. Run ${LOGIN[label.toLowerCase()] || 'its login'} in a terminal.`, resetsAt: null, detail };
+  if (NETWORK.test(text)) return { kind: 'network', message: `${label}: could not reach the service.`, resetsAt: null, detail };
+  return { kind: 'other', message: String(message).slice(0, 300), resetsAt: null, detail };
+}
+
+// Kinds after which calling the same pool again in this debate only fails again.
+export const POOL_FATAL = new Set(['quota', 'auth', 'missing']);

package/src/adapters/index.js

@@ -0,0 +1,11 @@
+import { run as claude } from './claude.js';
+import { run as codex } from './codex.js';
+import { run as agy } from './agy.js';
+import { run as api } from './endpoint.js';
+import { ADAPTERS, poolsByAccount } from './config.js';
+import { readCodexQuota, readAgyQuota, readClaudeQuota } from './quota.js';
+
+export const adapters = { claude, codex, agy, api };
+// Vendors whose quota needs a separate read (no model call). The others ride on replies or have none.
+export const quotaReaders = { claude: readClaudeQuota, codex: readCodexQuota, agy: readAgyQuota };
+export { ADAPTERS, poolsByAccount };

package/src/adapters/models.js

@@ -0,0 +1,106 @@
+// Model names and supported effort levels. Pure and browser-safe. Account access is decided
+// by the vendor CLI, not inferred from a subscription name in the picker.
+//
+// From the vendors' own pages; re-check when a vendor ships or retires a model:
+//   claude  https://code.claude.com/docs/en/model-config
+//   codex   https://learn.chatgpt.com/docs/models
+//   agy     `agy models` already lists what the signed-in account can use; nothing to add here.
+//           Its quota groups (which limits a model counts against) are matched below.
+
+export const MODELS = {
+  claude: [
+    { id: 'fable', label: 'Fable 5.1' },
+    { id: 'opus', label: 'Opus 5.5', note: 'default' },
+    { id: 'sonnet', label: 'Sonnet 5.5' },
+    // Pin the intended Haiku version instead of relying on the CLI alias.
+    { id: 'claude-haiku-4-5', label: 'Haiku 4.5', note: 'lightest' },
+  ],
+  codex: [
+    { id: 'gpt-6-astra', label: 'GPT-6 Astra' },
+    { id: 'gpt-6.1-sol', label: 'GPT-6.1 Sol' },
+    { id: 'gpt-6-sol', label: 'GPT-6 Sol' },
+    { id: 'gpt-6.1-terra', label: 'GPT-6.1 Terra' },
+    // efforts: only where a model takes fewer levels than its vendor offers (`codex debug models`
+    // supported_reasoning_levels: the Luna models stop at max)
+    { id: 'gpt-6-luna', label: 'GPT-6 Luna', note: 'lightest', efforts: ['low', 'medium', 'high', 'xhigh', 'max'] },
+  ],
+};
+
+// Broad capability tiers for the picker, not a benchmark ranking across vendors.
+// Unknown models retain their provider order after the known families.
+export function modelsByCapability(models = []) {
+  const tier = (model) => {
+    const name = `${model.id} ${model.label || ''}`.toLowerCase();
+    for (const [pattern, rank] of [[/\b(fable|astra)\b/, 6], [/\b(opus|argon)\b|\bgemini\b.*\bpro\b/, 5], [/\b(sol|sonnet)\b/, 4], [/\bterra\b/, 3], [/\b(flash|120b)\b/, 2], [/\b(haiku|luna|20b)\b/, 1]]) {
+      if (pattern.test(name)) return rank;
+    }
+    return 0;
+  };
+  return models.slice().sort((a, b) => tier(b) - tier(a));
+}
+
+// The effort levels a model takes: its vendor's levels, narrowed where the table names fewer.
+// A model the table does not know (a typed id, the CLI default) keeps the vendor's levels.
+export function modelEfforts(vendor, model, levels = []) {
+  const known = (MODELS[vendor] || []).find((m) => m.id === String(model || '').trim());
+  return known?.efforts ? levels.filter((l) => known.efforts.includes(l)) : levels;
+}
+
+// Retired for ChatGPT sign-in: a call with one of these fails. id -> [date, replacement].
+export const RETIRED = {
+  codex: {
+    'gpt-5.5': ['2026-10-14', 'gpt-6.1-sol'], 'gpt-5.4': ['2026-08-31', 'gpt-6-sol'], 'gpt-5.4-mini': ['2026-08-31', 'gpt-6-luna'],
+    'gpt-5.3-codex-spark': ['2026-09-14', 'gpt-6.1-sol'], 'gpt-5.3-codex': ['deprecated', 'gpt-6.1-sol'], 'gpt-5.2': ['deprecated', 'gpt-6.1-sol'],
+  },
+};
+
+export function retired(vendor, id) {
+  const r = RETIRED[vendor]?.[id];
+  return r ? { date: r[0], instead: r[1] } : null;
+}
+
+// agy ids carry the effort level ("gemini-4-argon-high"): one entry per model, the levels it has.
+export function agyFamilies(models = []) {
+  const fam = new Map();
+  for (const m of models) {
+    const hit = /^(.*)-(low|medium|high)$/.exec(m.id);
+    const id = hit ? hit[1] : m.id;
+    const label = String(m.label || id).replace(/\s*\((low|medium|high)\)\s*$/i, '');
+    if (!fam.has(id)) fam.set(id, { id, label, levels: [] });
+    if (hit) fam.get(id).levels.push(hit[2]);
+  }
+  const order = ['low', 'medium', 'high'];
+  return [...fam.values()].map((f) => ({ ...f, levels: f.levels.sort((a, b) => order.indexOf(a) - order.indexOf(b)) }));
+}
+
+// agy's quota comes in groups, each with its own windows (quota.js agyQuota). Which group a model
+// draws on is read from the CLI's own words: every word of the group's name, or of a model the
+// group lists ("Gemini Flash", "GPT-OSS"), is in the id. The longest such name wins. A model none
+// of them names goes to the one group of its family, if there is only one: an Argon model on a
+// plan without a separate Argon group counts against the Gemini group. null: no group can be
+// told, and every window applies.
+const words = (s) => String(s || '').toLowerCase().split(/[^a-z0-9.]+/).filter(Boolean);
+export function quotaGroup(groups, model) {
+  const id = words(model);
+  if (!id.length || !Array.isArray(groups)) return null;
+  const names = (g) => [g.name, ...(g.models || [])].map(words);
+  let best = null, score = 0;
+  for (const g of groups) for (const w of names(g)) if (w.length > score && w.every((x) => id.includes(x))) { best = g.name; score = w.length; }
+  if (best) return best;
+  const family = groups.filter((g) => names(g).some((w) => w[0] === id[0]));
+  return family.length === 1 ? family[0].name : null;
+}
+
+// The windows that apply to these models: their groups' when each model's group is known, else
+// every window (a quota without groups, a default model, an id no group names).
+export function quotaWindows(quota, models = []) {
+  const windows = quota?.windows || [];
+  if (!quota?.groups?.length) return windows;
+  const groups = new Set();
+  for (const m of [].concat(models)) {
+    const g = quotaGroup(quota.groups, m);
+    if (!g) return windows;
+    groups.add(g);
+  }
+  return groups.size ? windows.filter((w) => groups.has(w.group)) : windows;
+}

package/src/adapters/quota.js

@@ -0,0 +1,305 @@
+// Remaining subscription quota per vendor.
+//
+// One shape for the board, whatever the vendor reports:
+//   { windows: [{ label: '5h' | '7d' | ..., used: 0..1, resetsAt: epoch seconds | null }],
+//     plan: string | null, at: epoch ms }
+// A vendor whose limits differ by model adds groups: each window names its `group`, and
+// `groups: [{ name, models }]` lets models.js quotaGroup say which group a seat's model uses.
+//
+//  claude  separate read, no model call: `claude -p /usage --output-format json` is answered by
+//          the CLI itself (no turn, zero tokens, local_command "usage") -> sentences in `result`
+//          ("Current session: 53% used · resets Nov 2, 4:59am (Europe/Berlin)"). Each reply also
+//          carries a rate_limit_event (rate_limit_info.unifiedWindows, utilization 0..1), used
+//          when that read gives nothing.
+//  codex   separate read, no model call: `codex app-server` over stdio, JSON-RPC
+//          account/rateLimits/read -> rateLimits.{primary,secondary}.usedPercent (0..100).
+//  agy     separate read, no model call: `agy -p /usage --output-format json` is answered by the
+//          CLI itself (no turn, zero tokens) -> command.data.groups[].buckets[] with window,
+//          remaining_fraction (0..1) and reset_time (ISO, UTC). Groups are model families.
+import { resolveBinary, runProcess, cleanEnv, dataDir } from './spawn.js';
+import { VERSION } from '../version.js';
+import { spawn, execFileSync } from 'node:child_process';
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+
+// Keys seen in rate_limit_info.unifiedWindows (the third appeared in the first real debate after the
+// spike). An unknown key is shown with its underscores as spaces rather than hidden.
+const WINDOW_LABELS = { five_hour: '5h', seven_day: '7d', seven_day_overage_included: '7d incl. overage' };
+const windowKeyLabel = (k) => WINDOW_LABELS[k] || k.replace(/_/g, ' ');
+
+// claude: rate_limit_info from the last rate_limit_event of a stream-json call.
+export function claudeQuota(info, at = Date.now()) {
+  const wins = info?.unifiedWindows;
+  if (!wins || typeof wins !== 'object') return null;
+  const windows = Object.entries(wins)
+    .filter(([, w]) => w && typeof w.utilization === 'number')
+    .map(([k, w]) => ({ label: windowKeyLabel(k), used: w.utilization, resetsAt: w.resetsAt ?? null }));
+  return windows.length ? { windows, plan: null, at } : null;
+}
+
+// claude: the text `claude -p /usage` prints. Only the limit lines are read:
+//   Current session: 53% used · resets Nov 2, 4:59am (Europe/Berlin)
+//   Current week (all models): 57% used · resets Nov 2, 8:59pm (Europe/Berlin)
+//   Current week (Fable): 75% used · resets Nov 2, 8:59pm (Europe/Berlin)
+// The same answer summarises local activity (requests, sessions, skills, MCP servers); none of it
+// is kept. Labels match the reply's rate_limit_event (5h, 7d), so calibration compares like with
+// like; a week for one model family becomes "7d <family>".
+const CLAUDE_LIMIT = /^\s*Current (session|week)(?:\s*\(([^)]+)\))?\s*:\s*(\d{1,3}(?:\.\d+)?)%\s+used\b(?:\s*\S\s*resets\s+(.+?))?\s*$/i;
+export function claudeUsage(text, at = Date.now()) {
+  const windows = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const m = CLAUDE_LIMIT.exec(line);
+    if (!m) continue;
+    const family = m[2] && !/^all models$/i.test(m[2].trim()) ? m[2].trim() : null;
+    const label = m[1].toLowerCase() === 'session' ? '5h' : family ? `7d ${family}` : '7d';
+    if (windows.some((w) => w.label === label)) continue;
+    windows.push({ label, used: Math.min(1, Number(m[3]) / 100), resetsAt: m[4] ? claudeResetAt(m[4], at) : null });
+  }
+  return windows.length ? { windows, plan: null, at } : null;
+}
+
+// "Nov 2, 4:59am (Europe/Berlin)", or "4:59am (Europe/Berlin)" for later today: a wall-clock time
+// in a named zone, without a year. The next such moment from `now`, in epoch seconds; null when
+// the text or the zone cannot be read (the reply's figure then supplies exact reset times).
+const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+function zoneParts(ms, zone) {
+  const parts = new Intl.DateTimeFormat('en-US', { timeZone: zone, hourCycle: 'h23', year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric' }).formatToParts(ms);
+  const n = Object.fromEntries(parts.filter((p) => p.type !== 'literal').map((p) => [p.type, Number(p.value)]));
+  return n;
+}
+function zoneToEpochMs(year, month, day, hour, minute, zone) {
+  const wall = Date.UTC(year, month, day, hour, minute);
+  const offset = (ms) => { const p = zoneParts(ms, zone); return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second) - ms; };
+  const first = wall - offset(wall);
+  return wall - offset(first); // a second pass settles a daylight-saving change between the two
+}
+export function claudeResetAt(text, now = Date.now()) {
+  const m = /^(?:([a-z]{3})[a-z]*\.?\s+(\d{1,2}),?\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)\s*$/i.exec(String(text).trim());
+  if (!m) return null;
+  let today;
+  try { today = zoneParts(now, m[6].trim()); } catch { return null; } // a zone this runtime does not know
+  if (Number(m[3]) < 1 || Number(m[3]) > 12) return null; // a 12-hour clock: 13pm is no time
+  const hour = (Number(m[3]) % 12) + (m[5].toLowerCase() === 'pm' ? 12 : 0), minute = Number(m[4] || 0);
+  if (minute > 59) return null;
+  const month = m[1] ? MONTHS.indexOf(m[1].toLowerCase()) : today.month - 1;
+  if (month < 0) return null;
+  // A dated reset up to a day past is a display a little behind, not next year's; an undated one
+  // already past means tomorrow.
+  const candidates = m[1] ? [[today.year, month, Number(m[2])], [today.year + 1, month, Number(m[2])]]
+    : [[today.year, month, today.day], [today.year, month, today.day + 1]];
+  const grace = m[1] ? 86_400_000 : 60_000;
+  for (const [y, mo, d] of candidates) {
+    const t = zoneToEpochMs(y, mo, d, hour, minute, m[6].trim());
+    if (t >= now - grace) return Math.round(t / 1000);
+  }
+  return null;
+}
+
+// The read is free only when the CLI answered it as a local command: no turn, no cost, every
+// token counter zero. Anything else, an unreadable answer included, is not shown free.
+const CLAUDE_TOKENS = ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens'];
+export function claudeReadWasFree(obj) {
+  const u = obj?.usage;
+  return !!u && typeof u === 'object' && obj.num_turns === 0 && obj.local_command === 'usage'
+    && (obj.total_cost_usd ?? 0) === 0 && CLAUDE_TOKENS.every((k) => (u[k] ?? 0) === 0);
+}
+
+// The seats' lockdown (config.js claude args) minus --disable-slash-commands, which /usage needs.
+// --model haiku: should a CLI ever send "/usage" to a model, the stray turn is the cheapest one,
+// and the latch below stops every later read.
+export const CLAUDE_USAGE_ARGS = ['-p', '/usage', '--output-format', 'json', '--model', 'haiku', '--permission-mode', 'plan',
+  '--tools', '', '--disallowedTools', 'mcp__*', '--setting-sources', 'local', '--strict-mcp-config', '--safe-mode', '--no-session-persistence'];
+
+// A reader with its own latch, as for agy: an answer that is not shown free, or a read cut off by
+// the timeout, stops every later read until the server restarts. A proven-free answer without
+// limit lines, or with an error, is no figure this time; the next ordinary read may work.
+// It runs from an empty folder
+// so no project settings or instructions load, with the seats' cleaned environment (a shell
+// another agent CLI opened changes how the CLI treats slash commands). home: a named profile's
+// CLAUDE_CONFIG_DIR. run, resolve and cwd are injectable so tests never spawn the CLI.
+export function claudeQuotaReader({ run = runProcess, resolve = resolveBinary, warn = console.error, cwd = null } = {}) {
+  let stopped = null;
+  const stop = (why) => { stopped = why; warn(`[quota] claude: ${why}; Claude quota reads are off until the server restarts`); return null; };
+  const read = async ({ timeoutMs = 30_000, home = null } = {}) => {
+    if (stopped) return null;
+    let bin;
+    try { bin = resolve('claude'); } catch { return null; }
+    const dir = cwd || path.join(dataDir(), 'quota', 'claude');
+    let out;
+    try {
+      mkdirSync(dir, { recursive: true });
+      out = (await run(bin, CLAUDE_USAGE_ARGS, { timeoutMs, cwd: dir, env: cleanEnv(home ? { env: 'CLAUDE_CONFIG_DIR', dir: home } : null) })).stdout;
+    } catch (e) {
+      if (e.code === 'TIMEOUT') return stop(`/usage gave no answer within ${timeoutMs} ms, so it may have reached a model`);
+      return null; // it did not start, or the server is shutting down
+    }
+    const obj = lastJson(out);
+    if (!claudeReadWasFree(obj)) return stop(obj ? '/usage did not answer as a local command (a turn, tokens or a cost)' : '/usage gave no JSON answer');
+    if (obj.is_error) return null;
+    return claudeUsage(obj.result);
+  };
+  read.stopped = () => stopped;
+  return read;
+}
+export const readClaudeQuota = claudeQuotaReader();
+
+// codex: the result object of account/rateLimits/read.
+export function codexQuota(result, at = Date.now()) {
+  const rl = result?.rateLimits;
+  if (!rl) return null;
+  const windows = [rl.primary, rl.secondary]
+    .filter((w) => w && typeof w.usedPercent === 'number')
+    .map((w) => ({ label: windowLabel(w.windowDurationMins), used: w.usedPercent / 100, resetsAt: w.resetsAt ?? null }));
+  return windows.length ? { windows, plan: rl.planType ?? null, at } : null;
+}
+
+// agy: the parsed answer to `-p /usage`. A window is labelled by its group's short name and its
+// span ("Gemini 5h", "Claude and GPT 7d"), unique in the pool, since calibration matches windows
+// by label. A bucket without a figure (the CLI shows a disabled one dimmed) is left out, and so is
+// a group left with no window.
+const AGY_SPANS = { '5h': '5h', weekly: '7d' };
+const groupTag = (name) => String(name).replace(/\s+models$/i, '');
+// "Models within this group: Gemini Flash, Gemini Pro" -> ['Gemini Flash', 'Gemini Pro']
+const groupModels = (text) => { const m = /group:\s*(.+?)\.?$/i.exec(String(text || '')); return m ? m[1].split(',').map((s) => s.trim()).filter(Boolean) : []; };
+export function agyQuota(obj, at = Date.now()) {
+  const data = obj?.command?.name === 'usage' ? obj.command.data : null;
+  if (!Array.isArray(data?.groups)) return null;
+  const windows = [], groups = [];
+  for (const g of data.groups) {
+    if (typeof g?.name !== 'string' || !g.name) continue;
+    const own = (Array.isArray(g.buckets) ? g.buckets : [])
+      .filter((b) => typeof b?.remaining_fraction === 'number' && Number.isFinite(b.remaining_fraction))
+      .map((b) => {
+        const reset = Date.parse(b.reset_time);
+        return { label: `${groupTag(g.name)} ${AGY_SPANS[b.window] || b.window || 'window'}`, used: Math.min(1, Math.max(0, 1 - b.remaining_fraction)),
+          resetsAt: Number.isFinite(reset) ? Math.round(reset / 1000) : null, group: g.name };
+      });
+    if (!own.length) continue;
+    windows.push(...own);
+    groups.push({ name: g.name, models: groupModels(g.description) });
+  }
+  return windows.length ? { windows, groups, plan: null, at } : null;
+}
+
+// The read is free only when the CLI answered it itself: no turn, no conversation left behind,
+// and every token counter zero. Anything else, an unreadable answer included, is not shown free.
+export function agyReadWasFree(obj) {
+  const u = obj?.usage;
+  return !!u && typeof u === 'object' && obj.num_turns === 0 && !obj.conversation_id
+    && Object.values(u).every((n) => n === 0);
+}
+
+// The JSON object on stdout: the whole output when it is one (printed over several lines or one),
+// else the last line that is one (a notice printed before it is skipped).
+function lastJson(text) {
+  const whole = String(text || '').trim();
+  if (whole.startsWith('{')) { try { return JSON.parse(whole); } catch { /* not one object: scan the lines */ } }
+  for (const line of whole.split(/\r?\n/).reverse()) {
+    if (!line.trim().startsWith('{')) continue;
+    try { return JSON.parse(line); } catch { /* keep looking */ }
+  }
+  return null;
+}
+
+// A reader with its own latch. `-p /usage` reaches a model only if a CLI stops answering it
+// itself; the reader runs after every Antigravity reply, so the first answer that is not shown
+// free (a turn, tokens, a conversation, or a read cut off by the timeout) stops every later read
+// until the server restarts: one stray call at most, never one per reply. Slash commands stay
+// on here (the seats turn them off): /usage is the expansion this read needs. The cleaned
+// environment is load-bearing: run from a shell that another agent CLI opened (Claude Code's
+// variables set), agy 1.4.12 sent "/usage" to a model instead of answering it, a turn of 18k
+// tokens each time. The argv below is the one measured free; the seats' deny rules are not
+// added to it, since that was not measured, and the latch bounds a CLI that stops answering.
+// run and resolve are injectable so tests never spawn the CLI.
+// agy: the parsed answer to `-p /credits`, the AI credits that take over once a group's limits
+// are used: command.data.remaining_credits. null when the answer holds no such number.
+export function agyCredits(obj) {
+  const n = obj?.status === 'SUCCESS' && obj.command?.name === 'credits' ? obj.command.data?.remaining_credits : undefined;
+  return typeof n === 'number' && Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+// How often /credits is asked: a balance that moves only once a group's limits are used up, so
+// not after every reply as /usage is.
+export const AGY_CREDITS_EVERY_MS = 10 * 60_000;
+
+export function agyQuotaReader({ run = runProcess, resolve = resolveBinary, warn = console.error, now = Date.now } = {}) {
+  // credits: { remaining, at } from the last /credits answer that held a figure; askedAt: when it
+  // was last asked, answered or not, so an account without credits is not asked on every read
+  let stopped = null, credits = null, askedAt = null;
+  const stop = (why) => { stopped = why; warn(`[quota] agy: ${why}; Antigravity quota reads are off until the server restarts`); return null; };
+  // One command the CLI answers itself, or null: it did not start, or it was not shown free (the
+  // latch then says why, once). 30 s, as for `agy models`: both wait on the network, and a
+  // timeout turns reads off.
+  const ask = async (bin, command, timeoutMs) => {
+    let out;
+    try { out = (await run(bin, ['-p', command, '--output-format', 'json'], { timeoutMs, env: cleanEnv() })).stdout; } catch (e) {
+      if (e.code === 'TIMEOUT') return stop(`${command} gave no answer within ${timeoutMs} ms, so it may have reached a model`);
+      return null; // it did not start, or the server is shutting down
+    }
+    const obj = lastJson(out);
+    if (!agyReadWasFree(obj)) return stop(obj ? `${command} did not answer as a free command (a turn, tokens or a conversation)` : `${command} gave no JSON answer`);
+    return obj;
+  };
+  const read = async ({ timeoutMs = 30_000 } = {}) => {
+    if (stopped) return null;
+    let bin;
+    try { bin = resolve('agy'); } catch { return null; }
+    const usage = await ask(bin, '/usage', timeoutMs);
+    const q = usage?.status === 'SUCCESS' ? agyQuota(usage) : null; // ERROR: not signed in, or no network
+    if (!q) return null;
+    if (askedAt == null || now() - askedAt >= AGY_CREDITS_EVERY_MS) {
+      askedAt = now();
+      const answer = await ask(bin, '/credits', timeoutMs);
+      if (stopped) return null;
+      const remaining = agyCredits(answer);
+      if (remaining != null) credits = { remaining, at: now() };
+    }
+    return credits ? { ...q, credits } : q;
+  };
+  read.stopped = () => stopped;
+  return read;
+}
+export const readAgyQuota = agyQuotaReader();
+
+function windowLabel(mins) {
+  if (!mins) return 'window';
+  if (mins % 1440 === 0) return `${mins / 1440}d`;
+  if (mins % 60 === 0) return `${mins / 60}h`;
+  return `${mins}m`;
+}
+
+// Ask the codex app-server for the account's rate limits. Spawns `codex app-server` on stdio,
+// does the initialize handshake, reads one response, kills the child. Resolves null on any
+// failure so the board degrades to the usage-page link.
+// home: a named profile's CODEX_HOME, so each account's own limits are read.
+export function readCodexQuota({ timeoutMs = 20_000, home = null } = {}) {
+  return new Promise((resolve) => {
+    let bin;
+    try { bin = resolveBinary('codex', ['@openai/codex', 'bin/codex.js']); } catch { return resolve(null); }
+    const child = spawn(bin.file, [...bin.prefix, 'app-server'], { windowsHide: true, stdio: ['pipe', 'pipe', 'ignore'], env: cleanEnv(home ? { env: 'CODEX_HOME', dir: home } : null) });
+    let buf = '', done = false;
+    const finish = (v) => {
+      if (done) return;
+      done = true; clearTimeout(timer);
+      if (process.platform === 'win32') { try { execFileSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore' }); } catch {} }
+      else { try { child.kill('SIGKILL'); } catch {} }
+      resolve(v);
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    const send = (o) => { try { child.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...o }) + '\n'); } catch {} };
+    child.on('error', () => finish(null));
+    child.on('close', () => finish(null));
+    child.stdin.on('error', () => {});
+    child.stdout.setEncoding('utf8').on('data', (d) => {
+      buf += d;
+      let i;
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+        let msg; try { msg = JSON.parse(line); } catch { continue; }
+        if (msg.id === 1) { send({ method: 'initialized' }); send({ id: 2, method: 'account/rateLimits/read', params: null }); }
+        if (msg.id === 2) finish(msg.result ? codexQuota(msg.result) : null);
+      }
+    });
+    send({ id: 1, method: 'initialize', params: { clientInfo: { name: 'roundtable', version: VERSION } } });
+  });
+}