dual-brain 7.1.15 → 7.1.17

package/bin/dual-brain.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // dual-brain — CLI entry point. Commands: init, go, status, remember, forget
 
-import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync, readdirSync, unlinkSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync, mkdirSync, writeFileSync, statSync, readdirSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execSync, spawnSync as _spawnSyncTop } from 'node:child_process';
@@ -169,6 +169,14 @@ Commands:
   remember "preference"     Save a project-scoped preference
   forget "preference"       Remove a preference by fuzzy match
   search "keyword"           Search across all sessions
+  specialists               List available specialist agents with descriptions
+  python "task"             Force Python specialist for the task
+  typescript "task"         Force TypeScript specialist for the task
+  html "task"               Force HTML/CSS specialist for the task
+  linux "task"              Force Linux/DevOps specialist for the task
+  security "task"           Force Security specialist for the task
+    --dry-run               (specialist commands) Show routing without executing
+    --files a,b             (specialist commands) Provide file context
   shell-hook                Output bash snippet to add dual-brain to your shell
                             Usage: dual-brain shell-hook >> ~/.bashrc
 
@@ -391,27 +399,6 @@ 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);
@@ -632,6 +619,53 @@ function cmdForget(text) {
   console.log('Preference removed (if matched).');
 }
 
+function cmdBreakGlass(reason) {
+  if (!reason) err('Usage: dual-brain break-glass "reason"');
+  const cwd = process.cwd();
+  const dualbrain = join(cwd, '.dualbrain');
+  const tokenPath = join(dualbrain, 'break-glass.json');
+  const auditDir  = join(dualbrain, 'audit');
+  const auditFile = join(auditDir, 'head-audit.jsonl');
+  const TTL_MINUTES = 5;
+
+  mkdirSync(dualbrain, { recursive: true });
+  mkdirSync(auditDir, { recursive: true });
+
+  const token = {
+    createdAt: Date.now(),
+    ttlMinutes: TTL_MINUTES,
+    reason,
+  };
+  writeFileSync(tokenPath, JSON.stringify(token, null, 2));
+
+  // Audit entry
+  const auditEntry = {
+    ts: new Date().toISOString(),
+    event: 'break-glass-activated',
+    reason,
+    ttlMinutes: TTL_MINUTES,
+    expiresAt: new Date(token.createdAt + TTL_MINUTES * 60 * 1000).toISOString(),
+  };
+  try {
+    appendFileSync(auditFile, JSON.stringify(auditEntry) + '\n');
+  } catch { /* non-fatal */ }
+
+  const width = 51;
+  const inner = width - 2;
+  const pad = (s) => ' ' + s + ' '.repeat(inner - 1 - s.length);
+  const reasonLine  = `Reason: ${reason}`;
+  const expiresLine = `Expires: ${TTL_MINUTES} minutes`;
+  const auditLine   = 'All tool calls logged to audit.';
+
+  console.log('┌' + '─'.repeat(inner) + '┐');
+  console.log('│' + pad('🔓 Break-Glass Activated') + '│');
+  console.log('├' + '─'.repeat(inner) + '┤');
+  console.log('│' + pad(reasonLine) + '│');
+  console.log('│' + pad(expiresLine) + '│');
+  console.log('│' + pad(auditLine) + '│');
+  console.log('└' + '─'.repeat(inner) + '┘');
+}
+
 // ─── Screen helpers ───────────────────────────────────────────────────────────
 
 /**
@@ -1603,6 +1637,282 @@ async function subscriptionsScreen(rl, ask) {
   return { next: 'main' };
 }
 
+// ─── Onboarding Wizard ───────────────────────────────────────────────────────
+
+/**
+ * 5-step onboarding wizard shown on first run (no .dualbrain/profile.json).
+ * Matches the rounded ┌─┐ box style used in mainScreen / renderHeader.
+ * @param {{ auth, plans, existingSessions }} detection
+ * @param {string} cwd
+ * @param {object} rl  readline interface
+ * @returns {object|null}  profile object to save, or null if cancelled/skipped
+ */
+async function runOnboardingWizard(detection, cwd, rl) {
+  const ask = (q) => new Promise(res => rl.question(q, res));
+  const version = readVersion();
+
+  // ── Rounded box helpers (matching mainScreen style) ────────────────────────
+  const W = 51;
+  const wTop    = `  ┌${'─'.repeat(W)}┐`;
+  const wSep    = `  ├${'─'.repeat(W)}┤`;
+  const wBottom = `  └${'─'.repeat(W)}┘`;
+  const wPad = (s) => {
+    const plain = s.replace(/\x1b\[[0-9;]*m/g, '');
+    let vlen = 0;
+    for (const ch of plain) {
+      const cp = ch.codePointAt(0);
+      if (
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x2600  && cp <= 0x27bf)  ||
+        cp === 0xfe0f || cp === 0x20e3
+      ) { vlen += 2; } else { vlen += 1; }
+    }
+    return s + ' '.repeat(Math.max(0, W - vlen));
+  };
+  const wRow = (s) => `  │ ${wPad(s)}│`;
+
+  // ── Collected wizard state ─────────────────────────────────────────────────
+  const state = {
+    claudePlan:     null,
+    openaiPlan:     null,
+    headModel:      null,
+    importSessions: false,
+    profile:        'auto',
+  };
+
+  const { auth, plans, existingSessions } = detection;
+  const claudeReady = auth.claude.found;
+  const openaiReady = auth.openai.found;
+
+  // ══════════════════════════════════════════════════════════════════════════
+  // Step 1 — Welcome & provider detection
+  // ══════════════════════════════════════════════════════════════════════════
+  console.log('');
+  console.log(wTop);
+  console.log(wRow(`🧠 Dual-Brain v${version} — First-time Setup`));
+  console.log(wSep);
+  console.log(wRow(`Step 1 of 5: Detected providers`));
+  console.log(wSep);
+
+  const claudePlanLabel = claudeReady
+    ? (CLAUDE_PLAN_LABELS[plans.claude] ?? plans.claude ?? 'plan unknown')
+    : null;
+  const openaiPlanLabel = openaiReady
+    ? (OPENAI_PLAN_LABELS[plans.openai] ?? plans.openai ?? 'plan unknown')
+    : null;
+
+  console.log(wRow(claudeReady
+    ? `✓ Claude CLI  ${claudePlanLabel ? `(${claudePlanLabel})` : ''}`
+    : `✗ Claude CLI  not logged in`));
+  console.log(wRow(openaiReady
+    ? `✓ Codex CLI   ${openaiPlanLabel ? `(${openaiPlanLabel})` : ''}`
+    : `✗ Codex CLI   not logged in`));
+  if (existingSessions.length > 0) {
+    console.log(wRow(`✓ ${existingSessions.length} data-tools session${existingSessions.length !== 1 ? 's' : ''} found`));
+  }
+  console.log(wSep);
+  console.log(wRow(`[Enter] Continue setup   [s] Skip wizard`));
+  console.log(wBottom);
+  console.log('');
+
+  if (!claudeReady && !openaiReady) {
+    console.log('  No AI provider found. Log in first:');
+    console.log('    claude auth login   — for Claude');
+    console.log('    codex login         — for OpenAI/Codex');
+    console.log('  Then re-run: dual-brain init\n');
+    return null;
+  }
+
+  const step1 = (await ask('  > ')).trim().toLowerCase();
+  if (step1 === 's') {
+    // Skip: auto-save detected plans and proceed directly
+    const skippedProfile = loadProfile(cwd);
+    if (claudeReady) skippedProfile.providers.claude = { enabled: true, plan: plans.claude || 'pro' };
+    if (openaiReady) skippedProfile.providers.openai = { enabled: true, plan: plans.openai || 'plus' };
+    const enabledCount = [claudeReady, openaiReady].filter(Boolean).length;
+    skippedProfile.mode = enabledCount >= 2 ? 'auto' : claudeReady ? 'solo-claude' : 'solo-openai';
+    return skippedProfile;
+  }
+
+  // ══════════════════════════════════════════════════════════════════════════
+  // Step 2 — Budget / plan selection
+  // ══════════════════════════════════════════════════════════════════════════
+  console.log('');
+  console.log(wTop);
+  console.log(wRow(`🧠 Dual-Brain v${version} — First-time Setup`));
+  console.log(wSep);
+  console.log(wRow(`Step 2 of 5: Subscription plans`));
+  console.log(wSep);
+
+  if (claudeReady) {
+    const detectedClaudePlan = plans.claude || 'pro';
+    const detectedClaudeLabel = CLAUDE_PLAN_LABELS[detectedClaudePlan] ?? detectedClaudePlan;
+    console.log(wRow(`Claude — detected: ${detectedClaudeLabel}`));
+    console.log(wRow(`  [1] Pro ($20/mo)`));
+    console.log(wRow(`  [2] Max x5 ($100/mo)`));
+    console.log(wRow(`  [3] Max x20 ($200/mo)`));
+    console.log(wRow(`  [Enter] Keep detected (${detectedClaudeLabel})`));
+    console.log(wSep);
+    const claudeChoice = (await ask('  Claude plan [1/2/3/Enter]: ')).trim();
+    const claudePlanMap = { '1': 'pro', '2': 'max5', '3': 'max20' };
+    state.claudePlan = claudePlanMap[claudeChoice] || detectedClaudePlan;
+  }
+
+  if (openaiReady) {
+    const detectedOpenaiPlan = plans.openai || 'plus';
+    const detectedOpenaiLabel = OPENAI_PLAN_LABELS[detectedOpenaiPlan] ?? detectedOpenaiPlan;
+    console.log(wRow(`OpenAI — detected: ${detectedOpenaiLabel}`));
+    console.log(wRow(`  [1] Plus ($20/mo)`));
+    console.log(wRow(`  [2] Pro ($100/mo)`));
+    console.log(wRow(`  [3] Pro ($200/mo higher limits)`));
+    console.log(wRow(`  [Enter] Keep detected (${detectedOpenaiLabel})`));
+    console.log(wSep);
+    const openaiChoice = (await ask('  OpenAI plan [1/2/3/Enter]: ')).trim();
+    const openaiPlanMap = { '1': 'plus', '2': 'pro', '3': 'pro200' };
+    state.openaiPlan = openaiPlanMap[openaiChoice] || detectedOpenaiPlan;
+  }
+
+  console.log(wBottom);
+
+  // ══════════════════════════════════════════════════════════════════════════
+  // Step 3 — HEAD model selection
+  // ══════════════════════════════════════════════════════════════════════════
+  const hasBigPlan = state.claudePlan === 'max5' || state.claudePlan === 'max20';
+  const recommendedModel = hasBigPlan ? 'claude-opus-4-5' : 'claude-sonnet-4-5';
+  const recommendedLabel = hasBigPlan
+    ? 'Opus (Max plan — best quality)'
+    : 'Sonnet (Pro plan — balanced speed/quality)';
+
+  console.log('');
+  console.log(wTop);
+  console.log(wRow(`🧠 Dual-Brain v${version} — First-time Setup`));
+  console.log(wSep);
+  console.log(wRow(`Step 3 of 5: HEAD model (think-tier)`));
+  console.log(wSep);
+  console.log(wRow(`Recommended: ${recommendedLabel}`));
+  console.log(wSep);
+  console.log(wRow(`  [1] Haiku   — fastest, lowest cost`));
+  console.log(wRow(`  [2] Sonnet  — balanced (recommended for Pro)`));
+  console.log(wRow(`  [3] Opus    — best quality (recommended for Max)`));
+  console.log(wRow(`  [Enter] Use recommended`));
+  console.log(wBottom);
+  console.log('');
+
+  const step3 = (await ask('  HEAD model [1/2/3/Enter]: ')).trim();
+  const modelMap = {
+    '1': 'claude-haiku-4-5',
+    '2': 'claude-sonnet-4-5',
+    '3': 'claude-opus-4-5',
+  };
+  state.headModel = modelMap[step3] || recommendedModel;
+
+  // ══════════════════════════════════════════════════════════════════════════
+  // Step 4 — Import sessions + profile selection
+  // ══════════════════════════════════════════════════════════════════════════
+  console.log('');
+  console.log(wTop);
+  console.log(wRow(`🧠 Dual-Brain v${version} — First-time Setup`));
+  console.log(wSep);
+  console.log(wRow(`Step 4 of 5: Sessions & routing profile`));
+  console.log(wSep);
+
+  if (existingSessions.length > 0) {
+    console.log(wRow(`Import ${existingSessions.length} data-tools session${existingSessions.length !== 1 ? 's' : ''}?`));
+    console.log(wRow(`  [y] Yes   [Enter/n] Skip`));
+    console.log(wSep);
+    const importChoice = (await ask('  Import sessions [y/Enter]: ')).trim().toLowerCase();
+    state.importSessions = importChoice === 'y';
+    if (state.importSessions) {
+      console.log('');
+      console.log(`  Importing ${existingSessions.length} sessions...`);
+      const recent = existingSessions.slice(0, 5);
+      for (const sess of recent) {
+        console.log(`  ${sess.age.padEnd(6)}  ${sess.name}`);
+      }
+      if (existingSessions.length > 5) {
+        console.log(`  ... and ${existingSessions.length - 5} more`);
+      }
+    }
+    console.log(wSep);
+  }
+
+  console.log(wRow(`Routing profile:`));
+  console.log(wRow(`  [1] auto         — adapts based on task risk & outcomes`));
+  console.log(wRow(`  [2] balanced     — best model per tier, normal budgets`));
+  console.log(wRow(`  [3] cost-saver   — prefer cheaper models, skip GPT`));
+  console.log(wRow(`  [4] quality-first — dual-brain for medium+ risk`));
+  console.log(wRow(`  [Enter] auto (recommended)`));
+  console.log(wBottom);
+  console.log('');
+
+  const step4 = (await ask('  Profile [1/2/3/4/Enter]: ')).trim();
+  const profileMap = { '1': 'auto', '2': 'balanced', '3': 'cost-saver', '4': 'quality-first' };
+  state.profile = profileMap[step4] || 'auto';
+
+  // ══════════════════════════════════════════════════════════════════════════
+  // Step 5 — Summary & confirm
+  // ══════════════════════════════════════════════════════════════════════════
+  const claudeSummary = state.claudePlan
+    ? `Claude:     ${CLAUDE_PLAN_LABELS[state.claudePlan] ?? state.claudePlan}`
+    : `Claude:     not configured`;
+  const openaiSummary = state.openaiPlan
+    ? `OpenAI:     ${OPENAI_PLAN_LABELS[state.openaiPlan] ?? state.openaiPlan}`
+    : `OpenAI:     not configured`;
+  const modelSummary   = `HEAD model: ${state.headModel}`;
+  const profileSummary = `Profile:    ${state.profile}`;
+  const sessionSummary = existingSessions.length > 0
+    ? `Sessions:   ${state.importSessions ? `${existingSessions.length} imported` : 'skipped'}`
+    : null;
+
+  console.log('');
+  console.log(wTop);
+  console.log(wRow(`🧠 Dual-Brain v${version} — First-time Setup`));
+  console.log(wSep);
+  console.log(wRow(`Step 5 of 5: Summary`));
+  console.log(wSep);
+  console.log(wRow(claudeSummary));
+  console.log(wRow(openaiSummary));
+  console.log(wRow(modelSummary));
+  console.log(wRow(profileSummary));
+  if (sessionSummary) console.log(wRow(sessionSummary));
+  console.log(wSep);
+  console.log(wRow(`[Enter] Save and start   [q] Quit without saving`));
+  console.log(wBottom);
+  console.log('');
+
+  const step5 = (await ask('  > ')).trim().toLowerCase();
+  if (step5 === 'q') {
+    console.log('\n  Setup cancelled.\n');
+    return null;
+  }
+
+  // ── Build and return the profile object ────────────────────────────────────
+  const finalProfile = loadProfile(cwd);
+
+  if (state.claudePlan) {
+    finalProfile.providers.claude = { enabled: true, plan: state.claudePlan };
+  } else if (claudeReady) {
+    finalProfile.providers.claude = { enabled: true, plan: plans.claude || 'pro' };
+  }
+
+  if (state.openaiPlan) {
+    finalProfile.providers.openai = { enabled: true, plan: state.openaiPlan };
+  } else if (openaiReady) {
+    finalProfile.providers.openai = { enabled: true, plan: plans.openai || 'plus' };
+  }
+
+  const enabledCount = [
+    finalProfile.providers?.claude?.enabled,
+    finalProfile.providers?.openai?.enabled,
+  ].filter(Boolean).length;
+
+  finalProfile.mode = enabledCount >= 2 ? state.profile : claudeReady ? 'solo-claude' : 'solo-openai';
+  finalProfile.headModel = state.headModel;
+  finalProfile.bias = state.profile;
+
+  return finalProfile;
+}
+
 // ─── Screen: dashboardScreen (kept for internal reference, unreachable) ───────
 
 async function dashboardScreen(rl, ask) {
@@ -2244,6 +2554,151 @@ async function runScreens(startScreen = 'dashboard') {
   rl.close();
 }
 
+// ─── Specialist commands ──────────────────────────────────────────────────────
+
+const SPECIALIST_DEFAULTS = {
+  python:     { name: 'Python',       description: 'Python stdlib, typing, async' },
+  typescript: { name: 'TypeScript',   description: 'TS type system, React, Node' },
+  html:       { name: 'HTML/CSS',     description: 'Semantic HTML, CSS, accessibility' },
+  linux:      { name: 'Linux/DevOps', description: 'Sysadmin, Docker, nginx, shell' },
+  security:   { name: 'Security',     description: 'Auth, crypto, OWASP, threat model' },
+};
+
+function loadSpecialistRegistry() {
+  const regPath = join(__dirname, '..', 'agents', 'specialists', 'registry.json');
+  try {
+    const raw = JSON.parse(readFileSync(regPath, 'utf8'));
+    const out = {};
+    for (const [key, val] of Object.entries(raw.specialists || {})) {
+      out[key] = { name: val.name || key, description: val.description || '' };
+    }
+    return out;
+  } catch {
+    return SPECIALIST_DEFAULTS;
+  }
+}
+
+function cmdSpecialists() {
+  const registry = loadSpecialistRegistry();
+  const entries  = Object.entries(registry);
+
+  // Build padded rows
+  const rows = entries.map(([key, val]) => {
+    const k = key.padEnd(12);
+    const d = val.description;
+    return `│  ${k}${d}`;
+  });
+
+  // Find longest row for width
+  const inner = Math.max(
+    ...rows.map(r => r.length),
+    '│ Usage: dual-brain python "task description"     │'.length - 2,
+  );
+  const width = inner + 1; // account for trailing │
+
+  function pad(str) {
+    return str + ' '.repeat(Math.max(0, width - str.length - 1)) + '│';
+  }
+
+  const top    = '┌' + '─'.repeat(width - 1) + '┐';
+  const title  = pad('│ 🎯 Available Specialists');
+  const divTop = '├' + '─'.repeat(width - 1) + '┤';
+  const divBot = '├' + '─'.repeat(width - 1) + '┤';
+  const bot    = '└' + '─'.repeat(width - 1) + '┘';
+
+  console.log(top);
+  console.log(title);
+  console.log(divTop);
+  for (const row of rows) console.log(pad(row));
+  console.log(divBot);
+  console.log(pad('│ Usage: dual-brain python "task description"'));
+  console.log(pad('│ Auto-routing: off (use dual-brain go for auto)'));
+  console.log(bot);
+}
+
+async function cmdSpecialistGo(specialist, args) {
+  const dryRun   = args.includes('--dry-run');
+  const verbose  = args.includes('--verbose') || args.includes('-v');
+  const filesRaw = flag(args, '--files');
+  const files    = filesRaw && typeof filesRaw === 'string'
+    ? filesRaw.split(',').map(f => f.trim()).filter(Boolean)
+    : [];
+
+  const prompt = args.find(a => !a.startsWith('--') && !a.startsWith('-') && a !== (filesRaw ?? ''));
+  if (!prompt) err(`Usage: dual-brain ${specialist} "task description" [--dry-run] [--files a,b]`);
+
+  const cwd     = process.cwd();
+  const profile = await ensureProfile(cwd);
+  const detection = detectTask({ prompt, files });
+
+  // Override specialist, preserve everything else
+  detection.specialist = specialist;
+
+  console.log(`[specialist: ${specialist}] ${detection.explanation}`);
+
+  if (verbose) {
+    vtrace(`Intent: ${detection.intent} | Risk: ${detection.risk} | Complexity: ${detection.complexity} | Effort: ${detection.effort ?? 'n/a'}`);
+    vtrace(`Tier: ${detection.tier} | Specialist override: ${specialist}`);
+  }
+
+  const decision = decideRoute({ profile, detection, cwd });
+
+  if (verbose) {
+    const modelLabel = decision.effort ? `${decision.model} (${decision.effort})` : decision.model;
+    vtrace(`Model selection: ${modelLabel}`);
+    vtrace(`Dual-brain: ${decision.dualBrain ? 'yes' : 'no'}`);
+  }
+
+  console.log(`  specialist : ${specialist}`);
+  console.log(`  provider   : ${decision.provider}`);
+  console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
+  console.log(`  tier       : ${decision.tier}`);
+  console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
+  console.log(`  reason     : ${decision.explanation}`);
+
+  if (dryRun) {
+    console.log('\n(dry-run — not executing)');
+    return;
+  }
+
+  console.log('\nDispatching...');
+  let result;
+  if (decision.dualBrain) {
+    result = await dispatchDualBrain({ decision, prompt, files, cwd });
+    console.log(`\nConsensus: ${result.consensus}`);
+    if (result.claude?.summary) console.log(`Claude : ${result.claude.summary}`);
+    if (result.openai?.summary) console.log(`OpenAI : ${result.openai.summary}`);
+    saveSession({
+      objective:    prompt,
+      branch:       null,
+      filesChanged: files,
+      commandsRun:  [`dual-brain ${specialist} "${prompt}"`],
+      lastResult:   { status: 'success', summary: result.consensus || 'dual-brain complete' },
+      provider:     decision.provider,
+      nextAction:   null,
+    }, cwd);
+  } else {
+    result = await dispatch({ decision, prompt, files, cwd });
+    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);
+    if (result.error)   process.stderr.write(`${result.error}\n`);
+    saveSession({
+      objective:    prompt,
+      branch:       null,
+      filesChanged: files,
+      commandsRun:  [`dual-brain ${specialist} "${prompt}"`],
+      lastResult:   {
+        status:  result.status === 'completed' ? 'success' : 'failure',
+        summary: result.summary || (result.status === 'completed' ? 'completed' : `exit ${result.exitCode}`),
+      },
+      provider:     decision.provider,
+      nextAction:   null,
+    }, cwd);
+    if (result.status !== 'completed') process.exit(1);
+  }
+}
+
 // ─── Entry point ─────────────────────────────────────────────────────────────
 
 async function main() {
@@ -2267,9 +2722,20 @@ async function main() {
       if (profileExists(cwd)) {
         await runScreens('main');
       } else {
-        // First run: welcomeScreen handles auto-setup detection internally,
-        // then falls through to manual wizard if needed.
-        await runScreens('welcome');
+        // First run: run the 5-step onboarding wizard, then go to main.
+        process.stdout.write(`\ndual-brain v${readVersion()} — Setup\n\nDetecting your setup...\n`);
+        const auth  = await detectAuth();
+        const plans = detectPlans();
+        const existingSessions = importReplitSessions(cwd);
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const wizardProfile = await runOnboardingWizard({ auth, plans, existingSessions }, cwd, rl);
+        if (wizardProfile) {
+          saveProfile(wizardProfile, { cwd });
+          await cmdInstall(cwd);
+          console.log('\n  ✅ Setup complete! Starting dual-brain...\n');
+        }
+        rl.close();
+        await runScreens('main');
       }
     } else {
       // Non-TTY: print status card and exit
@@ -2285,8 +2751,21 @@ async function main() {
 
   if (cmd === 'init') {
     if (isInteractive) {
-      // Run welcome wizard then dashboard
-      await runScreens('welcome');
+      // Run 5-step onboarding wizard then main screen
+      const cwd = process.cwd();
+      process.stdout.write(`\ndual-brain v${readVersion()} — Setup\n\nDetecting your setup...\n`);
+      const auth  = await detectAuth();
+      const plans = detectPlans();
+      const existingSessions = importReplitSessions(cwd);
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const wizardProfile = await runOnboardingWizard({ auth, plans, existingSessions }, cwd, rl);
+      if (wizardProfile) {
+        saveProfile(wizardProfile, { cwd });
+        await cmdInstall(cwd);
+        console.log('\n  ✅ Setup complete! Starting dual-brain...\n');
+      }
+      rl.close();
+      await runScreens('main');
     } else {
       await cmdInit();
     }
@@ -2303,8 +2782,14 @@ async function main() {
   if (cmd === 'status')   { await cmdStatus(args.slice(1)); return; }
   if (cmd === 'hot')      { cmdHot(args[1]); return; }
   if (cmd === 'cool')     { cmdCool(args[1]); return; }
-  if (cmd === 'remember') { cmdRemember(args[1]); return; }
-  if (cmd === 'forget')   { cmdForget(args[1]); return; }
+  if (cmd === 'remember')    { cmdRemember(args[1]); return; }
+  if (cmd === 'forget')      { cmdForget(args[1]); return; }
+  if (cmd === 'break-glass') { cmdBreakGlass(args.slice(1).join(' ')); return; }
+
+  if (cmd === 'specialists') { cmdSpecialists(); return; }
+
+  const SPECIALIST_CMDS = new Set(Object.keys(loadSpecialistRegistry()));
+  if (SPECIALIST_CMDS.has(cmd)) { await cmdSpecialistGo(cmd, args.slice(1)); return; }
 
   if (cmd === 'search') {
     const query = args.slice(1).filter(a => !a.startsWith('--')).join(' ');

package/install.mjs

@@ -14,6 +14,7 @@ import { createInterface } from 'readline';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { spawnSync } from 'child_process';
+import { createHash } from 'crypto';
 
 // Skip hook installation during global npm install — hooks are installed
 // when the user runs 'dual-brain install' in their project directory.
@@ -863,6 +864,39 @@ function generateGitignoreEntries(workspace) {
   return { existing, needed };
 }
 
+// ─── Hook Manifest ──────────────────────────────────────────────────────────
+
+function hashString(s) {
+  return createHash('sha256').update(s).digest('hex');
+}
+
+function generateHookManifest(settings) {
+  const hooks = settings.hooks || {};
+  const preHooks = (hooks.PreToolUse || []).flatMap(entry =>
+    (entry.hooks || []).map(h => hashString(h.command || ''))
+  );
+  const postHooks = (hooks.PostToolUse || []).flatMap(entry =>
+    (entry.hooks || []).map(h => hashString(h.command || ''))
+  );
+  const settingsHash = hashString(JSON.stringify(hooks));
+  return {
+    generatedAt: new Date().toISOString(),
+    expectedHooks: {
+      PreToolUse: preHooks,
+      PostToolUse: postHooks,
+    },
+    settingsHash,
+  };
+}
+
+function writeHookManifest(workspace, settings) {
+  const dualbrain = join(workspace, '.dualbrain');
+  mkdirSync(dualbrain, { recursive: true });
+  const manifest = generateHookManifest(settings);
+  writeFileSync(join(dualbrain, 'hook-manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+  return manifest;
+}
+
 // ─── Installation ───────────────────────────────────────────────────────────
 
 function install(workspace, env, mode) {
@@ -915,6 +949,9 @@ function install(workspace, env, mode) {
   writeFileSync(join(target, 'settings.json'), JSON.stringify(settings, null, 2) + '\n');
   actions.push('✓ settings.json (hooks registered)');
 
+  writeHookManifest(workspace, settings);
+  actions.push('✓ .dualbrain/hook-manifest.json (integrity manifest)');
+
   const claudeMd = generateClaudeMd(mode);
   writeClaudeMd(join(target, 'CLAUDE.md'), claudeMd);
   actions.push('✓ CLAUDE.md (session instructions)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.1.15",
+  "version": "7.1.17",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
     "url": "https://github.com/1xmint/dual-brain.git"
   },
   "scripts": {
-    "test": "node hooks/test-orchestrator.mjs",
+    "test": "node .claude/hooks/test-orchestrator.mjs",
     "test:core": "node --test src/test.mjs",
     "postinstall": "echo 'dual-brain installed. Run: dual-brain install (in your project) to set up hooks.'"
   },