dual-brain 3.5.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, standard alerts' },
-  'cost-saver':    { emoji: '💸', uiLabel: 'Cost-saver',    desc: 'Prefers cheaper models, tighter alerts' },
-  'quality-first': { emoji: '💎', uiLabel: 'Quality-first', desc: 'Uses best models, dual-brain for medium+ risk' },
+  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 };
   }
 }
 
@@ -245,14 +247,48 @@ function countRunning() {
   return { claude, codex };
 }
 
-// ─── Cost Alert Label ─────────────────────────────────────────────────────
+// ─── Provider Balance ─────────────────────────────────────────────────────
 
-function costAlertLabel(profile) {
-  if (profile.hasCustomBudget) return 'Custom';
-  if (profile.name === 'balanced') return 'Default';
-  if (profile.name === 'cost-saver') return 'Tight';
-  if (profile.name === 'quality-first') return 'Relaxed';
-  return 'Default';
+function loadProviderBalance() {
+  const today = new Date().toISOString().slice(0, 10);
+  const logFile = join(__dirname, `usage-${today}.jsonl`);
+  if (!existsSync(logFile)) return { claude: 0, openai: 0, total: 0, label: 'No activity yet' };
+
+  let claude = 0, openai = 0;
+  try {
+    const lines = readFileSync(logFile, 'utf8').split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const e = JSON.parse(line);
+        if (e.provider === 'claude') claude++;
+        else if (e.provider === 'openai') openai++;
+      } catch {}
+    }
+  } catch {}
+
+  const total = claude + openai;
+  if (total === 0) return { claude: 0, openai: 0, total: 0, label: 'No activity yet' };
+
+  const claudePct = Math.round((claude / total) * 100);
+  const openaiPct = 100 - claudePct;
+
+  let label;
+  if (openaiPct === 0) label = 'Claude only — GPT subscription unused';
+  else if (claudePct === 0) label = 'GPT only — Claude subscription unused';
+  else if (Math.abs(claudePct - openaiPct) <= 20) label = 'Well balanced';
+  else if (claudePct > openaiPct) label = `Claude-heavy — GPT has capacity`;
+  else label = `GPT-heavy — Claude has capacity`;
+
+  return { claude: claudePct, openai: openaiPct, total, label };
+}
+
+function balanceBar(claudePct, openaiPct, width = 20) {
+  if (claudePct === 0 && openaiPct === 0) return dim('░'.repeat(width) + '  no activity');
+  const cFill = Math.round((claudePct / 100) * width);
+  const oFill = width - cFill;
+  const cBar = noColor ? '█'.repeat(cFill) : `\x1b[38;5;208m${'█'.repeat(cFill)}\x1b[0m`;
+  const oBar = noColor ? '▓'.repeat(oFill) : `\x1b[32m${'▓'.repeat(oFill)}\x1b[0m`;
+  return `${cBar}${oBar}  ${orange(claudePct + '%')} Claude · ${green(openaiPct + '%')} GPT`;
 }
 
 // ─── Menu Renderers ───────────────────────────────────────────────────────
