dual-brain 3.6.0 → 3.7.0

package/CLAUDE.md

@@ -56,13 +56,22 @@ Gate statuses: `pass` (safe to end), `issues_found` (fix first), `needs_human_re
 Active profile controls routing posture, budgets, and quality gate behavior.
 Profile persists to `.claude/dual-brain.profile.json` (gitignored).
 
-- **balanced** (default): Best model per tier, normal budgets, reviews at medium+ risk
+- **auto** (default): Adapts routing based on task risk, provider health, and outcomes. Uses file-path risk classification and failure-loop detection to auto-escalate when needed.
+- **balanced**: Best model per tier, normal budgets, reviews at medium+ risk
 - **cost-saver**: Prefer cheaper models, lower budgets, skip GPT for non-critical
 - **quality-first**: Dual-brain for medium+ risk, higher budgets, stricter reviews
 
 Switch profiles: `npx dual-brain mode cost-saver`
 Check status: `npx dual-brain status`
 
+## Adaptive Routing (Auto Mode)
+
+Auto mode classifies risk from file paths and adjusts routing in real-time:
+
+- **Risk classification**: auth/secrets→critical, billing/migrations→high, tests/utils→medium, docs→low
+- **Failure detection**: 2+ failures on same prompt in 2 hours → auto-escalate tier or trigger dual-brain
+- **Provider balance**: Routes to underused provider when one subscription is hot
+
 ## Available Tools
 
 - `node .claude/hooks/cost-report.mjs` — activity and cost estimates

package/hooks/control-panel.mjs

@@ -40,12 +40,14 @@ const blue = s => e('1;38;5;33', s);
 // ─── Profiles ──────────────────────────────────────────────────────────────
 
 const PROFILES = {
-  balanced:        { emoji: '⚖️',  uiLabel: 'Default',       desc: 'Auto-routes by complexity, uses both providers evenly' },
+  auto:            { emoji: '🤖', uiLabel: 'Auto',          desc: 'Adapts routing based on task risk, provider health, and outcomes' },
+  balanced:        { emoji: '⚖️',  uiLabel: 'Balanced',      desc: 'Routes by complexity, uses both providers evenly' },
   'cost-saver':    { emoji: '🛡️', uiLabel: 'Conservative',  desc: 'Fewer GPT dispatches, sticks to Claude for most work' },
   'quality-first': { emoji: '🚀', uiLabel: 'Aggressive',    desc: 'Maximizes both subscriptions, dual-brain for medium+ risk' },
 };
 
 const PROFILE_BUDGETS = {
+  auto:            { session_warn_usd: 5, session_limit_usd: 10, daily_warn_usd: 20, daily_limit_usd: 50 },
   balanced:        { session_warn_usd: 5, session_limit_usd: 10, daily_warn_usd: 20, daily_limit_usd: 50 },
   'cost-saver':    { session_warn_usd: 2, session_limit_usd: 5, daily_warn_usd: 8, daily_limit_usd: 20 },
   'quality-first': { session_warn_usd: 15, session_limit_usd: 30, daily_warn_usd: 50, daily_limit_usd: 100 },
@@ -54,11 +56,11 @@ const PROFILE_BUDGETS = {
 function loadProfile() {
   try {
     const data = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
-    const name = data.active && PROFILES[data.active] ? data.active : 'balanced';
+    const name = data.active && PROFILES[data.active] ? data.active : 'auto';
     const custom = data.custom_overrides || {};
     return { name, budgets: { ...PROFILE_BUDGETS[name], ...custom.budgets }, hasCustomBudget: !!custom.budgets };
   } catch {
-    return { name: 'balanced', budgets: PROFILE_BUDGETS.balanced, hasCustomBudget: false };
+    return { name: 'auto', budgets: PROFILE_BUDGETS.auto, hasCustomBudget: false };
   }
 }
 
@@ -358,7 +360,19 @@ function renderReturningMenu(providers, sessions) {
   // Provider status
   const cStat = providers.claude.authed ? '✅' : '⚠️';
   const xStat = providers.codex.authed ? '✅' : providers.codex.installed ? '⚠️' : '❌';
-  lines.push(`  🟠 Claude ${cStat}  🟢 Codex ${xStat}  ${pf.emoji}  ${bold(pf.uiLabel)}`);
+  let modeStatus = pf.uiLabel;
+  if (profile.name === 'auto') {
+    if (balance.total === 0) {
+      modeStatus = 'Auto · learning your workflow';
+    } else if (balance.openai > balance.claude + 20) {
+      modeStatus = 'Auto · routing GPT for isolated work';
+    } else if (balance.claude > balance.openai + 20) {
+      modeStatus = 'Auto · Claude-primary, GPT available';
+    } else {
+      modeStatus = 'Auto · balanced routing active';
+    }
+  }
+  lines.push(`  🟠 Claude ${cStat}  🟢 Codex ${xStat}  ${pf.emoji}  ${bold(modeStatus)}`);
 
   // Provider balance bar
   lines.push(`  ${balanceBar(balance.claude, balance.openai)}`);
@@ -415,7 +429,8 @@ function showProfilePicker(rl) {
     console.log('');
     for (const [i, [name, pf]] of Object.entries(PROFILES).entries()) {
       const active = name === current.name ? ' ✅' : '';
-      console.log(`  ${bold('[' + (i + 1) + ']')} ${pf.emoji}  ${pf.uiLabel.padEnd(15)} ${dim(pf.desc)}${active}`);
+      const recommended = name === 'auto' && current.name !== 'auto' ? dim(' (recommended)') : '';
+      console.log(`  ${bold('[' + (i + 1) + ']')} ${pf.emoji}  ${pf.uiLabel.padEnd(15)} ${dim(pf.desc)}${active}${recommended}`);
     }
     console.log(`  ${bold('[q]')} Cancel`);
     console.log('');

package/hooks/enforce-tier.mjs

@@ -3,6 +3,8 @@ import { readFileSync, writeFileSync, appendFileSync, renameSync } from 'fs';
 import { createHash } from 'crypto';
 import { dirname, resolve, join } from 'path';
 import { fileURLToPath } from 'url';
+import { classifyRisk, extractPaths } from './risk-classifier.mjs';
+import { checkFailureLoop } from './failure-detector.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CONFIG_FILE = resolve(__dirname, '..', 'orchestrator.json');
@@ -12,11 +14,12 @@ 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'; }
+    return data.active || 'auto';
+  } catch { return 'auto'; }
 }
 
 const PROFILE_SETTINGS = {
+  auto:            { demote_think: false, promote_execute: false, bias: 0 },
   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 },
@@ -231,9 +234,9 @@ try {
   // Balance hint — populated after tier is fully resolved
   let balanceHint = null;
 
-  // Helper to prepend optional warnings (duplicate + drift + balance) before a message
+  // Helper to prepend optional warnings (duplicate + drift + balance + auto) before a message
   const prependWarnings = (msg) => {
-    const parts = [duplicateWarning, driftWarning, msg, balanceHint].filter(Boolean);
+    const parts = [duplicateWarning, driftWarning, failureMessage, msg, autoStatus, balanceHint].filter(Boolean);
     return parts.join('\n\n');
   };
 
@@ -277,6 +280,32 @@ try {
     else tier = 'execute';
   }
 
+  // Risk classification from file paths in description
+  const filePaths = extractPaths(ti.description || '');
+  const riskResult = classifyRisk(filePaths);
+  let autoStatus = null;
+
+  // Bias high/critical risk toward think tier
+  if ((riskResult.level === 'critical' || riskResult.level === 'high') && tier !== 'think') {
+    tier = 'think';
+    autoStatus = riskResult.level === 'critical'
+      ? `Dual-brain: dual-brain review recommended — ${riskResult.reason.split(':')[0]} detected`
+      : `Dual-brain: promoting to think tier — ${riskResult.reason.split(':')[0]}`;
+  }
+
+  // Failure loop detection
+  const failureCheck = checkFailureLoop(promptHash);
+  let failureMessage = null;
+  if (failureCheck.isLoop) {
+    if (failureCheck.suggestion === 'promote_tier' && tier === 'execute') {
+      tier = 'think';
+      autoStatus = 'Dual-brain: escalating to think tier — previous attempt failed';
+    } else if (failureCheck.suggestion === 'escalate_to_dual_brain') {
+      autoStatus = 'Dual-brain: dual-brain review recommended — repeated failures detected';
+    }
+    failureMessage = `**[Failure Loop]** ${failureCheck.count} failed attempts in 2hrs. Consider: \`node .claude/hooks/dual-brain-think.mjs --question "why is this failing?"\``;
+  }
+
   // Apply profile-driven tier adjustments
   if (profileSettings.demote_think && tier === 'think' && !THINK_WORDS.test(text)) {
     tier = 'execute';
@@ -312,7 +341,7 @@ try {
         followed: true,
         profile: profileName,
       });
