dual-brain 3.1.0 → 3.3.0

package/hooks/cost-logger.mjs

@@ -12,19 +12,25 @@ import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
-// ---------------------------------------------------------------------------
-// Paths
-// ---------------------------------------------------------------------------
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROFILE_FILE = join(__dirname, '..', 'dual-brain.profile.json');
 
 function usageFile(date) {
   const d = date || new Date().toISOString().slice(0, 10);
   return join(__dirname, `usage-${d}.jsonl`);
 }
 
-// Ensure the hooks dir exists (idempotent, defensive)
 mkdirSync(__dirname, { recursive: true });
 
+function loadActiveProfile() {
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    return data.active || 'balanced';
+  } catch { return 'balanced'; }
+}
+
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || process.ppid?.toString() || null;
+
 // ---------------------------------------------------------------------------
 // Tier classification
 // ---------------------------------------------------------------------------
@@ -135,14 +141,21 @@ function classify(toolName, toolInput = {}, agentModel = null) {
 // Budget alerts
 // ---------------------------------------------------------------------------
 
-function checkBudget() {
+async function checkBudget() {
   let config;
   try {
     config = JSON.parse(readFileSync(join(__dirname, '..', 'orchestrator.json'), 'utf8'));
   } catch { return null; }
 
-  const budgets = config.budgets;
+  // Merge profile budget overrides on top of config defaults
+  let budgets = config.budgets;
   if (!budgets) return null;
+  try {
+    const profileData = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    if (profileData.custom_overrides?.budgets) {
+      budgets = { ...budgets, ...profileData.custom_overrides.budgets };
+    }
+  } catch {}
 
   // Rate limit alerts
   const cooldownFile = join(__dirname, '.budget-alerted');
@@ -152,18 +165,24 @@ function checkBudget() {
     if (Date.now() - Date.parse(lastAlert) < cooldownMin * 60 * 1000) return null;
   } catch {}
 
-  // Calculate today's estimated cost
-  const todayFile = usageFile();
-  let records = [];
+  // Use summary checkpoint for fast budget check (O(1) instead of full scan)
+  let totalCost = 0;
   try {
-    records = readFileSync(todayFile, 'utf8').split('\n').filter(Boolean).map(l => {
-      try { return JSON.parse(l); } catch { return null; }
-    }).filter(Boolean);
-  } catch { return null; }
-
-  // Simple cost estimate using tier heuristics
-  const RATES = { search: 0.003, execute: 0.012, think: 0.055 };
-  const totalCost = records.reduce((sum, r) => sum + (RATES[r.tier] || RATES.execute), 0);
+    const { readSummary } = await import('./summary-checkpoint.mjs');
+    const summary = readSummary();
+    totalCost = summary.totals.cost_estimate;
+  } catch {
+    // Fallback: scan the log (only if summary unavailable)
+    const todayFile = usageFile();
+    let records = [];
+    try {
+      records = readFileSync(todayFile, 'utf8').split('\n').filter(Boolean).map(l => {
+        try { return JSON.parse(l); } catch { return null; }
+      }).filter(Boolean);
+    } catch { return null; }
+    const RATES = { search: 0.003, execute: 0.012, think: 0.055 };
+    totalCost = records.reduce((sum, r) => sum + (RATES[r.tier] || RATES.execute), 0);
+  }
 
   let msg = null;
   if (budgets.daily_limit_usd && totalCost >= budgets.daily_limit_usd) {
@@ -215,8 +234,8 @@ async function main() {
 
   const status = (payload?.error || payload?.tool_response?.error || payload?.is_error) ? 'error' : 'ok';
 
-  const entry = JSON.stringify({
-    schema_version: 2,
+  const entryObj = {
+    schema_version: 3,
     timestamp: new Date().toISOString(),
     tier,
     tool: toolName,
@@ -224,19 +243,25 @@ async function main() {
     provider: detectProvider(model),
     dispatcher: 'claude-code',
     status,
-    session_id: process.env.CLAUDE_SESSION_ID || null,
+    session_id: SESSION_ID,
+    profile: loadActiveProfile(),
     input_tokens: inputTokens,
     output_tokens: outputTokens,
-  });
+  };
+
+  const entry = JSON.stringify(entryObj);
 
   try {
     appendFileSync(usageFile(), entry + "\n", { encoding: "utf8", flag: "a" });
-  } catch {
-    // Disk write failed — silently ignore so the hook never blocks the IDE
-  }
+  } catch {}
+
+  // Update summary checkpoint (non-blocking, best-effort)
+  try {
+    const { updateSummary } = await import('./summary-checkpoint.mjs');
+    updateSummary(entryObj);
+  } catch {}
 
-  // Check budget thresholds and emit a systemMessage if over limit
-  const budgetMsg = checkBudget();
+  const budgetMsg = await checkBudget();
 
   // PostToolUse hooks must emit a JSON object to stdout
   if (budgetMsg) {

package/hooks/decision-ledger.mjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+/**
+ * decision-ledger.mjs — Routing outcome tracking for the Dual-Brain Orchestrator.
+ *
+ * Records every routing decision with its context, and later enriches it with
+ * outcome data (duration, success, retries, user overrides, follow-up fixes).
+ *
+ * Over time, this builds a per-repo knowledge base of which provider/model
+ * performs best for which task shapes.
+ *
+ * Exported API:
+ *   recordDecision(decision)     → log a routing decision, returns decision_id
+ *   recordOutcome(id, outcome)   → enrich a decision with its outcome
+ *   getInsights(opts?)           → aggregate patterns from the ledger
+ *
+ * CLI:
+ *   node .claude/hooks/decision-ledger.mjs                # show insights
+ *   node .claude/hooks/decision-ledger.mjs --json         # JSON output
+ *   node .claude/hooks/decision-ledger.mjs --recent 20    # last N decisions
+ */
+
+import { appendFileSync, existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { randomBytes } from 'crypto';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LEDGER_FILE = join(__dirname, 'decision-ledger.jsonl');
+
+function genId() {
+  return randomBytes(6).toString('hex');
+}
+
+function recordDecision(decision = {}) {
+  const id = genId();
+  const entry = JSON.stringify({
+    type: 'decision',
+    id,
+    timestamp: new Date().toISOString(),
+    session_id: decision.session_id || process.env.CLAUDE_SESSION_ID || process.ppid?.toString() || null,
+    profile: decision.profile || 'balanced',
+
+    // Routing context
+    tier: decision.tier || 'execute',
+    provider: decision.provider || 'claude',
+    model: decision.model || 'unknown',
+    recommended_model: decision.recommended_model || null,
+    followed: decision.followed ?? null,
+
+    // Task shape
+    task_type: decision.task_type || null,
+    prompt_hash: decision.prompt_hash || null,
+    estimated_duration_ms: decision.estimated_duration_ms || null,
+    file_count: decision.file_count || null,
+    context_coupling: decision.context_coupling || null,
+    isolation: decision.isolation || null,
+
+    // Provider state at decision time
+    claude_pressure: decision.claude_pressure || null,
+    openai_pressure: decision.openai_pressure || null,
+  });
+
+  try {
+    appendFileSync(LEDGER_FILE, entry + '\n');
+  } catch {}
+
+  return id;
+}
+
+function recordOutcome(decisionId, outcome = {}) {
+  const entry = JSON.stringify({
+    type: 'outcome',
+    decision_id: decisionId,
+    timestamp: new Date().toISOString(),
+
+    // Timing
+    actual_duration_ms: outcome.actual_duration_ms || null,
+    codex_startup_ms: outcome.codex_startup_ms || null,
+
+    // Quality signals
+    success: outcome.success ?? null,
+    tests_passed: outcome.tests_passed ?? null,
+    tests_failed: outcome.tests_failed ?? null,
+    retries: outcome.retries || 0,
+    user_override: outcome.user_override ?? false,
+    followup_fix_needed: outcome.followup_fix_needed ?? false,
+
+    // Cost
+    actual_input_tokens: outcome.actual_input_tokens || null,
+    actual_output_tokens: outcome.actual_output_tokens || null,
+    estimated_cost_usd: outcome.estimated_cost_usd || null,
+
+    // Files
+    files_changed: outcome.files_changed || null,
+    files_read: outcome.files_read || null,
+  });
+
+  try {
+    appendFileSync(LEDGER_FILE, entry + '\n');
+  } catch {}
+}
+
+function loadLedger() {
+  if (!existsSync(LEDGER_FILE)) return { decisions: [], outcomes: [] };
+
+  let raw;
+  try { raw = readFileSync(LEDGER_FILE, 'utf8'); } catch { return { decisions: [], outcomes: [] }; }
+
+  const decisions = [];
+  const outcomes = [];
+
+  for (const line of raw.split('\n').filter(Boolean)) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === 'decision') decisions.push(entry);
+      else if (entry.type === 'outcome') outcomes.push(entry);
+    } catch {}
+  }
+
+  return { decisions, outcomes };
+}
+
+function mergeDecisionsWithOutcomes(decisions, outcomes) {
+  const outcomeMap = {};
+  for (const o of outcomes) {
+    outcomeMap[o.decision_id] = o;
+  }
+  return decisions.map(d => ({
+    ...d,
+    outcome: outcomeMap[d.id] || null,
+  }));
+}
+
+function getInsights(opts = {}) {
+  const { decisions, outcomes } = loadLedger();
+  const merged = mergeDecisionsWithOutcomes(decisions, outcomes);
+  const withOutcomes = merged.filter(d => d.outcome);
+
+  // Provider win rates
+  const providerStats = {};
+  for (const d of withOutcomes) {
+    const key = d.provider;
+    if (!providerStats[key]) providerStats[key] = { total: 0, success: 0, overrides: 0, followups: 0, totalDuration: 0, counted: 0 };
+    providerStats[key].total++;
+    if (d.outcome.success) providerStats[key].success++;
+    if (d.outcome.user_override) providerStats[key].overrides++;
+    if (d.outcome.followup_fix_needed) providerStats[key].followups++;
+    if (d.outcome.actual_duration_ms) {
+      providerStats[key].totalDuration += d.outcome.actual_duration_ms;
+      providerStats[key].counted++;
+    }
+  }
+
+  // Tier performance
+  const tierStats = {};
+  for (const d of withOutcomes) {
+    const key = `${d.provider}:${d.tier}`;
+    if (!tierStats[key]) tierStats[key] = { total: 0, success: 0, avgDuration: 0, counted: 0 };
+    tierStats[key].total++;
+    if (d.outcome.success) tierStats[key].success++;
+    if (d.outcome.actual_duration_ms) {
+      tierStats[key].counted++;
+      tierStats[key].avgDuration += (d.outcome.actual_duration_ms - tierStats[key].avgDuration) / tierStats[key].counted;
+    }
+  }
+
+  // Task type patterns
+  const taskPatterns = {};
+  for (const d of withOutcomes) {
+    if (!d.task_type) continue;
+    const key = d.task_type;
+    if (!taskPatterns[key]) taskPatterns[key] = {};
+    const pk = d.provider;
+    if (!taskPatterns[key][pk]) taskPatterns[key][pk] = { total: 0, success: 0 };
+    taskPatterns[key][pk].total++;
+    if (d.outcome.success) taskPatterns[key][pk].success++;
+  }
+
+  // Compliance rate
+  const total = decisions.length;
+  const followedCount = decisions.filter(d => d.followed === true).length;
+  const compliance = total > 0 ? Math.round((followedCount / total) * 100) : 0;
+
+  // Recommendations
+  const recommendations = [];
+  for (const [task, providers] of Object.entries(taskPatterns)) {
+    const sorted = Object.entries(providers)
+      .map(([p, s]) => ({ provider: p, rate: s.total > 0 ? s.success / s.total : 0, total: s.total }))
+      .filter(x => x.total >= 3)
+      .sort((a, b) => b.rate - a.rate);
+    if (sorted.length >= 2 && sorted[0].rate > sorted[1].rate + 0.1) {
+      recommendations.push(`${sorted[0].provider} wins ${task} tasks (${Math.round(sorted[0].rate * 100)}% vs ${Math.round(sorted[1].rate * 100)}%)`);
+    }
+  }
+
+  return {
+    total_decisions: total,
+    with_outcomes: withOutcomes.length,
+    compliance_rate: compliance,
+    provider_stats: providerStats,
+    tier_stats: tierStats,
+    task_patterns: taskPatterns,
+    recommendations,
+  };
+}
+
+// ─── CLI ────────────────────────────────────────────────────────────────────
+
+function printInsights() {
+  const insights = getInsights();
+
+  if (insights.total_decisions === 0) {
+    console.log('');
+    console.log('  No routing decisions recorded yet.');
+    console.log('  The decision ledger builds over time as you use Claude Code.');
+    console.log('');
+    return;
+  }
+
+  const W = 52;
+  const pad = (s, len = W - 2) => {
+    s = String(s);
+    return s.length >= len ? s.slice(0, len) : s + ' '.repeat(len - s.length);
+  };
+  const ln = (s) => `║ ${pad(s)} ║`;
+  const br = (l, r) => l + '═'.repeat(W) + r;
+  const sep = () => '╠' + '═'.repeat(W) + '╣';
+
+  const lines = [];
+  lines.push(br('╔', '╗'));
+  lines.push(ln('Decision Ledger Insights'));
+  lines.push(sep());
+  lines.push(ln(`Total decisions:  ${insights.total_decisions}`));
+  lines.push(ln(`With outcomes:    ${insights.with_outcomes}`));
+  lines.push(ln(`Compliance rate:  ${insights.compliance_rate}%`));
+  lines.push(sep());
+
+  // Provider stats
+  lines.push(ln('Provider Performance'));
+  for (const [provider, stats] of Object.entries(insights.provider_stats)) {
+    const rate = stats.total > 0 ? Math.round((stats.success / stats.total) * 100) : 0;
+    const avgMs = stats.counted > 0 ? Math.round(stats.totalDuration / stats.counted / 1000) : '?';
+    lines.push(ln(`  ${provider}: ${rate}% success, ${stats.overrides} overrides, avg ${avgMs}s`));
+    if (stats.followups > 0) {
+      lines.push(ln(`    ${stats.followups} follow-up fixes needed`));
+    }
+  }
+
+  // Recommendations
+  if (insights.recommendations.length > 0) {
+    lines.push(sep());
+    lines.push(ln('Recommendations'));
+    for (const rec of insights.recommendations) {
+      lines.push(ln(`  ${rec}`));
+    }
+  }
+
+  lines.push(br('╚', '╝'));
+  console.log('');
+  for (const l of lines) console.log(`  ${l}`);
+  console.log('');
+}
+
+function printRecent(n) {
+  const { decisions, outcomes } = loadLedger();
+  const merged = mergeDecisionsWithOutcomes(decisions, outcomes);
+  const recent = merged.slice(-n);
+
+  if (recent.length === 0) {
+    console.log('  No decisions recorded yet.');
+    return;
+  }
+
+  console.log('');
+  for (const d of recent) {
+    const time = d.timestamp?.slice(11, 19) || '??:??:??';
+    const status = d.outcome?.success ? '✓' : d.outcome ? '✗' : '?';
+    const dur = d.outcome?.actual_duration_ms ? `${Math.round(d.outcome.actual_duration_ms / 1000)}s` : '';
+    console.log(`  ${status} ${time} ${d.provider}/${d.model} [${d.tier}] ${dur}`);
+  }
+  console.log('');
+}
+
+// CLI entry
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(getInsights(), null, 2));
+  } else if (args.includes('--recent')) {
+    const idx = args.indexOf('--recent');
+    const n = parseInt(args[idx + 1]) || 20;
+    printRecent(n);
+  } else {
+    printInsights();
+  }
+}
+
+export { recordDecision, recordOutcome, getInsights, loadLedger };

