dual-brain 3.1.0 → 3.2.0

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;
 }

package/hooks/profiles.mjs

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+/**
+ * profiles.mjs — Profile system for the Dual-Brain Orchestrator.
+ *
+ * Profiles configure routing posture, budget limits, and quality gate behavior.
+ * Active profile persists to .claude/dual-brain.profile.json.
+ *
+ * Exported API:
+ *   PROFILES                    → built-in profile definitions
+ *   getActiveProfile()          → current profile name + merged settings
+ *   setActiveProfile(name)      → switch profile, returns success/error
+ *   getProfileOverrides(key)    → profile-driven overrides for a specific system
+ */
+
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROFILE_FILE = join(__dirname, '..', 'dual-brain.profile.json');
+const CONFIG_FILE = join(__dirname, '..', 'orchestrator.json');
+
+const PROFILES = {
+  balanced: {
+    description: 'Standard routing — best model for each tier, normal budgets',
+    routing: {
+      prefer_provider: 'auto',
+      think_threshold: 'normal',
+      gpt_dispatch_bias: 0,
+    },
+    budgets: {
+      session_warn_usd: 5.00,
+      session_limit_usd: 10.00,
+      daily_warn_usd: 20.00,
+      daily_limit_usd: 50.00,
+    },
+    quality_gate: {
+      sensitivity_floor: 'medium',
+      dual_brain_minimum: 'high',
+    },
+    tier_overrides: null,
+  },
+
+  'cost-saver': {
+    description: 'Minimize spend — prefer cheaper models, skip GPT for low risk',
+    routing: {
+      prefer_provider: 'cheapest',
+      think_threshold: 'strict',
+      gpt_dispatch_bias: -20,
+    },
+    budgets: {
+      session_warn_usd: 2.00,
+      session_limit_usd: 5.00,
+      daily_warn_usd: 8.00,
+      daily_limit_usd: 20.00,
+    },
+    quality_gate: {
+      sensitivity_floor: 'high',
+      dual_brain_minimum: 'critical',
+    },
+    tier_overrides: {
+      promote_execute_to_think: false,
+      demote_think_to_execute: true,
+    },
+  },
+
+  'quality-first': {
+    description: 'Maximum quality — dual-brain for medium+, stricter reviews',
+    routing: {
+      prefer_provider: 'most-capable',
+      think_threshold: 'relaxed',
+      gpt_dispatch_bias: 10,
+    },
+    budgets: {
+      session_warn_usd: 15.00,
+      session_limit_usd: 30.00,
+      daily_warn_usd: 50.00,
+      daily_limit_usd: 100.00,
+    },
+    quality_gate: {
+      sensitivity_floor: 'low',
+      dual_brain_minimum: 'medium',
+    },
+    tier_overrides: {
+      promote_execute_to_think: true,
+      demote_think_to_execute: false,
+    },
+  },
+};
+
+function loadProfileFile() {
+  try {
+    return JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function getActiveProfile() {
+  const saved = loadProfileFile();
+  const name = saved?.active || 'balanced';
+  const profile = PROFILES[name] || PROFILES.balanced;
+  const customOverrides = saved?.custom_overrides || {};
+
+  return {
+    name: PROFILES[name] ? name : 'balanced',
+    ...profile,
+    budgets: { ...profile.budgets, ...customOverrides.budgets },
+    routing: { ...profile.routing, ...customOverrides.routing },
+    switched_at: saved?.switched_at || null,
+  };
+}
+
+function setActiveProfile(name, customOverrides = null) {
+  if (!PROFILES[name]) {
+    return { ok: false, error: `Unknown profile: ${name}. Available: ${Object.keys(PROFILES).join(', ')}` };
+  }
+
+  const data = {
+    active: name,
+    switched_at: new Date().toISOString(),
+  };
+  if (customOverrides) data.custom_overrides = customOverrides;
+
+  try {
+    const tmp = PROFILE_FILE + '.tmp.' + process.pid;
+    writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+    renameSync(tmp, PROFILE_FILE);
+    return { ok: true, profile: PROFILES[name] };
+  } catch (err) {
+    return { ok: false, error: `Failed to write profile: ${err.message}` };
+  }
+}
+
+function setBudgetOverrides(sessionLimit, dailyLimit) {
+  const saved = loadProfileFile() || { active: 'balanced' };
+  saved.custom_overrides = saved.custom_overrides || {};
+  saved.custom_overrides.budgets = {};
+
+  if (sessionLimit != null) {
+    saved.custom_overrides.budgets.session_warn_usd = sessionLimit * 0.6;
+    saved.custom_overrides.budgets.session_limit_usd = sessionLimit;
+  }
+  if (dailyLimit != null) {
+    saved.custom_overrides.budgets.daily_warn_usd = dailyLimit * 0.6;
+    saved.custom_overrides.budgets.daily_limit_usd = dailyLimit;
+  }
+
+  saved.switched_at = saved.switched_at || new Date().toISOString();
+
+  try {
+    const tmp = PROFILE_FILE + '.tmp.' + process.pid;
+    writeFileSync(tmp, JSON.stringify(saved, null, 2) + '\n');
+    renameSync(tmp, PROFILE_FILE);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+function getProfileOverrides(system) {
+  const profile = getActiveProfile();
+
+  switch (system) {
+    case 'enforce-tier':
+      return {
+        think_threshold: profile.routing.think_threshold,
+        tier_overrides: profile.tier_overrides,
+        gpt_dispatch_bias: profile.routing.gpt_dispatch_bias,
+      };
+
+    case 'budget-balancer':
+      return {
+        budgets: profile.budgets,
+        prefer_provider: profile.routing.prefer_provider,
+      };
+
+    case 'quality-gate':
+      return {
+        sensitivity_floor: profile.quality_gate.sensitivity_floor,
+        dual_brain_minimum: profile.quality_gate.dual_brain_minimum,
+      };
+
+    default:
+      return {};
+  }
+}
+
+export {
+  PROFILES,
+  getActiveProfile,
+  setActiveProfile,
+  setBudgetOverrides,
+  getProfileOverrides,
+};

package/hooks/quality-gate.mjs

@@ -23,9 +23,31 @@ import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ORCHESTRATOR_CONFIG = resolve(__dirname, '..', 'orchestrator.json');
+const PROFILE_FILE = resolve(__dirname, '..', 'dual-brain.profile.json');
 const REVIEWS_DIR = resolve(__dirname, '..', 'reviews');
 const DUAL_BRAIN = resolve(__dirname, 'dual-brain-review.mjs');
 
+const RISK_LEVELS = ['low', 'medium', 'high', 'critical'];
+
+function loadProfileGateSettings() {
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    const name = data.active || 'balanced';
+    const defaults = {
+      balanced:        { sensitivity_floor: 'medium', dual_brain_minimum: 'high' },
+      'cost-saver':    { sensitivity_floor: 'high',   dual_brain_minimum: 'critical' },
+      'quality-first': { sensitivity_floor: 'low',    dual_brain_minimum: 'medium' },
+    };
+    return defaults[name] || defaults.balanced;
+  } catch {
+    return { sensitivity_floor: 'medium', dual_brain_minimum: 'high' };
+  }
+}
+
+function riskMeetsFloor(risk, floor) {
+  return RISK_LEVELS.indexOf(risk) >= RISK_LEVELS.indexOf(floor);
+}
+
 function exit(obj) {
   process.stdout.write(JSON.stringify(obj) + '\n');
   process.exit(0);
@@ -162,14 +184,16 @@ function main() {
   // 5a. Score sensitivity BEFORE running any external review
   const sensitivity = scoreSensitivity(qualifyingFiles, config);
 
-  // 5b. Low risk — skip GPT review entirely
-  if (sensitivity.gate === 'self-check') {
+  // 5b. Apply profile-driven sensitivity floor
+  const profileGate = loadProfileGateSettings();
+  if (!riskMeetsFloor(sensitivity.risk, profileGate.sensitivity_floor)) {
     exit({
       gate: 'pass',
-      risk: 'low',
+      risk: sensitivity.risk,
       sensitivity_score: sensitivity.score,
       sensitivity_reasons: sensitivity.reasons,
-      reason: 'low sensitivity — self-check only',
+      reason: `${sensitivity.risk} risk — below profile floor (${profileGate.sensitivity_floor})`,
+      profile_floor: profileGate.sensitivity_floor,
       files: qualifyingFiles,
     });
   }
@@ -232,14 +256,18 @@ function main() {
     reviewResult.error === true ||
     !reviewResult.review;
 
+  // Profile can lower the dual-brain threshold
+  const needsDualBrain = riskMeetsFloor(sensitivity.risk, profileGate.dual_brain_minimum);
+
   let gateStatus;
-  if (sensitivity.gate === 'dual-brain-required') {
-    // Critical: always flag for dual-brain + user attention regardless of review outcome
+  if (sensitivity.gate === 'dual-brain-required' || (needsDualBrain && sensitivity.risk === 'critical')) {
     gateStatus = 'needs_dual_think';
   } else if (reviewUnavailable) {
     gateStatus = 'needs_human_review';
   } else if (reviewResult.issues_found) {
     gateStatus = 'issues_found';
+  } else if (needsDualBrain) {
+    gateStatus = 'reviewed';
   } else {
     gateStatus = sensitivity.gate === 'dual-brain-recommended' ? 'reviewed' : 'pass';
   }