-      const onlyWarnings = [duplicateWarning, driftWarning, balanceHint].filter(Boolean).join('\n\n');
+      const onlyWarnings = [duplicateWarning, driftWarning, failureMessage, autoStatus, balanceHint].filter(Boolean).join('\n\n');
       if (onlyWarnings) {
         process.stdout.write(JSON.stringify({ systemMessage: onlyWarnings }));
       } else {
@@ -344,7 +373,7 @@ try {
         followed: true,
         profile: profileName,
       });
-      const onlyWarnings = [duplicateWarning, driftWarning, balanceHint].filter(Boolean).join('\n\n');
+      const onlyWarnings = [duplicateWarning, driftWarning, failureMessage, autoStatus, balanceHint].filter(Boolean).join('\n\n');
       if (onlyWarnings) {
         process.stdout.write(JSON.stringify({ systemMessage: onlyWarnings }));
       } else {

package/hooks/failure-detector.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * failure-detector.mjs — Detects repeated failure loops for adaptive routing.
+ *
+ * Exports:
+ *   checkFailureLoop(promptHash) → { isLoop, count, suggestion }
+ *   recordFailure(promptHash, tier, reason) → void
+ */
+
+import { readFileSync, appendFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LEDGER_FILE = join(__dirname, 'decision-ledger.jsonl');
+
+function checkFailureLoop(promptHash) {
+  if (!promptHash) return { isLoop: false, count: 0, suggestion: null };
+
+  const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
+  let failures = 0;
+  let lastTier = null;
+
+  try {
+    const lines = readFileSync(LEDGER_FILE, 'utf8').split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.prompt_hash !== promptHash) continue;
+        if (Date.parse(entry.timestamp) < twoHoursAgo) continue;
+        if (entry.success === false || entry.followed === false) {
+          failures++;
+          lastTier = entry.tier;
+        }
+      } catch {}
+    }
+  } catch {}
+
+  if (failures < 2) return { isLoop: false, count: failures, suggestion: null };
+
+  const suggestion = lastTier === 'execute'
+    ? 'promote_tier'
+    : 'escalate_to_dual_brain';
+
+  return { isLoop: true, count: failures, suggestion };
+}
+
+function recordFailure(promptHash, tier, reason) {
+  const entry = JSON.stringify({
+    type: 'failure',
+    timestamp: new Date().toISOString(),
+    prompt_hash: promptHash,
+    tier,
+    reason: reason || 'unknown',
+    success: false,
+  });
+  try {
+    appendFileSync(LEDGER_FILE, entry + '\n');
+  } catch {}
+}
+
+export { checkFailureLoop, recordFailure };

