@jojonax/codex-copilot 1.5.5 → 1.6.1

package/src/utils/provider.js

@@ -1,769 +1,773 @@
-/**
- * AI Provider Registry — supports multiple AI coding tools
- * 
- * Each provider has its own invocation pattern:
- *   - Codex CLI:    piped stdin → codex exec --full-auto
- *   - Claude Code:  -p flag + --allowedTools for safe auto-execution
- *   - Cursor Agent: cursor-agent CLI with -p headless mode
- *   - Gemini CLI:   gemini -p for non-interactive prompt
- *   - Codex Desktop / Cursor IDE / Antigravity IDE: clipboard + manual
- */
-
-import { execSync, spawn } from 'child_process';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
-import { log } from './logger.js';
-import { ask } from './prompt.js';
-import { automator } from './automator.js';
-
-const HOME = process.env.HOME || process.env.USERPROFILE || '~';
-
-// ──────────────────────────────────────────────
-// Provider Registry — each provider is unique
-// ──────────────────────────────────────────────
-
-const PROVIDERS = {
-  // ─── CLI Providers (auto-execute) ───
-
-  'codex-cli': {
-    name: 'Codex CLI',
-    type: 'cli',
-    detect: 'codex',
-    // Codex uses piped stdin: cat file | codex exec --full-auto -
-    buildCommand: (promptPath, cwd) =>
-      `cat ${shellEscape(promptPath)} | codex exec --full-auto -`,
-    description: 'OpenAI Codex CLI — pipes prompt via stdin',
-    version: {
-      command: 'codex --version',
-      parse: (output) => output.match(/[\d.]+/)?.[0],
-      latest: { type: 'brew-cask', name: 'codex' },
-      update: 'brew upgrade --cask codex',
-    },
-  },
-
-  'claude-code': {
-    name: 'Claude Code',
-    type: 'cli',
-    detect: 'claude',
-    // Claude Code uses -p (print/non-interactive) + --allowedTools for permissions
-    // Reads the file content and passes as argument (not piped)
-    buildCommand: (promptPath, cwd) => {
-      const escaped = shellEscape(promptPath);
-      // Use subshell to read file content into -p argument
-      return `claude -p "$(cat ${escaped})" --allowedTools "Bash(git*),Read,Write,Edit"`;
-    },
-    description: 'Anthropic Claude Code CLI — -p mode with tool permissions',
-    version: {
-      command: 'claude --version',
-      parse: (output) => output.match(/[\d.]+/)?.[0],
-      latest: { type: 'npm', name: '@anthropic-ai/claude-code' },
-      update: 'npm update -g @anthropic-ai/claude-code',
-    },
-  },
-
-  'cursor-agent': {
-    name: 'Cursor Agent',
-    type: 'cli',
-    detect: 'cursor-agent',
-    // Cursor Agent uses -p flag for headless/non-interactive mode
-    buildCommand: (promptPath, cwd) => {
-      const escaped = shellEscape(promptPath);
-      return `cursor-agent -p "$(cat ${escaped})"`;
-    },
-    description: 'Cursor Agent CLI — headless -p mode',
-    // No standard package manager — skip version check
-  },
-
-  'gemini-cli': {
-    name: 'Gemini CLI',
-    type: 'cli',
-    detect: 'gemini',
-    // Gemini CLI uses -p for non-interactive prompt execution
-    buildCommand: (promptPath, cwd) => {
-      const escaped = shellEscape(promptPath);
-      return `gemini -p "$(cat ${escaped})"`;
-    },
-    description: 'Google Gemini CLI — non-interactive -p mode',
-    version: {
-      command: 'gemini --version',
-      parse: (output) => output.match(/[\d.]+/)?.[0],
-      latest: { type: 'brew', name: 'gemini-cli' },
-      update: 'brew upgrade gemini-cli',
-    },
-  },
-
-  // ─── IDE Providers (clipboard + manual) ───
-
-  'codex-desktop': {
-    name: 'Codex Desktop',
-    type: 'ide',
-    instructions: 'Open Codex Desktop → paste the prompt → execute',
-    displayPrompt: true, // Show the prompt content in terminal box
-  },
-
-  'cursor': {
-    name: 'Cursor IDE',
-    type: 'ide',
-    instructions: 'Open Cursor → Ctrl/Cmd+I (Composer) → paste the prompt → run as Agent',
-    displayPrompt: false, // Too long to display, just copy to clipboard
-  },
-
-  'antigravity': {
-    name: 'Antigravity (Gemini)',
-    type: 'ide',
-    instructions: 'Open Antigravity → paste the prompt into chat → execute',
-    displayPrompt: false,
-  },
-};
-
-/**
- * Get a provider by ID
- */
-export function getProvider(id) {
-  return PROVIDERS[id] || null;
-}
-
-/**
- * Get all provider IDs
- */
-export function getAllProviderIds() {
-  return Object.keys(PROVIDERS);
-}
-
-/**
- * Detect which CLI providers are installed on the system
- * @returns {string[]} list of available provider IDs
- */
-export function detectAvailable() {
-  const available = [];
-  for (const [id, prov] of Object.entries(PROVIDERS)) {
-    if (prov.type === 'cli' && prov.detect) {
-      try {
-        const cmd = process.platform === 'win32'
-          ? `where ${prov.detect}`
-          : `which ${prov.detect}`;
-        execSync(cmd, { stdio: 'pipe' });
-        available.push(id);
-      } catch {
-        // Not installed
-      }
-    }
-  }
-  return available;
-}
-
-/**
- * Build the selection menu for init
- * Groups CLIs first (with detection status), then IDEs
- * @returns {{ label: string, value: string }[]}
- */
-export function buildProviderChoices(versionCache = {}) {
-  const detected = detectAvailable();
-  const choices = [];
-
-  // CLI providers first with detection indicator + version info
-  for (const [id, prov] of Object.entries(PROVIDERS)) {
-    if (prov.type === 'cli') {
-      const installed = detected.includes(id);
-      let tag = installed ? ' ✓ detected' : '';
-
-      // Append version info if available in cache
-      const vi = versionCache[id];
-      if (vi && vi.current) {
-        if (vi.updateAvailable) {
-          tag += ` (v${vi.current} → v${vi.latest} available)`;
-        } else if (vi.latest) {
-          tag += ` (v${vi.current} ✓ latest)`;
-        } else {
-          tag += ` (v${vi.current})`;
-        }
-      }
-
-      choices.push({
-        label: `${prov.name}${tag} — ${prov.description}`,
-        value: id,
-        available: installed,
-      });
-    }
-  }
-
-  // IDE providers — show auto-paste capability if recipe exists
-  for (const [id, prov] of Object.entries(PROVIDERS)) {
-    if (prov.type === 'ide') {
-      const hasAutoPaste = automator.hasRecipe(id);
-      const tag = hasAutoPaste ? 'auto-paste' : 'clipboard + manual';
-      choices.push({
-        label: `${prov.name} — ${tag}`,
-        value: id,
-        available: true,
-      });
-    }
-  }
-
-  return choices;
-}
-
-/**
- * Execute a prompt using the configured provider
- * 
- * CLI providers: auto-execute via their specific command
- * IDE providers: copy to clipboard + display instructions + wait
- * 
- * @param {string} providerId - Provider ID from config
- * @param {string} promptPath - Absolute path to prompt file
- * @param {string} cwd - Working directory
- * @returns {Promise<{ ok: boolean, rateLimited?: boolean, retryAt?: Date }>}
- */
-export async function executePrompt(providerId, promptPath, cwd) {
-  const prov = PROVIDERS[providerId];
-
-  if (!prov) {
-    log.warn(`Unknown provider '${providerId}', falling back to clipboard mode`);
-    const ok = await clipboardFallback(promptPath);
-    return { ok };
-  }
-
-  if (prov.type === 'cli') {
-    return await executeCLI(prov, providerId, promptPath, cwd);
-  } else {
-    const ok = await executeIDE(prov, providerId, promptPath);
-    return { ok };
-  }
-}
-
-/**
- * Execute via CLI provider — each tool has its own command pattern.
- * Output is captured and filtered to show only file-level progress,
- * keeping the terminal clean (like Claude Code's compact display).
- */
-async function executeCLI(prov, providerId, promptPath, cwd) {
-  // Verify the CLI is still available
-  if (prov.detect) {
-    try {
-      const cmd = process.platform === 'win32'
-        ? `where ${prov.detect}`
-        : `which ${prov.detect}`;
-      execSync(cmd, { stdio: 'pipe' });
-    } catch {
-      log.warn(`${prov.name} not found in PATH, falling back to clipboard mode`);
-      const ok = await clipboardFallback(promptPath);
-      return { ok };
-    }
-  }
-
-  const command = prov.buildCommand(promptPath, cwd);
-  log.info(`Executing via ${prov.name}...`);
-  log.dim(`  \u2192 ${command.substring(0, 80)}${command.length > 80 ? '...' : ''}`);
-
-  return new Promise((resolvePromise) => {
-    const child = spawn('sh', ['-c', command], {
-      cwd,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    let lastFile = '';
-    let statusText = command.substring(0, 80);
-    let lineBuffer = '';
-    let stderrBuffer = '';  // Capture stderr for rate limit detection
-    const FILE_EXT = /(?:^|\s|['"|(/])([a-zA-Z0-9_.\/-]+\.(?:rs|ts|js|jsx|tsx|py|go|toml|yaml|yml|json|md|css|html|sh|sql|prisma|vue|svelte))\b/;
-
-    // Spinner animation — gives a dynamic, alive feel
-    const SPINNER = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F'];
-    let spinIdx = 0;
-    const spinTimer = setInterval(() => {
-      const frame = SPINNER[spinIdx % SPINNER.length];
-      process.stdout.write(`\r\x1b[K \x1b[36m${frame}\x1b[0m ${statusText}`);
-      spinIdx++;
-    }, 80);
-
-    function processLine(line) {
-      const fileMatch = line.match(FILE_EXT);
-      if (fileMatch && fileMatch[1] !== lastFile) {
-        lastFile = fileMatch[1];
-        statusText = lastFile;
-      }
-    }
-
-    child.stdout.on('data', (data) => {
-      const text = data.toString();
-      lineBuffer += text;
-      stderrBuffer += text;  // Also check stdout for rate limit messages
-      const lines = lineBuffer.split('\n');
-      lineBuffer = lines.pop();
-      for (const line of lines) processLine(line);
-    });
-
-    child.stderr.on('data', (data) => {
-      const text = data.toString();
-      stderrBuffer += text;
-      const trimmed = text.trim();
-      if (trimmed && !trimmed.includes('\u2588') && !trimmed.includes('progress')) {
-        for (const line of trimmed.split('\n').slice(0, 3)) {
-          if (line.trim()) log.dim(`  ${line.substring(0, 120)}`);
-        }
-      }
-    });
-
-    child.on('close', (code) => {
-      clearInterval(spinTimer);
-      process.stdout.write('\r\x1b[K');
-      if (code === 0) {
-        log.info(`${prov.name} execution complete`);
-        resolvePromise({ ok: true });
-      } else {
-        // Check for rate limit error in captured output
-        const rateLimitInfo = parseRateLimitError(stderrBuffer);
-        if (rateLimitInfo) {
-          log.warn(`${prov.name} hit rate limit — retry at ${rateLimitInfo.retryAtStr}`);
-          resolvePromise({ ok: false, rateLimited: true, retryAt: rateLimitInfo.retryAt, retryAtStr: rateLimitInfo.retryAtStr });
-        } else {
-          log.warn(`${prov.name} exited with code ${code}`);
-          resolvePromise({ ok: false });
-        }
-      }
-    });
-
-    child.on('error', (err) => {
-      clearInterval(spinTimer);
-      process.stdout.write('\r\x1b[K');
-      log.warn(`${prov.name} execution failed: ${err.message}`);
-      resolvePromise({ ok: false });
-    });
-  });
-}
-
-/**
- * Execute via IDE provider
- * 
- * Priority: auto-paste (if IDE running) → manual clipboard fallback
- */
-async function executeIDE(prov, providerId, promptPath) {
-  const prompt = readFileSync(promptPath, 'utf-8');
-
-  // ── Try auto-paste first ──
-  if (automator.hasRecipe(providerId)) {
-    if (automator.isIDERunning(providerId)) {
-      log.info(`${prov.name} detected — attempting auto-paste...`);
-      const ok = automator.activateAndPaste(providerId, prompt);
-      if (ok) {
-        log.info(`✅ Prompt auto-pasted into ${prov.name}`);
-        log.blank();
-        await ask(`Press Enter after ${prov.name} development is complete...`);
-        return true;
-      }
-      log.warn('Auto-paste failed, falling back to manual mode');
-    } else {
-      log.warn(`${prov.name} is not running — using clipboard mode`);
-    }
-  }
-
-  // ── Manual fallback ──
-  log.blank();
-  log.info(`📋 ${prov.instructions}`);
-  log.dim(`   Prompt file: ${promptPath}`);
-  log.blank();
-
-  // Some providers benefit from seeing the prompt in terminal
-  if (prov.displayPrompt) {
-    const lines = prompt.split('\n');
-    const maxLines = 30;
-    const show = lines.slice(0, maxLines);
-    console.log('  ┌─── Prompt Preview ─────────────────────────────────────┐');
-    for (const line of show) {
-      console.log(`  │ ${line}`);
-    }
-    if (lines.length > maxLines) {
-      console.log(`  │ ... (${lines.length - maxLines} more lines — see full file)`);
-    }
-    console.log('  └────────────────────────────────────────────────────────┘');
-    log.blank();
-  }
-
-  copyToClipboard(prompt);
-
-  await ask(`Press Enter after ${prov.name} development is complete...`);
-  return true;
-}
-
-/**
- * Fallback: copy to clipboard and wait for any provider
- */
-async function clipboardFallback(promptPath) {
-  const prompt = readFileSync(promptPath, 'utf-8');
-
-  log.blank();
-  log.info('📋 Paste the prompt into your AI coding tool and execute');
-  log.dim(`   Prompt file: ${promptPath}`);
-  log.blank();
-
-  copyToClipboard(prompt);
-
-  await ask('Press Enter after development is complete...');
-  return true;
-}
-
-function copyToClipboard(text) {
-  try {
-    if (process.platform === 'darwin') {
-      execSync('pbcopy', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
-    } else if (process.platform === 'linux') {
-      // Try xclip first, then xsel
-      try {
-        execSync('xclip -selection clipboard', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
-      } catch {
-        execSync('xsel --clipboard --input', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
-      }
-    }
-    // Windows: skip — no good CLI clipboard tool
-    log.info('📋 Copied to clipboard');
-  } catch {
-    log.dim('(Could not copy to clipboard — copy the file manually)');
-  }
-}
-
-function shellEscape(str) {
-  return `'${str.replace(/'/g, "'\\''")}'`;
-}
-
-/**
- * Lightweight AI query — capture output rather than inherit stdio.
- * Only works for CLI providers. Returns null for IDE providers.
- * 
- * @param {string} providerId - Provider ID
- * @param {string} question - The question/prompt text
- * @param {string} cwd - Working directory
- * @returns {Promise<string|null>} AI response text, or null if unsupported/failed
- */
-export async function queryAI(providerId, question, cwd) {
-  const prov = PROVIDERS[providerId];
-  if (!prov || prov.type !== 'cli') return null;
-
-  // Verify CLI is available
-  if (prov.detect) {
-    try {
-      const cmd = process.platform === 'win32'
-        ? `where ${prov.detect}`
-        : `which ${prov.detect}`;
-      execSync(cmd, { stdio: 'pipe' });
-    } catch {
-      return null;
-    }
-  }
-
-  // Write question to temp file
-  const tmpPath = resolve(cwd, '.codex-copilot/_query_prompt.md');
-  writeFileSync(tmpPath, question);
-
-  const command = prov.buildCommand(tmpPath, cwd);
-
-  try {
-    const output = execSync(command, {
-      cwd,
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 60000, // 60s timeout for classification
-    });
-    return output.trim();
-  } catch (err) {
-    log.dim(`AI query failed: ${(err.message || '').substring(0, 80)}`);
-    return null;
-  }
-}
-
-/**
- * Use AI to classify code review feedback.
- * 
- * Returns 'pass' if AI determines no actionable issues,
- * 'fix' if there are issues to address, or null if classification failed.
- * 
- * @param {string} providerId - Provider ID
- * @param {string} feedbackText - The collected review feedback
- * @param {string} cwd - Working directory
- * @returns {Promise<'pass'|'fix'|null>}
- */
-export async function classifyReview(providerId, feedbackText, cwd) {
-  const classificationPrompt = `You are a code review classifier. Your ONLY job is to determine if the following code review feedback contains actionable issues that require code changes.
-
-## Code Review Feedback
-${feedbackText}
-
-## Instructions
-- If the review says the code looks good, has no issues, is purely informational, or explicitly states no changes are needed: output exactly PASS
-- If the review requests specific code changes, points out bugs, security issues, or improvements that need action: output exactly FIX
-
-IMPORTANT: Output ONLY a single word on the first line: either PASS or FIX. No other text.`;
-
-  const response = await queryAI(providerId, classificationPrompt, cwd);
-  if (!response) return null;
-
-  // Parse the first meaningful line
-  const firstLine = response.split('\n').map(l => l.trim()).find(l => l.length > 0);
-  if (!firstLine) return null;
-
-  const upper = firstLine.toUpperCase();
-  if (upper.includes('PASS')) return 'pass';
-  if (upper.includes('FIX')) return 'fix';
-
-  return null; // Ambiguous — caller decides fallback
-}
-
-// ──────────────────────────────────────────────
-// Version Check & Auto-Update
-// ──────────────────────────────────────────────
-
-/**
- * Compare two semver-like version strings.
- * Returns true if latest > current.
- */
-function isNewerVersion(current, latest) {
-  if (!current || !latest) return false;
-  const a = current.split('.').map(Number);
-  const b = latest.split('.').map(Number);
-  const len = Math.max(a.length, b.length);
-  for (let i = 0; i < len; i++) {
-    const av = a[i] || 0;
-    const bv = b[i] || 0;
-    if (bv > av) return true;
-    if (bv < av) return false;
-  }
-  return false;
-}
-
-/**
- * Get the locally installed version of a provider.
- * @returns {string|null} version string or null
- */
-function getLocalVersion(providerId) {
-  const prov = PROVIDERS[providerId];
-  if (!prov?.version) return null;
-  try {
-    const output = execSync(prov.version.command, {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 5000,
-    }).trim();
-    return prov.version.parse(output);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Fetch the latest available version from the package registry.
- * @returns {string|null} latest version string or null
- */
-function fetchLatestVersion(providerId) {
-  const prov = PROVIDERS[providerId];
-  if (!prov?.version?.latest) return null;
-
-  const { type, name } = prov.version.latest;
-  try {
-    if (type === 'npm') {
-      return execSync(`npm view ${name} version`, {
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 10000,
-      }).trim();
-    }
-    if (type === 'brew') {
-      const json = execSync(`brew info ${name} --json=v2`, {
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 10000,
-      });
-      const data = JSON.parse(json);
-      return data.formulae?.[0]?.versions?.stable || null;
-    }
-    if (type === 'brew-cask') {
-      const json = execSync(`brew info --cask ${name} --json=v2`, {
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 10000,
-      });
-      const data = JSON.parse(json);
-      return data.casks?.[0]?.version || null;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-
-/**
- * Check version status for a single provider.
- * @param {string} providerId
- * @returns {{ current: string|null, latest: string|null, updateAvailable: boolean, updateCommand: string|null }}
- */
-export function checkProviderVersion(providerId) {
-  const prov = PROVIDERS[providerId];
-  if (!prov?.version) {
-    return { current: null, latest: null, updateAvailable: false, updateCommand: null };
-  }
-
-  const current = getLocalVersion(providerId);
-  const latest = fetchLatestVersion(providerId);
-  const updateAvailable = isNewerVersion(current, latest);
-
-  return {
-    current,
-    latest,
-    updateAvailable,
-    updateCommand: updateAvailable ? prov.version.update : null,
-  };
-}
-
-/**
- * Check versions for all installed CLI providers in parallel.
- * Returns a map of providerId → version info.
- * Non-blocking: failures are silently ignored.
- */
-export function checkAllVersions() {
-  const detected = detectAvailable();
-  const results = {};
-
-  for (const id of detected) {
-    const prov = PROVIDERS[id];
-    if (!prov?.version) continue;
-    try {
-      results[id] = checkProviderVersion(id);
-    } catch {
-      // Skip on failure — non-blocking
-    }
-  }
-
-  return results;
-}
-
-/**
- * Execute the update command for a provider.
- * @param {string} providerId
- * @returns {boolean} true if update succeeded
- */
-export function updateProvider(providerId) {
-  const prov = PROVIDERS[providerId];
-  if (!prov?.version?.update) return false;
-
-  try {
-    log.info(`Updating ${prov.name}...`);
-    execSync(prov.version.update, {
-      encoding: 'utf-8',
-      stdio: 'inherit',
-      timeout: 120000, // 2 minute timeout for updates
-    });
-    log.info(`✅ ${prov.name} updated successfully`);
-    return true;
-  } catch (err) {
-    log.warn(`Failed to update ${prov.name}: ${(err.message || '').substring(0, 100)}`);
-    return false;
-  }
-}
-
-// ──────────────────────────────────────────────
-// Rate Limit Detection
-// ──────────────────────────────────────────────
-
-/**
- * Parse rate limit error from CLI output.
- * Looks for: "try again at X:XX PM" or "try again at X:XX AM"
- * @param {string} output - Combined stdout+stderr text
- * @returns {{ retryAt: Date, retryAtStr: string } | null}
- */
-function parseRateLimitError(output) {
-  if (!output) return null;
-
-  // Match "usage limit" or "rate limit" patterns
-  const isRateLimited = /usage limit|rate limit|too many requests/i.test(output);
-  if (!isRateLimited) return null;
-
-  // Extract time: "try again at 6:06 PM" or "try again at 18:06"
-  const timeMatch = output.match(/try again at\s+(\d{1,2}:\d{2}(?::\d{2})?\s*(?:AM|PM)?)/i);
-  if (!timeMatch) {
-    // Rate limited but no specific time — estimate 30 minutes from now
-    const retryAt = new Date(Date.now() + 30 * 60 * 1000);
-    return { retryAt, retryAtStr: retryAt.toLocaleTimeString() };
-  }
-
-  const timeStr = timeMatch[1].trim();
-  const now = new Date();
-  const today = now.toISOString().split('T')[0]; // YYYY-MM-DD
-
-  // Parse the time string
-  let retryAt;
-  if (/AM|PM/i.test(timeStr)) {
-    // 12-hour format: "6:06 PM"
-    retryAt = new Date(`${today} ${timeStr}`);
-  } else {
-    // 24-hour format: "18:06"
-    retryAt = new Date(`${today}T${timeStr}`);
-  }
-
-  // If parsed time is in the past, it's tomorrow
-  if (retryAt <= now) {
-    retryAt.setDate(retryAt.getDate() + 1);
-  }
-
-  // Sanity check: if retry is more than 6 hours away, something's wrong
-  if (retryAt - now > 6 * 60 * 60 * 1000) {
-    retryAt = new Date(Date.now() + 30 * 60 * 1000);
-  }
-
-  return { retryAt, retryAtStr: timeStr };
-}
-
-// ──────────────────────────────────────────────
-// Quota Pre-Check
-// ──────────────────────────────────────────────
-
-/**
- * Check current Codex 7d quota usage before execution.
- * Reads the latest rollout file for quota data.
- * 
- * @param {number} threshold - Percentage at which to block (default 97)
- * @returns {{ ok: boolean, quota5h: number|null, quota7d: number|null, warning: boolean }}
- */
-export function checkQuotaBeforeExecution(threshold = 97) {
-  try {
-    const sessionsDir = resolve(HOME, '.codex/sessions');
-    if (!existsSync(sessionsDir)) return { ok: true, quota5h: null, quota7d: null, warning: false };
-
-    // Find the most recent rollout file
-    const raw = execSync(
-      `find "${sessionsDir}" -name "rollout-*.jsonl" -type f | sort -r | head -1`,
-      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 }
-    ).trim();
-    if (!raw || !existsSync(raw)) return { ok: true, quota5h: null, quota7d: null, warning: false };
-
-    // Get the last token_count event with rate_limits
-    const line = execSync(
-      `grep '"rate_limits"' "${raw}" | tail -1`,
-      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 }
-    ).trim();
-    if (!line) return { ok: true, quota5h: null, quota7d: null, warning: false };
-
-    const data = JSON.parse(line);
-    const limits = data?.payload?.rate_limits;
-    if (!limits) return { ok: true, quota5h: null, quota7d: null, warning: false };
-
-    const quota5h = limits.primary?.used_percent ?? null;
-    const quota7d = limits.secondary?.used_percent ?? null;
-
-    // Block if 7d quota exceeds threshold
-    if (quota7d !== null && quota7d >= threshold) {
-      return { ok: false, quota5h, quota7d, warning: false };
-    }
-
-    // Warn if 7d quota is high (>= 95%)
-    const warning = quota7d !== null && quota7d >= 95;
-    return { ok: true, quota5h, quota7d, warning };
-  } catch {
-    // Quota check failed — don't block execution
-    return { ok: true, quota5h: null, quota7d: null, warning: false };
-  }
-}
-
-export const provider = {
-  getProvider, getAllProviderIds, detectAvailable,
-  buildProviderChoices, executePrompt, queryAI, classifyReview,
-  checkProviderVersion, checkAllVersions, updateProvider,
-  checkQuotaBeforeExecution,
-};
+/**
+ * AI Provider Registry — supports multiple AI coding tools
+ * 
+ * Each provider has its own invocation pattern:
+ *   - Codex CLI:    piped stdin → codex exec --full-auto
+ *   - Claude Code:  -p flag + --allowedTools for safe auto-execution
+ *   - Cursor Agent: cursor-agent CLI with -p headless mode
+ *   - Gemini CLI:   gemini -p for non-interactive prompt
+ *   - Codex Desktop / Cursor IDE / Antigravity IDE: clipboard + manual
+ */
+
+import { execSync, spawn } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { log } from './logger.js';
+import { ask } from './prompt.js';
+import { automator } from './automator.js';
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '~';
+
+// ──────────────────────────────────────────────
+// Provider Registry — each provider is unique
+// ──────────────────────────────────────────────
+
+const PROVIDERS = {
+  // ─── CLI Providers (auto-execute) ───
+
+  'codex-cli': {
+    name: 'Codex CLI',
+    type: 'cli',
+    detect: 'codex',
+    // Codex uses piped stdin: cat file | codex exec --full-auto -
+    buildCommand: (promptPath, cwd) =>
+      `cat ${shellEscape(promptPath)} | codex exec --full-auto -`,
+    description: 'OpenAI Codex CLI — pipes prompt via stdin',
+    version: {
+      command: 'codex --version',
+      parse: (output) => output.match(/[\d.]+/)?.[0],
+      latest: { type: 'brew-cask', name: 'codex' },
+      update: 'brew upgrade --cask codex',
+    },
+  },
+
+  'claude-code': {
+    name: 'Claude Code',
+    type: 'cli',
+    detect: 'claude',
+    // Claude Code uses -p (print/non-interactive) + --allowedTools for permissions
+    // Reads the file content and passes as argument (not piped)
+    buildCommand: (promptPath, cwd) => {
+      const escaped = shellEscape(promptPath);
+      // Use subshell to read file content into -p argument
+      return `claude -p "$(cat ${escaped})" --allowedTools "Bash(git*),Read,Write,Edit"`;
+    },
+    description: 'Anthropic Claude Code CLI — -p mode with tool permissions',
+    version: {
+      command: 'claude --version',
+      parse: (output) => output.match(/[\d.]+/)?.[0],
+      latest: { type: 'npm', name: '@anthropic-ai/claude-code' },
+      update: 'npm update -g @anthropic-ai/claude-code',
+    },
+  },
+
+  'cursor-agent': {
+    name: 'Cursor Agent',
+    type: 'cli',
+    detect: 'cursor-agent',
+    // Cursor Agent uses -p flag for headless/non-interactive mode
+    buildCommand: (promptPath, cwd) => {
+      const escaped = shellEscape(promptPath);
+      return `cursor-agent -p "$(cat ${escaped})"`;
+    },
+    description: 'Cursor Agent CLI — headless -p mode',
+    // No standard package manager — skip version check
+  },
+
+  'gemini-cli': {
+    name: 'Gemini CLI',
+    type: 'cli',
+    detect: 'gemini',
+    // Gemini CLI uses -p for non-interactive prompt execution
+    buildCommand: (promptPath, cwd) => {
+      const escaped = shellEscape(promptPath);
+      return `gemini -p "$(cat ${escaped})"`;
+    },
+    description: 'Google Gemini CLI — non-interactive -p mode',
+    version: {
+      command: 'gemini --version',
+      parse: (output) => output.match(/[\d.]+/)?.[0],
+      latest: { type: 'brew', name: 'gemini-cli' },
+      update: 'brew upgrade gemini-cli',
+    },
+  },
+
+  // ─── IDE Providers (clipboard + manual) ───
+
+  'codex-desktop': {
+    name: 'Codex Desktop',
+    type: 'ide',
+    instructions: 'Open Codex Desktop → paste the prompt → execute',
+    displayPrompt: true, // Show the prompt content in terminal box
+  },
+
+  'cursor': {
+    name: 'Cursor IDE',
+    type: 'ide',
+    instructions: 'Open Cursor → Ctrl/Cmd+I (Composer) → paste the prompt → run as Agent',
+    displayPrompt: false, // Too long to display, just copy to clipboard
+  },
+
+  'antigravity': {
+    name: 'Antigravity (Gemini)',
+    type: 'ide',
+    instructions: 'Open Antigravity → paste the prompt into chat → execute',
+    displayPrompt: false,
+  },
+};
+
+/**
+ * Get a provider by ID
+ */
+export function getProvider(id) {
+  return PROVIDERS[id] || null;
+}
+
+/**
+ * Get all provider IDs
+ */
+export function getAllProviderIds() {
+  return Object.keys(PROVIDERS);
+}
+
+/**
+ * Detect which CLI providers are installed on the system
+ * @returns {string[]} list of available provider IDs
+ */
+export function detectAvailable() {
+  const available = [];
+  for (const [id, prov] of Object.entries(PROVIDERS)) {
+    if (prov.type === 'cli' && prov.detect) {
+      try {
+        const cmd = process.platform === 'win32'
+          ? `where ${prov.detect}`
+          : `which ${prov.detect}`;
+        execSync(cmd, { stdio: 'pipe' });
+        available.push(id);
+      } catch {
+        // Not installed
+      }
+    }
+  }
+  return available;
+}
+
+/**
+ * Build the selection menu for init
+ * Groups CLIs first (with detection status), then IDEs
+ * @returns {{ label: string, value: string }[]}
+ */
+export function buildProviderChoices(versionCache = {}) {
+  const detected = detectAvailable();
+  const choices = [];
+
+  // CLI providers first with detection indicator + version info
+  for (const [id, prov] of Object.entries(PROVIDERS)) {
+    if (prov.type === 'cli') {
+      const installed = detected.includes(id);
+      let tag = installed ? ' ✓ detected' : '';
+
+      // Append version info if available in cache
+      const vi = versionCache[id];
+      if (vi && vi.current) {
+        if (vi.updateAvailable) {
+          tag += ` (v${vi.current} → v${vi.latest} available)`;
+        } else if (vi.latest) {
+          tag += ` (v${vi.current} ✓ latest)`;
+        } else {
+          tag += ` (v${vi.current})`;
+        }
+      }
+
+      choices.push({
+        label: `${prov.name}${tag} — ${prov.description}`,
+        value: id,
+        available: installed,
+      });
+    }
+  }
+
+  // IDE providers — show auto-paste capability if recipe exists
+  for (const [id, prov] of Object.entries(PROVIDERS)) {
+    if (prov.type === 'ide') {
+      const hasAutoPaste = automator.hasRecipe(id);
+      const tag = hasAutoPaste ? 'auto-paste' : 'clipboard + manual';
+      choices.push({
+        label: `${prov.name} — ${tag}`,
+        value: id,
+        available: true,
+      });
+    }
+  }
+
+  return choices;
+}
+
+/**
+ * Execute a prompt using the configured provider
+ * 
+ * CLI providers: auto-execute via their specific command
+ * IDE providers: copy to clipboard + display instructions + wait
+ * 
+ * @param {string} providerId - Provider ID from config
+ * @param {string} promptPath - Absolute path to prompt file
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{ ok: boolean, rateLimited?: boolean, retryAt?: Date }>}
+ */
+export async function executePrompt(providerId, promptPath, cwd) {
+  const prov = PROVIDERS[providerId];
+
+  if (!prov) {
+    log.warn(`Unknown provider '${providerId}', falling back to clipboard mode`);
+    const ok = await clipboardFallback(promptPath);
+    return { ok };
+  }
+
+  if (prov.type === 'cli') {
+    return await executeCLI(prov, providerId, promptPath, cwd);
+  } else {
+    const ok = await executeIDE(prov, providerId, promptPath);
+    return { ok };
+  }
+}
+
+/**
+ * Execute via CLI provider — each tool has its own command pattern.
+ * Output is captured and filtered to show only file-level progress,
+ * keeping the terminal clean (like Claude Code's compact display).
+ */
+async function executeCLI(prov, providerId, promptPath, cwd) {
+  // Verify the CLI is still available
+  if (prov.detect) {
+    try {
+      const cmd = process.platform === 'win32'
+        ? `where ${prov.detect}`
+        : `which ${prov.detect}`;
+      execSync(cmd, { stdio: 'pipe' });
+    } catch {
+      log.warn(`${prov.name} not found in PATH, falling back to clipboard mode`);
+      const ok = await clipboardFallback(promptPath);
+      return { ok };
+    }
+  }
+
+  const command = prov.buildCommand(promptPath, cwd);
+  log.info(`Executing via ${prov.name}...`);
+  log.dim(`  \u2192 ${command.substring(0, 80)}${command.length > 80 ? '...' : ''}`);
+
+  return new Promise((resolvePromise) => {
+    const child = spawn('sh', ['-c', command], {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let lastFile = '';
+    let statusText = command.substring(0, 80);
+    let lineBuffer = '';
+    let stderrBuffer = '';  // Capture stderr for rate limit detection
+    const FILE_EXT = /(?:^|\s|['"|(/])([a-zA-Z0-9_.\/-]+\.(?:rs|ts|js|jsx|tsx|py|go|toml|yaml|yml|json|md|css|html|sh|sql|prisma|vue|svelte))\b/;
+
+    // Spinner animation — gives a dynamic, alive feel
+    const SPINNER = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F'];
+    let spinIdx = 0;
+    const spinTimer = setInterval(() => {
+      const frame = SPINNER[spinIdx % SPINNER.length];
+      process.stdout.write(`\r\x1b[K \x1b[36m${frame}\x1b[0m ${statusText}`);
+      spinIdx++;
+    }, 80);
+
+    function processLine(line) {
+      const fileMatch = line.match(FILE_EXT);
+      if (fileMatch && fileMatch[1] !== lastFile) {
+        lastFile = fileMatch[1];
+        statusText = lastFile;
+      }
+    }
+
+    child.stdout.on('data', (data) => {
+      const text = data.toString();
+      lineBuffer += text;
+      stderrBuffer += text;  // Also check stdout for rate limit messages
+      const lines = lineBuffer.split('\n');
+      lineBuffer = lines.pop();
+      for (const line of lines) processLine(line);
+    });
+
+    child.stderr.on('data', (data) => {
+      const text = data.toString();
+      stderrBuffer += text;
+      const trimmed = text.trim();
+      if (trimmed && !trimmed.includes('\u2588') && !trimmed.includes('progress')) {
+        for (const line of trimmed.split('\n').slice(0, 3)) {
+          if (line.trim()) log.dim(`  ${line.substring(0, 120)}`);
+        }
+      }
+    });
+
+    child.on('close', (code) => {
+      clearInterval(spinTimer);
+      process.stdout.write('\r\x1b[K');
+      if (code === 0) {
+        log.info(`${prov.name} execution complete`);
+        resolvePromise({ ok: true });
+      } else {
+        // Check for rate limit error in captured output
+        const rateLimitInfo = parseRateLimitError(stderrBuffer);
+        if (rateLimitInfo) {
+          log.warn(`${prov.name} hit rate limit — retry at ${rateLimitInfo.retryAtStr}`);
+          resolvePromise({ ok: false, rateLimited: true, retryAt: rateLimitInfo.retryAt, retryAtStr: rateLimitInfo.retryAtStr });
+        } else {
+          log.warn(`${prov.name} exited with code ${code}`);
+          resolvePromise({ ok: false });
+        }
+      }
+    });
+
+    child.on('error', (err) => {
+      clearInterval(spinTimer);
+      process.stdout.write('\r\x1b[K');
+      log.warn(`${prov.name} execution failed: ${err.message}`);
+      resolvePromise({ ok: false });
+    });
+  });
+}
+
+/**
+ * Execute via IDE provider
+ * 
+ * Priority: auto-paste (if IDE running) → manual clipboard fallback
+ */
+async function executeIDE(prov, providerId, promptPath) {
+  const prompt = readFileSync(promptPath, 'utf-8');
+
+  // ── Try auto-paste first ──
+  if (automator.hasRecipe(providerId)) {
+    if (automator.isIDERunning(providerId)) {
+      log.info(`${prov.name} detected — attempting auto-paste...`);
+      const ok = automator.activateAndPaste(providerId, prompt);
+      if (ok) {
+        log.info(`✅ Prompt auto-pasted into ${prov.name}`);
+        log.blank();
+        await ask(`Press Enter after ${prov.name} development is complete...`);
+        return true;
+      }
+      log.warn('Auto-paste failed, falling back to manual mode');
+    } else {
+      log.warn(`${prov.name} is not running — using clipboard mode`);
+    }
+  }
+
+  // ── Manual fallback ──
+  log.blank();
+  log.info(`📋 ${prov.instructions}`);
+  log.dim(`   Prompt file: ${promptPath}`);
+  log.blank();
+
+  // Some providers benefit from seeing the prompt in terminal
+  if (prov.displayPrompt) {
+    const lines = prompt.split('\n');
+    const maxLines = 30;
+    const show = lines.slice(0, maxLines);
+    console.log('  ┌─── Prompt Preview ─────────────────────────────────────┐');
+    for (const line of show) {
+      console.log(`  │ ${line}`);
+    }
+    if (lines.length > maxLines) {
+      console.log(`  │ ... (${lines.length - maxLines} more lines — see full file)`);
+    }
+    console.log('  └────────────────────────────────────────────────────────┘');
+    log.blank();
+  }
+
+  copyToClipboard(prompt);
+
+  await ask(`Press Enter after ${prov.name} development is complete...`);
+  return true;
+}
+
+/**
+ * Fallback: copy to clipboard and wait for any provider
+ */
+async function clipboardFallback(promptPath) {
+  const prompt = readFileSync(promptPath, 'utf-8');
+
+  log.blank();
+  log.info('📋 Paste the prompt into your AI coding tool and execute');
+  log.dim(`   Prompt file: ${promptPath}`);
+  log.blank();
+
+  copyToClipboard(prompt);
+
+  await ask('Press Enter after development is complete...');
+  return true;
+}
+
+function copyToClipboard(text) {
+  try {
+    if (process.platform === 'darwin') {
+      execSync('pbcopy', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+    } else if (process.platform === 'linux') {
+      // Try xclip first, then xsel
+      try {
+        execSync('xclip -selection clipboard', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+      } catch {
+        execSync('xsel --clipboard --input', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+      }
+    } else if (process.platform === 'win32') {
+      execSync('clip', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    log.info('📋 Copied to clipboard');
+  } catch {
+    log.dim('(Could not copy to clipboard — copy the file manually)');
+  }
+}
+
+function shellEscape(str) {
+  if (process.platform === 'win32') {
+    return `"${str.replace(/"/g, '\\"')}"`;
+  }
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Lightweight AI query — capture output rather than inherit stdio.
+ * Only works for CLI providers. Returns null for IDE providers.
+ * 
+ * @param {string} providerId - Provider ID
+ * @param {string} question - The question/prompt text
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string|null>} AI response text, or null if unsupported/failed
+ */
+export async function queryAI(providerId, question, cwd) {
+  const prov = PROVIDERS[providerId];
+  if (!prov || prov.type !== 'cli') return null;
+
+  // Verify CLI is available
+  if (prov.detect) {
+    try {
+      const cmd = process.platform === 'win32'
+        ? `where ${prov.detect}`
+        : `which ${prov.detect}`;
+      execSync(cmd, { stdio: 'pipe' });
+    } catch {
+      return null;
+    }
+  }
+
+  // Write question to temp file
+  const tmpPath = resolve(cwd, '.codex-copilot/_query_prompt.md');
+  writeFileSync(tmpPath, question);
+
+  const command = prov.buildCommand(tmpPath, cwd);
+
+  try {
+    const output = execSync(command, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 60000, // 60s timeout for classification
+    });
+    return output.trim();
+  } catch (err) {
+    log.dim(`AI query failed: ${(err.message || '').substring(0, 80)}`);
+    return null;
+  }
+}
+
+/**
+ * Use AI to classify code review feedback.
+ * 
+ * Returns 'pass' if AI determines no actionable issues,
+ * 'fix' if there are issues to address, or null if classification failed.
+ * 
+ * @param {string} providerId - Provider ID
+ * @param {string} feedbackText - The collected review feedback
+ * @param {string} cwd - Working directory
+ * @returns {Promise<'pass'|'fix'|null>}
+ */
+export async function classifyReview(providerId, feedbackText, cwd) {
+  const classificationPrompt = `You are a code review classifier. Your ONLY job is to determine if the following code review feedback contains actionable issues that require code changes.
+
+## Code Review Feedback
+${feedbackText}
+
+## Instructions
+- If the review says the code looks good, has no issues, is purely informational, or explicitly states no changes are needed: output exactly PASS
+- If the review requests specific code changes, points out bugs, security issues, or improvements that need action: output exactly FIX
+
+IMPORTANT: Output ONLY a single word on the first line: either PASS or FIX. No other text.`;
+
+  const response = await queryAI(providerId, classificationPrompt, cwd);
+  if (!response) return null;
+
+  // Parse the first meaningful line
+  const firstLine = response.split('\n').map(l => l.trim()).find(l => l.length > 0);
+  if (!firstLine) return null;
+
+  const upper = firstLine.toUpperCase();
+  if (upper.includes('PASS')) return 'pass';
+  if (upper.includes('FIX')) return 'fix';
+
+  return null; // Ambiguous — caller decides fallback
+}
+
+// ──────────────────────────────────────────────
+// Version Check & Auto-Update
+// ──────────────────────────────────────────────
+
+/**
+ * Compare two semver-like version strings.
+ * Returns true if latest > current.
+ */
+function isNewerVersion(current, latest) {
+  if (!current || !latest) return false;
+  const a = current.split('.').map(Number);
+  const b = latest.split('.').map(Number);
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const av = a[i] || 0;
+    const bv = b[i] || 0;
+    if (bv > av) return true;
+    if (bv < av) return false;
+  }
+  return false;
+}
+
+/**
+ * Get the locally installed version of a provider.
+ * @returns {string|null} version string or null
+ */
+function getLocalVersion(providerId) {
+  const prov = PROVIDERS[providerId];
+  if (!prov?.version) return null;
+  try {
+    const output = execSync(prov.version.command, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+    return prov.version.parse(output);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetch the latest available version from the package registry.
+ * @returns {string|null} latest version string or null
+ */
+function fetchLatestVersion(providerId) {
+  const prov = PROVIDERS[providerId];
+  if (!prov?.version?.latest) return null;
+
+  const { type, name } = prov.version.latest;
+  try {
+    if (type === 'npm') {
+      return execSync(`npm view ${name} version`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000,
+      }).trim();
+    }
+    if (type === 'brew') {
+      const json = execSync(`brew info ${name} --json=v2`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000,
+      });
+      const data = JSON.parse(json);
+      return data.formulae?.[0]?.versions?.stable || null;
+    }
+    if (type === 'brew-cask') {
+      const json = execSync(`brew info --cask ${name} --json=v2`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000,
+      });
+      const data = JSON.parse(json);
+      return data.casks?.[0]?.version || null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Check version status for a single provider.
+ * @param {string} providerId
+ * @returns {{ current: string|null, latest: string|null, updateAvailable: boolean, updateCommand: string|null }}
+ */
+export function checkProviderVersion(providerId) {
+  const prov = PROVIDERS[providerId];
+  if (!prov?.version) {
+    return { current: null, latest: null, updateAvailable: false, updateCommand: null };
+  }
+
+  const current = getLocalVersion(providerId);
+  const latest = fetchLatestVersion(providerId);
+  const updateAvailable = isNewerVersion(current, latest);
+
+  return {
+    current,
+    latest,
+    updateAvailable,
+    updateCommand: updateAvailable ? prov.version.update : null,
+  };
+}
+
+/**
+ * Check versions for all installed CLI providers in parallel.
+ * Returns a map of providerId → version info.
+ * Non-blocking: failures are silently ignored.
+ */
+export function checkAllVersions() {
+  const detected = detectAvailable();
+  const results = {};
+
+  for (const id of detected) {
+    const prov = PROVIDERS[id];
+    if (!prov?.version) continue;
+    try {
+      results[id] = checkProviderVersion(id);
+    } catch {
+      // Skip on failure — non-blocking
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Execute the update command for a provider.
+ * @param {string} providerId
+ * @returns {boolean} true if update succeeded
+ */
+export function updateProvider(providerId) {
+  const prov = PROVIDERS[providerId];
+  if (!prov?.version?.update) return false;
+
+  try {
+    log.info(`Updating ${prov.name}...`);
+    execSync(prov.version.update, {
+      encoding: 'utf-8',
+      stdio: 'inherit',
+      timeout: 120000, // 2 minute timeout for updates
+    });
+    log.info(`✅ ${prov.name} updated successfully`);
+    return true;
+  } catch (err) {
+    log.warn(`Failed to update ${prov.name}: ${(err.message || '').substring(0, 100)}`);
+    return false;
+  }
+}
+
+// ──────────────────────────────────────────────
+// Rate Limit Detection
+// ──────────────────────────────────────────────
+
+/**
+ * Parse rate limit error from CLI output.
+ * Looks for: "try again at X:XX PM" or "try again at X:XX AM"
+ * @param {string} output - Combined stdout+stderr text
+ * @returns {{ retryAt: Date, retryAtStr: string } | null}
+ */
+function parseRateLimitError(output) {
+  if (!output) return null;
+
+  // Match "usage limit" or "rate limit" patterns
+  const isRateLimited = /usage limit|rate limit|too many requests/i.test(output);
+  if (!isRateLimited) return null;
+
+  // Extract time: "try again at 6:06 PM" or "try again at 18:06"
+  const timeMatch = output.match(/try again at\s+(\d{1,2}:\d{2}(?::\d{2})?\s*(?:AM|PM)?)/i);
+  if (!timeMatch) {
+    // Rate limited but no specific time — estimate 30 minutes from now
+    const retryAt = new Date(Date.now() + 30 * 60 * 1000);
+    return { retryAt, retryAtStr: retryAt.toLocaleTimeString() };
+  }
+
+  const timeStr = timeMatch[1].trim();
+  const now = new Date();
+  const today = now.toISOString().split('T')[0]; // YYYY-MM-DD
+
+  // Parse the time string
+  let retryAt;
+  if (/AM|PM/i.test(timeStr)) {
+    // 12-hour format: "6:06 PM"
+    retryAt = new Date(`${today} ${timeStr}`);
+  } else {
+    // 24-hour format: "18:06"
+    retryAt = new Date(`${today}T${timeStr}`);
+  }
+
+  // If parsed time is in the past, it's tomorrow
+  if (retryAt <= now) {
+    retryAt.setDate(retryAt.getDate() + 1);
+  }
+
+  // Sanity check: if retry is more than 6 hours away, something's wrong
+  if (retryAt - now > 6 * 60 * 60 * 1000) {
+    retryAt = new Date(Date.now() + 30 * 60 * 1000);
+  }
+
+  return { retryAt, retryAtStr: timeStr };
+}
+
+// ──────────────────────────────────────────────
+// Quota Pre-Check
+// ──────────────────────────────────────────────
+
+/**
+ * Check current Codex 7d quota usage before execution.
+ * Reads the latest rollout file for quota data.
+ * 
+ * @param {number} threshold - Percentage at which to block (default 97)
+ * @returns {{ ok: boolean, quota5h: number|null, quota7d: number|null, warning: boolean }}
+ */
+export function checkQuotaBeforeExecution(threshold = 97) {
+  try {
+    const sessionsDir = resolve(HOME, '.codex/sessions');
+    if (!existsSync(sessionsDir)) return { ok: true, quota5h: null, quota7d: null, warning: false };
+
+    // Find the most recent rollout file
+    const raw = execSync(
+      `find "${sessionsDir}" -name "rollout-*.jsonl" -type f | sort -r | head -1`,
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 }
+    ).trim();
+    if (!raw || !existsSync(raw)) return { ok: true, quota5h: null, quota7d: null, warning: false };
+
+    // Get the last token_count event with rate_limits
+    const line = execSync(
+      `grep '"rate_limits"' "${raw}" | tail -1`,
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 }
+    ).trim();
+    if (!line) return { ok: true, quota5h: null, quota7d: null, warning: false };
+
+    const data = JSON.parse(line);
+    const limits = data?.payload?.rate_limits;
+    if (!limits) return { ok: true, quota5h: null, quota7d: null, warning: false };
+
+    const quota5h = limits.primary?.used_percent ?? null;
+    const quota7d = limits.secondary?.used_percent ?? null;
+
+    // Block if 7d quota exceeds threshold
+    if (quota7d !== null && quota7d >= threshold) {
+      return { ok: false, quota5h, quota7d, warning: false };
+    }
+
+    // Warn if 7d quota is high (>= 95%)
+    const warning = quota7d !== null && quota7d >= 95;
+    return { ok: true, quota5h, quota7d, warning };
+  } catch {
+    // Quota check failed — don't block execution
+    return { ok: true, quota5h: null, quota7d: null, warning: false };
+  }
+}
+
+export const provider = {
+  getProvider, getAllProviderIds, detectAvailable,
+  buildProviderChoices, executePrompt, queryAI, classifyReview,
+  checkProviderVersion, checkAllVersions, updateProvider,
+  checkQuotaBeforeExecution,
+};