dual-brain 3.1.0 → 3.3.0

package/hooks/dual-brain-think.mjs

@@ -60,8 +60,33 @@ function findCodex() {
 // Prompt builder
 // ---------------------------------------------------------------------------
 
-function buildGptPrompt({ question, context, files }) {
+function buildGptPrompt({ question, context, files, round, claudePerspective }) {
+  if (round === 2 && claudePerspective) {
+    return `You are GPT-5.5 in a collaborative architectural discussion with Claude (Opus).
+You gave your initial analysis on a question. Claude has now provided its independent perspective.
+This is a professional dialogue — two experts refining a decision together.
+
+Original question: ${question}
+${context ? `\nContext: ${context}` : ''}
+
+Claude's perspective:
+${claudePerspective}
+
+Now respond as a colleague, not a critic. Structure your response:
+1. AGREEMENTS: Where Claude's analysis strengthens or confirms your thinking
+2. PUSHBACK: Where you disagree — be specific about WHY with evidence or reasoning
+3. NEW INSIGHTS: Anything Claude's perspective surfaced that you missed
+4. REFINED RECOMMENDATION: Your updated recommendation incorporating both perspectives
+5. REMAINING CONCERNS: Open questions neither of you fully resolved
+6. CONFIDENCE DELTA: Has your confidence changed? Why?
+
+Be direct and substantive. If Claude is right about something you got wrong, say so.
+If you still disagree after considering their points, explain what specific evidence would change your mind.`;
+  }
+
   return `You are GPT-5.5, providing an independent architectural perspective.
+This is Round 1 of a dual-brain analysis — Claude (Opus) will independently analyze the same question,
+then send you their perspective for a collaborative discussion in Round 2.
 
 Question: ${question}
 ${context ? `\nContext: ${context}` : ''}
@@ -165,7 +190,7 @@ function logUsage({ durationMs, usage, success }) {
 // Core exported function
 // ---------------------------------------------------------------------------
 
-export async function dualThink({ question, context, files } = {}) {
+export async function dualThink({ question, context, files, round, claudePerspective } = {}) {
   if (!question) {
     return {
       gpt: null,
@@ -174,6 +199,8 @@ export async function dualThink({ question, context, files } = {}) {
     };
   }
 
+  const effectiveRound = (round === 2 && claudePerspective) ? 2 : 1;
+
   const codexBin = findCodex();
   if (!codexBin) {
     return {
@@ -183,7 +210,6 @@ export async function dualThink({ question, context, files } = {}) {
     };
   }
 
-  // Check Codex auth before running
   try {
     execSync(`${codexBin} login status`, {
       encoding: 'utf8',
@@ -198,7 +224,7 @@ export async function dualThink({ question, context, files } = {}) {
     };
   }
 
-  const prompt = buildGptPrompt({ question, context, files });
+  const prompt = buildGptPrompt({ question, context, files, round: effectiveRound, claudePerspective });
   const raw = runGptAnalysis(codexBin, prompt);
 
   logUsage({ durationMs: raw.durationMs, usage: raw.usage, success: raw.success });
@@ -207,18 +233,44 @@ export async function dualThink({ question, context, files } = {}) {
     return {
       gpt: null,
       error: raw.error || 'GPT analysis failed',
-      fallback: 'Proceed with single-brain analysis on Claude Opus',
+      fallback: effectiveRound === 2
+        ? 'GPT rebuttal unavailable — synthesize from Round 1 analysis alone'
+        : 'Proceed with single-brain analysis on Claude Opus',
+    };
+  }
+
+  if (effectiveRound === 2) {
+    return {
+      round: 2,
+      gpt: {
+        rebuttal: raw.text,
+        model: MODEL,
+        durationMs: raw.durationMs,
+        tokens: raw.usage,
+      },
+      instructions: `GPT has responded to your analysis. Now synthesize both rounds into a FINAL DECISION:
+1. Where you both agree → high confidence, proceed
+2. Where GPT pushed back on your points → re-evaluate honestly
+3. Where you still disagree → state why and what evidence would resolve it
+4. Final recommendation with combined confidence level`,
+      question,
     };
   }
 
   return {
+    round: 1,
     gpt: {
       recommendation: raw.text,
       model: MODEL,
       durationMs: raw.durationMs,
       tokens: raw.usage,
     },
-    instructions: 'Now provide YOUR independent analysis of the same question. Then compare both perspectives and make a final decision. If you disagree with GPT, explain why with evidence.',
+    instructions: `Round 1 complete. Now:
+1. Provide YOUR independent analysis of the same question (same structure: recommendation, rationale, alternatives, risks, confidence, verification)
+2. Then call Round 2 to send your perspective back to GPT:
+   node .claude/hooks/dual-brain-think.mjs --question "<same question>" --round 2 --claude-says "<your analysis summary>"
+3. GPT will respond to your specific points — agreements, pushback, and refined recommendation
+4. You then synthesize both rounds into the final decision`,
     question,
     context: context || null,
   };
@@ -268,32 +320,41 @@ function printResult(result, question) {
   const TOP = '╔══════════════════════════════════════════════════╗';
   const BOT = '╚══════════════════════════════════════════════════╝';
 
+  const roundLabel = result.round === 2 ? 'Round 2 — Rebuttal' : 'Round 1 — Initial';
+
   console.log(TOP);
-  console.log('║              Dual-Brain Think                    ║');
+  console.log(`║  🧠 Dual-Brain Think · ${roundLabel}`.padEnd(51) + '║');
   console.log(BAR);
-  // Truncate question to fit the box
   const q = question.length > 44 ? question.slice(0, 41) + '...' : question;
   console.log(`║ Question: ${q.padEnd(38)} ║`);
   console.log(BAR);
 
   if (!result.gpt) {
-    // Failure path
-    console.log(`║ ERROR: ${(result.error || 'Unknown error').padEnd(41)} ║`);
+    console.log(`║ ❌ ${(result.error || 'Unknown error').padEnd(45)} ║`);
     console.log(BAR);
-    console.log(`║ Fallback: ${(result.fallback || '').padEnd(39)} ║`);
+    console.log(`║ ↩️  ${(result.fallback || '').padEnd(45)} ║`);
     console.log(BOT);
     return;
   }
 
-  const durSec = (result.gpt.durationMs / 1000).toFixed(1);
-  console.log(`║ GPT-5.5 Perspective (${MODEL}, ${durSec}s):`.padEnd(51) + '║');
+  const gptData = result.gpt;
+  const durSec = (gptData.durationMs / 1000).toFixed(1);
+  console.log(`║ 🤖 GPT-5.5 (${durSec}s):`.padEnd(51) + '║');
   console.log(BAR);
   console.log('');
-  console.log(result.gpt.recommendation);
+  console.log(gptData.recommendation || gptData.rebuttal);
   console.log('');
   console.log(BAR);
-  console.log('║ Now: Provide YOUR analysis and compare.          ║');
-  console.log('║ If you disagree, explain why with evidence.      ║');
+
+  if (result.round === 2) {
+    console.log('║ 🔄 Synthesize both rounds into final decision.  ║');
+    console.log('║ Where you agree → high confidence.               ║');
+    console.log('║ Where you disagree → state what would resolve it.║');
+  } else {
+    console.log('║ 📝 Your turn: analyze independently, then call   ║');
+    console.log('║    Round 2 with --round 2 --claude-says "..."    ║');
+    console.log('║    for GPT\'s rebuttal to your analysis.          ║');
+  }
   console.log(BOT);
 }
 
@@ -306,7 +367,8 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 
   if (!args.question) {
     console.error(
-      'Usage: node dual-brain-think.mjs --question "<question>" [--context "<context>"] [--files file1,file2]'
+      'Usage: node dual-brain-think.mjs --question "<question>" [--context "<ctx>"] [--files f1,f2]\n' +
+      '       node dual-brain-think.mjs --question "<question>" --round 2 --claude-says "<analysis>"'
     );
     process.exit(1);
   }
@@ -315,6 +377,8 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     question: args.question,
     context: args.context,
     files: args.files,
+    round: args.round ? parseInt(args.round, 10) : 1,
+    claudePerspective: args['claude-says'] || null,
   });
 
   printResult(result, args.question);

package/hooks/enforce-tier.mjs

@@ -1,13 +1,27 @@
 #!/usr/bin/env node
-import { readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { readFileSync, writeFileSync, appendFileSync, renameSync } from 'fs';
 import { createHash } from 'crypto';
 import { dirname, resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CONFIG_FILE = resolve(__dirname, '..', 'orchestrator.json');
+const PROFILE_FILE = resolve(__dirname, '..', 'dual-brain.profile.json');
 const DRIFT_STATE = resolve(__dirname, '.drift-warned');
 
+function loadProfile() {
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    return data.active || 'balanced';
+  } catch { return 'balanced'; }
+}
+
+const PROFILE_SETTINGS = {
+  balanced:        { demote_think: false, promote_execute: false, bias: 0 },
+  'cost-saver':    { demote_think: true,  promote_execute: false, bias: -20 },
+  'quality-first': { demote_think: false, promote_execute: true,  bias: 10 },
+};
+
 function checkPricingDrift(config) {
   const verified = config.pricing_verified;
   if (!verified) return null;
@@ -29,9 +43,12 @@ function checkPricingDrift(config) {
   return `**[Drift Warning]** Pricing was last verified ${age} days ago. Run \`node .claude/hooks/setup-wizard.mjs\` to update.`;
 }
 
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || process.ppid?.toString() || null;
+
 function logRecommendation(event) {
   const logFile = join(__dirname, `usage-${new Date().toISOString().slice(0, 10)}.jsonl`);
-  const entry = JSON.stringify({
+  const profileName = event.profile || 'balanced';
+  const entryObj = {
     timestamp: new Date().toISOString(),
     type: 'tier_recommendation',
     detected_tier: event.tier,
@@ -39,13 +56,64 @@ function logRecommendation(event) {
     actual_model: event.actual,
     prompt_hash: event.promptHash,
     followed: event.followed,
-  });
+    session_id: SESSION_ID,
+    profile: profileName,
+  };
+  const entry = JSON.stringify(entryObj);
   try {
     appendFileSync(logFile, entry + '\n');
   } catch {}
+
+  // Sync summary update (for dupe detection on next call)
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const summaryFile = join(__dirname, `usage-summary-${today}.json`);
+    let summary;
+    try { summary = JSON.parse(readFileSync(summaryFile, 'utf8')); } catch { summary = { version: 1, recent_hashes: [] }; }
+    if (event.promptHash) {
+      summary.recent_hashes = summary.recent_hashes || [];
+      summary.recent_hashes.push({ hash: event.promptHash, ts: entryObj.timestamp });
+      const tenMinAgo = Date.now() - 10 * 60 * 1000;
+      summary.recent_hashes = summary.recent_hashes.filter(h => Date.parse(h.ts) >= tenMinAgo);
+    }
+    summary.updated_at = new Date().toISOString();
+    const tmp = summaryFile + '.tmp.' + process.pid;
+    writeFileSync(tmp, JSON.stringify(summary, null, 2) + '\n');
+    renameSync(tmp, summaryFile);
+  } catch {}
+
+  // Sync ledger write (append-only, fast)
+  try {
+    const ledgerEntry = JSON.stringify({
+      type: 'decision',
+      id: entryObj.timestamp.replace(/\W/g, '').slice(-12),
+      timestamp: entryObj.timestamp,
+      session_id: SESSION_ID,
+      profile: profileName,
+      tier: event.tier,
+      provider: detectProvider(event.actual),
+      model: event.actual || 'unknown',
+      recommended_model: event.recommended,
+      followed: event.followed,
+      prompt_hash: event.promptHash,
+    });
+    appendFileSync(join(__dirname, 'decision-ledger.jsonl'), ledgerEntry + '\n');
+  } catch {}
 }
 
 function checkDuplicate(promptHash) {
+  // Try summary checkpoint first (O(1))
+  try {
+    const summaryPath = join(__dirname, `usage-summary-${new Date().toISOString().slice(0, 10)}.json`);
+    const summary = JSON.parse(readFileSync(summaryPath, 'utf8'));
+    const tenMinAgo = Date.now() - 10 * 60 * 1000;
+    const match = (summary.recent_hashes || []).find(
+      h => h.hash === promptHash && Date.parse(h.ts) >= tenMinAgo
+    );
+    if (match) return { timestamp: match.ts, prompt_hash: promptHash };
+  } catch {}
+
+  // Fallback: scan log
   const logFile = join(__dirname, `usage-${new Date().toISOString().slice(0, 10)}.jsonl`);
   try {
     const lines = readFileSync(logFile, 'utf8').split('\n').filter(Boolean);
@@ -73,27 +141,34 @@ function detectProvider(model) {
 }
 
 function quickPressureCheck(tier) {
+  // Try summary checkpoint first (O(1))
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const summaryPath = join(__dirname, `usage-summary-${today}.json`);
+    const summary = JSON.parse(readFileSync(summaryPath, 'utf8'));
+    const cutoff = Date.now() - 5 * 60 * 60 * 1000;
+    const claudeTs = (summary.pressure?.claude?.[tier] || []).filter(t => Date.parse(t) >= cutoff);
+    const openaiTs = (summary.pressure?.openai?.[tier] || []).filter(t => Date.parse(t) >= cutoff);
+    return { claudeCalls: claudeTs.length, openaiCalls: openaiTs.length };
+  } catch {}
+
+  // Fallback: scan log
   try {
     const today = new Date().toISOString().slice(0, 10);
     const logFile = join(__dirname, `usage-${today}.jsonl`);
     const lines = readFileSync(logFile, 'utf8').split('\n').filter(Boolean);
-
     const fiveHoursAgo = Date.now() - 5 * 60 * 60 * 1000;
     let claudeCalls = 0, openaiCalls = 0;
-
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
         if (Date.parse(entry.timestamp) < fiveHoursAgo) continue;
         if (entry.tier !== tier) continue;
-
-        const provider = entry.provider ||
-          (entry.model?.includes('gpt') ? 'openai' : 'claude');
+        const provider = entry.provider || (entry.model?.includes('gpt') ? 'openai' : 'claude');
         if (provider === 'claude') claudeCalls++;
         else openaiCalls++;
       } catch {}
     }
-
     return { claudeCalls, openaiCalls };
   } catch {
     return null;
@@ -162,6 +237,10 @@ try {
     return parts.join('\n\n');
   };
 
+  // Load profile early so all log entries can reference it
+  const profileName = loadProfile();
+  const profileSettings = PROFILE_SETTINGS[profileName] || PROFILE_SETTINGS.balanced;
+
   // Multi-tier detection — only when tier is not already resolved from subagent_defaults
   if (!tier) {
     const hasThink = THINK_WORDS.test(text);
@@ -186,6 +265,7 @@ try {
         actual: currentModel,
         promptHash,
         followed: false,
+        profile: profileName,
       });
       process.stdout.write(JSON.stringify({ systemMessage: fullMsg }));
       process.exit(0);
@@ -197,12 +277,21 @@ try {
     else tier = 'execute';
   }
 
+  // Apply profile-driven tier adjustments
+  if (profileSettings.demote_think && tier === 'think' && !THINK_WORDS.test(text)) {
+    tier = 'execute';
+  }
+  if (profileSettings.promote_execute && tier === 'execute' && THINK_WORDS.test(text)) {
+    tier = 'think';
+  }
+
   // Compute balance hint now that tier is resolved
   {
     const currentProvider = detectProvider(currentModel);
     if (currentProvider === 'claude') {
       const balance = quickPressureCheck(tier);
-      if (balance && balance.claudeCalls > balance.openaiCalls * 2 && balance.claudeCalls > 10) {
+      const biasThreshold = profileSettings.bias >= 0 ? 10 : 20;
+      if (balance && balance.claudeCalls > balance.openaiCalls * 2 && balance.claudeCalls > biasThreshold) {
         const dispatchModel = tier === 'think' ? 'gpt-5.5' : tier === 'execute' ? 'gpt-5.4' : 'gpt-4.1-mini';
         balanceHint = `\n\n💡 **Balance tip:** Claude has ${balance.claudeCalls} ${tier} calls vs OpenAI's ${balance.openaiCalls} in the last 5hrs. Consider dispatching isolated work to GPT: \`node .claude/hooks/gpt-work-dispatcher.mjs --task "..." --model ${dispatchModel}\``;
       }
@@ -221,6 +310,7 @@ try {
         actual: currentModel,
         promptHash,
         followed: true,
+        profile: profileName,
       });
       const onlyWarnings = [duplicateWarning, driftWarning, balanceHint].filter(Boolean).join('\n\n');
       if (onlyWarnings) {
@@ -241,6 +331,7 @@ try {
       actual: currentModel,
       promptHash,
       followed: false,
+      profile: profileName,
     });
     process.stdout.write(JSON.stringify({ systemMessage: prependWarnings(msg) }));
   } else {
@@ -251,6 +342,7 @@ try {
         actual: currentModel,
         promptHash,
         followed: true,
+        profile: profileName,
       });
       const onlyWarnings = [duplicateWarning, driftWarning, balanceHint].filter(Boolean).join('\n\n');
       if (onlyWarnings) {
@@ -271,6 +363,7 @@ try {
       actual: currentModel,
       promptHash,
       followed: false,
+      profile: profileName,
     });
     process.stdout.write(JSON.stringify({ systemMessage: prependWarnings(msg) }));
   }

package/hooks/gpt-work-dispatcher.mjs

@@ -18,7 +18,7 @@
  */
 
 import { execSync, spawnSync } from 'child_process';
-import { appendFileSync } from 'fs';
+import { appendFileSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -117,10 +117,19 @@ function executeCodex(codexBin, model, prompt, cwd, timeoutMs) {
     .filter(m => m.type === 'item.completed' && m.item?.type === 'command_execution')
     .map(m => m.item);
 
+  // Estimate startup time: time to first agent message or completed item
+  const firstItemTs = messages.find(m => m.type === 'item.completed')?.timestamp;
+  let startupMs = null;
+  if (firstItemTs) {
+    startupMs = Date.parse(firstItemTs) - startTime;
+    if (startupMs < 0 || startupMs > durationMs) startupMs = null;
+  }
+
   return {
     success: proc.status === 0 && errors.length === 0,
     summary: agentMessages.join('\n\n'),
     durationMs,
+    startupMs,
     model,
     usage: usage || null,
     errors: errors.map(e => e.message || e.error?.message || 'unknown'),
@@ -134,10 +143,18 @@ function executeCodex(codexBin, model, prompt, cwd, timeoutMs) {
 // Usage logger
 // ---------------------------------------------------------------------------
 
+function loadActiveProfile() {
+  try {
+    return JSON.parse(readFileSync(join(__dirname, '..', 'dual-brain.profile.json'), 'utf8')).active || 'balanced';
+  } catch { return 'balanced'; }
+}
+
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || process.ppid?.toString() || null;
+
 function logUsageEvent(result, task) {
   const logFile = join(__dirname, `usage-${new Date().toISOString().slice(0, 10)}.jsonl`);
-  const entry = JSON.stringify({
-    schema_version: 2,
+  const entryObj = {
+    schema_version: 3,
     timestamp: new Date().toISOString(),
     provider: 'openai',
     tier: task.tier || 'execute',
@@ -145,14 +162,40 @@ function logUsageEvent(result, task) {
     model: result.model,
     status: result.success ? 'ok' : 'error',
     durationMs: result.durationMs,
+    codex_startup_ms: result.startupMs || null,
+    codex_total_ms: result.durationMs,
     input_tokens: result.usage?.input_tokens ?? null,
     output_tokens: result.usage?.output_tokens ?? null,
-    session_id: process.env.CLAUDE_SESSION_ID || null,
+    session_id: SESSION_ID,
+    profile: result.profile || 'balanced',
     dispatcher: 'gpt-work-dispatcher',
-  });
+  };
   try {
-    appendFileSync(logFile, entry + '\n');
+    appendFileSync(logFile, JSON.stringify(entryObj) + '\n');
   } catch {}
+
+  // Update summary checkpoint with codex latency
+  import('./summary-checkpoint.mjs').then(({ updateSummary }) => {
+    updateSummary(entryObj);
+  }).catch(() => {});
+
+  // Record to decision ledger
+  import('./decision-ledger.mjs').then(({ recordDecision, recordOutcome }) => {
+    const id = recordDecision({
+      session_id: SESSION_ID,
+      profile: entryObj.profile,
+      tier: task.tier || 'execute',
+      provider: 'openai',
+      model: result.model,
+    });
+    recordOutcome(id, {
+      actual_duration_ms: result.durationMs,
+      codex_startup_ms: result.startupMs || null,
+      success: result.success,
+      actual_input_tokens: result.usage?.input_tokens || null,
+      actual_output_tokens: result.usage?.output_tokens || null,
+    });
+  }).catch(() => {});
 }
 
 // ---------------------------------------------------------------------------
@@ -171,6 +214,7 @@ export async function dispatchGptTask(task) {
   const model = task.model || 'gpt-5.4';
   const prompt = buildPrompt(task);
   const result = executeCodex(codexBin, model, prompt, task.cwd, task.timeoutMs);
+  result.profile = loadActiveProfile();
   logUsageEvent(result, task);
   return result;
 }