@jojonax/codex-copilot 1.3.6 → 1.4.1

package/bin/cli.js

@@ -22,6 +22,8 @@ import { status } from '../src/commands/status.js';
 import { reset } from '../src/commands/reset.js';
 import { retry } from '../src/commands/retry.js';
 import { skip } from '../src/commands/skip.js';
+import { usage } from '../src/commands/usage.js';
+import { evolve } from '../src/commands/evolve.js';
 import { log } from '../src/utils/logger.js';
 import { checkForUpdates } from '../src/utils/update-check.js';
 
@@ -95,6 +97,20 @@ async function main() {
         break;
       }
 
+      case 'usage':
+        await usage();
+        process.exit(0);
+        break;
+
+      case 'evolve':
+      case 'next':
+        if (!existsSync(resolve(projectDir, '.codex-copilot/config.json'))) {
+          log.error('Not initialized. Run: codex-copilot init');
+          process.exit(1);
+        }
+        await evolve(projectDir);
+        break;
+
       case 'update':
         log.info('Updating to latest version...');
         try {
@@ -132,6 +148,8 @@ async function main() {
         console.log('    reset     Reset state and start over');
         console.log('    retry     Retry blocked tasks with enhanced prompts');
         console.log('    skip <id> Force-skip a task to unblock dependents');
+        console.log('    usage     Show AI token usage for recent sessions');
+        console.log('    evolve    Start next PRD iteration round (gap analysis → plan → run)');
         console.log('    update    Update to latest version');
         console.log('');
         console.log('  Workflow:');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jojonax/codex-copilot",
-  "version": "1.3.6",
+  "version": "1.4.1",
   "description": "PRD-driven automated development orchestrator for CodeX / Cursor",
   "bin": {
     "codex-copilot": "./bin/cli.js"

package/src/commands/evolve.js

@@ -0,0 +1,321 @@
+/**
+ * codex-copilot evolve - Multi-round PRD iteration
+ *
+ * Flow: Archive current round → Gap analysis → Plan next round → Reset → Run
+ *
+ * Each round is tracked in .codex-copilot/rounds.json with summaries of
+ * what was built, enabling intelligent gap analysis against the full PRD.
+ */
+
+import { readFileSync, writeFileSync, existsSync, copyFileSync } from 'fs';
+import { resolve } from 'path';
+import { log } from '../utils/logger.js';
+import { provider } from '../utils/provider.js';
+import { readPRD } from '../utils/detect-prd.js';
+import { closePrompt } from '../utils/prompt.js';
+import { run } from './run.js';
+
+function readJSON(path) {
+  return JSON.parse(readFileSync(path, 'utf-8'));
+}
+
+function writeJSON(path, data) {
+  writeFileSync(path, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Load or initialize rounds.json
+ */
+function loadRounds(copilotDir) {
+  const roundsPath = resolve(copilotDir, 'rounds.json');
+  if (existsSync(roundsPath)) {
+    return readJSON(roundsPath);
+  }
+  return { current_round: 0, rounds: [] };
+}
+
+function saveRounds(copilotDir, rounds) {
+  writeJSON(resolve(copilotDir, 'rounds.json'), rounds);
+}
+
+/**
+ * Archive the current round: count results, save summary
+ */
+function archiveCurrentRound(copilotDir, tasks, roundNumber) {
+  const completed = tasks.tasks.filter(t => t.status === 'completed');
+  const blocked = tasks.tasks.filter(t => t.status === 'blocked');
+  const skipped = tasks.tasks.filter(t => t.status === 'skipped');
+
+  // Build a text summary of what was completed
+  const completedSummary = completed.map(t =>
+    `- Task #${t.id}: ${t.title}`
+  ).join('\n');
+
+  const blockedSummary = blocked.length > 0
+    ? '\n\nBlocked tasks:\n' + blocked.map(t => `- Task #${t.id}: ${t.title}`).join('\n')
+    : '';
+
+  const summary = `Round ${roundNumber} completed ${completed.length}/${tasks.total} tasks.\n\nCompleted:\n${completedSummary}${blockedSummary}`;
+
+  const roundEntry = {
+    round: roundNumber,
+    started_at: tasks.tasks[0]?.started_at || new Date().toISOString(),
+    completed_at: new Date().toISOString(),
+    tasks_total: tasks.total,
+    tasks_completed: completed.length,
+    tasks_blocked: blocked.length,
+    tasks_skipped: skipped.length,
+    summary,
+    // Store completed task titles + descriptions for gap analysis
+    completed_features: completed.map(t => ({
+      title: t.title,
+      description: t.description,
+      acceptance: t.acceptance,
+    })),
+  };
+
+  // Archive tasks.json → tasks_round_N.json
+  const archivePath = resolve(copilotDir, `tasks_round_${roundNumber}.json`);
+  copyFileSync(resolve(copilotDir, 'tasks.json'), archivePath);
+  log.dim(`  Archived to tasks_round_${roundNumber}.json`);
+
+  return roundEntry;
+}
+
+/**
+ * Build the gap analysis + next-round planning prompt
+ */
+function buildEvolvePrompt(prdContent, rounds, copilotDir) {
+  // Collect all completed features across all rounds
+  const allCompleted = [];
+  for (const r of rounds.rounds) {
+    if (r.completed_features) {
+      for (const f of r.completed_features) {
+        allCompleted.push(f);
+      }
+    }
+  }
+
+  const completedSection = allCompleted.length > 0
+    ? allCompleted.map((f, i) => `${i + 1}. **${f.title}**\n   ${f.description?.substring(0, 200) || ''}`).join('\n\n')
+    : 'No features completed yet.';
+
+  const roundHistorySection = rounds.rounds.map(r =>
+    `### Round ${r.round}\n- Completed: ${r.tasks_completed}/${r.tasks_total} tasks\n- Summary: ${r.summary?.substring(0, 300) || 'N/A'}`
+  ).join('\n\n');
+
+  const nextRound = rounds.current_round + 1;
+
+  return `You are a senior software architect planning the next development iteration.
+
+## Context
+
+This is Round ${nextRound} of an iterative PRD implementation.
+
+### Full PRD Document
+
+${prdContent}
+
+### Development History
+
+${roundHistorySection}
+
+### Features Already Completed (across all rounds)
+
+${completedSection}
+
+## Your Task
+
+1. **Gap Analysis**: Compare the PRD requirements against the completed features. Identify ALL remaining features, improvements, and details that have NOT been implemented yet.
+
+2. **Priority Planning**: From the gaps identified, select the most important batch for Round ${nextRound}. Consider:
+   - Dependencies (build foundations before features)
+   - User value (core features before polish)
+   - Technical feasibility (group related changes)
+   - Moderate batch size (8-15 tasks per round)
+
+3. **Generate tasks.json**: Output the next round's task plan.
+
+## Output Format
+
+Write the result to \`.codex-copilot/tasks.json\` in the following format:
+
+\`\`\`json
+{
+  "project": "Project Name",
+  "round": ${nextRound},
+  "total": N,
+  "tasks": [
+    {
+      "id": 1,
+      "title": "Task title (brief)",
+      "description": "Detailed task description with specific features and technical details",
+      "acceptance": ["Acceptance criteria 1", "Acceptance criteria 2"],
+      "branch": "feature/${String(nextRound).padStart(2, '0')}01-task-slug",
+      "status": "pending",
+      "depends_on": []
+    }
+  ]
+}
+\`\`\`
+
+## Important Rules
+1. Do NOT re-implement features that are already completed
+2. Branch names should be prefixed with the round number: feature/${String(nextRound).padStart(2, '0')}XX-slug
+3. Each task must be specific and actionable (not vague like "improve performance")
+4. Include detailed descriptions that reference the PRD's specific requirements
+5. If the PRD has been fully implemented, output an empty tasks array with a comment
+`;
+}
+
+export async function evolve(projectDir) {
+  log.title('🔄 Multi-Round PRD Evolution');
+  log.blank();
+
+  const copilotDir = resolve(projectDir, '.codex-copilot');
+  const tasksPath = resolve(copilotDir, 'tasks.json');
+  const configPath = resolve(copilotDir, 'config.json');
+
+  // Validate project state
+  if (!existsSync(copilotDir) || !existsSync(configPath)) {
+    log.error('Project not initialized. Run: codex-copilot init');
+    closePrompt();
+    process.exit(1);
+  }
+
+  const config = readJSON(configPath);
+  const providerId = config.provider || 'codex-cli';
+  const rounds = loadRounds(copilotDir);
+
+  // ===== Step 1: Archive current round =====
+  if (existsSync(tasksPath)) {
+    const tasks = readJSON(tasksPath);
+    const hasCompletedTasks = tasks.tasks?.some(t => t.status === 'completed');
+    const roundNumber = tasks.round || rounds.current_round || 1;
+
+    // Check if this round was already archived (prevent duplicate archiving)
+    const archiveExists = existsSync(resolve(copilotDir, `tasks_round_${roundNumber}.json`));
+    const alreadyInHistory = rounds.rounds.some(r => r.round === roundNumber);
+
+    if (hasCompletedTasks && !archiveExists && !alreadyInHistory) {
+      log.step(`Step 1: Archiving Round ${roundNumber}...`);
+
+      const roundEntry = archiveCurrentRound(copilotDir, tasks, roundNumber);
+      rounds.rounds.push(roundEntry);
+      rounds.current_round = roundNumber;
+      saveRounds(copilotDir, rounds);
+
+      const pct = Math.round((roundEntry.tasks_completed / roundEntry.tasks_total) * 100);
+      log.info(`  Round ${roundNumber}: ${roundEntry.tasks_completed}/${roundEntry.tasks_total} tasks (${pct}%)`);
+      log.blank();
+    } else if (hasCompletedTasks && (archiveExists || alreadyInHistory)) {
+      log.dim(`  Round ${roundNumber} already archived — skipping`);
+      // Ensure rounds.current_round is up to date
+      if (rounds.current_round < roundNumber) {
+        rounds.current_round = roundNumber;
+        saveRounds(copilotDir, rounds);
+      }
+      log.blank();
+    } else if (rounds.current_round === 0) {
+      log.warn('No completed tasks found. Starting from Round 1.');
+      rounds.current_round = 0;
+      saveRounds(copilotDir, rounds);
+      log.blank();
+    }
+  }
+
+  // ===== Step 2 + 3: Gap analysis & next-round planning =====
+  const nextRound = rounds.current_round + 1;
+  log.step(`Step 2: Planning Round ${nextRound} (Gap Analysis + Task Planning)...`);
+  log.blank();
+
+  // Read PRD
+  let prdContent;
+  try {
+    prdContent = readPRD(config.prd_path);
+  } catch {
+    log.error(`Cannot read PRD: ${config.prd_path}`);
+    closePrompt();
+    process.exit(1);
+  }
+
+  // Build the evolve prompt
+  const evolvePrompt = buildEvolvePrompt(prdContent, rounds, copilotDir);
+  const promptPath = resolve(copilotDir, 'evolve-prompt.md');
+  writeFileSync(promptPath, evolvePrompt);
+  log.info(`  Evolve prompt saved: .codex-copilot/evolve-prompt.md`);
+  log.blank();
+
+  // Execute via AI provider
+  log.step(`Invoking AI to analyze gaps and plan Round ${nextRound}...`);
+  const ok = await provider.executePrompt(providerId, promptPath, projectDir);
+
+  if (!ok) {
+    log.error('AI invocation failed. You can manually edit the prompt and retry.');
+    closePrompt();
+    process.exit(1);
+  }
+
+  // ===== Step 4: Validate new tasks.json =====
+  if (!existsSync(tasksPath)) {
+    log.error('AI did not generate tasks.json. Check the evolve prompt output.');
+    closePrompt();
+    process.exit(1);
+  }
+
+  let newTasks;
+  try {
+    newTasks = readJSON(tasksPath);
+  } catch {
+    log.error('Generated tasks.json is invalid JSON.');
+    closePrompt();
+    process.exit(1);
+  }
+
+  if (!newTasks.tasks || newTasks.tasks.length === 0) {
+    log.blank();
+    log.title('🎉 PRD fully implemented!');
+    log.info('All features from the PRD have been built across all rounds.');
+    log.info(`Total rounds: ${rounds.current_round}`);
+
+    // Show round history
+    for (const r of rounds.rounds) {
+      log.dim(`  Round ${r.round}: ${r.tasks_completed}/${r.tasks_total} tasks`);
+    }
+
+    closePrompt();
+    return;
+  }
+
+  // Update round tracking
+  rounds.current_round = nextRound;
+  saveRounds(copilotDir, rounds);
+
+  // Reset checkpoint for fresh round
+  const statePath = resolve(copilotDir, 'state.json');
+  writeJSON(statePath, {
+    current_task: 0,
+    phase: null,
+    phase_step: null,
+    current_pr: null,
+    review_round: 0,
+    branch: null,
+    status: 'initialized',
+    last_updated: new Date().toISOString(),
+  });
+
+  log.blank();
+  log.title(`✅ Round ${nextRound} planned — ${newTasks.tasks.length} tasks`);
+  log.blank();
+
+  for (const t of newTasks.tasks) {
+    log.dim(`  ${t.id}. ${t.title}`);
+  }
+  log.blank();
+
+  // ===== Step 5: Auto-start run =====
+  log.step(`Starting Round ${nextRound} execution...`);
+  log.blank();
+
+  await run(projectDir);
+}

package/src/commands/run.js

@@ -93,6 +93,45 @@ export async function run(projectDir) {
     log.info(`⏩ Resuming task #${state.current_task} from: ${state.phase} → ${state.phase_step}`);
   }
 
+  // ===== Auto-retry blocked tasks =====
+  // On each run, reset blocked tasks to pending so they're retried in order.
+  // Per-task checkpoint steps are cleared so the task starts fresh.
+  // The main checkpoint position (current_task) is preserved.
+  const blockedTasks = tasks.tasks.filter(t => t.status === 'blocked');
+  if (blockedTasks.length > 0) {
+    log.blank();
+    log.info(`🔄 Auto-retrying ${blockedTasks.length} blocked task(s)...`);
+    for (const bt of blockedTasks) {
+      bt.status = 'pending';
+      bt.retry_count = (bt.retry_count || 0) + 1;
+      bt._retrying = true; // Flag: don't skip even if below checkpoint
+
+      // Clear per-task checkpoint steps — the task needs a fresh start
+      // (The main checkpoint.current_task is NOT affected)
+      checkpoint.clearTask(bt.id);
+
+      // Clean up old branch to avoid "branch already exists" errors
+      try {
+        git.resetBranch(projectDir, bt.branch, baseBranch);
+        log.dim(`   ↳ Task #${bt.id}: ${bt.title.substring(0, 50)} (attempt ${bt.retry_count + 1}, branch reset)`);
+      } catch {
+        // If branch cleanup fails, still let the task try
+        log.dim(`   ↳ Task #${bt.id}: ${bt.title.substring(0, 50)} (attempt ${bt.retry_count + 1})`);
+      }
+
+      // Close any existing PR for this task (stale from previous attempt)
+      if (bt.pr_number) {
+        try {
+          github.closePR(projectDir, bt.pr_number);
+          delete bt.pr_number;
+        } catch { /* ignore */ }
+      }
+    }
+    // Switch back to base branch after all resets
+    git.checkoutMain(projectDir, baseBranch);
+    writeJSON(tasksPath, tasks);
+  }
+
   const completedCount = tasks.tasks.filter(t => t.status === 'completed').length;
   log.blank();
   progressBar(completedCount, tasks.total, `${completedCount}/${tasks.total} tasks done`);
@@ -103,9 +142,12 @@ export async function run(projectDir) {
     // Skip fully completed tasks
     if (task.status === 'completed' || task.status === 'skipped') continue;
 
-    // Skip tasks whose ID is below the completed threshold (and not the resuming task)
+    // Skip tasks whose ID is below the checkpoint (unless retrying a blocked task)
     const isResumingTask = state.current_task === task.id && state.phase;
-    if (task.id < state.current_task && !isResumingTask) continue;
+    if (task.id < state.current_task && !isResumingTask && !task._retrying) continue;
+
+    // Clean up retry flag (used only to bypass checkpoint skip)
+    delete task._retrying;
 
     log.blank();
     log.title(`━━━ Task ${task.id}/${tasks.total}: ${task.title} ━━━`);
@@ -217,6 +259,17 @@ export async function run(projectDir) {
   log.blank();
   process.removeListener('SIGINT', gracefulShutdown);
   process.removeListener('SIGTERM', gracefulShutdown);
+
+  // ===== Auto-evolve: trigger next round if enabled =====
+  if (config.auto_evolve !== false) {
+    log.blank();
+    log.info('🔄 Auto-evolving to next round...');
+    log.blank();
+    const { evolve } = await import('./evolve.js');
+    await evolve(projectDir);
+    return; // evolve() calls run() internally
+  }
+
   closePrompt();
 }
 

package/src/commands/status.js

@@ -24,6 +24,24 @@ export async function status(projectDir) {
   log.title(`📊 Project: ${tasks.project}`);
   log.blank();
 
+  // Round info
+  const roundsPath = resolve(projectDir, '.codex-copilot/rounds.json');
+  if (existsSync(roundsPath)) {
+    try {
+      const rounds = JSON.parse(readFileSync(roundsPath, 'utf-8'));
+      const currentRound = tasks.round || rounds.current_round || 1;
+      const totalCompleted = rounds.rounds.reduce((s, r) => s + r.tasks_completed, 0);
+      log.info(`📦 Round: ${currentRound}  |  Total across all rounds: ${totalCompleted} tasks`);
+      if (rounds.rounds.length > 0) {
+        for (const r of rounds.rounds) {
+          const pct = Math.round((r.tasks_completed / r.tasks_total) * 100);
+          log.dim(`   Round ${r.round}: ${r.tasks_completed}/${r.tasks_total} (${pct}%)`);
+        }
+      }
+      log.blank();
+    } catch { /* ignore parse errors */ }
+  }
+
   // Progress bar
   const completed = tasks.tasks.filter(t => t.status === 'completed').length;
   const inProgress = tasks.tasks.filter(t => t.status === 'in_progress' || t.status === 'developed').length;

package/src/commands/usage.js

@@ -0,0 +1,329 @@
+/**
+ * codex-copilot usage - Show token usage stats for recent AI sessions
+ *
+ * Data sources:
+ *   Codex CLI:    ~/.codex/state_5.sqlite (threads) + rollout JSONL (token breakdown)
+ *   Cursor:       ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+ *   Claude Code:  ~/.claude/stats-cache.json
+ *   Antigravity:  (no local usage data available)
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { resolve, join } from 'path';
+import { log } from '../utils/logger.js';
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '~';
+
+// ─── Helpers ─────────────────────────────────────────────
+
+function formatTokens(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+  return String(n);
+}
+
+function padRight(s, len) {
+  const str = String(s);
+  return str.length >= len ? str.substring(0, len) : str + ' '.repeat(len - str.length);
+}
+
+function padLeft(s, len) {
+  const str = String(s);
+  return str.length >= len ? str.substring(0, len) : ' '.repeat(len - str.length) + str;
+}
+
+function printTable(headers, rows, colWidths, alignRight = []) {
+  const topBorder = ' ┌─' + colWidths.map(w => '─'.repeat(w)).join('─┬─') + '─┐';
+  const headSep = ' ├─' + colWidths.map(w => '─'.repeat(w)).join('─┼─') + '─┤';
+  const botBorder = ' └─' + colWidths.map(w => '─'.repeat(w)).join('─┴─') + '─┘';
+
+  const headerLine = headers.map((h, i) => padRight(h, colWidths[i])).join(' │ ');
+  console.log(topBorder);
+  console.log(` │ ${headerLine} │`);
+  console.log(headSep);
+
+  for (const row of rows) {
+    const cells = row.map((cell, i) =>
+      alignRight.includes(i) ? padLeft(String(cell), colWidths[i]) : padRight(String(cell), colWidths[i])
+    );
+    console.log(` │ ${cells.join(' │ ')} │`);
+  }
+  console.log(botBorder);
+}
+
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch { return ''; }
+}
+
+// ─── Codex CLI ───────────────────────────────────────────
+
+function getCodexAccount() {
+  const authPath = resolve(HOME, '.codex/auth.json');
+  if (!existsSync(authPath)) return { email: null, sub: null };
+
+  try {
+    const auth = JSON.parse(readFileSync(authPath, 'utf-8'));
+    const token = auth.tokens?.access_token || '';
+    if (token.startsWith('eyJ')) {
+      const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+      return { email: payload.email || null, sub: payload.sub || null };
+    }
+    return { email: null, sub: null };
+  } catch { return { email: null, sub: null }; }
+}
+
+function getCodexPlan() {
+  // Get plan_type from the most recent rollout's token_count event
+  const sessionsDir = resolve(HOME, '.codex/sessions');
+  if (!existsSync(sessionsDir)) return null;
+
+  try {
+    // Find the most recent rollout file
+    const raw = safeExec(`find "${sessionsDir}" -name "rollout-*.jsonl" -type f | sort -r | head -1`);
+    if (!raw) return null;
+
+    const planLine = safeExec(`grep '"plan_type"' "${raw}" | tail -1`);
+    if (!planLine) return null;
+
+    const d = JSON.parse(planLine);
+    return d?.payload?.rate_limits?.plan_type || null;
+  } catch { return null; }
+}
+
+function getCodexSessions(limit = 3) {
+  const dbPath = resolve(HOME, '.codex/state_5.sqlite');
+  if (!existsSync(dbPath)) return [];
+
+  try {
+    const query = `SELECT id, replace(replace(substr(title,1,50),char(10),' '),char(13),' ') as title, tokens_used, model, datetime(created_at,'unixepoch','localtime') as created, datetime(updated_at,'unixepoch','localtime') as updated, cwd, rollout_path FROM threads WHERE archived=0 ORDER BY updated_at DESC LIMIT ${limit}`;
+
+    const raw = safeExec(`sqlite3 -json "${dbPath}" "${query}"`);
+    if (!raw) return [];
+
+    return JSON.parse(raw).map(r => ({
+      id: r.id,
+      title: (r.title || '').substring(0, 50),
+      tokens: r.tokens_used || 0,
+      model: r.model || 'unknown',
+      created: r.created || '',
+      updated: r.updated || '',
+      cwd: r.cwd || '',
+      rolloutPath: r.rollout_path || '',
+    }));
+  } catch { return []; }
+}
+
+function getCodexTokenBreakdown(rolloutPath) {
+  if (!rolloutPath || !existsSync(rolloutPath)) return null;
+
+  try {
+    // Get the last token_count event with info (has cumulative totals)
+    const raw = safeExec(`grep '"token_count"' "${rolloutPath}" | grep '"total_token_usage"' | tail -1`);
+    if (!raw) return null;
+
+    const d = JSON.parse(raw);
+    const usage = d?.payload?.info?.total_token_usage;
+    const limits = d?.payload?.rate_limits;
+    if (!usage) return null;
+
+    return {
+      input: usage.input_tokens || 0,
+      cached: usage.cached_input_tokens || 0,
+      output: usage.output_tokens || 0,
+      reasoning: usage.reasoning_output_tokens || 0,
+      total: usage.total_tokens || 0,
+      rateLimits: limits ? {
+        primaryUsed: limits.primary?.used_percent,
+        secondaryUsed: limits.secondary?.used_percent,
+        primaryResets: limits.primary?.resets_at,
+        secondaryResets: limits.secondary?.resets_at,
+      } : null,
+    };
+  } catch { return null; }
+}
+
+// ─── Cursor ──────────────────────────────────────────────
+
+function getCursorAccount() {
+  const dbPath = resolve(HOME, 'Library/Application Support/Cursor/User/globalStorage/state.vscdb');
+  if (!existsSync(dbPath)) return null;
+
+  try {
+    const email = safeExec(`sqlite3 "${dbPath}" "SELECT value FROM ItemTable WHERE key='cursorAuth/cachedEmail'"`);
+    const plan = safeExec(`sqlite3 "${dbPath}" "SELECT value FROM ItemTable WHERE key='cursorAuth/stripeMembershipType'"`);
+    if (!email) return null;
+    return { email, plan: plan || 'free' };
+  } catch { return null; }
+}
+
+// ─── Claude Code ─────────────────────────────────────────
+
+function getClaudeAccount() {
+  // Claude Code doesn't store email locally in an easily accessible way
+  const settingsPath = resolve(HOME, '.claude/settings.json');
+  if (!existsSync(settingsPath)) return null;
+  try {
+    const s = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    return s.email || null;
+  } catch { return null; }
+}
+
+function getClaudeStats(days = 7) {
+  const statsPath = resolve(HOME, '.claude/stats-cache.json');
+  if (!existsSync(statsPath)) return null;
+
+  try {
+    const data = JSON.parse(readFileSync(statsPath, 'utf-8'));
+    if (!data.dailyActivity?.length) return null;
+
+    const recent = data.dailyActivity.slice(-days).filter(d => d.messageCount > 0);
+    return {
+      days: recent,
+      total: recent.reduce((s, d) => ({
+        messages: s.messages + (d.messageCount || 0),
+        sessions: s.sessions + (d.sessionCount || 0),
+        toolCalls: s.toolCalls + (d.toolCallCount || 0),
+      }), { messages: 0, sessions: 0, toolCalls: 0 }),
+    };
+  } catch { return null; }
+}
+
+// ─── Antigravity / Gemini ────────────────────────────────
+
+function getAntigravityInfo() {
+  // Antigravity doesn't expose local usage data currently
+  return null;
+}
+
+// ─── Main ────────────────────────────────────────────────
+
+export async function usage() {
+  log.title('📊 AI Usage Report');
+  log.blank();
+
+  let hasAny = false;
+
+  // ═══ Codex CLI ═══
+  const codexAccount = getCodexAccount();
+  const codexPlan = getCodexPlan();
+  const codexSessions = getCodexSessions(3);
+
+  if (codexSessions.length > 0) {
+    hasAny = true;
+    const accountDisplay = codexAccount.email || codexAccount.sub || 'N/A';
+    console.log(`\x1b[36m  ◆ Codex CLI\x1b[0m`);
+    console.log(`    Account: ${accountDisplay}`);
+    if (codexPlan) console.log(`    Plan: ${codexPlan}`);
+    log.blank();
+
+    // Session overview table
+    const rows = codexSessions.map(s => {
+      const project = s.cwd.split('/').pop() || s.cwd;
+      const title = s.title.length > 36 ? s.title.substring(0, 33) + '...' : s.title;
+      return [title, s.model, formatTokens(s.tokens), project, s.updated.substring(0, 16)];
+    });
+
+    printTable(
+      ['Session', 'Model', 'Tokens', 'Project', 'Last Active'],
+      rows,
+      [36, 16, 10, 14, 16],
+      [2],
+    );
+
+    const totalTokens = codexSessions.reduce((sum, s) => sum + s.tokens, 0);
+    log.info(`  Total (${codexSessions.length} sessions): ${formatTokens(totalTokens)} tokens`);
+    log.blank();
+
+    // Token breakdown per session
+    for (const session of codexSessions) {
+      const breakdown = getCodexTokenBreakdown(session.rolloutPath);
+      if (!breakdown) continue;
+
+      const title = session.title.length > 50 ? session.title.substring(0, 47) + '...' : session.title;
+      console.log(`\x1b[2m    ┌ ${title}\x1b[0m`);
+
+      const bRows = [
+        ['Input', formatTokens(breakdown.input)],
+        ['  ↳ Cached', formatTokens(breakdown.cached)],
+        ['Output', formatTokens(breakdown.output)],
+        ['  ↳ Reasoning', formatTokens(breakdown.reasoning)],
+        ['Total', formatTokens(breakdown.total)],
+      ];
+      for (const [label, val] of bRows) {
+        console.log(`\x1b[2m    │ ${padRight(label, 16)} ${padLeft(val, 10)}\x1b[0m`);
+      }
+
+      if (breakdown.rateLimits) {
+        const rl = breakdown.rateLimits;
+        const resetPrimary = rl.primaryResets ? new Date(rl.primaryResets * 1000).toLocaleString() : 'N/A';
+        console.log(`\x1b[2m    │ Quota: ${rl.primaryUsed ?? '?'}% (5h) / ${rl.secondaryUsed ?? '?'}% (7d)  Resets: ${resetPrimary}\x1b[0m`);
+      }
+      console.log(`\x1b[2m    └──\x1b[0m`);
+    }
+    log.blank();
+  }
+
+  // ═══ Cursor ═══
+  const cursorAccount = getCursorAccount();
+  if (cursorAccount) {
+    hasAny = true;
+    console.log(`\x1b[33m  ◆ Cursor\x1b[0m`);
+    console.log(`    Account: ${cursorAccount.email}`);
+    console.log(`    Plan: ${cursorAccount.plan}`);
+    console.log(`\x1b[2m    Note: Cursor does not expose per-session token usage locally.\x1b[0m`);
+    console.log(`\x1b[2m    Check usage at: https://www.cursor.com/settings\x1b[0m`);
+    log.blank();
+  }
+
+  // ═══ Claude Code ═══
+  const claudeStats = getClaudeStats(7);
+  const claudeAccount = getClaudeAccount();
+
+  if (claudeStats) {
+    hasAny = true;
+    console.log(`\x1b[35m  ◆ Claude Code\x1b[0m`);
+    console.log(`    Account: ${claudeAccount || 'N/A (check ~/.claude/settings.json)'}`);
+    log.blank();
+
+    const rows = claudeStats.days.slice(-5).map(d => [
+      d.date, String(d.sessionCount), String(d.messageCount), String(d.toolCallCount),
+    ]);
+
+    if (rows.length > 0) {
+      printTable(
+        ['Date', 'Sessions', 'Messages', 'Tool Calls'],
+        rows,
+        [12, 10, 10, 12],
+        [1, 2, 3],
+      );
+    }
+
+    log.info(`  Total (7d): ${claudeStats.total.messages} msgs, ${claudeStats.total.toolCalls} tool calls, ${claudeStats.total.sessions} sessions`);
+    console.log(`\x1b[2m    Note: Claude Code tracks message/tool counts, not token counts locally.\x1b[0m`);
+    console.log(`\x1b[2m    Token-level billing: https://console.anthropic.com/settings/billing\x1b[0m`);
+    log.blank();
+  }
+
+  // ═══ Antigravity / Gemini ═══
+  const agInfo = getAntigravityInfo();
+  if (!agInfo) {
+    console.log(`\x1b[2m  ◆ Antigravity / Gemini: No local usage data available.\x1b[0m`);
+    console.log(`\x1b[2m    Check: https://console.cloud.google.com/billing\x1b[0m`);
+    log.blank();
+  }
+
+  // ═══ Codex CLI vs Client Shared Pool Note ═══
+  if (codexSessions.length > 0) {
+    log.blank();
+    console.log(`\x1b[2m  ℹ Codex CLI and the Codex VS Code extension share the same OpenAI account token pool.\x1b[0m`);
+    console.log(`\x1b[2m    Usage shown above is CLI-only. Combined usage: https://platform.openai.com/usage\x1b[0m`);
+  }
+
+  if (!hasAny) {
+    log.warn('No AI tool usage data found.');
+    log.info('Supported: Codex CLI, Cursor, Claude Code');
+  }
+}

package/src/utils/git.js

@@ -65,13 +65,37 @@ export function checkoutBranch(cwd, branch, baseBranch = 'main') {
   execSafe(`git checkout ${baseBranch}`, cwd);
   execSafe(`git pull origin ${baseBranch}`, cwd);
 
-  // Try to switch, create if not exists
+  // Try to switch to existing branch
   const result = execSafe(`git checkout ${branch}`, cwd);
   if (!result.ok) {
+    // Branch doesn't exist or checkout failed — clean up and create fresh
+    execSafe(`git branch -D ${branch}`, cwd); // Delete if exists but broken
     exec(`git checkout -b ${branch}`, cwd);
   }
 }
 
+/**
+ * Delete a branch (local + remote) and recreate fresh from base.
+ * Used when retrying blocked tasks to ensure a clean slate.
+ */
+export function resetBranch(cwd, branch, baseBranch = 'main') {
+  validateBranch(branch);
+  validateBranch(baseBranch);
+
+  // Switch to base first (can't delete current branch)
+  execSafe(`git checkout ${baseBranch}`, cwd);
+  execSafe(`git pull origin ${baseBranch}`, cwd);
+
+  // Delete local branch (force, ignore errors if doesn't exist)
+  execSafe(`git branch -D ${branch}`, cwd);
+
+  // Delete remote branch (ignore errors if doesn't exist)
+  execSafe(`git push origin --delete ${branch}`, cwd);
+
+  // Create fresh branch from base
+  exec(`git checkout -b ${branch}`, cwd);
+}
+
 /**
  * Commit all changes
  */
@@ -111,6 +135,6 @@ export function checkoutMain(cwd, baseBranch = 'main') {
 }
 
 export const git = {
-  isClean, currentBranch, getRepoInfo, checkoutBranch,
+  isClean, currentBranch, getRepoInfo, checkoutBranch, resetBranch,
   commitAll, pushBranch, checkoutMain, exec, execSafe,
 };

package/src/utils/github.js

@@ -306,14 +306,73 @@ export function isPrivateRepo(cwd) {
 }
 
 /**
- * Request bots to re-review the PR by posting a /review comment.
- * Triggers Gemini Code Assist and similar bots to run a fresh review.
+ * Request bots to re-review the PR.
+ * Auto-detects which review bots have previously commented on the PR
+ * and triggers only those. Falls back to all known bot triggers.
  */
 export function requestReReview(cwd, prNumber) {
+  // Known review bots and their re-review trigger commands
+  const REVIEW_BOTS = [
+    { login: 'gemini-code-assist', trigger: '/gemini review' },
+    { login: 'coderabbitai', trigger: '@coderabbitai review' },
+    { login: 'sourcery-ai', trigger: '@sourcery-ai review' },
+    { login: 'deepsource', trigger: '@deepsource review' },
+    { login: 'sweep-ai', trigger: 'sweep: review' },
+    { login: 'openai-codex', trigger: '@codex review' },
+    { login: 'claude', trigger: '@claude review' },
+    { login: 'copilot', trigger: '@copilot review' },
+  ];
+
   try {
     const num = validatePRNumber(prNumber);
-    gh(`pr comment ${num} --body "/review"`, cwd);
-    return true;
+
+    // Detect which bots have previously interacted with this PR
+    const reviews = getReviews(cwd, num);
+    const comments = getIssueComments(cwd, num);
+    const reviewComments = getReviewComments(cwd, num);
+
+    const allLogins = new Set();
+    for (const r of reviews) if (r.user?.login) allLogins.add(r.user.login);
+    for (const c of comments) if (c.user?.login) allLogins.add(c.user.login);
+    for (const c of reviewComments) if (c.user?.login) allLogins.add(c.user.login);
+
+    // Find matching bots that have been active on this PR
+    const activeBots = REVIEW_BOTS.filter(bot =>
+      [...allLogins].some(login => login.includes(bot.login))
+    );
+
+    // Determine which triggers to fire
+    const triggers = activeBots.length > 0
+      ? activeBots.filter(b => b.trigger).map(b => b.trigger)
+      : REVIEW_BOTS.filter(b => b.trigger).map(b => b.trigger).slice(0, 1); // fallback: try gemini
+
+    // Fire triggers as separate comments
+    let triggered = 0;
+    for (const trigger of triggers) {
+      try {
+        gh(`pr comment ${num} --body "${trigger}"`, cwd);
+        triggered++;
+      } catch { /* individual trigger failure is non-critical */ }
+    }
+
+    // Also try to request re-review from previous human reviewers via GitHub API
+    try {
+      const prReviews = ghJSON(`pr view ${num} --json reviews --jq '.reviews[].author.login'`, cwd);
+      if (prReviews && typeof prReviews === 'string') {
+        const logins = [...new Set(prReviews.trim().split('\n').filter(l => l && !l.includes('[bot]')))];
+        if (logins.length > 0) {
+          const owner = execSync('gh repo view --json owner --jq .owner.login', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+          const repo = execSync('gh repo view --json name --jq .name', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+          execSync(`gh api repos/${owner}/${repo}/pulls/${num}/requested_reviewers -f "reviewers[]=${logins[0]}" -X POST`, {
+            cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+          });
+        }
+      }
+    } catch {
+      // Non-critical: human re-review request failed
+    }
+
+    return triggered > 0;
   } catch {
     return false;
   }

package/src/utils/provider.js

@@ -225,7 +225,7 @@ async function executeCLI(prov, providerId, promptPath, cwd) {
     });
 
     let lastFile = '';
-    let statusText = 'Working...';
+    let statusText = command.substring(0, 80);
     let lineBuffer = '';
     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/;
 
@@ -234,7 +234,7 @@ async function executeCLI(prov, providerId, promptPath, cwd) {
     let spinIdx = 0;
     const spinTimer = setInterval(() => {
       const frame = SPINNER[spinIdx % SPINNER.length];
-      process.stdout.write(`\r\x1b[K  \x1b[36m${frame}\x1b[0m ${statusText}`);
+      process.stdout.write(`\r\x1b[K \x1b[36m${frame}\x1b[0m ${statusText}`);
       spinIdx++;
     }, 80);