@@ -314,16 +350,33 @@ function renderReturningMenu(providers, sessions) {
   const profile = loadProfile();
   const pf = PROFILES[profile.name];
   const running = countRunning();
+  const balance = loadProviderBalance();
   const lines = [];
 
   lines.push('');
   lines.push(`  🧠 ${bold(`Dual-Brain v${VERSION}`)}`);
   lines.push('');
 
-  // Compact provider + mode line
+  // 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)}`);
+  if (balance.total > 0) lines.push(`  ${dim(balance.label + ' · ' + balance.total + ' calls today')}`);
 
   // Recent sessions
   if (sessions.length > 0) {
@@ -350,7 +403,6 @@ function renderReturningMenu(providers, sessions) {
   if (sessions.length > 0) lines.push(`  ${bold('[1-9]')} Resume numbered above`);
   lines.push(`  ${bold('[n]')} New session`);
   lines.push(`  ${bold('[p]')} Mode: ${dim(pf.uiLabel)}`);
-  lines.push(`  ${bold('[b]')} Cost alerts: ${dim(costAlertLabel(profile))}`);
 
   // Auth if needed
   if (!providers.claude.authed) lines.push(`  ${bold('[j]')} Sign in to Claude`);
@@ -368,12 +420,17 @@ function renderReturningMenu(providers, sessions) {
 function showProfilePicker(rl) {
   return new Promise((resolve) => {
     const current = loadProfile();
+    const balance = loadProviderBalance();
     console.log('');
-    console.log(`  ${bold('Switch mode:')}`);
+    console.log(`  ${bold('Switch routing mode:')}`);
+    if (balance.total > 0) {
+      console.log(`  ${dim('Current balance: Claude ' + balance.claude + '% / GPT ' + balance.openai + '% · ' + balance.label)}`);
+    }
     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('');
@@ -396,49 +453,7 @@ function showProfilePicker(rl) {
   });
 }
 
-// ─── Cost Alert Editor ────────────────────────────────────────────────────
-
-function showCostAlertEditor(rl) {
-  return new Promise((resolve) => {
-    const profile = loadProfile();
-    console.log('');
-    console.log(`  ${bold('Cost alerts')}`);
-    console.log(`  ${dim('Dual-brain estimates API costs from session activity.')}`);
-    console.log(`  ${dim('These are alerts, not billing caps.')}`);
-    console.log('');
-    console.log(`  Current: warn at $${profile.budgets.session_warn_usd}/session, $${profile.budgets.daily_warn_usd}/day`);
-    console.log(`           limit at $${profile.budgets.session_limit_usd}/session, $${profile.budgets.daily_limit_usd}/day`);
-    console.log('');
-
-    rl.question('  Session alert limit ($, Enter = keep): ', (sessionStr) => {
-      if (!sessionStr.trim()) return resolve();
-      const session = parseFloat(sessionStr);
-      if (isNaN(session) || session <= 0) { console.log('  Cancelled.'); return resolve(); }
-
-      rl.question('  Daily alert limit ($, Enter = auto): ', (dailyStr) => {
-        const daily = parseFloat(dailyStr);
-        const finalDaily = (isNaN(daily) || daily <= 0) ? session * 3 : daily;
-
-        let existing = {};
-        try { existing = JSON.parse(readFileSync(PROFILE_FILE, 'utf8')); } catch {}
-        const custom = existing.custom_overrides || {};
-        custom.budgets = {
-          session_warn_usd: +(session * 0.6).toFixed(2),
-          session_limit_usd: session,
-          daily_warn_usd: +(finalDaily * 0.6).toFixed(2),
-          daily_limit_usd: finalDaily,
-        };
-        const data = { active: existing.active || 'balanced', switched_at: existing.switched_at || new Date().toISOString(), custom_overrides: custom };
-        const tmp = PROFILE_FILE + '.tmp.' + process.pid;
-        writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
-        renameSync(tmp, PROFILE_FILE);
-
-        console.log(`  ✅ Cost alerts: $${session}/session · $${finalDaily}/day`);
-        resolve();
-      });
-    });
-  });
-}
+// (Cost alert editor removed — replaced by provider balance + mode switching)
 
 // ─── Session Runner ───────────────────────────────────────────────────────
 
@@ -514,11 +529,6 @@ async function mainLoop() {
       continue;
     }
 
-    if (choice === 'b') {
-      await showCostAlertEditor(rl);
-      continue;
-    }
-
     if (choice === 'j') {
       console.log('');
       console.log('  Starting Claude login...');

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,8 +21,28 @@ 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: 'Standard routing — best model for each tier, normal budgets',
+    description: 'Auto-routes by complexity, uses both providers evenly',
     routing: {
       prefer_provider: 'auto',
       think_threshold: 'normal',
@@ -42,7 +62,7 @@ const PROFILES = {
   },
 
   'cost-saver': {
-    description: 'Minimize spend — prefer cheaper models, skip GPT for low risk',
+    description: 'Conservative — fewer GPT dispatches, sticks to Claude',
     routing: {
       prefer_provider: 'cheapest',
       think_threshold: 'strict',
@@ -65,7 +85,7 @@ const PROFILES = {
   },
 
   'quality-first': {
-    description: 'Maximum quality — dual-brain for medium+, stricter reviews',
+    description: 'Aggressive — maximizes both subscriptions, dual-brain for medium+',
     routing: {
       prefer_provider: 'most-capable',
       think_threshold: 'relaxed',
@@ -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

@@ -57,10 +57,10 @@ if (flag('--help') || flag('-h')) {
     --json       Output detection as JSON
     --help       Show this help
 
-  🎛️  Profiles:
-    ⚖️  balanced       Standard routing — best model per tier
-    💸 cost-saver     Minimize spend — prefer cheaper models
-    💎 quality-first  Maximum quality — dual-brain for medium+
+  🎛️  Routing modes:
+    ⚖️  Default        Auto-routes, uses both providers evenly
+    🛡️  Conservative   Fewer GPT dispatches, sticks to Claude
+    🚀 Aggressive     Maximizes both subscriptions, dual-brain for medium+
 
   🚀 Examples:
     ${cmd('npx dual-brain')}                  # install or update
@@ -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`);
@@ -424,19 +425,19 @@ function profilePath(workspace) {
 
 const PROFILES = {
   balanced: {
-    description: 'Standard routing — best model for each tier, normal budgets',
+    description: 'Auto-routes by complexity, uses both providers evenly',
     routing: { prefer_provider: 'auto', think_threshold: 'normal', gpt_dispatch_bias: 0 },
     budgets: { session_warn_usd: 5, session_limit_usd: 10, daily_warn_usd: 20, daily_limit_usd: 50 },
     quality_gate: { sensitivity_floor: 'medium', dual_brain_minimum: 'high' },
   },
   'cost-saver': {
-    description: 'Minimize spend — prefer cheaper models, skip GPT for low risk',
+    description: 'Conservative — fewer GPT dispatches, sticks to Claude',
     routing: { prefer_provider: 'cheapest', think_threshold: 'strict', gpt_dispatch_bias: -20 },
     budgets: { session_warn_usd: 2, session_limit_usd: 5, daily_warn_usd: 8, daily_limit_usd: 20 },
     quality_gate: { sensitivity_floor: 'high', dual_brain_minimum: 'critical' },
   },
   'quality-first': {
-    description: 'Maximum quality — dual-brain for medium+, stricter reviews',
+    description: 'Aggressive — maximizes both subscriptions, dual-brain for medium+',
     routing: { prefer_provider: 'most-capable', think_threshold: 'relaxed', gpt_dispatch_bias: 10 },
     budgets: { session_warn_usd: 15, session_limit_usd: 30, daily_warn_usd: 50, daily_limit_usd: 100 },
     quality_gate: { sensitivity_floor: 'low', dual_brain_minimum: 'medium' },
@@ -490,16 +491,18 @@ function cmdMode() {
 
   if (!modeArg || modeArg === 'list') {
     const current = loadProfile(workspace);
-    const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '💸', 'quality-first': '💎' };
+    const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '🛡️', 'quality-first': '🚀' };
+    const UI_NAMES = { balanced: 'Default', 'cost-saver': 'Conservative', 'quality-first': 'Aggressive' };
     console.log('');
-    console.log('  🎛️  Profiles:');
+    console.log('  🎛️  Routing modes:');
     console.log('');
     for (const [name, p] of Object.entries(PROFILES)) {
       const active = name === current.name ? ' ✅ active' : '';
-      console.log(`    ${PEMOJIS[name] || '  '} ${name.padEnd(15)} ${p.description}${active}`);
+      const label = UI_NAMES[name] || name;
+      console.log(`    ${PEMOJIS[name] || '  '} ${label.padEnd(15)} ${p.description}${active}`);
     }
     console.log('');
-    console.log(`  Switch: ${cmd('npx dual-brain mode <profile>')}`);
+    console.log(`  Switch: ${cmd('npx dual-brain mode <name>')}`);
     console.log('');
     return;
   }
@@ -522,9 +525,10 @@ function cmdMode() {
 
   saveProfile(workspace, modeArg, customOverrides);
 
-  const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '💸', 'quality-first': '💎' };
+  const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '🛡️', 'quality-first': '🚀' };
+  const UI_NAMES = { balanced: 'Default', 'cost-saver': 'Conservative', 'quality-first': 'Aggressive' };
   console.log('');
-  console.log(`  ✅ Profile switched: ${PEMOJIS[modeArg] || ''} ${modeArg}`);
+  console.log(`  ✅ Mode switched: ${PEMOJIS[modeArg] || ''} ${UI_NAMES[modeArg] || modeArg}`);
   console.log(`  ${profile.description}`);
   console.log('');
   console.log('  🧭 Routing changes:');
@@ -547,12 +551,12 @@ function cmdBudget() {
   if (sessionArg == null) {
     const profile = loadProfile(workspace);
     console.log('');
-    console.log('  💵 Current budget:');
-    console.log(`    Session: ⚠️  $${profile.budgets.session_warn_usd} warn · 🛑 $${profile.budgets.session_limit_usd} limit`);
-    console.log(`    Daily:   ⚠️  $${profile.budgets.daily_warn_usd} warn · 🛑 $${profile.budgets.daily_limit_usd} limit`);
+    console.log('  📊 Usage alert thresholds (estimated, not billing caps):');
+    console.log(`    Session: ⚠️  $${profile.budgets.session_warn_usd} warn · 🛑 $${profile.budgets.session_limit_usd} alert`);
+    console.log(`    Daily:   ⚠️  $${profile.budgets.daily_warn_usd} warn · 🛑 $${profile.budgets.daily_limit_usd} alert`);
     console.log('');
-    console.log(`  Set limits: ${cmd('npx dual-brain budget <session$> [daily$]')}`);
-    console.log(`  Example:    ${cmd('npx dual-brain budget 8 25')}`);
+    console.log(`  Adjust: ${cmd('npx dual-brain budget <session$> [daily$]')}`);
+    console.log(`  Example: ${cmd('npx dual-brain budget 8 25')}`);
     console.log('');
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "3.5.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": {