package/hooks/dual-brain-review.mjs

@@ -19,7 +19,11 @@ import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-const REVIEW_PROMPT = `Review the current uncommitted changes in this repo for:
+const REVIEW_PROMPT_R1 = `You are GPT-5.5 performing Round 1 of a dual-brain code review.
+Claude (Opus) will independently review the same changes, then send you their findings
+for a collaborative Round 2 discussion.
+
+Review the current uncommitted changes for:
 1. Correctness — logic errors, off-by-one, null/undefined risks
 2. Security — injection, auth bypass, data exposure
 3. Edge cases — what could break under unusual input
@@ -34,6 +38,24 @@ Required output:
 
 Be concise. Flag only real issues, not style preferences. If the code looks good, say "LGTM" and note any minor suggestions. Output your review as plain text, not JSON.`;
 
+const REVIEW_PROMPT_R2 = `You are GPT-5.5 in Round 2 of a collaborative code review with Claude (Opus).
+You already reviewed this diff in Round 1. Claude has now independently reviewed the same changes.
+This is a professional peer review dialogue — two senior engineers refining their assessment together.
+
+Claude's review findings:
+---CLAUDE_REVIEW---
+
+Now respond as a peer reviewer:
+1. CONFIRMED: Issues you both found — these are high-confidence findings
+2. MISSED: Issues Claude caught that you missed — acknowledge them
+3. DISAGREE: Claude's findings you think are false positives — explain why
+4. ESCALATED: Issues that are MORE severe than either of you initially rated
+5. VERDICT: Combined assessment — LGTM, minor issues, or blocks merge
+
+Be direct. If Claude found something real that you missed, say so.
+If Claude flagged something that isn't actually a problem, explain why with evidence.
+The goal is the most accurate review, not defending your initial take.`;
+
 function loadReviewRules() {
   const rulesFile = resolve(__dirname, '..', 'review-rules.md');
   try {
@@ -127,9 +149,9 @@ function exit(obj) {
 
 /**
  * Try GPT review via Codex CLI (uses ChatGPT subscription auth).
- * Returns review text or null if codex isn't available.
+ * Round 1: independent review. Round 2: respond to Claude's review.
  */
-function tryCodexReview(diff) {
+function tryCodexReview(diff, { round = 1, claudeReview = null } = {}) {
   if (!CODEX_BIN) return null;
   try {
     spawnSync(CODEX_BIN, ['login', 'status'], {
@@ -145,7 +167,14 @@ function tryCodexReview(diff) {
       ? diff.slice(0, MAX_DIFF_CHARS) + '\n[truncated]'
       : diff;
 
-    const fullPrompt = REVIEW_PROMPT + loadReviewRules();
+    let basePrompt;
+    if (round === 2 && claudeReview) {
+      basePrompt = REVIEW_PROMPT_R2.replace('---CLAUDE_REVIEW---', claudeReview);
+    } else {
+      basePrompt = REVIEW_PROMPT_R1;
+    }
+    const fullPrompt = basePrompt + loadReviewRules();
+
     const proc = spawnSync(CODEX_BIN, [
       'exec', '--json', '--ephemeral',
       '-c', `model="${model}"`,
@@ -159,7 +188,6 @@ function tryCodexReview(diff) {
     });
     const result = proc.stdout || '';
 
-    // Parse JSONL output, find agent_message items
     const messages = result
       .split('\n')
       .filter(l => l.trim())
@@ -173,16 +201,17 @@ function tryCodexReview(diff) {
     const usage = messages.find(m => m.type === 'turn.completed')?.usage;
 
     if (agentMessages.length > 0) {
+      const reviewText = agentMessages.join('\n\n');
       return {
-        review: agentMessages.join('\n\n'),
+        round,
+        review: reviewText,
         model,
         auth_type: 'codex_subscription',
-        issues_found: hasIssues(agentMessages.join(' ')),
+        issues_found: hasIssues(reviewText),
         tokens: usage || null,
       };
     }
 
-    // Check for errors
     const errors = messages.filter(m => m.type === 'error' || m.type === 'turn.failed');
     if (errors.length > 0) {
       return {
@@ -205,7 +234,7 @@ function tryCodexReview(diff) {
 /**
  * Try GPT review via direct API call (needs OPENAI_API_KEY).
  */
-async function tryApiReview(diff) {
+async function tryApiReview(diff, { round = 1, claudeReview = null } = {}) {
   const apiKey = process.env.OPENAI_API_KEY;
   if (!apiKey) return null;
 
@@ -214,7 +243,14 @@ async function tryApiReview(diff) {
     ? diff.slice(0, MAX_DIFF_CHARS) + '\n[truncated]'
     : diff;
 
-  const fullPrompt = REVIEW_PROMPT + loadReviewRules();
+  let basePrompt;
+  if (round === 2 && claudeReview) {
+    basePrompt = REVIEW_PROMPT_R2.replace('---CLAUDE_REVIEW---', claudeReview);
+  } else {
+    basePrompt = REVIEW_PROMPT_R1;
+  }
+  const fullPrompt = basePrompt + loadReviewRules();
+
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 30_000);
 
@@ -245,6 +281,7 @@ async function tryApiReview(diff) {
     if (!text) return null;
 
     return {
+      round,
       review: text,
       model,
       auth_type: 'api_key',
@@ -256,7 +293,37 @@ async function tryApiReview(diff) {
   }
 }
 
+function parseArgs(argv) {
+  const args = {};
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx !== -1) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('--')) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = true;
+        }
+      }
+    }
+    i++;
+  }
+  return args;
+}
+
 async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const round = args.round ? parseInt(args.round, 10) : 1;
+  const claudeReview = args['claude-review'] || null;
+  const opts = { round, claudeReview };
+
   // 1. Get diff
   let diff = runGit('git diff --staged') || '';
   if (countLines(diff) < MIN_DIFF_LINES) {
@@ -264,12 +331,11 @@ async function main() {
     if (countLines(headDiff) > countLines(diff)) diff = headDiff;
   }
 
-  // Also gather content of untracked source files
   try {
     const untracked = runGit('git ls-files --others --exclude-standard') || '';
     const sourceExts = /\.(ts|tsx|js|jsx|py|rs|go|java|rb|swift|kt|mjs|cjs)$/;
     const untrackedSrc = untracked.split('\n').filter(f => f && sourceExts.test(f));
-    for (const f of untrackedSrc.slice(0, 10)) { // cap at 10 files
+    for (const f of untrackedSrc.slice(0, 10)) {
       const content = runGit(`git diff --no-index /dev/null "${f}"`);
       if (content) diff += '\n' + content;
     }
@@ -279,13 +345,36 @@ async function main() {
     exit({ review: 'No significant changes to review' });
   }
 
-  // 2. Try Codex CLI first (uses ChatGPT subscription)
-  const codexResult = tryCodexReview(diff);
-  if (codexResult) exit(codexResult);
+  // 2. Try Codex CLI first
+  const codexResult = tryCodexReview(diff, opts);
+  if (codexResult) {
+    if (round === 1) {
+      codexResult.instructions = `Round 1 complete. Now:
+1. Provide YOUR independent code review of the same changes
+2. Then call Round 2 to send your findings back to GPT:
+   node .claude/hooks/dual-brain-review.mjs --round 2 --claude-review "<your findings>"
+3. GPT will respond — confirming shared findings, acknowledging misses, and pushing back on false positives
+4. You then synthesize both rounds into the final review verdict`;
+    } else {
+      codexResult.instructions = `GPT has responded to your review. Synthesize into a FINAL REVIEW:
+- CONFIRMED findings (both found) → high confidence, must fix
+- GPT-only findings you agree with → add to your list
+- Your findings GPT disputed → re-evaluate honestly
+- Final verdict: LGTM, minor issues, or blocks merge`;
+    }
+    exit(codexResult);
+  }
 
   // 3. Try direct API
-  const apiResult = await tryApiReview(diff);
-  if (apiResult) exit(apiResult);
+  const apiResult = await tryApiReview(diff, opts);
+  if (apiResult) {
+    if (round === 1) {
+      apiResult.instructions = `Round 1 complete. Provide YOUR independent review, then call Round 2 with --round 2 --claude-review "<findings>"`;
+    } else {
+      apiResult.instructions = `Synthesize both rounds into a final review verdict.`;
+    }
+    exit(apiResult);
+  }
 
   // 4. No GPT available
   exit({