dual-brain 2.0.0

package/hooks/enforce-tier.mjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, appendFileSync } 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 DRIFT_STATE = resolve(__dirname, '.drift-warned');
+
+function checkPricingDrift(config) {
+  const verified = config.pricing_verified;
+  if (!verified) return null;
+
+  const age = Math.floor((Date.now() - Date.parse(verified)) / 86400000);
+  if (age < 30) return null;
+
+  // Rate limit: only warn once per day
+  try {
+    const lastWarn = readFileSync(DRIFT_STATE, 'utf8').trim();
+    const today = new Date().toISOString().slice(0, 10);
+    if (lastWarn === today) return null;
+  } catch {}
+
+  try {
+    writeFileSync(DRIFT_STATE, new Date().toISOString().slice(0, 10));
+  } catch {}
+
+  return `**[Drift Warning]** Pricing was last verified ${age} days ago. Run \`node .claude/hooks/setup-wizard.mjs\` to update.`;
+}
+
+function logRecommendation(event) {
+  const logFile = join(__dirname, `usage-${new Date().toISOString().slice(0, 10)}.jsonl`);
+  const entry = JSON.stringify({
+    timestamp: new Date().toISOString(),
+    type: 'tier_recommendation',
+    detected_tier: event.tier,
+    recommended_model: event.recommended,
+    actual_model: event.actual,
+    prompt_hash: event.promptHash,
+    followed: event.followed,
+  });
+  try {
+    appendFileSync(logFile, entry + '\n');
+  } catch {}
+}
+
+function checkDuplicate(promptHash) {
+  const logFile = join(__dirname, `usage-${new Date().toISOString().slice(0, 10)}.jsonl`);
+  try {
+    const lines = readFileSync(logFile, 'utf8').split('\n').filter(Boolean);
+    const tenMinAgo = Date.now() - 10 * 60 * 1000;
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'tier_recommendation' &&
+            entry.prompt_hash === promptHash &&
+            Date.parse(entry.timestamp) > tenMinAgo) {
+          return entry;
+        }
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
+
+function detectProvider(model) {
+  if (!model || model === 'main-session') return 'claude';
+  const m = String(model).toLowerCase();
+  if (m.includes('gpt') || m.includes('o1') || m.includes('o3') || m.includes('o4')) return 'openai';
+  if (m.includes('opus') || m.includes('sonnet') || m.includes('haiku') || m.includes('claude')) return 'claude';
+  return 'claude';
+}
+
+function quickPressureCheck(tier) {
+  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');
+        if (provider === 'claude') claudeCalls++;
+        else openaiCalls++;
+      } catch {}
+    }
+
+    return { claudeCalls, openaiCalls };
+  } catch {
+    return null;
+  }
+}
+
+const SEARCH_WORDS = /\b(explore|search|find|grep|locate|where\s+is|list\s+files|read[-\s]?only|lookup|scan)\b/i;
+const THINK_WORDS = /\b(plan|design|architect|review|audit|security|code[-\s]?review|threat[-\s]?model|complex[-\s]?debug)\b/i;
+
+function preferredModel(config, tier) {
+  const models = config?.subscriptions?.claude?.models ?? {};
+  for (const [name, meta] of Object.entries(models)) {
+    if (meta?.tier === tier) return name;
+  }
+  return null;
+}
+
+try {
+  const input = JSON.parse(readFileSync('/dev/stdin', 'utf8'));
+
+  if (input.tool_name !== 'Agent') {
+    process.stdout.write('{}');
+    process.exit(0);
+  }
+
+  const ti = input.tool_input || {};
+  const text = `${ti.description || ''} ${ti.prompt || ''}`.toLowerCase();
+  const subType = (ti.subagent_type || '').toLowerCase();
+  const currentModel = (ti.model || '').toLowerCase();
+
+  // Compute prompt hash early for duplicate detection and logging
+  const promptHash = createHash('sha256').update(text).digest('hex').slice(0, 12);
+
+  // Check for duplicate agent dispatch before tier classification
+  const duplicate = checkDuplicate(promptHash);
+  let duplicateWarning = null;
+  if (duplicate) {
+    const minutesAgo = Math.round((Date.now() - Date.parse(duplicate.timestamp)) / 60000);
+    duplicateWarning = `**[Duplicate Warning]** A similar agent task was dispatched ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago. Reuse the prior result unless the scope changed.`;
+  }
+
+  let config;
+  try {
+    config = JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    process.stdout.write('{}');
+    process.exit(0);
+  }
+
+  const driftWarning = checkPricingDrift(config);
+
+  const intelligence = config.model_intelligence || {};
+  const defaults = config.routing_rules?.subagent_defaults || {};
+  let tier = null;
+
+  for (const [key, val] of Object.entries(defaults)) {
+    if (subType === key.toLowerCase()) { tier = val; break; }
+  }
+
+  // Balance hint — populated after tier is fully resolved
+  let balanceHint = null;
+
+  // Helper to prepend optional warnings (duplicate + drift + balance) before a message
+  const prependWarnings = (msg) => {
+    const parts = [duplicateWarning, driftWarning, msg, balanceHint].filter(Boolean);
+    return parts.join('\n\n');
+  };
+
+  // Multi-tier detection — only when tier is not already resolved from subagent_defaults
+  if (!tier) {
+    const hasThink = THINK_WORDS.test(text);
+    const hasExecute = /\b(edit|write|fix|implement|modify|refactor|delete|commit|test|build|run|add|update|create)\b/i.test(text);
+    const hasSearch = SEARCH_WORDS.test(text);
+
+    const detectedTiers = [
+      hasSearch && 'search',
+      hasExecute && 'execute',
+      hasThink && 'think',
+    ].filter(Boolean);
+
+    if (detectedTiers.length > 1) {
+      const splitMsg = `**[Tier Enforcer]** This spans **${detectedTiers.join(' + ')}** work. Consider splitting: ` +
+        (hasSearch ? 'search first (haiku), ' : '') +
+        (hasExecute ? 'then execute edits (sonnet), ' : '') +
+        (hasThink ? 'keep planning/review on think tier (opus).' : '');
+      const fullMsg = prependWarnings(splitMsg.replace(/, $/, '.'));
+      logRecommendation({
+        tier: detectedTiers.join('+'),
+        recommended: null,
+        actual: currentModel,
+        promptHash,
+        followed: false,
+      });
+      process.stdout.write(JSON.stringify({ systemMessage: fullMsg }));
+      process.exit(0);
+    }
+
+    if (THINK_WORDS.test(text)) tier = 'think';
+    else if (/\b(edit|write|fix|implement|modify|refactor|delete|commit|test|build|run|add|update|create)\b/i.test(text)) tier = 'execute';
+    else if (SEARCH_WORDS.test(text)) tier = 'search';
+    else tier = 'execute';
+  }
+
+  // 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 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}\``;
+      }
+    }
+  }
+
+  const expected = preferredModel(config, tier);
+
+  if (tier === 'think') {
+    const thinkModels = ['opus', 'gpt-5.5', 'o1', 'o3'];
+    const isThink = !currentModel || thinkModels.some(m => currentModel.includes(m));
+    if (isThink) {
+      logRecommendation({
+        tier,
+        recommended: expected,
+        actual: currentModel,
+        promptHash,
+        followed: true,
+      });
+      const onlyWarnings = [duplicateWarning, driftWarning, balanceHint].filter(Boolean).join('\n\n');
+      if (onlyWarnings) {
+        process.stdout.write(JSON.stringify({ systemMessage: onlyWarnings }));
+      } else {
+        process.stdout.write('{}');
+      }
+      process.exit(0);
+    }
+    // If we get here, a non-think model is being used for think work
+    const thinkBestFor = intelligence[expected || 'opus']?.best_for;
+    const thinkBestForSuffix = thinkBestFor ? ` (best for: ${thinkBestFor})` : '';
+    const msg = `**[Tier Enforcer]** This looks like **think** work (architecture/review/planning). ` +
+      `Don't send it to "${currentModel}" — keep it on the main session (${expected || 'opus'}${thinkBestForSuffix}) for best results.`;
+    logRecommendation({
+      tier,
+      recommended: expected,
+      actual: currentModel,
+      promptHash,
+      followed: false,
+    });
+    process.stdout.write(JSON.stringify({ systemMessage: prependWarnings(msg) }));
+  } else {
+    if (!expected || currentModel.includes(expected)) {
+      logRecommendation({
+        tier,
+        recommended: expected,
+        actual: currentModel,
+        promptHash,
+        followed: true,
+      });
+      const onlyWarnings = [duplicateWarning, driftWarning, balanceHint].filter(Boolean).join('\n\n');
+      if (onlyWarnings) {
+        process.stdout.write(JSON.stringify({ systemMessage: onlyWarnings }));
+      } else {
+        process.stdout.write('{}');
+      }
+      process.exit(0);
+    }
+    const savings = tier === 'search' ? 'Haiku is 19x cheaper than Opus for read-only lookups.' : 'Sonnet is 5x cheaper than Opus for implementation work.';
+    const bestFor = intelligence[expected]?.best_for;
+    const bestForSuffix = bestFor ? ` (best for: ${bestFor})` : '';
+    const msg = `**[Tier Enforcer]** This looks like **${tier}** work. ` +
+      `Use \`model: "${expected}"\`${bestForSuffix} instead of "${currentModel || 'opus (inherited)'}". ${savings}`;
+    logRecommendation({
+      tier,
+      recommended: expected,
+      actual: currentModel,
+      promptHash,
+      followed: false,
+    });
+    process.stdout.write(JSON.stringify({ systemMessage: prependWarnings(msg) }));
+  }
+} catch (err) {
+  process.stdout.write(JSON.stringify({
+    systemMessage: `[Tier Enforcer] Config error: ${err?.message?.slice(0, 100) || 'unknown'}. Falling back to main-session judgment.`
+  }));
+}
+process.exit(0);