package/hooks/profiles.mjs

@@ -21,6 +21,26 @@ const PROFILE_FILE = join(__dirname, '..', 'dual-brain.profile.json');
 const CONFIG_FILE = join(__dirname, '..', 'orchestrator.json');
 
 const PROFILES = {
+  auto: {
+    description: 'Adapts routing based on task risk, provider health, and outcomes',
+    routing: {
+      prefer_provider: 'auto',
+      think_threshold: 'adaptive',
+      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,
+  },
+
   balanced: {
     description: 'Auto-routes by complexity, uses both providers evenly',
     routing: {
@@ -106,12 +126,12 @@ function loadConfig() {
 
 function getActiveProfile() {
   const saved = loadProfileFile();
-  const name = saved?.active || 'balanced';
-  const profile = PROFILES[name] || PROFILES.balanced;
+  const name = saved?.active || 'auto';
+  const profile = PROFILES[name] || PROFILES.auto;
   const customOverrides = saved?.custom_overrides || {};
 
   return {
-    name: PROFILES[name] ? name : 'balanced',
+    name: PROFILES[name] ? name : 'auto',
     ...profile,
     budgets: { ...profile.budgets, ...customOverrides.budgets },
     routing: { ...profile.routing, ...customOverrides.routing },

package/hooks/risk-classifier.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * risk-classifier.mjs — File-path risk classification for adaptive routing.
+ *
+ * Export: classifyRisk(paths) → { level, reason }
+ */
+
+const PATTERNS = [
+  { level: 'critical', regex: /\b(auth|credential|secret|\.env|key[s]?|token[s]?|password|encrypt|certificate|cert[s]?|\.pem|\.key)\b/i, label: 'security-sensitive' },
+  { level: 'high', regex: /\b(billing|payment|migration|deploy|ci[-/]cd|\.github\/workflows|security|permission|policy|schema\.prisma|schema\.sql|api[-_]?contract|openapi|swagger)\b/i, label: 'high-impact infrastructure' },
+  { level: 'medium', regex: /\b(test|spec|\.test\.|\.spec\.|shared|util[s]?|lib\/|public[-_]?api|integrat|config|\.config\.)\b/i, label: 'shared/tested code' },
+  { level: 'low', regex: /\b(readme|\.md$|docs?\/|comment|format|lint|\.prettierrc|local[-_]?script|internal[-_]?only|changelog)\b/i, label: 'docs/formatting' },
+];
+
+const LEVEL_ORDER = { critical: 3, high: 2, medium: 1, low: 0 };
+
+function classifyRisk(paths) {
+  if (!paths || paths.length === 0) return { level: 'low', reason: 'no file paths detected' };
+
+  let highest = { level: 'low', reason: 'no matching risk patterns' };
+
+  for (const p of paths) {
+    for (const pattern of PATTERNS) {
+      if (pattern.regex.test(p) && LEVEL_ORDER[pattern.level] > LEVEL_ORDER[highest.level]) {
+        highest = { level: pattern.level, reason: `${pattern.label}: ${p}` };
+        if (pattern.level === 'critical') return highest;
+      }
+    }
+  }
+
+  return highest;
+}
+
+function extractPaths(text) {
+  if (!text) return [];
+  const matches = text.match(/(?:^|\s|["'`])([./~]?(?:[\w@.-]+\/)+[\w@.*-]+(?:\.\w+)?)/g);
+  if (!matches) return [];
+  return matches.map(m => m.trim().replace(/^["'`]/, ''));
+}
+
+export { classifyRisk, extractPaths };

package/hooks/summary-checkpoint.mjs

@@ -57,6 +57,14 @@ function emptySummary() {
     token_averages: {},
 
     codex_latencies: [],
+
+    session_insights: {
+      gpt_latency_status: 'normal',
+      provider_override_count: 0,
+      failure_domains: [],
+      dual_brain_useful: false,
+      balance_posture: 'no activity yet',
+    },
   };
 }
 
@@ -199,6 +207,16 @@ function getTokenAverages(date) {
   return summary.token_averages;
 }
 
+function updateSessionInsight(key, value, date) {
+  const validKeys = ['gpt_latency_status', 'provider_override_count', 'failure_domains', 'dual_brain_useful', 'balance_posture'];
+  if (!validKeys.includes(key)) return;
+  const summary = readSummary(date);
+  if (!summary.session_insights) summary.session_insights = {};
+  summary.session_insights[key] = value;
+  summary.updated_at = new Date().toISOString();
+  atomicWrite(summaryPath(date), summary);
+}
+
 function getAdaptiveCodexThreshold(date) {
   const summary = readSummary(date);
   const latencies = summary.codex_latencies || [];
@@ -227,5 +245,6 @@ export {
   getPressureBuckets,
   getTokenAverages,
   getAdaptiveCodexThreshold,
+  updateSessionInsight,
   atomicWrite,
 };

package/install.mjs

@@ -336,6 +336,7 @@ function install(workspace, env, mode) {
     'install-git-hooks.mjs', 'session-report.mjs', 'budget-balancer.mjs',
     'gpt-work-dispatcher.mjs', 'profiles.mjs',
     'summary-checkpoint.mjs', 'decision-ledger.mjs', 'control-panel.mjs',
+    'risk-classifier.mjs', 'failure-detector.mjs',
   ];
   for (const h of HOOKS) cpSync(join(__dirname, 'hooks', h), join(target, 'hooks', h));
   actions.push(`✓ ${HOOKS.length} hook scripts`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "Dual-provider orchestration for Claude Code — tiered routing, budget balancing, and GPT dual-brain review across Claude + OpenAI subscriptions",
   "type": "module",
   "bin": {