dual-brain 7.1.4 → 7.1.6

package/CLAUDE.md

@@ -2,7 +2,7 @@
 
 This project uses dual-provider orchestration. Config: `.claude/orchestrator.json`.
 
-## Core Architecture (v6)
+## Core Architecture (v7)
 
 Four modules in `src/` form the decision pipeline:
 
@@ -71,21 +71,21 @@ Dual-brain is a multi-round conversation between Claude and GPT — not a single
 ## Quality Gate
 
 Before ending a session with code changes:
-1. Run `node .claude/hooks/session-report.mjs`
-2. Run `node .claude/hooks/quality-gate.mjs`
+1. `node .claude/hooks/session-report.mjs` (allowed by head-guard for hook scripts)
+2. `node .claude/hooks/quality-gate.mjs`
 
 Gate statuses: `pass` (safe to end), `issues_found` (fix first), `needs_human_review` (GPT unavailable).
 
 ## Profiles
 
-Profile persists to `.claude/dual-brain.profile.json` (gitignored).
+Profile persists to `.dualbrain/profile.json` (project-scoped, gitignored).
 
 - **auto** (default): Adapts routing based on task risk, provider health, and outcomes
 - **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: `dual-brain mode cost-saver` · Natural language aliases work: "be careful", "cheap mode", "thorough"
+Switch via the interactive Profile screen in `dual-brain`, or set `bias` in `.dualbrain/profile.json`.
 
 ## Adaptive Routing (Auto Mode)
 

package/README.md

@@ -24,7 +24,7 @@ dual-brain detects the intent and risk of your task, picks the best model based
 
 ### `dual-brain init`
 
-First-time setup. Three questions: which providers you have, subscription tiers, and optimization preference.
+First-time setup. Three questions: which providers you have, subscription tiers, and optimization preference. The actual flow auto-detects existing auth and adapts — you may see fewer prompts if credentials are already configured.
 
 ```
 Dual-Brain Orchestrator — First-time setup
@@ -121,7 +121,7 @@ Preferences are stored in `.dualbrain/profile.json` and applied on every `go` in
 import { orchestrate } from 'dual-brain';
 
 const result = await orchestrate({ prompt: "fix the bug", cwd: "." });
-console.log(result.summary);
+console.log(result.result?.summary);
 ```
 
 Individual modules are also exported:
@@ -174,7 +174,7 @@ For Claude Code users, a hooks layer provides deeper integration. Hooks fire on
 
 ```bash
 # Install hooks into .claude/settings.json
-npx -y dual-brain
+npx dual-brain install
 ```
 
 The installer auto-detects your environment (Claude CLI, Codex CLI, Replit), registers `enforce-tier.mjs` and `cost-logger.mjs` hooks, and writes `orchestrator.json` with your subscription config. Re-run anytime — it's idempotent.

package/bin/dual-brain.mjs

@@ -65,10 +65,8 @@ Commands:
   forget "preference"       Remove a preference by fuzzy match
 
 Interactive mode (entered with no args on a TTY):
-  Shows dashboard screen with menu-driven navigation.
-  [g] Go — dispatch a task
-  [s] Status, [p] Profile, [a] Auth, [d] Diagnostics
-  [c] Command mode (REPL), [q] Exit
+  Session manager with recent sessions and routing.
+  [n] New session, [c] Continue last, [1-9] Resume, [s] Settings, [q] Exit
 
 Options:
   --version                 Print version