package/hooks/gpt-work-dispatcher.mjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * gpt-work-dispatcher.mjs
+ *
+ * Dispatches execution tasks to GPT via the Codex CLI.
+ * Packages a work order, runs `codex exec`, captures the results,
+ * and returns structured output.
+ *
+ * Usage as CLI:
+ *   node .claude/hooks/gpt-work-dispatcher.mjs \
+ *     --task "Add tests for budget-balancer.mjs" \
+ *     --model gpt-5.4 \
+ *     --files hooks/budget-balancer.mjs
+ *
+ * Usage as module:
+ *   import { dispatchGptTask } from './gpt-work-dispatcher.mjs';
+ *   const result = await dispatchGptTask({ task, model, files, constraints, timeoutMs });
+ */
+
+import { execSync, spawnSync } from 'child_process';
+import { appendFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ---------------------------------------------------------------------------
+// Codex discovery — mirrors dual-brain-review.mjs
+// ---------------------------------------------------------------------------
+
+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;
+}
+
+// ---------------------------------------------------------------------------
+// Prompt builder
+// ---------------------------------------------------------------------------
+
+function buildPrompt(task) {
+  let prompt = `You are a GPT execution agent inside the Dual-Brain Orchestrator.
+
+Task: ${task.task}
+
+Own this task completely. Edit files directly.
+
+`;
+  if (task.files?.length) {
+    prompt += `Relevant files:\n${task.files.map(f => `- ${f}`).join('\n')}\n\n`;
+  }
+  if (task.constraints?.length) {
+    prompt += `Constraints:\n${task.constraints.map(c => `- ${c}`).join('\n')}\n\n`;
+  }
+  prompt += `When done, output a summary of:
+1. What you changed (files and behavior)
+2. Tests run and results (if applicable)
+3. Remaining risks or edge cases
+4. Any assumptions you made`;
+  return prompt;
+}
+
+// ---------------------------------------------------------------------------
+// Codex executor
+// ---------------------------------------------------------------------------
+
+function executeCodex(codexBin, model, prompt, cwd, timeoutMs) {
+  const startTime = Date.now();
+
+  const proc = spawnSync(codexBin, [
+    'exec', '--json', '--ephemeral',
+    '-m', model,
+    '-s', 'danger-full-access',
+    prompt,
+  ], {
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    timeout: timeoutMs || 120000,
+    cwd: cwd || process.cwd(),
+  });
+
+  const durationMs = Date.now() - startTime;
+
+  // Parse JSONL output
+  const messages = (proc.stdout || '')
+    .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;
+  const errors = messages.filter(m => m.type === 'error' || m.type === 'turn.failed');
+
+  // Detect changed files from command_execution items
+  const commands = messages
+    .filter(m => m.type === 'item.completed' && m.item?.type === 'command_execution')
+    .map(m => m.item);
+
+  return {
+    success: proc.status === 0 && errors.length === 0,
+    summary: agentMessages.join('\n\n'),
+    durationMs,
+    model,
+    usage: usage || null,
+    errors: errors.map(e => e.message || e.error?.message || 'unknown'),
+    commands: commands.length,
+    exitCode: proc.status,
+    signal: proc.signal,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Usage logger
+// ---------------------------------------------------------------------------
+
+function logUsageEvent(result, task) {
+  const logFile = join(__dirname, `usage-${new Date().toISOString().slice(0, 10)}.jsonl`);
+  const entry = JSON.stringify({
+    schema_version: 2,
+    timestamp: new Date().toISOString(),
+    provider: 'openai',
+    tier: task.tier || 'execute',
+    tool: 'codex-exec',
+    model: result.model,
+    status: result.success ? 'ok' : 'error',
+    durationMs: result.durationMs,
+    input_tokens: result.usage?.input_tokens ?? null,
+    output_tokens: result.usage?.output_tokens ?? null,
+    session_id: process.env.CLAUDE_SESSION_ID || null,
+    dispatcher: 'gpt-work-dispatcher',
+  });
+  try {
+    appendFileSync(logFile, entry + '\n');
+  } catch {}
+}
+
+// ---------------------------------------------------------------------------
+// Main exported function
+// ---------------------------------------------------------------------------
+
+export async function dispatchGptTask(task) {
+  const codexBin = findCodex();
+  if (!codexBin) {
+    return {
+      success: false,
+      error: 'Codex CLI not found. Install with: npm i -g @openai/codex && codex login',
+    };
+  }
+
+  const model = task.model || 'gpt-5.4';
+  const prompt = buildPrompt(task);
+  const result = executeCodex(codexBin, model, prompt, task.cwd, task.timeoutMs);
+  logUsageEvent(result, task);
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// CLI argument parser
+// ---------------------------------------------------------------------------
+
+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) {
+        // --key=value form
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        args[key] = value;
+      } else {
+        // --key value form
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('--')) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = true;
+        }
+      }
+    }
+    i++;
+  }
+
+  // Normalize known fields
+  if (typeof args.files === 'string') {
+    args.files = args.files.split(',').map(f => f.trim()).filter(Boolean);
+  }
+  if (typeof args.constraints === 'string') {
+    args.constraints = args.constraints.split(',').map(c => c.trim()).filter(Boolean);
+  }
+  if (args.timeout !== undefined) {
+    args.timeoutMs = Number(args.timeout) * 1000;
+    delete args.timeout;
+  }
+
+  return args;
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const rawArgs = parseArgs(process.argv.slice(2));
+
+  if (!rawArgs.task) {
+    console.error('Usage: node gpt-work-dispatcher.mjs --task "<description>" [--model gpt-5.4] [--files file1,file2] [--timeout 120]');
+    process.exit(1);
+  }
+
+  const result = await dispatchGptTask(rawArgs);
+
+  if (result.success) {
+    console.log('\n╔══════════════════════════════════════════════════╗');
+    console.log('║         GPT Task Completed                       ║');
+    console.log('╠══════════════════════════════════════════════════╣');
+    if (result.summary) {
+      console.log(result.summary);
+    }
+    console.log('╠══════════════════════════════════════════════════╣');
+    console.log(`║ Model: ${result.model}  Duration: ${(result.durationMs / 1000).toFixed(1)}s`);
+    console.log('╚══════════════════════════════════════════════════╝');
+  } else {
+    console.error('Task failed:', result.errors?.join(', ') || result.error);
+  }
+
+  // Also output JSON for piping
+  process.stdout.write('\n' + JSON.stringify(result) + '\n');
+}