dual-brain 0.1.0

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

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+/**
+ * dual-brain-review.mjs
+ *
+ * Sends git diffs to GPT for independent code review using the Codex CLI
+ * (uses your ChatGPT subscription — no API key needed).
+ *
+ * Falls back to direct OpenAI API if OPENAI_API_KEY is set.
+ * Falls back to "no GPT available" if neither works.
+ *
+ * Usage:  node .claude/hooks/dual-brain-review.mjs
+ * Output: JSON to stdout — always valid, never crashes.
+ */
+
+import { spawnSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const IS_REPLIT = !!(process.env.REPL_ID || process.env.REPL_SLUG);
+const SANDBOX = IS_REPLIT ? 'danger-full-access' : 'read-only';
+
+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
+4. Quality — naming, structure, unnecessary complexity
+
+Required output:
+- Findings only, ordered by severity
+- File/line references when possible
+- Whether tests cover the changed behavior
+- Whether the change follows existing repo patterns
+- Whether any issue should block merge
+
+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 {
+    const content = readFileSync(rulesFile, 'utf8').trim();
+    if (!content) return '';
+    return '\n\nAlso enforce these project-specific rules:\n' + content;
+  } catch {
+    return '';
+  }
+}
+
+const MAX_DIFF_CHARS = 15000;
+const MIN_DIFF_LINES = 5;
+const CODEX_TIMEOUT = 90;
+
+function findCodex() {
+  const candidates = [
+    process.env.CODEX_BIN,
+  ].filter(Boolean);
+  for (const c of candidates) {
+    try { spawnSync(c, ['--version'], { stdio: 'pipe', timeout: 3000 }); return c; } catch {}
+  }
+  try {
+    const which = spawnSync('which', ['codex'], { encoding: 'utf8', stdio: 'pipe', timeout: 3000 });
+    if (which.status === 0 && which.stdout.trim()) return which.stdout.trim();
+  } catch {}
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const fallbacks = [
+    join(home, '.local', 'bin', 'codex'),
+    join(home, 'bin', 'codex'),
+    '/usr/local/bin/codex',
+  ];
+  for (const p of fallbacks) {
+    try { spawnSync(p, ['--version'], { stdio: 'pipe', timeout: 3000 }); return p; } catch {}
+  }
+  return null;
+}
+
+const CODEX_BIN = findCodex();
+
+function runGit(args) {
+  try {
+    const proc = spawnSync('git', args, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10_000,
+    });
+    return proc.status === 0 ? proc.stdout : null;
+  } catch { return null; }
+}
+
+function isCodexAuthenticated(result) {
+  const out = ((result?.stdout || '') + (result?.stderr || '')).toLowerCase();
+  if (/\b(not\s+logged\s+in|unauthenticated|logged\s+out|no\s+auth)\b/.test(out)) return false;
+  return result?.status === 0 ||
+    /\b(logged\s+in|authenticated|signed\s+in)\b/.test(out);
+}
+
+function countLines(str) {
+  return (str || '').split('\n').filter(l => l.trim().length > 0).length;
+}
+
+function getThinkModel() {
+  try {
+    const config = JSON.parse(readFileSync(resolve(__dirname, '..', 'orchestrator.json'), 'utf8'));
+    const models = config?.subscriptions?.openai?.models ?? {};
+    for (const [name, info] of Object.entries(models)) {
+      if (info?.tier === 'think') return name;
+    }
+  } catch {}
+  return 'gpt-5.5';
+}
+
+function hasIssues(text) {
+  const lower = text.toLowerCase();
+
+  // Check for concrete issue indicators first
+  const issuePatterns = [
+    /\b(bug|crash|vulnerability|incorrect|broken|dangerous|unsafe|injection|leak)\b/i,
+    /\bshould\s+(fix|change|update|remove|replace|refactor)\b/i,
+    /\bmust\s+(fix|change|update|remove|replace|refactor)\b/i,
+    /\b(will\s+break|could\s+break|might\s+break|can\s+crash|could\s+crash)\b/i,
+    /\b(missing\s+(check|validation|guard|null|error|handling))\b/i,
+    /\b(race\s+condition|deadlock|overflow|underflow|out\s+of\s+bounds)\b/i,
+  ];
+  const hasIssueIndicators = issuePatterns.some(p => p.test(text));
+
+  // If concrete issues found, always flag — even if "LGTM" also appears
+  if (hasIssueIndicators) return true;
+
+  // No concrete issues — check if review explicitly says it's clean
+  const good = ['lgtm', 'looks good', 'no issues', 'no problems', 'no concerns', 'all good', 'clean', 'approved', 'ship it', 'ready to merge', 'good to go', 'looks fine', 'no blockers'];
+  if (good.some(g => lower.includes(g))) return false;
+
+  // Ambiguous — default to flagging for human review
+  return true;
+}
+
+function exit(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+  process.exit(0);
+}
+
+/**
+ * Try GPT review via Codex CLI (uses ChatGPT subscription auth).
+ * Round 1: independent review. Round 2: respond to Claude's review.
+ */
+function tryCodexReview(diff, { round = 1, claudeReview = null } = {}) {
+  if (!CODEX_BIN) return null;
+  const login = spawnSync(CODEX_BIN, ['login', 'status'], {
+    encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000,
+  });
+  if (!isCodexAuthenticated(login)) {
+    return null;
+  }
+
+  try {
+    const model = getThinkModel();
+    const truncated = diff.length > MAX_DIFF_CHARS
+      ? diff.slice(0, MAX_DIFF_CHARS) + '\n[truncated]'
+      : diff;
+
+    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}"`,
+      '-s', SANDBOX,
+      fullPrompt,
+    ], {
+      input: truncated,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: CODEX_TIMEOUT * 1000,
+    });
+    const result = proc.stdout || '';
+
+    const messages = result
+      .split('\n')
+      .filter(l => l.trim())
+      .map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(Boolean);
+
+    const agentMessages = messages
+      .filter(m => m.type === 'item.completed' && m.item?.type === 'agent_message')
+      .map(m => m.item.text);
+
+    const usage = messages.find(m => m.type === 'turn.completed')?.usage;
+
+    if (agentMessages.length > 0) {
+      const reviewText = agentMessages.join('\n\n');
+      return {
+        round,
+        review: reviewText,
+        model,
+        auth_type: 'codex_subscription',
+        issues_found: hasIssues(reviewText),
+        tokens: usage || null,
+      };
+    }
+
+    const errors = messages.filter(m => m.type === 'error' || m.type === 'turn.failed');
+    if (errors.length > 0) {
+      return {
+        review: `Codex error: ${errors[0].message || errors[0].error?.message || 'unknown'}`,
+        error: true,
+        auth_type: 'codex_subscription',
+      };
+    }
+
+    return null;
+  } catch (err) {
+    return {
+      review: `Codex exec failed: ${err.message?.slice(0, 200) || 'unknown error'}`,
+      error: true,
+      auth_type: 'codex_subscription',
+    };
+  }
+}
+
+/**
+ * Try GPT review via direct API call (needs OPENAI_API_KEY).
+ */
+async function tryApiReview(diff, { round = 1, claudeReview = null } = {}) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) return null;
+
+  const model = getThinkModel();
+  const truncated = diff.length > MAX_DIFF_CHARS
+    ? diff.slice(0, MAX_DIFF_CHARS) + '\n[truncated]'
+    : diff;
+
+  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);
+
+  try {
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      signal: controller.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: 'system', content: fullPrompt },
+          { role: 'user', content: `Review this diff:\n\n\`\`\`diff\n${truncated}\n\`\`\`` },
+        ],
+        temperature: 0,
+        max_tokens: 1000,
+      }),
+    });
+
+    clearTimeout(timer);
+    if (!response.ok) return null;
+
+    const data = await response.json();
+    const text = data?.choices?.[0]?.message?.content ?? '';
+    if (!text) return null;
+
+    return {
+      round,
+      review: text,
+      model,
+      auth_type: 'api_key',
+      issues_found: hasIssues(text),
+    };
+  } catch {
+    clearTimeout(timer);
+    return null;
+  }
+}
+
+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(['diff', '--staged']) || '';
+  if (countLines(diff) < MIN_DIFF_LINES) {
+    const headDiff = runGit(['diff', 'HEAD']) || '';
+    if (countLines(headDiff) > countLines(diff)) diff = headDiff;
+  }
+
+  try {
+    const untracked = runGit(['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)) {
+      const content = runGit(['diff', '--no-index', '/dev/null', f]);
+      if (content) diff += '\n' + content;
+    }
+  } catch {}
+
+  if (countLines(diff) < MIN_DIFF_LINES) {
+    exit({ review: 'No significant changes to review' });
+  }
+
+  // 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, 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({
+    review: 'No GPT review available. Install Codex CLI and login with your ChatGPT subscription, or set OPENAI_API_KEY.',
+    skip_reason: 'no_gpt_auth',
+  });
+}
+
+main().catch(err => {
+  process.stdout.write(
+    JSON.stringify({ review: `Unexpected error: ${err?.message ?? String(err)}`, error: true }) + '\n'
+  );
+  process.exit(0);
+});