@@ -155,6 +153,9 @@ async function cmdInit(rl) {
   const profile = await runOnboarding({ interactive: true, detectedAuth: auth, rl });
   saveProfile(profile, { cwd });
 
+  // --- Step 2b: Install hooks so enforcement is active from first run ---
+  await cmdInstall(cwd);
+
   // --- Step 3: Show dashboard ---
   console.log('');
   const repo    = loadRepoCache(cwd);
@@ -280,6 +281,27 @@ async function cmdGo(args) {
     }, cwd);
   } else {
     result = await dispatch({ decision, prompt, files, cwd });
+    if (result.status === 'completed' && result.type === 'native-agent') {
+      const nd = result.nativeDispatch || {};
+      const promptPreview = (nd.prompt || prompt).slice(0, 100);
+      const promptSuffix  = (nd.prompt || prompt).length > 100 ? '...' : '';
+      console.log(`\nRouted: ${decision.provider}/${nd.model || decision.model} (${decision.tier})`);
+      console.log('To dispatch, use the Agent tool with:');
+      console.log(`  model: ${nd.model || decision.model}`);
+      console.log(`  prompt: ${promptPreview}${promptSuffix}`);
+      if (nd.isolation)  console.log(`  isolation: ${nd.isolation}`);
+      if (nd.maxTurns)   console.log(`  maxTurns: ${nd.maxTurns}`);
+      saveSession({
+        objective:    prompt,
+        branch:       null,
+        filesChanged: files,
+        commandsRun:  [`dual-brain go "${prompt}"`],
+        lastResult:   { status: 'success', summary: `native-agent routed to ${nd.model || decision.model}` },
+        provider:     decision.provider,
+        nextAction:   null,
+      }, cwd);
+      return;
+    }
     const statusLine = result.status === 'completed' ? 'Done' : `Failed (exit ${result.exitCode})`;
     console.log(`\n${statusLine} in ${(result.durationMs / 1000).toFixed(1)}s`);
     if (result.summary) console.log(result.summary);
@@ -443,7 +465,7 @@ async function cmdStatus(args = []) {
 
 const PROVIDER_MODEL_CLASSES = {
   claude: ['haiku', 'sonnet', 'opus'],
-  openai: ['o4-mini', 'o3', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-5.4', 'gpt-5.5'],
+  openai: ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.4', 'gpt-5.5'],
 };
 
 function cmdHot(providerArg) {
@@ -466,8 +488,8 @@ function cmdCool(providerArg) {
   console.log(`Cleared hot state for all ${provider} model classes.`);
 }
 
-async function cmdInstall() {
-  const cwd = process.cwd();
+async function cmdInstall(cwd) {
+  if (!cwd) cwd = process.cwd();
 
   // Run the main install.mjs (orchestrator config, all hooks, CLAUDE.md, etc.)
   const { spawnSync } = await import('child_process');
@@ -486,8 +508,6 @@ async function cmdInstall() {
     console.log(`Enforcement hooks already present (${skipped.length}):`);
     for (const item of skipped) console.log(`  = ${item}`);
   }
-
-  process.exit(0);
 }
 
 function cmdRemember(text) {
@@ -559,7 +579,8 @@ async function welcomeScreen(rl, ask) {
     } else {
       // Enter or anything else → save and go to dashboard
       saveProfile(setup.profile, { cwd });
-      return { next: 'dashboard' };
+      await cmdInstall(cwd);
+      return { next: 'main' };
     }
   } else {
     // Not confident — show what's missing before falling through to wizard
@@ -685,109 +706,209 @@ async function welcomeScreen(rl, ask) {
   console.log(box('Setup Complete', summaryLines));
   console.log('');
 
-  return { next: 'dashboard' };
+  await cmdInstall(cwd);
+
+  return { next: 'main' };
 }
 
-// ─── Screen: dashboardScreen ──────────────────────────────────────────────────
+// ─── Screen: mainScreen ───────────────────────────────────────────────────────
 
-async function dashboardScreen(rl, ask) {
+async function mainScreen(rl, ask) {
   const cwd = process.cwd();
   const version = readVersion();
   const profile = loadProfile(cwd);
   const auth = await detectAuth();
-  const env = detectEnvironment();
 
-  // Build status lines for box
-  // If auth is found but provider is disabled in profile, show warning instead of green
-  const claudeProviderEnabled = profile?.providers?.claude?.enabled !== false;
-  const openaiProviderEnabled = profile?.providers?.openai?.enabled !== false;
-  const claudeStatus = auth.claude.found
-    ? (claudeProviderEnabled ? `🟢 Claude ${badge('connected')}` : `⚠️  Claude ${badge('warning')} disabled`)
-    : `🔴 Claude ${badge('missing')}`;
-  const openaiStatus = auth.openai.found
-    ? (openaiProviderEnabled ? `🟢 OpenAI ${badge('connected')}` : `⚠️  OpenAI ${badge('warning')} disabled`)
-    : `🔴 OpenAI ${badge('missing')}`;
-  const envLabel = env.hasReplitTools ? 'Replit + replit-tools' : env.isReplit ? 'Replit' : 'local';
-
-  // Enforcement check
+  const claudePlan = profile?.providers?.claude?.plan ?? 'Pro';
+  const openaiPlan = profile?.providers?.openai?.plan ?? 'Plus';
+  const claudeStatus = auth.claude.found ? `Claude: ${claudePlan} ✓` : `Claude: missing`;
+  const openaiStatus = auth.openai.found ? `OpenAI: ${openaiPlan} ✓` : `OpenAI: missing`;
+
+  console.log(`\ndual-brain v${version}`);
+  console.log(`${claudeStatus}  ·  ${openaiStatus}\n`);
+
+  const recentSessions = importReplitSessions(cwd).slice(0, 5);
+
+  if (recentSessions.length > 0) {
+    console.log('Recent:');
+    recentSessions.forEach((sess, i) => {
+      const activeIndicator = sess.isActive ? ' ●' : '';
+      console.log(`  [${i + 1}] ${sess.age.padEnd(6)}  ${sess.name}${activeIndicator}`);
+    });
+    console.log('');
+  }
+
+  console.log('  [c] Continue last session');
+  console.log('  [n] New session');
+  if (recentSessions.length > 0) {
+    console.log('  [1-9] Resume numbered above');
+  }
+  console.log('  [d] Switch to data-tools');
+  if (!auth.claude.found) console.log('  [j] Login to Claude');
+  if (!auth.openai.found) console.log('  [k] Login to Codex');
+  console.log('  [s] Settings  [q] Exit');
+  console.log('');
+
+  const choice = (await ask('  Choice: ')).trim().toLowerCase();
+
+  if (choice === 'n') { return { next: 'new-session' }; }
+
+  if (choice === 'c') {
+    const sessions = importReplitSessions(cwd);
+    if (sessions.length === 0) {
+      console.log('\n  No recent sessions found.\n');
+      await ask('  Press Enter to continue...');
+      return { next: 'main' };
+    }
+    const { spawnSync } = await import('node:child_process');
+    console.log(`\n  Launching: claude --resume ${sessions[0].id}\n`);
+    spawnSync('claude', ['--resume', sessions[0].id], { stdio: 'inherit' });
+    return { next: 'main' };
+  }
+
+  const numChoice = parseInt(choice, 10);
+  if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= recentSessions.length) {
+    const sess = recentSessions[numChoice - 1];
+    const { spawnSync } = await import('node:child_process');
+    console.log(`\n  Launching: claude --resume ${sess.id}\n`);
+    spawnSync('claude', ['--resume', sess.id], { stdio: 'inherit' });
+    return { next: 'main' };
+  }
+
+  if (choice === 'd') {
+    const { spawnSync } = await import('node:child_process');
+    const which = spawnSync('which', ['claude-menu'], { encoding: 'utf8' });
+    if (which.status === 0) {
+      spawnSync('claude-menu', { stdio: 'inherit' });
+    } else {
+      console.log('\n  data-tools not found — install with: npm i -g replit-tools\n');
+      await ask('  Press Enter to continue...');
+    }
+    return { next: 'main' };
+  }
+
+  if (choice === 'j') {
+    const { spawnSync } = await import('node:child_process');
+    spawnSync('claude', ['login'], { stdio: 'inherit' });
+    return { next: 'main' };
+  }
+
+  if (choice === 'k') {
+    const { spawnSync } = await import('node:child_process');
+    spawnSync('codex', ['login'], { stdio: 'inherit' });
+    return { next: 'main' };
+  }
+
+  if (choice === 's') { return { next: 'settings' }; }
+  if (choice === 'q' || choice === 'exit') { return { next: 'exit' }; }
+
+  return { next: 'main' };
+}
+
+// ─── Screen: newSessionScreen ─────────────────────────────────────────────────
+
+async function newSessionScreen(rl, ask) {
+  const cwd = process.cwd();
+  const input = (await ask('\n  What do you want to do? ')).trim();
+  if (!input) { return { next: 'main' }; }
+
+  const profile = loadProfile(cwd);
+  const detection = detectTask({ prompt: input });
+  const decision = decideRoute({ profile, detection, cwd });
+
+  console.log(`\n  Routing: ${decision.provider}/${decision.model} (${decision.tier})`);
+  console.log(`  Reason: ${decision.explanation}\n`);
+
+  const { spawnSync } = await import('node:child_process');
+  if (decision.provider === 'openai') {
+    spawnSync('codex', [input], { stdio: 'inherit' });
+  } else {
+    spawnSync('claude', ['-p', input], { stdio: 'inherit' });
+  }
+
+  return { next: 'main' };
+}
+
+// ─── Screen: settingsScreen ───────────────────────────────────────────────────
+
+async function settingsScreen(rl, ask) {
+  const cwd = process.cwd();
+  const profile = loadProfile(cwd);
+  const auth = await detectAuth();
+
   let guardCount = 0;
   try {
     const settingsFile = join(cwd, '.claude', 'settings.json');
     if (existsSync(settingsFile)) {
       const settings = JSON.parse(readFileSync(settingsFile, 'utf8'));
       const preToolUse = settings?.hooks?.PreToolUse ?? [];
-      const guardCmd  = 'node .claude/hooks/head-guard.mjs';
-      const tierCmd   = 'node .claude/hooks/enforce-tier.mjs';
-      const hasEdit   = preToolUse.some(e => e.matcher === 'Edit'   && e.hooks?.some(h => h.command === guardCmd));
-      const hasWrite  = preToolUse.some(e => e.matcher === 'Write'  && e.hooks?.some(h => h.command === guardCmd));
-      const hasBash   = preToolUse.some(e => e.matcher === 'Bash'   && e.hooks?.some(h => h.command === guardCmd));
-      const hasAgent  = preToolUse.some(e => e.matcher === 'Agent'  && e.hooks?.some(h => h.command === tierCmd));
+      const guardCmd = 'node .claude/hooks/head-guard.mjs';
+      const tierCmd  = 'node .claude/hooks/enforce-tier.mjs';
+      const hasEdit  = preToolUse.some(e => e.matcher === 'Edit'  && e.hooks?.some(h => h.command === guardCmd));
+      const hasWrite = preToolUse.some(e => e.matcher === 'Write' && e.hooks?.some(h => h.command === guardCmd));
+      const hasBash  = preToolUse.some(e => e.matcher === 'Bash'  && e.hooks?.some(h => h.command === guardCmd));
+      const hasAgent = preToolUse.some(e => e.matcher === 'Agent' && e.hooks?.some(h => h.command === tierCmd));
       guardCount = [hasEdit, hasWrite, hasBash, hasAgent].filter(Boolean).length;
     }
   } catch { /* ignore */ }
 
-  const authSummary = (auth.claude.found && auth.openai.found)
-    ? 'both providers connected'
-    : auth.claude.found
-      ? 'Claude connected, OpenAI missing'
-      : auth.openai.found
-        ? 'OpenAI connected, Claude missing'
-        : 'no providers connected';
-
-  const dashLines = [
-    `${claudeStatus}   ${openaiStatus}`,
-    `🌀 ${envLabel}`,
+  const modeLabel = (m) => m === profile.mode ? `${m} (active)` : m;
+
+  const settingsLines = [
+    `Mode:`,
+    `  [1] ${modeLabel('cost-saver')}`,
+    `  [2] ${modeLabel('balanced')}`,
+    `  [3] ${modeLabel('quality-first')}`,
+    '',
+    `Auth:`,
+    `  Claude: ${auth.claude.found ? `connected (${auth.claude.source})` : 'missing'}`,
+    `  OpenAI: ${auth.openai.found ? `connected (${auth.openai.source})` : 'missing'}`,
     '',
-    `✓ Profile: ${profile.mode} · ${profile.providers?.claude?.enabled && profile.providers?.openai?.enabled ? 'dual' : 'solo'} mode`,
-    `✓ Enforcement: ${guardCount} guards active`,
-    `✓ Auth: ${authSummary}`,
+    `Enforcement: ${guardCount}/4 guards active`,
   ];
 
-  console.log(box(`🧠 Dual-Brain v${version}`, dashLines));
   console.log('');
-
-  // ── Recent Sessions (replit-tools import) ──────────────────────────────────
-  const recentSessions = importReplitSessions(cwd).slice(0, 5);
-  if (recentSessions.length > 0) {
-    console.log(separator('Recent Sessions'));
-    recentSessions.forEach((sess, i) => {
-      const activeIndicator = sess.isActive ? '●' : ' ';
-      const promptsLabel = `(${sess.promptCount} prompt${sess.promptCount !== 1 ? 's' : ''})`;
-      console.log(`  [${i + 1}] ${sess.age.padEnd(6)}  ${activeIndicator} ${sess.name} ${promptsLabel}`);
-    });
-    console.log('');
-  }
-
+  console.log(box('Settings', settingsLines));
+  console.log('');
   console.log(menu([
-    { key: 's', label: 'Status — detailed provider info', section: 'Info' },
-    { key: 'p', label: 'Profile & preferences',        section: 'Settings' },
-    { key: 'a', label: 'Auth management',              section: 'Settings' },
-    { key: 'd', label: 'Diagnostics & repair',         section: 'Settings' },
-    { key: 'q', label: 'Exit to shell',                section: '' },
+    { key: '1', label: 'Switch to cost-saver',   section: 'Mode' },
+    { key: '2', label: 'Switch to balanced',      section: 'Mode' },
+    { key: '3', label: 'Switch to quality-first', section: 'Mode' },
+    { key: 'a', label: 'Add API key',             section: 'Auth' },
+    { key: 'i', label: 'Reinstall hooks',         section: 'Enforcement' },
+    { key: 'b', label: 'Back',                    section: '' },
   ]));
   console.log('');
 
   const choice = (await ask('  Choice: ')).trim().toLowerCase();
 
-  // Numeric choice → session detail
-  const numChoice = parseInt(choice, 10);
-  if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= recentSessions.length) {
-    return { next: 'session-detail', session: recentSessions[numChoice - 1] };
+  if (choice === '1' || choice === '2' || choice === '3') {
+    const modeMap = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
+    profile.mode = modeMap[choice];
+    saveProfile(profile, { cwd });
+    console.log(`  Mode set to: ${profile.mode}`);
+    return { next: 'settings' };
   }
 
-  if (choice === 's') {
-    await cmdStatus([]);
-    await ask('\n  Press Enter to return to dashboard...');
-    return { next: 'dashboard' };
+  if (choice === 'a') {
+    await setupAuth(rl);
+    return { next: 'settings' };
   }
 
-  if (choice === 'p') { return { next: 'profile' }; }
-  if (choice === 'a') { return { next: 'auth' }; }
-  if (choice === 'd') { return { next: 'diagnostics' }; }
-  if (choice === 'q' || choice === 'exit') { return { next: 'exit' }; }
+  if (choice === 'i') {
+    await cmdInstall();
+    return { next: 'settings' };
+  }
 
-  // Unknown choice — stay on dashboard
-  return { next: 'dashboard' };
+  if (choice === 'b' || choice === 'back') { return { next: 'main' }; }
+
+  return { next: 'settings' };
+}
+
+// ─── Screen: dashboardScreen (kept for internal reference, unreachable) ───────
+
+async function dashboardScreen(rl, ask) {
+  return { next: 'main' };
 }
 
 // ─── Screen: authScreen ───────────────────────────────────────────────────────
@@ -1278,12 +1399,15 @@ async function sessionDetailScreen(rl, ask, ctx = {}) {
 // ─── Screen state machine ─────────────────────────────────────────────────────
 
 const SCREENS = {
-  welcome:        welcomeScreen,
-  dashboard:      dashboardScreen,
-  auth:           authScreen,
-  profile:        profileScreen,
-  diagnostics:    diagnosticsScreen,
-  repl:           replScreen,
+  welcome:          welcomeScreen,
+  main:             mainScreen,
+  'new-session':    newSessionScreen,
+  settings:         settingsScreen,
+  dashboard:        dashboardScreen,
+  auth:             authScreen,
+  profile:          profileScreen,
+  diagnostics:      diagnosticsScreen,
+  repl:             replScreen,
   'session-detail': sessionDetailScreen,
 };
 
@@ -1303,7 +1427,7 @@ async function runScreens(startScreen = 'dashboard') {
       ctx = result?.session ? { session: result.session } : {};
     } catch (e) {
       console.error(`Error: ${e.message}`);
-      current = 'dashboard'; // recover to dashboard on error
+      current = 'main';
       ctx = {};
     }
   }
@@ -1326,8 +1450,7 @@ async function main() {
     if (isInteractive) {
       const cwd = process.cwd();
       if (profileExists(cwd)) {
-        // Profile already exists → go straight to dashboard
-        await runScreens('dashboard');
+        await runScreens('main');
       } else {
         // First run: welcomeScreen handles auto-setup detection internally,
         // then falls through to manual wizard if needed.

package/hooks/head-guard.mjs

@@ -15,7 +15,15 @@
 
 import { readFileSync } from 'fs';
 
-const BLOCKED_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit', 'Bash']);
+const BLOCKED_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
+
+// Patterns that indicate a Bash command is writing/mutating the filesystem.
+// Anchored to avoid false positives on grep/find output containing these words.
+const WRITE_BASH_RE = /\brm\b|\bmv\b|\bcp\b|\bmkdir\b|\btouch\b|\bchmod\b|\bchown\b|\bdd\b|\binstall\b|\btruncate\b|\btee\b|\bsed\s+-i\b|\bawk\s+-i\b|>>|(?<![><])>(?![>=])/;
+
+function isBashWriteIntent(command) {
+  return WRITE_BASH_RE.test(command);
+}
 
 // Read stdin JSON payload
 let input;
@@ -23,9 +31,16 @@ try {
   const raw = readFileSync('/dev/stdin', 'utf8');
   input = JSON.parse(raw);
 } catch {
-  // If we can't read / parse input, fail open — don't break sessions
-  // that aren't using dual-brain at all.
-  process.exit(0);
+  // Can't parse input — fail closed to avoid guard bypass.
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: '[dual-brain] head-guard could not parse hook input — blocking as a safety measure.',
+    },
+  };
+  process.stdout.write(JSON.stringify(output));
+  process.exit(2);
 }
 
 const toolName = input.tool_name || '';
@@ -50,9 +65,30 @@ if (BLOCKED_TOOLS.has(toolName)) {
   process.exit(2);
 }
 
-// Also block MCP filesystem write tools (any mcp__ tool with write/create/
-// delete/remove/move/rename in the name).
-if (toolName.startsWith('mcp__') && /write|create|delete|remove|move|rename/i.test(toolName)) {
+// Bash: allow read-only commands; block write-intent ones.
+// Always allow node .claude/hooks/ and node hooks/ — CLAUDE.md instructs HEAD to run these.
+if (toolName === 'Bash') {
+  const command = (input.tool_input && input.tool_input.command) || '';
+  if (/^node\s+\.?(?:\.claude\/)?hooks\//.test(command.trimStart())) {
+    process.exit(0);
+  }
+  if (isBashWriteIntent(command)) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason:
+          '[dual-brain] HEAD cannot run write-intent Bash commands. Dispatch via: dual-brain go "task description"',
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(2);
+  }
+  process.exit(0);
+}
+
+// Block MCP filesystem write tools by name.
+if (toolName.startsWith('mcp__') && /write|create|delete|remove|move|rename|append|patch|truncate|copy|commit|push|stage|merge|update|overwrite/i.test(toolName)) {
   const output = {
     hookSpecificOutput: {
       hookEventName: 'PreToolUse',

package/hooks/test-orchestrator.mjs

@@ -445,7 +445,7 @@ test('enforce-tier: cost-saver demotes think', () => {
     // cost-saver's demote_think=true demotes think→execute when text lacks think words
     const payload = JSON.stringify({
       tool_name: 'Agent',
-      tool_input: { prompt: 'edit the README file', model: 'opus' },
+      tool_input: { prompt: '<!-- dual-brain-dispatch: test23 -->edit the README file', model: 'opus' },
     });
     const { parsed, status } = run(ENFORCE_TIER, payload);
     if (status !== 0) return `non-zero exit: ${status}`;
@@ -494,7 +494,7 @@ test('enforce-tier: auto profile with high-risk file', () => {
     // Description with auth/credentials path → risk classifier detects critical risk → promote to think
     const payload = JSON.stringify({
       tool_name: 'Agent',
-      tool_input: { description: 'update src/auth/credentials.mjs', prompt: 'change the token logic', model: 'sonnet' },
+      tool_input: { description: 'update src/auth/credentials.mjs', prompt: '<!-- dual-brain-dispatch: test25 -->change the token logic', model: 'sonnet' },
     });
     const { parsed, status } = run(ENFORCE_TIER, payload);
     if (status !== 0) return `non-zero exit: ${status}`;
@@ -740,9 +740,9 @@ test('install: preserves existing hooks', () => {
   if (!installSrc.includes('.filter'))
     return 'install.mjs missing .filter() call — may clobber non-dual-brain hooks';
 
-  // The merge logic should spread existingEntries first, then add dual-brain hooks
-  if (!installSrc.includes('existingEntries'))
-    return 'install.mjs missing existingEntries variable — may not preserve other hooks';
+  // The merge logic should filter existing hooks before merging dual-brain hooks
+  if (!installSrc.includes('existingPre') && !installSrc.includes('existingEntries'))
+    return 'install.mjs missing existing hook preservation — may not preserve other hooks';
 
   // Verify it reads existing settings before overwriting
   if (!installSrc.includes('existing') || !installSrc.includes('settings.json'))
@@ -1017,7 +1017,7 @@ test('adaptive loop: end-to-end hash match', () => {
     writeFileSync(LEDGER, '', 'utf8');
 
     // Step 1: Define a specific Agent payload used consistently across all steps
-    const toolInput = { prompt: 'fix the auth bug', description: 'patch auth module' };
+    const toolInput = { prompt: '<!-- dual-brain-dispatch: test40 -->fix the auth bug', description: 'patch auth module' };
     const agentPayload = JSON.stringify({ tool_name: 'Agent', tool_input: toolInput });
 
     // Step 2: Run enforce-tier with this payload (computes and may log a promptHash)

package/mcp-server/index.mjs

@@ -253,7 +253,7 @@ async function handleRequest(msg) {
         return respond(id, {
           protocolVersion: '2024-11-05',
           capabilities: { tools: {} },
-          serverInfo: { name: 'dual-brain', version: '7.1.0' },
+          serverInfo: { name: 'dual-brain', version: '7.1.4' },
         });
 
       case 'initialized':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.1.4",
+  "version": "7.1.6",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.1.0",
+  "version": "7.1.4",
   "description": "Dual-provider AI orchestration — smart routing between Claude and OpenAI",
   "skills": [
     { "name": "go", "description": "Route and dispatch a task", "file": "skills/go.md" },

package/src/decide.mjs

@@ -71,10 +71,37 @@ const MODEL_CAPABILITIES = {
     effortLevels: ['low', 'medium', 'high'],
     costTier: 'medium',
   },
+  'gpt-5.2': {
+    provider: 'openai',
+    tierFit: ['search', 'execute'],
+    contextWindow: 200_000,
+    costTier: 'medium',
+    strengths: ['code-generation', 'analysis'],
+    weaknesses: [],
+    effortLevels: null,
+  },
+  'gpt-5.4-mini': {
+    provider: 'openai',
+    tierFit: ['search'],
+    contextWindow: 200_000,
+    costTier: 'low',
+    strengths: ['quick-tasks', 'search'],
+    weaknesses: ['complex-edits', 'architecture'],
+    effortLevels: null,
+  },
+  'gpt-5.3-codex': {
+    provider: 'openai',
+    tierFit: ['execute'],
+    contextWindow: 200_000,
+    costTier: 'medium',
+    strengths: ['code-generation', 'refactoring'],
+    weaknesses: ['architecture', 'security'],
+    effortLevels: null,
+  },
   'gpt-5.4': {
     provider: 'openai',
     tierFit: ['execute', 'think'],
-    contextWindow: 200_000,
+    contextWindow: 1_050_000,
     strengths: ['refactor', 'debug', 'code-generation', 'test'],
     weaknesses: ['cost'],
     effortLevels: ['low', 'medium', 'high', 'xhigh'],
@@ -83,7 +110,7 @@ const MODEL_CAPABILITIES = {
   'gpt-5.5': {
     provider: 'openai',
     tierFit: ['think'],
-    contextWindow: 200_000,
+    contextWindow: 1_000_000,
     strengths: ['architecture', 'security', 'review', 'planning', 'complex-debug'],
     weaknesses: ['cost', 'latency'],
     effortLevels: ['low', 'medium', 'high', 'xhigh'],
@@ -264,16 +291,19 @@ function applyHealthDowngrade(model, score, provider, available, isHighStakes) {
   }
 }
 
-function applyProfileBias(model, profile, provider, available) {
+function applyProfileBias(model, profile, provider, available, tier) {
   const mode = profile?.mode || profile?.profile || 'auto';
   if (mode === 'cost-saver') {
-    // Prefer cheapest available
+    // Prefer cheapest available that also fits the required tier
     const ranks = {
       claude: ['haiku', 'sonnet', 'opus'],
       openai: ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.4', 'gpt-5.5'],
     };
     for (const m of ranks[provider]) {
-      if (available.includes(m)) return m;
+      if (!available.includes(m)) continue;
+      const caps = MODEL_CAPABILITIES[m];
+      if (tier && caps && !caps.tierFit.includes(tier)) continue;
+      return m;
     }
   }
   if (mode === 'quality-first') {
@@ -535,7 +565,7 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
   model = applyHealthDowngrade(model, healthScores[provider], provider, available[provider], isHighStakes);
 
   // Apply profile mode bias (cost-saver / quality-first / preferences) using patched profile
-  model = applyProfileBias(model, profileWithEffectiveBias, provider, available[provider]);
+  model = applyProfileBias(model, profileWithEffectiveBias, provider, available[provider], detection.tier);
 
   // Safety floor: critical-risk tasks must never use haiku/gpt-4.1-mini even in cost-saver mode
   model = applyCriticalRiskFloor(model, provider, available[provider], detection.risk);

package/src/dispatch.mjs

@@ -647,13 +647,14 @@ async function dispatch(input = {}) {
     }
     _recordDispatchBudget(prompt);
     return {
-      status:        'native-agent',
+      status:        'completed',
+      type:          'native-agent',
       provider:      effectiveProvider,
       model:         effectiveModel,
       command:       null,
       nativeDispatch: nativeDescriptor,
-      exitCode:      null,
-      summary:       `[native] ${nativeDescriptor.description}`,
+      exitCode:      0,
+      summary:       `Routed to ${effectiveProvider}/${effectiveModel} (${effectiveDecision.tier})`,
       durationMs:    0,
       usage:         null,
       error:         null,

package/src/index.mjs

@@ -6,7 +6,7 @@
  * orchestrate() convenience function for programmatic use.
  */
 
-export { loadProfile, saveProfile, ensureProfile, runOnboarding, rememberPreference, forgetPreference, getActivePreferences, getAvailableProviders, isSoloBrain, getHeadModel, detectAuth, detectEnvironment, setupAuth, getActiveKey, removeAuthKey, disableKey, rotateToNextKey } from './profile.mjs';
+export { loadProfile, saveProfile, ensureProfile, runOnboarding, rememberPreference, forgetPreference, getActivePreferences, getAvailableProviders, isSoloBrain, getHeadModel, detectAuth, detectEnvironment, setupAuth, getActiveKey } from './profile.mjs';
 export { detectTask, classifyIntent, classifyRisk, estimateComplexity, inferTier, extractPaths } from './detect.mjs';
 export { decideRoute, getModelCapabilities, getAvailableModels, shouldDualBrain, explainDecision } from './decide.mjs';
 export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrain } from './dispatch.mjs';

package/src/profile.mjs

@@ -269,46 +269,13 @@ async function detectAuth() {
 const AUTH_FILE = (cwd) => join(cwd || process.cwd(), '.dualbrain', 'auth.json');
 
 /**
- * Migrate old single-key format to array format transparently.
- * Old: { claude: { key, savedAt, expiresAt }, openai: { ... } }
- * New: { claude: [{ key, label, savedAt, expiresAt, priority, enabled }], openai: [...] }
- * @param {object} auth
- * @returns {object} migrated auth object
- */
-function _migrateAuthFormat(auth) {
-  const migrated = {};
-  for (const [provider, value] of Object.entries(auth)) {
-    if (Array.isArray(value)) {
-      // Already new format
-      migrated[provider] = value;
-    } else if (value && typeof value === 'object' && value.key) {
-      // Old single-key format — wrap in array
-      migrated[provider] = [
-        {
-          key: value.key,
-          label: 'primary',
-          savedAt: value.savedAt || new Date().toISOString(),
-          expiresAt: value.expiresAt || null,
-          priority: 1,
-          enabled: true,
-        },
-      ];
-    } else {
-      migrated[provider] = value;
-    }
-  }
-  return migrated;
-}
-
-/**
- * Load .dualbrain/auth.json, migrating old single-key format to array format.
+ * Load .dualbrain/auth.json.
  * @param {string} [cwd]
  * @returns {object} auth object with arrays per provider
  */
 function loadAuthKeys(cwd) {
   try {
-    const raw = JSON.parse(readFileSync(AUTH_FILE(cwd), 'utf8'));
-    return _migrateAuthFormat(raw);
+    return JSON.parse(readFileSync(AUTH_FILE(cwd), 'utf8'));
   } catch {
     return {};
   }
@@ -380,73 +347,6 @@ function saveAuthKey(provider, key, opts = {}) {
   }
 }
 
-/**
- * Remove a key by index from the provider's array.
- * @param {string} provider
- * @param {number} index
- * @param {string} [cwd]
- */
-function removeAuthKey(provider, index, cwd) {
-  const authFile = AUTH_FILE(cwd);
-  const dir = dirname(authFile);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
-
-  const auth = loadAuthKeys(cwd);
-  if (!Array.isArray(auth[provider])) return;
-
-  auth[provider].splice(index, 1);
-  writeFileSync(authFile, JSON.stringify(auth, null, 2));
-  chmodSync(authFile, 0o600);
-}
-
-/**
- * Mark a key as enabled:false (used during failover when a key hits rate limits).
- * @param {string} provider
- * @param {number} index
- * @param {string} [cwd]
- */
-function disableKey(provider, index, cwd) {
-  const authFile = AUTH_FILE(cwd);
-  const dir = dirname(authFile);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
-
-  const auth = loadAuthKeys(cwd);
-  if (!Array.isArray(auth[provider]) || !auth[provider][index]) return;
-
-  auth[provider][index].enabled = false;
-  writeFileSync(authFile, JSON.stringify(auth, null, 2));
-  chmodSync(authFile, 0o600);
-}
-
-/**
- * Called when the active key hits a rate limit. Disables the current active key
- * temporarily and returns the next valid key, or null if none available.
- * @param {string} provider
- * @param {string} [cwd]
- * @returns {{ key: string, label: string, priority: number, enabled: boolean, expiresAt: string|null }|null}
- */
-function rotateToNextKey(provider, cwd) {
-  const auth = loadAuthKeys(cwd);
-  const keys = auth[provider] || [];
-  const now = new Date();
-
-  // Find current active key index
-  const sortedValid = keys
-    .map((k, i) => ({ ...k, _idx: i }))
-    .filter(k => k.enabled)
-    .filter(k => !k.expiresAt || new Date(k.expiresAt) > now)
-    .sort((a, b) => (a.priority || 99) - (b.priority || 99));
-
-  if (sortedValid.length === 0) return null;
-
-  // Disable the current active key
-  const currentIdx = sortedValid[0]._idx;
-  disableKey(provider, currentIdx, cwd);
-
-  // Reload and get the next valid key
-  return getActiveKey(provider, cwd);
-}
-
 /**
  * Interactive setup flow: walks user through entering API keys for missing providers.
  * Accepts an existing readline Interface (rl) — does NOT close it.
@@ -974,6 +874,6 @@ export {
   detectPlans, syncPreferencesToMemory,
   detectAuth, detectEnvironment,
   setupAuth, saveAuthKey, loadAuthKeys,
-  getActiveKey, removeAuthKey, disableKey, rotateToNextKey,
+  getActiveKey,
   defaultProfile, autoSetup,
 };