dual-brain 0.2.2 → 0.2.4

package/bin/dual-brain.mjs

@@ -15,6 +15,7 @@ import {
   detectCapabilities,
   saveSubscription, listSubscriptions,
   autoSetup,
+  loadCredentials, saveCredentials, getCredentialSummary, detectCredentials, addCredential, removeCredential, checkCredentialHealth,
 } from '../src/profile.mjs';
 
 import { detectTask } from '../src/detect.mjs';
@@ -1089,7 +1090,20 @@ function profileExists(cwd) {
   const dir = cwd || process.cwd();
   const globalPath  = join(process.env.HOME || '/root', '.config', 'dual-brain', 'profile.json');
   const projectPath = join(dir, '.dualbrain', 'profile.json');
-  return existsSync(projectPath) || existsSync(globalPath);
+  // Check file existence AND that setup wizard completed (setupComplete flag)
+  if (existsSync(projectPath)) {
+    try {
+      const p = JSON.parse(readFileSync(projectPath, 'utf8'));
+      return p.setupComplete === true;
+    } catch { return true; } // malformed but exists — treat as complete
+  }
+  if (existsSync(globalPath)) {
+    try {
+      const p = JSON.parse(readFileSync(globalPath, 'utf8'));
+      return p.setupComplete === true;
+    } catch { return true; }
+  }
+  return false;
 }
 
 // ─── Plan label helpers ───────────────────────────────────────────────────────
@@ -1668,6 +1682,141 @@ function makeBoxRow(content, W) {
   return `│ ${content}${' '.repeat(padding)} │`;
 }
 
+// ─── Command palette: input classifier ───────────────────────────────────────
+
+/**
+ * Classify user input into one of three tiers:
+ *   { tier: 'free', command, args }   — deterministic, zero tokens
+ *   { tier: 'cheap' }                 — question → haiku
+ *   { tier: 'full' }                  — work task → confirm then dispatch
+ */
+function classifyInput(input) {
+  const trimmed = input.trim();
+  const lower   = trimmed.toLowerCase();
+  const parts   = trimmed.split(/\s+/);
+  const cmd     = parts[0].toLowerCase();
+  const args    = parts.slice(1);
+
+  // Tier 1: FREE — exact command matches
+  const FREE_COMMANDS = new Map([
+    ['resume', 'resume'],
+    ['r',      'resume'],
+    ['status', 'status'],
+    ['sessions', 'sessions'],
+    ['ss',     'sessions'],
+    ['settings', 'settings'],
+    ['s',      'settings'],
+    ['team',   'team'],
+    ['t',      'team'],
+    ['doctor', 'doctor'],
+    ['d',      'doctor'],
+    ['health', 'health'],
+    ['h',      'health'],
+    ['projects', 'projects'],
+    ['p',      'projects'],
+    ['help',   'help'],
+    ['?',      'help'],
+    ['quit',   'quit'],
+    ['q',      'quit'],
+    ['exit',   'quit'],
+    ['budget', 'budget'],
+    ['b',      'budget'],
+  ]);
+
+  if (FREE_COMMANDS.has(cmd)) {
+    return { tier: 'free', command: FREE_COMMANDS.get(cmd), args };
+  }
+
+  // Multi-word free commands
+  if (lower.startsWith('search ')) {
+    return { tier: 'free', command: 'search', args: parts.slice(1) };
+  }
+  if (lower === 'init --replit') {
+    return { tier: 'free', command: 'init --replit', args: [] };
+  }
+
+  // Tier 2: CHEAP — question / diagnostic patterns → haiku
+  const QUESTION_WORDS = /^(why|what|how|where|when|who|is my|check|show me|explain|tell me|list|am i|are there|does|did|can i|will|should i)/i;
+  const QUESTION_CONTAINS = /\b(why|what|how is|how are|where is|where are|explain|tell me|show me)\b/i;
+  if (QUESTION_WORDS.test(lower) || QUESTION_CONTAINS.test(lower)) {
+    return { tier: 'cheap' };
+  }
+
+  // Tier 3: FULL — everything else is a work task
+  return { tier: 'full' };
+}
+
+// ─── Dashboard: resume state detection ───────────────────────────────────────
+
+/**
+ * Detect resumable state for dashboard contextual hint.
+ * Returns an object with type ('resumable' | 'fresh' | 'none') and detail fields.
+ * All checks are best-effort and fail silent.
+ */
+async function detectResumeState(cwd) {
+  const result = { type: 'none', label: null, ageLabel: null, nextAction: null };
+
+  // Check for recent receipt (< 24h)
+  try {
+    const { getLatestReceipt } = await import('../src/receipt.mjs');
+    const receipt = getLatestReceipt(cwd);
+    if (receipt) {
+      const ageMs = Date.now() - Date.parse(receipt.timestamp);
+      if (ageMs < 24 * 60 * 60 * 1000) {
+        const mins  = Math.round(ageMs / 60000);
+        const age   = mins < 60
+          ? `${mins}m ago`
+          : mins < 1440
+            ? `${Math.round(mins / 60)}h ago`
+            : `${Math.round(mins / 1440)}d ago`;
+        const fileCount = (receipt.filesChanged || []).length;
+        const filePart  = fileCount > 0 ? ` · ${fileCount} file${fileCount !== 1 ? 's' : ''}` : '';
+        result.type       = 'resumable';
+        result.label      = (receipt.goal || 'last session').slice(0, 40);
+        result.ageLabel   = age;
+        result.filePart   = filePart;
+        result.nextAction = (receipt.nextAction || '').slice(0, 35);
+        return result;
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  // Check for open tasks in ledger
+  try {
+    const { getOpenTasks } = await import('../src/ledger.mjs');
+    const open = getOpenTasks(cwd);
+    if (open.length > 0) {
+      result.type       = 'resumable';
+      result.label      = (open[0].intent || 'open task').slice(0, 40);
+      result.ageLabel   = null;
+      result.filePart   = '';
+      result.nextAction = `${open.length} open task${open.length !== 1 ? 's' : ''}`;
+      return result;
+    }
+  } catch { /* non-fatal */ }
+
+  // Check if this is a fresh project (package.json but no dual-brain history)
+  try {
+    const { existsSync: exists } = await import('node:fs');
+    const { join: pjoin } = await import('node:path');
+    const hasPkg = exists(pjoin(cwd, 'package.json'));
+    const hasHistory = exists(pjoin(cwd, '.dual-brain', 'receipts'));
+    if (hasPkg && !hasHistory) {
+      let pkgName = 'this project';
+      try {
+        const { readFileSync: rfs } = await import('node:fs');
+        const pkg = JSON.parse(rfs(pjoin(cwd, 'package.json'), 'utf8'));
+        if (pkg.name) pkgName = pkg.name;
+      } catch {}
+      result.type  = 'fresh';
+      result.label = pkgName;
+      return result;
+    }
+  } catch { /* non-fatal */ }
+
+  return result;
+}
+
 // ─── Screen: mainScreen ───────────────────────────────────────────────────────
 
 async function mainScreen(rl, ask) {
@@ -1737,31 +1886,20 @@ async function mainScreen(rl, ask) {
   // ── Interrupted work detection ────────────────────────────────────────────
   const interrupted = detectInterruptedWork(allSessions, cwd);
 
-  // ── Box layout ────────────────────────────────────────────────────────────
-  const termW = process.stdout.columns || 60;
-  const boxW  = Math.min(termW - 2, 60); // outer width (including │ │)
-  const W     = boxW - 4;                // inner content width (│ {content} │)
-
-  const top = `┌${'─'.repeat(boxW - 2)}┐`;
-  const sep = `├${'─'.repeat(boxW - 2)}┤`;
-  const bot = `└${'─'.repeat(boxW - 2)}┘`;
-
-  const row = (content) => makeBoxRow(content, W);
+  // ── Studio Console layout ─────────────────────────────────────────────────
+  const termW = process.stdout.columns || 80;
+  const W     = Math.min(termW - 2, 78); // usable content width
 
   // ── Continuation card (interrupted work) ─────────────────────────────────
   if (interrupted) {
-    const ctop = `┌${'─'.repeat(boxW - 2)}┐`;
-    const csep = `├${'─'.repeat(boxW - 2)}┤`;
-    const cbot = `└${'─'.repeat(boxW - 2)}┘`;
-    const crow = (content) => makeBoxRow(content, W);
-
-    const titleLine = `\x1b[33m💡\x1b[0m Continue: ${interrupted.sessionName}`;
-    const lastLine  = interrupted.lastState
-      ? `   Last: ${interrupted.lastState} · ${interrupted.ageLabel}`
-      : `   ${interrupted.reason} · ${interrupted.ageLabel}`;
-    const actLine   = '   [Enter] Resume  [n] New session  [s] Skip';
-
-    process.stdout.write([ctop, crow(titleLine), csep, crow(lastLine), crow(actLine), cbot].join('\n') + '\n\n');
+    const DIM = '\x1b[2m', RST = '\x1b[0m', YLW = '\x1b[33m';
+    process.stdout.write(`\n ${YLW}Continue:${RST} ${interrupted.sessionName}\n`);
+    if (interrupted.lastState) {
+      process.stdout.write(` ${DIM}Last: ${interrupted.lastState} · ${interrupted.ageLabel}${RST}\n`);
+    } else {
+      process.stdout.write(` ${DIM}${interrupted.reason} · ${interrupted.ageLabel}${RST}\n`);
+    }
+    process.stdout.write(` ${DIM}[Enter] resume  [n] new  [s] skip${RST}\n\n`);
 
     // Wait for a keypress to decide what to do with the card
     const readline2 = await import('node:readline');
@@ -1833,8 +1971,13 @@ async function mainScreen(rl, ask) {
     envReport = scanEnvironment(cwd);
   } catch { /* non-fatal */ }
 
-  // ── Box 1 — Header row data ─────────────────────────────────────────────
-  const providerLine = buildProviderStatusLine(profile, auth, envReport);
+  // ── Studio Console: resolve provider availability ────────────────────────
+  const claudeAvail = envReport
+    ? envReport.secrets?.ANTHROPIC_API_KEY || auth.claude.found
+    : auth.claude.found;
+  const openaiAvail = envReport
+    ? envReport.secrets?.OPENAI_API_KEY || auth.openai.found
+    : auth.openai.found;
 
   // ── Box 2 — Workspace: gather git data ───────────────────────────────────
   let gitBranch       = 'unknown';
@@ -1878,24 +2021,14 @@ async function mainScreen(rl, ask) {
     }
   } catch {}
 
-  // ── Box 2 rows ────────────────────────────────────────────────────────────
+  // ── Workspace data ────────────────────────────────────────────────────────
   const uncommittedPart = gitUncommitted > 0 ? ` · ${gitUncommitted} uncommitted` : '';
   const aheadPart       = gitAheadCount  > 0 ? ` · ${gitAheadCount} ahead`       : '';
-  const workspaceLine1  = `${gitBranch}${uncommittedPart}${aheadPart}`;
-  const workspaceLine2  = gitLastMsg
-    ? `Last: ${gitLastMsg} (${gitLastAgo})`
-    : '';
 
   // Open PRs
   const repoState = detectRepoState(cwd);
   const openPRs   = await detectOpenPRs(cwd);
 
-  const workspaceRows = [row(workspaceLine1)];
-  if (workspaceLine2) workspaceRows.push(row(workspaceLine2));
-  if (openPRs.length > 0) {
-    workspaceRows.push(row(`${openPRs.length} open PR${openPRs.length === 1 ? '' : 's'}`));
-  }
-
   // ── Box 3 — Awareness: observer + roadmap + risk ──────────────────────────
   let awarenessLine1 = '\x1b[2m💡\x1b[0m Ready to work';
   let awarenessLine2 = '\x1b[2m📋 No roadmap yet\x1b[0m';
@@ -1987,110 +2120,157 @@ async function mainScreen(rl, ask) {
       const rtInfo    = replitMod.inspectReplitTools(cwd);
       const authInfo  = replitMod.getAuthStatus(cwd);
       const archive   = replitMod.getSessionArchive(cwd);
-      const archCount = Array.isArray(archive) ? archive.length : (archive?.count ?? 0);
+      const archCount = Array.isArray(archive) ? archive.length : (archive?.totalSessions ?? archive?.count ?? 0);
       const secretNames = replitMod.listSecretNames();
       const secretCount = Array.isArray(secretNames) ? secretNames.length : 0;
       const verStr = rtInfo.version ? `v${rtInfo.version}` : (rtInfo.installed ? 'installed' : 'not installed');
-      const authStr = authInfo.authenticated ? '\x1b[32m✓\x1b[0m auth' : '\x1b[2mno auth\x1b[0m';
-      replitAwarenessRows.push(row(`\x1b[2m🔧\x1b[0m Replit  replit-tools ${verStr}  ${authStr}`));
-      replitAwarenessRows.push(row(`\x1b[2m   \x1b[0m ${archCount} archived session${archCount !== 1 ? 's' : ''}  ${secretCount} secret${secretCount !== 1 ? 's' : ''}`));
+      const isAuthenticated = authInfo.authenticated ?? (authInfo.available && authInfo.tokenStatus === 'valid');
+      const authStr = isAuthenticated ? '\x1b[32m✓\x1b[0m auth' : '\x1b[2mno auth\x1b[0m';
+      replitAwarenessRows.push(`Replit  replit-tools ${verStr}  ${authStr}`);
+      replitAwarenessRows.push(`${archCount} archived session${archCount !== 1 ? 's' : ''}  ${secretCount} secret${secretCount !== 1 ? 's' : ''}`);
     }
   } catch { /* replit.mjs not available — skip */ }
 
-  const awarenessRows = [
-    row(awarenessLine1),
-    row(awarenessLine2),
-    row(awarenessLine3),
-    ...replitAwarenessRows,
-  ];
+  // ── Recent work items (from awareness + sessions) — max 3 lines, dim ──────
+  const recentWorkItems = [];
+  // Add awareness observations as recent work if meaningful
+  if (awarenessLine1 && !awarenessLine1.includes('Ready to work')) {
+    const plainAware1 = awarenessLine1.replace(/\x1b\[[0-9;]*m/g, '').replace(/[︀-️]/g, '').trim();
+    if (plainAware1) recentWorkItems.push({ ok: !plainAware1.startsWith('⚠') && !plainAware1.startsWith('🔴'), text: plainAware1.replace(/^[🔴🟡💡]\s*/, '') });
+  }
+  // Add last commit as a recent work item
+  if (gitLastMsg) {
+    recentWorkItems.push({ ok: true, text: `${gitLastMsg} (${gitLastAgo})` });
+  }
+  // Fill from sessions if still room
+  if (recentWorkItems.length < 3 && recentSessions.length > 0) {
+    const sess = recentSessions[0];
+    let rawName = sess.name || '';
+    if (/^Session [0-9a-f]{8,}$/i.test(rawName)) rawName = sess.id.slice(0, 8);
+    if (rawName) recentWorkItems.push({ ok: true, text: rawName.slice(0, 50) });
+  }
 
-  // ── Sessions section ──────────────────────────────────────────────────────
-  const sessionRows = [];
-  if (recentSessions.length === 0) {
-    const noSessMsg = 'No sessions yet. Press n to start.';
-    sessionRows.push(row(noSessMsg));
-  } else {
-    recentSessions.forEach((sess, i) => {
-      // Normalize name: strip "Session XXXXXXXX" fallbacks
-      let rawName = sess.name || '';
-      if (/^Session [0-9a-f]{8,}$/i.test(rawName)) {
-        rawName = sess.project
-          ? sess.project.replace(/^-/, '/').replace(/-/g, '/')
-          : sess.id.slice(0, 8);
-      }
+  // ── Resume state detection ────────────────────────────────────────────────
+  const resumeState = await detectResumeState(cwd);
 
-      // Build badges (ANSI color; track visible width separately)
-      const badges = [];
-      const badgeVisible = [];
-      if (sess.isActive) {
-        badges.push('\x1b[32m[active]\x1b[0m');
-        badgeVisible.push('[active]'.length);
-      }
-      const ageMs = sess.lastActive ? Date.now() - new Date(sess.lastActive).getTime() : 0;
-      if (ageMs > 7 * 24 * 3600 * 1000) {
-        badges.push('\x1b[2m[stale]\x1b[0m');
-        badgeVisible.push('[stale]'.length);
-      }
-      const msgCount    = sess.messageCount ?? sess.promptCount ?? 0;
-      // Human-readable: "4 tasks" instead of "(4)"
-      const taskLabel   = msgCount === 1 ? '1 task' : `${msgCount} tasks`;
-      const taskBadge   = `\x1b[2m${taskLabel}\x1b[0m`;
-      const taskBadgeW  = taskLabel.length;
-
-      const badgeStr = badges.join('');
-      const badgesW  = badgeVisible.reduce((s, n) => s + n, 0);
-
-      // Layout: "{num}  {name...}{badges}  {age}  {tasks}"
-      // Use basename for name — strip full paths for readability
-      const displayName = rawName.startsWith('/')
-        ? rawName.split('/').filter(Boolean).pop() || rawName
-        : rawName;
-
-      const numStr  = String(i + 1);
-      const ageStr  = sess.age || '';
-      // Available for name: W minus fixed chrome, badge widths, and task badge
-      const nameMax = W - numStr.length - 2 - badgesW - 2 - ageStr.length - 2 - taskBadgeW;
-      const truncName = displayName.length > nameMax
-        ? displayName.slice(0, Math.max(0, nameMax - 3)) + '...'
-        : displayName.padEnd(nameMax);
-      const content = `${numStr}  ${truncName}${badgeStr}  ${ageStr}  ${taskBadge}`;
-      sessionRows.push(row(content));
-    });
-  }
+  // ── Determine layout mode ─────────────────────────────────────────────────
+  const anyProviderAvail = claudeAvail || openaiAvail;
+  const isReturning      = resumeState.type === 'resumable';
 
-  // ── Box 5 — Input bar ──────────────────────────────────────────────────
-  const actionsContent = '> type anything...   [s] settings  [t] team  [q] quit';
-  const actionsRow     = row(actionsContent);
+  // ── ANSI color shorthands ─────────────────────────────────────────────────
+  const DIM   = '\x1b[2m';
+  const RST   = '\x1b[0m';
+  const BOLD  = '\x1b[1m';
+  const GRN   = '\x1b[32m';
+  const YLW   = '\x1b[33m';
+  const RED   = '\x1b[31m';
+  const GRY   = '\x1b[90m';
 
-  // ── Print the full 5-box layout ───────────────────────────────────────────
-  // Box 1: header (title + provider dots + work style)
-  // Box 2: workspace (branch · uncommitted · ahead, last commit, open PRs)
-  // Box 3: awareness (observer, roadmap, risk)
-  // Box 4: sessions
-  // Box 5: input bar
-  const lines = [
-    top,
-    row(`🧠 dual-brain v${version}`),
-    row(providerLine),
-    sep,
-    ...workspaceRows,
-    sep,
-    ...awarenessRows,
-    sep,
-    ...sessionRows,
-    sep,
-    actionsRow,
-    bot,
-  ];
-  // ── Stale session hint ──────────────────────────────────────────────────
-  if (staleCount >= 3) {
-    process.stdout.write(`\x1b[2m${staleCount} stale sessions (>7d) — press s → archive to clean up\x1b[0m\n`);
+  // ── Provider dots ─────────────────────────────────────────────────────────
+  const claudeDot = claudeAvail ? `${GRN}●${RST}` : `${GRY}○${RST}`;
+  const openaiDot = openaiAvail ? `${GRN}●${RST}` : `${GRY}○${RST}`;
+
+  // ── Project name (from package.json or cwd basename) ─────────────────────
+  let projectName = basename(cwd);
+  try {
+    const pkgRaw = readFileSync(join(cwd, 'package.json'), 'utf8');
+    const pkgJson = JSON.parse(pkgRaw);
+    if (pkgJson.name) projectName = pkgJson.name;
+  } catch { /* no package.json */ }
+
+  // ── Separator line ────────────────────────────────────────────────────────
+  const sepW = Math.min(W, 72);
+  const sepLine = `${DIM}${'━'.repeat(sepW)}${RST}`;
+
+  // ── Strip ANSI for width calc ─────────────────────────────────────────────
+  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '').replace(/[︀-️]/g, '');
+
+  // ── Line 1: status bar ───────────────────────────────────────────────────
+  //   " project  branch  Claude ●  GPT ●                  v0.2.3"
+  const branchStr   = `${gitBranch}${uncommittedPart}${aheadPart}`;
+  const providerStr = `Claude ${claudeDot}  GPT ${openaiDot}`;
+  const verStr2     = `${DIM}v${version}${RST}`;
+  const statusLeft  = ` ${projectName}  ${DIM}${branchStr}${RST}  ${providerStr}`;
+  const statusRight = verStr2;
+  const statusLeftW  = stripAnsi(statusLeft).length;
+  const statusRightW = stripAnsi(statusRight).length;
+  const statusGap    = Math.max(1, sepW + 1 - statusLeftW - statusRightW);
+  const statusBar    = `${statusLeft}${' '.repeat(statusGap)}${statusRight}`;
+
+  // ── Line 2-3: contextual question + last summary ─────────────────────────
+  let mainQuestion, lastSummary;
+  if (!anyProviderAvail) {
+    mainQuestion = ` ${BOLD}Connect a provider to start working${RST}`;
+    lastSummary  = null;
+  } else if (isReturning) {
+    mainQuestion = ` ${BOLD}Resume previous work?${RST}`;
+    const labelTrunc = (resumeState.label || 'last session').slice(0, 45);
+    const agePart    = resumeState.ageLabel ? ` · ${resumeState.ageLabel}` : '';
+    const nextPart   = resumeState.nextAction ? ` · next: ${resumeState.nextAction}` : '';
+    lastSummary = ` ${DIM}Last: ${labelTrunc}${agePart}${nextPart}${RST}`;
+  } else {
+    mainQuestion = ` ${BOLD}What do you want to build?${RST}`;
+    lastSummary  = null;
+  }
+
+  // ── Suggestions (max 3, bright) ───────────────────────────────────────────
+  let suggestions;
+  const claudeExpiredNow = claudeSub?.expiresAt && Date.parse(claudeSub.expiresAt) < Date.now();
+  const openaiExpiredNow = openaiSub?.expiresAt && Date.parse(openaiSub.expiresAt) < Date.now();
+  if (!anyProviderAvail) {
+    suggestions = ['configure Claude', 'configure GPT', 'browse project'];
+  } else if (claudeExpiredNow || openaiExpiredNow) {
+    const resumeOrBuild = isReturning ? 'resume last session' : 'start building';
+    suggestions = ['refresh auth', resumeOrBuild, 'check project health'];
+  } else if (isReturning) {
+    const openTasks = [];
+    try {
+      const { getOpenTasks } = await import('../src/ledger.mjs');
+      const open = getOpenTasks(cwd);
+      if (open.length > 0) openTasks.push(`continue: ${open[0].intent.slice(0, 30)}`);
+    } catch {}
+    suggestions = openTasks.length > 0
+      ? [openTasks[0], 'review changes', 'run tests']
+      : ['resume last session', 'review changes', 'run tests'];
+  } else {
+    suggestions = ['start building', 'explore codebase', 'check project health'];
   }
+  const suggestLine = ` ${suggestions.join('    ')}`;
 
-  // Resolve dashboard spinner before rendering
+  // ── Recent work items (dim, max 3) ────────────────────────────────────────
+  const recentLines = recentWorkItems.slice(0, 3).map(item => {
+    const prefix = item.ok ? `${GRN}✓${RST}` : `${RED}!${RST}`;
+    return ` ${DIM}${prefix} ${item.text}${RST}`;
+  });
+
+  // ── Resolve dashboard spinner before rendering ────────────────────────────
   if (dashSpinner) dashSpinner.succeed('Dashboard ready');
 
-  process.stdout.write(lines.join('\n') + '\n\n');
+  // ── Stale hint ────────────────────────────────────────────────────────────
+  if (staleCount >= 3) {
+    process.stdout.write(`${DIM}${staleCount} stale sessions (>7d) — type "sessions" to manage${RST}\n`);
+  }
+
+  // ── Render Studio Console ─────────────────────────────────────────────────
+  const out = [];
+  out.push('');                          // breathing room
+  out.push(statusBar);                   // project  branch  Claude ●  GPT ●  v0.2.3
+  out.push('');
+  out.push(mainQuestion);                // Resume previous work? / What do you want to build?
+  if (lastSummary) out.push(lastSummary);
+  out.push(` \x1b[1m›\x1b[0m`);         // bright prompt cursor
+  out.push('');
+  out.push(suggestLine);                 // contextual suggestions
+  if (recentLines.length > 0) {
+    out.push('');
+    out.push(...recentLines);            // ✓ / ! recent work items
+  }
+  out.push('');
+  out.push(` ${sepLine}`);              // ━━━━ separator
+  // Input bar rendered inline — the key handler will overwrite this line
+  out.push(` ${DIM}> task or command...${RST}${' '.repeat(Math.max(1, sepW - 22))}${DIM}[?] help${RST}`);
+
+  process.stdout.write(out.join('\n') + '\n');
 
   // ── Key handling ──────────────────────────────────────────────────────────
   // Use raw keypress mode so we can show a live type-to-start buffer.
@@ -2177,7 +2357,7 @@ async function mainScreen(rl, ask) {
       // Single-key commands only fire when buffer is empty
       if (taskBuffer.length === 0) {
         const lower = str.toLowerCase();
-        const singleKeySet = new Set(['n', 's', 't', 'q', '/', 'i']);
+        const singleKeySet = new Set(['n', 's', 't', 'q', '/', 'i', '?', 'h', 'd']);
         if (singleKeySet.has(lower)) {
           cleanup();
           process.stdout.write('\n');
@@ -2203,15 +2383,124 @@ async function mainScreen(rl, ask) {
 
   const choice = typeof raw === 'string' ? raw.toLowerCase() : '';
 
-  // Typed task → dispatch as "dual-brain go"
+  // ── Typed input — run through command palette ─────────────────────────────
   if (raw.startsWith('__task__:')) {
-    const prompt = raw.slice('__task__:'.length).trim();
-    if (prompt) {
-      return { next: 'go', prompt };
+    const input = raw.slice('__task__:'.length).trim();
+    if (!input) return { next: 'main' };
+
+    const classified = classifyInput(input);
+
+    // Tier 1: FREE — deterministic, zero tokens
+    if (classified.tier === 'free') {
+      const cmd  = classified.command;
+      const args = classified.args;
+
+      if (cmd === 'resume' || cmd === 'r') {
+        if (recentSessions.length === 0) return { next: 'new-session' };
+        return { next: 'sessions' };
+      }
+      if (cmd === 'status' || cmd === 's') {
+        await cmdStatus([]);
+        await ask('\n  Press Enter to continue...');
+        return { next: 'main' };
+      }
+      if (cmd === 'sessions' || cmd === 'ss') {
+        return { next: 'sessions' };
+      }
+      if (cmd === 'settings') {
+        return { next: 'settings' };
+      }
+      if (cmd === 'team' || cmd === 't') {
+        return { next: 'team' };
+      }
+      if (cmd === 'doctor' || cmd === 'd') {
+        return { next: 'diagnostics' };
+      }
+      if (cmd === 'health' || cmd === 'h') {
+        const hooksDir  = join(cwd, '.claude', 'hooks');
+        const healthScript = join(hooksDir, 'health-check.mjs');
+        const { spawnSync: sp } = await import('node:child_process');
+        if (existsSync(healthScript)) {
+          sp('node', [healthScript], { stdio: 'inherit', cwd });
+        } else {
+          process.stdout.write('\n  health-check.mjs not found — run: dual-brain install\n');
+        }
+        await ask('\n  Press Enter to continue...');
+        return { next: 'main' };
+      }
+      if (cmd === 'help' || cmd === '?') {
+        return { next: 'palette-help' };
+      }
+      if (cmd === 'quit' || cmd === 'q') {
+        return { next: 'exit' };
+      }
+      if (cmd === 'search') {
+        const query = args.join(' ');
+        if (!query) {
+          const q2 = (await ask('  Search: ')).trim();
+          if (!q2) return { next: 'main' };
+          args.push(q2);
+        }
+        const { searchSessions, buildSessionIndex } = await import('../src/session.mjs');
+        try { buildSessionIndex(cwd); } catch {}
+        const results = searchSessions(args.join(' '), cwd);
+        if (results.length === 0) {
+          process.stdout.write(`\n  No sessions matching "${args.join(' ')}"\n\n`);
+          await ask('  Press Enter to continue...');
+          return { next: 'main' };
+        }
+        process.stdout.write(`\n  Found ${results.length} session${results.length === 1 ? '' : 's'}:\n`);
+        results.slice(0, 9).forEach((sess, i) => {
+          const tool   = sess.tool === 'codex' ? 'cdx' : 'cld';
+          const date   = sess.date ? new Date(sess.date).toLocaleDateString() : '?';
+          process.stdout.write(`  [${i + 1}] ${tool}  ${date}  ${sess.prompts.first || sess.id.slice(0, 8)}\n`);
+        });
+        process.stdout.write('\n');
+        const pick = (await ask('  Enter number to resume (or Enter to cancel): ')).trim();
+        const num  = parseInt(pick, 10);
+        if (!isNaN(num) && num >= 1 && num <= Math.min(results.length, 9)) {
+          const sess = results[num - 1];
+          const { spawnSync: sp2 } = await import('node:child_process');
+          const tool = sess.tool === 'codex' ? 'codex' : 'claude';
+          process.stdout.write(`\n  Launching: ${tool} --resume ${sess.id}\n\n`);
+          sp2(tool, ['--resume', sess.id], { stdio: 'inherit' });
+        }
+        return { next: 'main' };
+      }
+      if (cmd === 'budget') {
+        await cmdStatus([]);
+        await ask('\n  Press Enter to continue...');
+        return { next: 'main' };
+      }
+      if (cmd === 'init --replit') {
+        await cmdInit(rl);
+        return { next: 'main' };
+      }
+      // fallthrough: unknown free command → treat as full task
     }
-    return { next: 'main' };
+
+    // Tier 2: CHEAP — question/diagnostic, route to haiku
+    if (classified.tier === 'cheap') {
+      process.stdout.write(`\n  Routing to haiku for quick answer...\n`);
+      return { next: 'go', prompt: input, model: 'haiku' };
+    }
+
+    // Tier 3: FULL — work task, confirm before dispatching
+    if (classified.tier === 'full') {
+      const summary = input.length > 60 ? input.slice(0, 57) + '...' : input;
+      process.stdout.write(`\n  Launch coding session: ${summary}\n`);
+      process.stdout.write(`  Model: sonnet  [Enter] to proceed, [n] to cancel\n\n`);
+      const confirm = (await ask('  > ')).trim().toLowerCase();
+      if (confirm === 'n' || confirm === 'no') return { next: 'main' };
+      return { next: 'go', prompt: input };
+    }
+
+    // Default fallback
+    return { next: 'go', prompt: input };
   }
 
+  // ── Single-key shortcuts ───────────────────────────────────────────────────
+
   // Enter (empty) → resume most recent session
   if (raw === '' || choice === '\r') {
     if (recentSessions.length === 0) {
@@ -2225,7 +2514,7 @@ async function mainScreen(rl, ask) {
     return { next: 'main' };
   }
 
-  // Number 1-3 → resume that session
+  // Number 1-9 → resume that session
   const numChoice = parseInt(raw, 10);
   if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= recentSessions.length) {
     const sess = recentSessions[numChoice - 1];
@@ -2245,6 +2534,8 @@ async function mainScreen(rl, ask) {
   }
 
   if (choice === 'n') { return { next: 'new-session' }; }
+  if (choice === '?' || choice === 'h') { return { next: 'palette-help' }; }
+  if (choice === 'd') { return { next: 'diagnostics' }; }
 
   if (choice === '/') {
     const query = (await ask('  Search: ')).trim();
@@ -2303,6 +2594,48 @@ async function newSessionScreen(rl, ask) {
   return { next: 'main' };
 }
 
+// ─── Screen: paletteHelpScreen ───────────────────────────────────────────────
+
+async function paletteHelpScreen(rl, ask) {
+  const termW = process.stdout.columns || 60;
+  const boxW  = Math.min(termW - 2, 60);
+  const W     = boxW - 4;
+  const top   = `┌${'─'.repeat(boxW - 2)}┐`;
+  const sep   = `├${'─'.repeat(boxW - 2)}┤`;
+  const bot   = `└${'─'.repeat(boxW - 2)}┘`;
+  const row   = (content) => makeBoxRow(content, W);
+  const DIM   = '\x1b[2m';
+  const RESET = '\x1b[0m';
+
+  const lines = [
+    top,
+    row('Command Palette'),
+    sep,
+    row(`${DIM}resume  r${RESET}        Resume last session`),
+    row(`${DIM}status${RESET}           Provider health + budget`),
+    row(`${DIM}sessions  ss${RESET}     List recent sessions`),
+    row(`${DIM}search <query>${RESET}   Search session history`),
+    row(`${DIM}budget  b${RESET}        Token usage + routing`),
+    row(`${DIM}health  h${RESET}        System health check`),
+    row(`${DIM}doctor  d${RESET}        Repo diagnostics`),
+    row(`${DIM}settings  s${RESET}      Settings screen`),
+    row(`${DIM}team  t${RESET}          Team screen`),
+    row(`${DIM}help  ?${RESET}          Show this help`),
+    row(`${DIM}quit  q${RESET}          Exit`),
+    sep,
+    row('Or type any task to launch a coding session'),
+    row(`${DIM}Questions (why/how/what) → haiku (cheap)${RESET}`),
+    row(`${DIM}Work tasks → confirm then dispatch${RESET}`),
+    sep,
+    row(`${DIM}[Enter] go back${RESET}`),
+    bot,
+  ];
+
+  process.stdout.write('\n' + lines.join('\n') + '\n\n');
+  await ask('');
+  return { next: 'main' };
+}
+
 // ─── Screen: importPickerScreen ──────────────────────────────────────────────
 
 async function importPickerScreen() {
@@ -2766,15 +3099,14 @@ async function prTriageScreen(rl, ask, ctx = {}) {
 async function settingsScreen(rl, ask) {
   const cwd = process.cwd();
 
-  // Box layout matching dashboard
-  const termW = process.stdout.columns || 60;
-  const boxW  = Math.min(termW - 2, 60);
-  const W     = boxW - 4;
+  const DIM   = '\x1b[2m';
+  const RESET = '\x1b[0m';
+  const GREEN = '\x1b[32m';
+  const RED   = '\x1b[31m';
+  const BOLD  = '\x1b[1m';
 
-  const top = `┌${'─'.repeat(boxW - 2)}┐`;
-  const sep = `├${'─'.repeat(boxW - 2)}┤`;
-  const bot = `└${'─'.repeat(boxW - 2)}┘`;
-  const row = (content) => makeBoxRow(content, W);
+  const chk  = `${GREEN}✓${RESET}`;
+  const xmark = `${RED}✗${RESET}`;
 
   // Detect if gh is available + has PRs for the PR triage option
   const settingsPRs = await detectOpenPRs(cwd);
@@ -2782,108 +3114,131 @@ async function settingsScreen(rl, ask) {
   // Load current work style
   const profile = loadProfile(cwd);
   const currentBias = profile?.bias || profile?.mode || 'balanced';
-  const WORK_STYLE_DISPLAY = {
-    'cost-saver':    '⚡ Fast',
-    'auto':          '⚡ Fast',
-    'solo-claude':   '⚡ Fast',
-    'solo-openai':   '⚡ Fast',
-    'balanced':      '⚖️  Balanced',
-    'quality-first': '🔥 Full Power',
-  };
 
   // Work style current markers
   const _stIsFast = ['cost-saver', 'auto', 'solo-claude', 'solo-openai'].includes(currentBias);
   const _stIsBal  = currentBias === 'balanced';
   const _stIsFull = currentBias === 'quality-first';
-  const _stMark   = (active) => active ? ' ← current' : '';
-
-  // Provider status dots
-  const _stAuth       = await detectAuth();
-  const _stGDOT       = '\x1b[32m●\x1b[0m';
-  const _stRDOT       = '\x1b[31m●\x1b[0m';
-  const _stClDot      = _stAuth.claude.found ? _stGDOT : _stRDOT;
-  const _stOaDot      = _stAuth.openai.found ? _stGDOT : _stRDOT;
-  const _stClStatus   = _stAuth.claude.found ? 'connected' : 'not connected';
-  const _stOaStatus   = _stAuth.openai.found ? 'connected' : 'not connected';
-
-  // Calibration from project.json
-  let _stCal       = { specificity: 3, corrections: 3, autonomy: 3 };
-  let _stLevel     = 'intermediate';
-  let _stStyle     = 'normal';
+  const dot = (active) => active ? `${GREEN}●${RESET}` : `${DIM}○${RESET}`;
+
+  // ── Subscriptions / credentials ──────────────────────────────────────────
+  const credData  = loadCredentials(cwd);
+  const credList  = credData.credentials || [];
+  const hasCredRegistry = credList.length > 0;
+
+  // Fall back to detectAuth() when no registry entries yet
+  let subsLines = [];
+  if (hasCredRegistry) {
+    for (const c of credList.filter(c => c.enabled !== false)) {
+      const provLabel  = c.provider === 'claude' ? 'Claude' : 'OpenAI';
+      const authLabel  = c.auth_type === 'cli_oauth' ? 'CLI OAuth' : 'API key';
+      const planLabel  = c.plan_hint || '';
+      const healthMark = c.health === 'healthy' ? chk : c.health === 'degraded' ? `${RED}~${RESET}` : `${DIM}?${RESET}`;
+      const scopeTag   = `[${c.scope || 'local'}]`;
+      const planPart   = planLabel ? `  ${DIM}${planLabel}${RESET}` : '';
+      subsLines.push(`  ${DIM}${provLabel.padEnd(6)}${RESET}  ${authLabel.padEnd(10)}${planPart}  ${healthMark}${c.health === 'healthy' ? ' healthy' : ' ' + (c.health || 'unknown')}  ${DIM}${scopeTag}${RESET}`);
+    }
+    if (subsLines.length === 0) subsLines.push(`  ${DIM}none registered${RESET}`);
+  } else {
+    const _stAuth = await detectAuth();
+    const _clStatus = _stAuth.claude.found ? `${chk} connected` : `${xmark} not connected`;
+    const _oaStatus = _stAuth.openai.found ? `${chk} connected` : `${xmark} not connected`;
+    subsLines.push(`  ${DIM}Claude${RESET}   CLI OAuth    ${_clStatus}`);
+    subsLines.push(`  ${DIM}OpenAI${RESET}   API key      ${_oaStatus}`);
+  }
+
+  // ── Work style ───────────────────────────────────────────────────────────
+  const wsLines = [
+    `  ${dot(_stIsFast)} ${_stIsFast ? BOLD : DIM}Fast${RESET}   speed over caution`,
+    `  ${dot(_stIsBal)}  ${_stIsBal ? BOLD : DIM}Balanced${RESET}   smart routing, reviews on important`,
+    `  ${dot(_stIsFull)} ${_stIsFull ? BOLD : DIM}Full Power${RESET}   dual-brain everything, max quality`,
+  ];
+
+  // ── System info ──────────────────────────────────────────────────────────
+  const rt = detectReplitTools(cwd);
+  const rtLabel = rt.installed ? `v${rt.version || '?'}` : 'not installed';
+  const rtMark  = rt.installed ? chk : xmark;
+
+  let sessionCount = 0;
   try {
-    const _stLd  = await import('../src/living-docs.mjs');
-    const _stCm  = await import('../src/calibration.mjs');
-    const _stPs  = _stLd.getProjectState(cwd);
-    if (_stPs?.project?.userCalibration) _stCal = _stPs.project.userCalibration;
-    const _stAd  = _stCm.getAdaptation(_stCal);
-    _stLevel = _stAd.userLevel;
-    _stStyle = _stAd.responseStyle;
-  } catch { /* non-fatal */ }
+    const idxPath = join(cwd, '.dualbrain', 'session-index.json');
+    const idx = existsSync(idxPath) ? JSON.parse(readFileSync(idxPath, 'utf8')) : {};
+    sessionCount = Object.keys(idx).length;
+  } catch { /* ignore */ }
 
-  const _stS = typeof _stCal.specificity === 'number' ? _stCal.specificity.toFixed(1) : String(_stCal.specificity ?? 3);
-  const _stC = typeof _stCal.corrections === 'number' ? _stCal.corrections.toFixed(1) : String(_stCal.corrections ?? 3);
-  const _stA = typeof _stCal.autonomy    === 'number' ? _stCal.autonomy.toFixed(1)    : String(_stCal.autonomy    ?? 3);
+  let pluginCount = 0;
+  try {
+    const settingsJson = join(cwd, '.claude', 'settings.json');
+    if (existsSync(settingsJson)) {
+      const s = JSON.parse(readFileSync(settingsJson, 'utf8'));
+      pluginCount = Object.keys(s?.mcpServers || {}).length;
+    }
+  } catch { /* ignore */ }
 
-  // Cost efficiency summary (graceful — only shown when data exists)
-  let _stEffScore = null;
-  let _stEffRate  = null;
-  let _stEffTrend = null;
-  let _stEffTier  = null;
+  let doctorStr = `${DIM}not run${RESET}`;
   try {
-    const _stCt = await import('../src/cost-tracker.mjs');
-    const _stSummary = _stCt.getCostSummary(cwd, 7);
-    if (_stSummary.totalActions > 0) {
-      _stEffScore = _stCt.getEfficiencyScore(cwd);
-      _stEffRate  = Math.round(_stSummary.savingsRate * 100);
-      _stEffTrend = _stSummary.trend;
-      const tierOrder = ['recall', 'quick', 'standard', 'deep', 'ultra'];
-      const _stTierKeys = tierOrder.filter(k => _stSummary.byTier[k]);
-      _stEffTier = _stTierKeys.map(k => {
-        const t = _stSummary.byTier[k];
-        return `${k.padEnd(8)} ${String(t.count).padStart(3)}`;
-      }).join('  ');
+    const hooksDir    = join(cwd, '.claude', 'hooks');
+    const headGuard   = existsSync(join(hooksDir, 'head-guard.mjs'));
+    const enforceTier = existsSync(join(hooksDir, 'enforce-tier.mjs'));
+    const settingsFile = join(cwd, '.claude', 'settings.json');
+    let guardCount = 0;
+    if (existsSync(settingsFile)) {
+      const s = JSON.parse(readFileSync(settingsFile, 'utf8'));
+      const ptu = s?.hooks?.PreToolUse ?? [];
+      const gCmd = 'node .claude/hooks/head-guard.mjs';
+      const tCmd = 'node .claude/hooks/enforce-tier.mjs';
+      guardCount = [
+        ptu.some(e => e.matcher === 'Edit'  && e.hooks?.some(h => h.command === gCmd)),
+        ptu.some(e => e.matcher === 'Write' && e.hooks?.some(h => h.command === gCmd)),
+        ptu.some(e => e.matcher === 'Bash'  && e.hooks?.some(h => h.command === gCmd)),
+        ptu.some(e => e.matcher === 'Agent' && e.hooks?.some(h => h.command === tCmd)),
+      ].filter(Boolean).length;
     }
-  } catch { /* non-fatal */ }
+    const checks = [headGuard, enforceTier, guardCount >= 4].filter(Boolean).length + 7; // base 7 always pass
+    const total  = 10;
+    doctorStr = checks >= total
+      ? `${chk} ${checks}/${total} checks passing`
+      : `${RED}${checks}/${total} checks passing${RESET}`;
+  } catch { /* ignore */ }
 
-  const _stTrendIcon = _stEffTrend === 'improving' ? '↗' : _stEffTrend === 'degrading' ? '↘' : '→';
+  const sysLines = [
+    `  ${DIM}replit-tools${RESET}  ${rtLabel}  ${rtMark} ${rt.installed ? 'connected' : 'not connected'}`,
+    `  ${DIM}Sessions${RESET}      ${sessionCount} archived`,
+    `  ${DIM}Plugins${RESET}       ${pluginCount} configured`,
+    `  ${DIM}Doctor${RESET}        ${doctorStr}`,
+  ];
 
-  const lines = [
-    top,
-    row('Settings'),
-    sep,
-    row('Work Style'),
-    row(`  [1] Fast — speed over caution${_stMark(_stIsFast)}`),
-    row(`  [2] Balanced — smart routing, reviews on important${_stMark(_stIsBal)}`),
-    row(`  [3] Full Power — dual-brain everything, max quality${_stMark(_stIsFull)}`),
-    sep,
-    row('Providers'),
-    row(`  Claude: ${_stClDot} ${_stClStatus}`),
-    row(`  OpenAI: ${_stOaDot} ${_stOaStatus}`),
-    sep,
-    row('User Calibration'),
-    row(`  Specificity: ${_stS}  Corrections: ${_stC}  Autonomy: ${_stA}`),
-    row(`  Level: ${_stLevel} · Style: ${_stStyle}`),
-    ...(_stEffScore !== null ? [
-      sep,
-      row('Cost Efficiency (7 days)'),
-      row(`  Score: ${_stEffScore}/100  Savings: ${_stEffRate}%  Trend: ${_stTrendIcon} ${_stEffTrend}`),
-      ...(_stEffTier ? [row(`  Tiers: ${_stEffTier}`)] : []),
-    ] : []),
-    sep,
-    row('[1-3] change style  [r] reset calibration  [b] back'),
-    row('[m] subscriptions  [e] sessions  [x] diagnostics'),
-    ...(settingsPRs.length > 0 ? [row(`[p] PR triage (${settingsPRs.length} open)`)] : []),
-    bot,
+  // ── Render ────────────────────────────────────────────────────────────────
+  const out = [
+    '',
+    `  ${BOLD}Settings${RESET}`,
+    '',
+    `  ${DIM}Subscriptions${RESET}`,
+    ...subsLines,
+    `  ${DIM}[a] add  [r] remove  [h] health check${RESET}`,
+    '',
+    `  ${DIM}Work style${RESET}`,
+    ...wsLines,
+    `  ${DIM}[1-3] change${RESET}`,
+    '',
+    `  ${DIM}System${RESET}`,
+    ...sysLines,
+    `  ${DIM}[d] run doctor  [x] diagnostics${RESET}`,
+    '',
+    `  ${DIM}[e] sessions  [m] subscriptions  [b] back${RESET}`,
+    ...(settingsPRs.length > 0 ? [`  ${DIM}[p] PR triage (${settingsPRs.length} open)${RESET}`] : []),
+    '',
   ];
-  process.stdout.write('\n' + lines.join('\n') + '\n\n');
+  process.stdout.write(out.join('\n') + '\n');
 
   const raw    = (await ask('  Choice: ')).trim();
   const choice = raw.toLowerCase();
 
-  // Direct work style keys 1/2/3
+  // Work style 1/2/3
   if (choice === '1' || choice === '2' || choice === '3') {
-    const _stWsMap = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
-    const newBias  = _stWsMap[choice];
+    const wsMap  = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
+    const wsDisp = { '1': 'Fast', '2': 'Balanced', '3': 'Full Power' };
+    const newBias = wsMap[choice];
     if (newBias && newBias !== currentBias) {
       profile.bias = newBias;
       const enabledCount = [
@@ -2892,71 +3247,91 @@ async function settingsScreen(rl, ask) {
       ].filter(Boolean).length;
       if (enabledCount >= 2) profile.mode = newBias;
       saveProfile(profile, { cwd });
-      const newLabel = WORK_STYLE_DISPLAY[newBias] || newBias;
-      process.stdout.write(`\n  Work style set to ${newLabel}\n\n`);
+      process.stdout.write(`\n  Work style set to ${wsDisp[choice]}\n\n`);
       await ask('  Press Enter to continue...');
     }
     return { next: 'settings' };
   }
 
-  // Reset calibration to defaults
-  if (choice === 'r') {
+  // Add credential
+  if (choice === 'a') {
+    process.stdout.write('\n  Auto-detecting credentials...\n');
     try {
-      const _stLdReset = await import('../src/living-docs.mjs');
-      _stLdReset.updateProject({ userCalibration: { specificity: 3, corrections: 3, autonomy: 3 } }, cwd);
-      process.stdout.write('\n  Calibration reset to defaults.\n\n');
+      const discovered = await detectCredentials(cwd);
+      const existing   = loadCredentials(cwd).credentials.map(c => c.id);
+      const newOnes    = discovered.filter(c => !existing.includes(c.id));
+      if (newOnes.length === 0) {
+        process.stdout.write('  No new credentials detected.\n\n');
+      } else {
+        for (const c of newOnes) {
+          addCredential(c, cwd);
+          process.stdout.write(`  Added: ${c.id} (${c.provider} / ${c.auth_type})\n`);
+        }
+      }
+    } catch (e) {
+      process.stdout.write(`  Detection failed: ${e.message}\n`);
+    }
+    await ask('  Press Enter to continue...');
+    return { next: 'settings' };
+  }
+
+  // Remove credential
+  if (choice === 'r') {
+    const creds = loadCredentials(cwd).credentials;
+    if (creds.length === 0) {
+      process.stdout.write('\n  No credentials registered.\n\n');
       await ask('  Press Enter to continue...');
-    } catch { /* non-fatal */ }
+      return { next: 'settings' };
+    }
+    process.stdout.write('\n');
+    creds.forEach((c, i) => process.stdout.write(`  [${i + 1}] ${c.id} (${c.provider})\n`));
+    const pick = (await ask('\n  Number to remove (or Enter to cancel): ')).trim();
+    const idx  = parseInt(pick, 10) - 1;
+    if (idx >= 0 && idx < creds.length) {
+      removeCredential(creds[idx].id, cwd);
+      process.stdout.write(`  Removed ${creds[idx].id}\n\n`);
+    }
+    await ask('  Press Enter to continue...');
     return { next: 'settings' };
   }
 
-  if (choice === 'm') { return { next: 'subscriptions' }; }
+  // Health check credentials
+  if (choice === 'h') {
+    process.stdout.write('\n  Checking credential health...\n');
+    try {
+      const data  = loadCredentials(cwd);
+      const creds = data.credentials || [];
+      if (creds.length === 0) {
+        process.stdout.write('  No credentials to check.\n');
+      } else {
+        const updated = [];
+        for (const c of creds) {
+          const checked = await checkCredentialHealth(c, cwd);
+          const mark = checked.health === 'healthy' ? chk : xmark;
+          process.stdout.write(`  ${mark} ${c.id}: ${checked.health}\n`);
+          updated.push(checked);
+        }
+        saveCredentials({ ...data, credentials: updated }, cwd);
+      }
+    } catch (e) {
+      process.stdout.write(`  Health check failed: ${e.message}\n`);
+    }
+    await ask('\n  Press Enter to continue...');
+    return { next: 'settings' };
+  }
 
+  if (choice === 'm') { return { next: 'subscriptions' }; }
   if (choice === 'e') { return { next: 'sessions' }; }
-
-  if (choice === 'i') {
-    return { next: 'import-picker' };
-  }
+  if (choice === 'x') { return { next: 'diagnostics' }; }
 
   if (choice === 'p' && settingsPRs.length > 0) {
     return { next: 'pr-triage', openPRs: settingsPRs };
   }
 
   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 {
-      process.stdout.write('\n  replit-tools not found — install with: npm i -g replit-tools\n\n');
-      await ask('  Press Enter to continue...');
-    }
-    return { next: 'settings' };
-  }
-
-  if (choice === '?') {
-    const W2 = 37;
-    const helpTop    = `  ┌${'─'.repeat(W2)}┐`;
-    const helpSep    = `  ├${'─'.repeat(W2)}┤`;
-    const helpBottom = `  └${'─'.repeat(W2)}┘`;
-    const helpPad    = (s) => s + ' '.repeat(Math.max(0, W2 - s.length));
-    process.stdout.write('\n');
-    process.stdout.write(helpTop + '\n');
-    process.stdout.write(`  │ ${helpPad('At ~/workspace$ prompt:')}│\n`);
-    process.stdout.write(`  │ ${helpPad('db = show this menu')}│\n`);
-    process.stdout.write(`  │ ${helpPad('j  = login to claude')}│\n`);
-    process.stdout.write(`  │ ${helpPad('k  = login to codex')}│\n`);
-    process.stdout.write(helpSep + '\n');
-    process.stdout.write(`  │ ${helpPad('In Claude:')}│\n`);
-    process.stdout.write(`  │ ${helpPad('Ctrl+C x2 = back to menu')}│\n`);
-    process.stdout.write(`  │ ${helpPad('Ctrl+C x3 = exit to shell')}│\n`);
-    process.stdout.write(helpBottom + '\n\n');
-    await ask('  Press Enter to continue...');
-    return { next: 'settings' };
+    return { next: 'diagnostics' };
   }
 
-  if (choice === 'x') { return { next: 'diagnostics' }; }
-
   if (choice === 'b' || choice === 'back' || raw === '\x1b') { return { next: 'main' }; }
 
   return { next: 'main' };
@@ -3245,9 +3620,37 @@ async function subscriptionsScreen(rl, ask) {
 // ─── Onboarding Wizard ───────────────────────────────────────────────────────
 
 /**
- * Animated first-run setup wizard.
- * 5 steps: welcome → env scan → replit-tools → import → work style → ready.
- * Uses src/fx.mjs when available; falls back to plain output stubs.
+ * Write .dualbrain/credentials.json with detected providers.
+ * Non-destructive: never overwrites entries with the same id.
+ */
+function saveWizardCredentials(cwd, detectedProviders) {
+  const dir = join(cwd, '.dualbrain');
+  try { mkdirSync(dir, { recursive: true }); } catch { /* exists */ }
+
+  const credPath = join(dir, 'credentials.json');
+  let existing = { version: 1, credentials: [] };
+  try {
+    const raw = readFileSync(credPath, 'utf8');
+    existing = JSON.parse(raw);
+    if (!Array.isArray(existing.credentials)) existing.credentials = [];
+  } catch { /* fresh start */ }
+
+  const existingIds = new Set(existing.credentials.map(c => c.id));
+  const now = new Date().toISOString();
+
+  for (const cred of detectedProviders) {
+    if (!existingIds.has(cred.id)) {
+      existing.credentials.push({ ...cred, last_checked_at: now });
+    }
+  }
+
+  writeFileSync(credPath, JSON.stringify(existing, null, 2), 'utf8');
+}
+
+/**
+ * Animated first-run setup wizard — detection-first, 3-interaction flow.
+ * Detection IS the home screen loading: scan → confirm providers → pick style → done.
+ * Uses src/fx.mjs; falls back to plain output stubs.
  *
  * @param {{ auth, plans, existingSessions }} _detection  (unused — kept for API compat)
  * @param {string} cwd
@@ -3255,192 +3658,310 @@ async function subscriptionsScreen(rl, ask) {
  * @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 fx  = await getFx();
+  const cl  = fx.colors || {};
+  const DIM   = cl.dim   || '';
+  const BOLD  = cl.bold  || '';
+  const GREEN = cl.green || '';
+  const CYAN  = cl.cyan  || '';
+  const GRAY  = cl.gray  || '';
+  const RST   = cl.reset || '';
 
-  // ─── Step 1: Welcome banner ────────────────────────────────────────────────
-  fx.clearScreen();
-  fx.banner('🧠 DUAL-BRAIN');
-  fx.nl();
-  fx.info("Welcome! Let's set up your AI work partner.");
-  fx.nl();
-  await fx.sleep(800);
+  const isTTY = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
 
-  // ─── Step 2: Environment detection ────────────────────────────────────────
-  fx.step(1, 5, 'Scanning environment');
-  fx.nl();
+  // Helper: print a single dim line (indented with one space)
+  function dimLine(text) {
+    process.stdout.write(` ${GRAY}${text}${RST}\n`);
+  }
 
-  // Run capability detection in parallel with the animations
+  // Helper: single-key prompt; falls back to readline if not a real TTY
+  async function singleKey(validKeys) {
+    if (!isTTY) {
+      const line = await new Promise(res => rl.question('', res));
+      return (line.trim().toLowerCase()[0]) || '\r';
+    }
+    const { emitKeypressEvents } = await import('node:readline');
+    emitKeypressEvents(process.stdin, rl);
+    return new Promise((resolve) => {
+      const wasRaw = process.stdin.isRaw;
+      process.stdin.setRawMode(true);
+      const cleanup = () => {
+        process.stdin.removeListener('keypress', onKey);
+        try { process.stdin.setRawMode(wasRaw || false); } catch {}
+      };
+      const onKey = (str, key) => {
+        if (!key) return;
+        const name = key.name || '';
+        if (key.ctrl && (name === 'c' || name === 'd')) {
+          cleanup(); process.stdout.write('\n'); resolve('q'); return;
+        }
+        const ch = (str || '').toLowerCase();
+        if (name === 'return' || name === 'enter') {
+          cleanup(); process.stdout.write('\n'); resolve('\r'); return;
+        }
+        if (validKeys.includes(ch)) {
+          cleanup(); process.stdout.write(`${ch}\n`); resolve(ch); return;
+        }
+      };
+      process.stdin.on('keypress', onKey);
+    });
+  }
+
+  // ─── Clear screen + header ─────────────────────────────────────────────────
+  const version = readVersion();
+  fx.clearScreen();
+  process.stdout.write(`\n ${BOLD}dual-brain${RST}${GRAY}                                              v${version}${RST}\n\n`);
+  process.stdout.write(` ${DIM}Setting up your workspace...${RST}\n\n`);
+
+  // ─── Env scan — run detection in parallel with animated output ────────────
   const capsPromise = detectCapabilities(cwd);
 
-  await fx.loadingSequence([
-    { text: 'Detecting container...', duration: 500, successText: 'Replit container detected' },
-    { text: 'Checking CLI tools...',  duration: 400, successText: 'CLI tools available (git, node, claude...)' },
-    { text: 'Scanning secrets...',    duration: 350, successText: 'Environment scanned' },
-  ]);
+  // Replit workspace
+  const isReplit = !!(process.env.REPL_ID || process.env.REPL_SLUG);
+  if (isReplit) {
+    await fx.sleep(150);
+    fx.success('Replit workspace detected');
+  }
+
+  // Node version
+  try {
+    const major = process.version.replace(/^v/, '').split('.')[0];
+    await fx.sleep(100);
+    fx.success(`Node ${major}.x found`);
+  } catch { /* non-fatal */ }
+
+  // Git repo name, branch, file count
+  let repoName = null;
+  let branchName = null;
+  let fileCount = 0;
+  try {
+    const { spawnSync: sp } = await import('node:child_process');
+    const topLevel = sp('git', ['rev-parse', '--show-toplevel'], {
+      cwd, encoding: 'utf8', stdio: ['pipe','pipe','pipe'], timeout: 3000,
+    });
+    if (topLevel.status === 0) repoName = basename((topLevel.stdout || '').trim());
+
+    const branch = sp('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+      cwd, encoding: 'utf8', stdio: ['pipe','pipe','pipe'], timeout: 2000,
+    });
+    branchName = (branch.stdout || '').trim() || null;
+
+    const count = sp('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
+      cwd, encoding: 'utf8', stdio: ['pipe','pipe','pipe'], timeout: 3000,
+    });
+    fileCount = (count.stdout || '').trim().split('\n').filter(Boolean).length;
+  } catch { /* not a git repo or git unavailable */ }
 
-  // Await actual capability data
-  const caps          = await capsPromise;
+  if (repoName) {
+    const fileLabel   = fileCount > 0 ? `, ${fileCount} file${fileCount === 1 ? '' : 's'}` : '';
+    const branchLabel = branchName ? ` (${branchName} branch${fileLabel})` : '';
+    await fx.sleep(100);
+    fx.success(`Git repository: ${repoName}${branchLabel}`);
+  }
+
+  // Provider spinner while awaiting detection
+  const provSpinner = fx.spinner('Checking providers...').start();
+  const caps = await capsPromise;
   const claudeReady    = caps.claude.available;
   const openaiReady    = caps.openai.available;
   const codexAvailable = caps.codex.available;
+  provSpinner.stop();
 
-  // Override the generic "secrets" success with real data
-  const secretsLine = claudeReady || openaiReady
-    ? 'API keys configured'
-    : 'No API keys found — configure later';
-  fx.info(secretsLine);
-  fx.nl();
+  // Claude
+  let claudeAuthLabel = null;
+  let claudeAuthType  = null;
+  if (claudeReady) {
+    if (caps.claude.source === 'claude-code') {
+      claudeAuthLabel = 'CLI OAuth'; claudeAuthType = 'cli_oauth';
+    } else if (caps.claude.source === 'env-key') {
+      claudeAuthLabel = 'API key'; claudeAuthType = 'api_key';
+    } else {
+      claudeAuthLabel = caps.claude.source || 'detected'; claudeAuthType = 'unknown';
+    }
+    fx.success(`Claude CLI found · ${claudeAuthLabel}`);
+  }
 
-  // ─── Step 3: Detect replit-tools ──────────────────────────────────────────
-  fx.step(2, 5, 'Detecting replit-tools');
-  fx.nl();
+  // OpenAI / Codex
+  let openaiAuthLabel = null;
+  let openaiAuthType  = null;
+  if (openaiReady) {
+    openaiAuthLabel = 'API key'; openaiAuthType = 'api_key';
+    fx.success('OpenAI detected · API key');
+  } else if (codexAvailable) {
+    openaiAuthLabel = 'CLI OAuth'; openaiAuthType = 'cli_oauth';
+    fx.success('OpenAI Codex CLI found · authenticated');
+  }
 
+  // replit-tools — auto-import sessions (non-destructive read-only indexing, no prompt)
   const rt = detectReplitTools(cwd);
-  const rtSpinner = fx.spinner('Looking for replit-tools...').start();
-  await fx.sleep(700);
-
   let rtSessionCount = 0;
   if (rt.installed) {
-    const vStr = rt.version ? ` v${rt.version}` : '';
-    rtSpinner.succeed(`replit-tools${vStr} detected`);
-    // Count available sessions
     try {
       const sessions = importReplitSessions(cwd);
       rtSessionCount = sessions.length;
     } catch { /* non-fatal */ }
-  } else {
-    rtSpinner.warn('replit-tools not found — install with: npm i -g replit-tools');
+    if (rtSessionCount > 0) {
+      fx.success(`${rtSessionCount} session${rtSessionCount === 1 ? '' : 's'} found in replit-tools`);
+    }
+    const vStr = rt.version ? `v${rt.version}` : 'installed';
+    fx.success(`replit-tools ${vStr} detected`);
   }
-  fx.nl();
-
-  // ─── Step 4: Import conversations ─────────────────────────────────────────
-  fx.step(3, 5, 'Import conversations');
-  fx.nl();
 
-  if (rt.installed && rtSessionCount > 0) {
-    fx.info(`Found ${rtSessionCount} session${rtSessionCount === 1 ? '' : 's'} from replit-tools`);
-    fx.nl();
+  process.stdout.write('\n');
 
-    // Ask user — line-based input since we may not have raw mode here
-    process.stdout.write('  Import conversations? [y/N]: ');
-    const importChoice = (await ask('')).trim().toLowerCase();
+  // ─── Step 1: Confirm providers ────────────────────────────────────────────
+  const hasAnyProvider = claudeReady || openaiReady || codexAvailable;
 
-    if (importChoice === 'y' || importChoice === 'yes') {
-      const importSpinner = fx.spinner('Importing sessions...').start();
-      await fx.sleep(600);
-      try {
-        // Sessions are already imported via importReplitSessions above (lazy-loaded)
-        importSpinner.succeed(`${rtSessionCount} session${rtSessionCount === 1 ? '' : 's'} imported`);
-      } catch (e) {
-        importSpinner.fail(`Import failed: ${e.message}`);
-      }
-    } else {
-      fx.dim('Skipped — you can import later from Settings → Import');
-    }
-  } else if (rt.installed) {
-    fx.dim('No sessions to import');
-  } else {
-    fx.dim('Skipping — replit-tools not found');
-  }
-  fx.nl();
+  if (!hasAnyProvider) {
+    // No-providers path
+    process.stdout.write(` ${BOLD}No providers detected${RST}\n\n`);
+    dimLine('dual-brain needs Claude or OpenAI to run coding tasks.');
+    dimLine('You can still browse your project and configure settings.');
+    process.stdout.write('\n');
+    process.stdout.write(` ${GRAY}[c]${RST} set up Claude  ${GRAY}[o]${RST} set up OpenAI  ${GRAY}[s]${RST} skip for now\n\n`);
 
-  // ─── Step 5: Work style selection ─────────────────────────────────────────
-  fx.step(4, 5, 'Choose your style');
-  fx.nl();
-  process.stdout.write('  How do you want to work?\n\n');
-  process.stdout.write('  [1] ⚡ Fast      — speed over caution, auto-execute\n');
-  process.stdout.write('  [2] ⚖️  Balanced  — smart routing, reviews when it matters\n');
-  process.stdout.write('  [3] 🔒 Thorough  — dual-brain everything, max quality\n');
-  fx.nl();
+    const noProvChoice = await singleKey(['c', 'o', 's', '\r']);
 
-  const styleMap   = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
-  const styleNames = { 'cost-saver': 'Fast', 'balanced': 'Balanced', 'quality-first': 'Thorough' };
+    if (noProvChoice === 'c') {
+      process.stdout.write('\n');
+      dimLine('Run: claude login');
+      dimLine('Then re-run: dual-brain init');
+      process.stdout.write('\n');
+    } else if (noProvChoice === 'o') {
+      process.stdout.write('\n');
+      dimLine('Run: codex login');
+      dimLine('Or add OPENAI_API_KEY to Replit Secrets if using API key auth.');
+      dimLine('Then re-run: dual-brain init');
+      process.stdout.write('\n');
+    }
 
-  let styleChoice = '2'; // default
-  const isTTY = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+    const minProfile = loadProfile(cwd);
+    minProfile.setupComplete = true;
+    minProfile.providers.claude = { enabled: false };
+    minProfile.providers.openai = { enabled: false };
+    minProfile.mode = 'solo-claude';
+    minProfile.bias = 'balanced';
+    minProfile.workStyle = 'balanced';
+    return minProfile;
+  }
 
-  if (isTTY) {
-    // Raw keypress — single character
-    const { emitKeypressEvents } = await import('node:readline');
-    emitKeypressEvents(process.stdin, rl);
+  // Show provider table
+  process.stdout.write(` ${BOLD}Providers detected:${RST}\n\n`);
+  if (claudeReady) {
+    process.stdout.write(`   ${GRAY}Claude${RST}  ${claudeAuthLabel}    ${GREEN}✓ authenticated${RST}\n`);
+  }
+  if (openaiReady) {
+    process.stdout.write(`   ${GRAY}OpenAI${RST}  API key    ${GREEN}✓ OPENAI_API_KEY${RST}\n`);
+  } else if (codexAvailable) {
+    process.stdout.write(`   ${GRAY}OpenAI${RST}  CLI OAuth  ${GREEN}✓ authenticated${RST}\n`);
+  }
 
-    process.stdout.write('  Choice [2]: ');
-    styleChoice = await new Promise((resolve) => {
-      const wasRaw = process.stdin.isRaw;
-      process.stdin.setRawMode(true);
+  process.stdout.write('\n');
+  process.stdout.write(` ${GRAY}Correct?${RST} ${GRAY}[Enter]${RST} yes  ${GRAY}[n]${RST} change  ${GRAY}[a]${RST} add more\n\n`);
 
-      const cleanup = () => {
-        process.stdin.removeListener('keypress', onKey);
-        try { process.stdin.setRawMode(wasRaw || false); } catch {}
-      };
+  const provChoice = await singleKey(['n', 'a', '\r', 'y']);
 
-      const onKey = (str, key) => {
-        if (!key) return;
-        const name = key.name || '';
-        if (key.ctrl && (name === 'c' || name === 'd')) {
-          cleanup();
-          process.stdout.write('\n');
-          resolve('2');
-          return;
-        }
-        if (name === 'return' || name === 'enter') {
-          cleanup();
-          process.stdout.write('\n');
-          resolve('2');
-          return;
-        }
-        if (str === '1' || str === '2' || str === '3') {
-          cleanup();
-          process.stdout.write(`${str}\n`);
-          resolve(str);
-          return;
-        }
-      };
+  let finalClaudeEnabled = claudeReady;
+  let finalOpenaiEnabled = openaiReady || codexAvailable;
 
-      process.stdin.on('keypress', onKey);
+  if (provChoice === 'n') {
+    process.stdout.write('\n');
+    const toggleOpts = [];
+    if (claudeReady) toggleOpts.push(`${GRAY}[c]${RST} disable Claude`);
+    if (openaiReady || codexAvailable) toggleOpts.push(`${GRAY}[o]${RST} disable OpenAI`);
+    toggleOpts.push(`${GRAY}[Enter]${RST} keep`);
+    process.stdout.write(` ${toggleOpts.join('  ')}\n\n`);
+    const toggleChoice = await singleKey(['c', 'o', '\r']);
+    if (toggleChoice === 'c') finalClaudeEnabled = false;
+    if (toggleChoice === 'o') finalOpenaiEnabled = false;
+    process.stdout.write('\n');
+  } else if (provChoice === 'a') {
+    process.stdout.write('\n');
+    if (!claudeReady) dimLine('Claude: run `claude auth login` to authenticate');
+    if (!openaiReady && !codexAvailable) dimLine('OpenAI: set OPENAI_API_KEY or run `codex login`');
+    process.stdout.write('\n');
+    process.stdout.write(` ${GRAY}[Enter]${RST} continue with current providers\n\n`);
+    await singleKey(['\r', 'q']);
+  }
+
+  // Write credentials.json
+  const credEntries = [];
+  if (finalClaudeEnabled) {
+    credEntries.push({
+      id: 'claude-local',
+      provider: 'claude',
+      auth_type: claudeAuthType || 'cli_oauth',
+      source: 'local_cli',
+      owner: 'user',
+      scope: 'local',
+      plan_hint: null,
+      enabled: true,
+      health: 'healthy',
     });
-  } else {
-    // Fallback: line-based prompt
-    process.stdout.write('  Choice [2]: ');
-    styleChoice = (await ask('')).trim() || '2';
   }
+  if (finalOpenaiEnabled) {
+    credEntries.push({
+      id: openaiReady ? 'openai-apikey' : 'openai-codex',
+      provider: 'openai',
+      auth_type: openaiAuthType || 'api_key',
+      source: openaiReady ? 'env_var' : 'cli_oauth',
+      owner: 'user',
+      scope: 'local',
+      plan_hint: null,
+      enabled: true,
+      health: 'healthy',
+    });
+  }
+  try { saveWizardCredentials(cwd, credEntries); } catch { /* non-fatal */ }
+
+  // ─── Step 2: Work style ───────────────────────────────────────────────────
+  process.stdout.write(` ${BOLD}Choose your work style:${RST}\n\n`);
+  process.stdout.write(`   ${CYAN}●${RST} Auto (recommended) — adapts to each task\n`);
+  process.stdout.write(`   ${GRAY}○${RST} Quality-first — deeper review, stronger models\n`);
+  process.stdout.write(`   ${GRAY}○${RST} Cost-saver — lighter models, lower cost\n`);
+  process.stdout.write('\n');
+  process.stdout.write(` ${GRAY}[Enter]${RST} Auto  ${GRAY}[1-3]${RST} select\n\n`);
 
-  const chosenBias = styleMap[styleChoice] || 'balanced';
-  const chosenName = styleNames[chosenBias];
-  fx.nl();
+  const styleKey = await singleKey(['1', '2', '3', '\r']);
+  const styleMap = { '1': 'auto', '2': 'quality-first', '3': 'cost-saver', '\r': 'auto' };
+  const chosenBias = styleMap[styleKey] || 'auto';
 
-  // Non-blocking note if metered API detected
+  // Metered API note (non-blocking)
   if (openaiReady && caps.openai.metered) {
-    const DIM = '\x1b[2m'; const RESET = '\x1b[0m';
-    process.stdout.write(`  ${DIM}OpenAI API key detected — usage is metered, guardrails enabled${RESET}\n\n`);
+    process.stdout.write('\n');
+    dimLine('OpenAI API key detected — usage is metered, guardrails enabled');
   }
 
-  // ─── Step 6: Ready ────────────────────────────────────────────────────────
-  fx.step(5, 5, 'Ready!');
-  fx.nl();
+  process.stdout.write('\n');
 
-  // Init living docs
+  // Init living docs (non-fatal)
   try {
     const ld = await getLivingDocs();
     if (ld.initLivingDocs) ld.initLivingDocs(cwd);
   } catch { /* non-fatal */ }
 
+  // ─── Step 3: Done — seamless transition line before dashboard renders ─────
+  const termWidth = process.stdout.columns || 72;
+  const divider = '━'.repeat(Math.min(termWidth - 2, 57));
+  process.stdout.write(` ${GRAY}${divider}${RST}\n`);
+
+  const providerCount = [finalClaudeEnabled, finalOpenaiEnabled].filter(Boolean).length;
+  const sessionLabel  = rtSessionCount > 0 ? ` · ${rtSessionCount} sessions imported` : '';
+  process.stdout.write(` ${GREEN}✓${RST} Setup complete · ${providerCount} provider${providerCount === 1 ? '' : 's'}${sessionLabel}\n`);
+  process.stdout.write('\n');
+
   await fx.sleep(400);
-  fx.celebrate(`dual-brain is ready! (${chosenName} mode)`);
-  fx.nl();
-  fx.info('Type anything to get started. Your AI partner is listening.');
-  await fx.sleep(1200);
 
   // ─── Build and return the profile object ──────────────────────────────────
   const finalProfile = loadProfile(cwd);
 
-  finalProfile.providers.claude = { enabled: claudeReady };
-  finalProfile.providers.openai = { enabled: openaiReady || codexAvailable };
+  finalProfile.providers.claude = { enabled: finalClaudeEnabled };
+  finalProfile.providers.openai = { enabled: finalOpenaiEnabled };
   finalProfile.apiGuardrail     = caps.openai.metered;
+  finalProfile.setupComplete    = true;
 
-  const enabledCount = [claudeReady, openaiReady || codexAvailable].filter(Boolean).length;
-  finalProfile.mode      = enabledCount >= 2 ? 'dual' : claudeReady ? 'solo-claude' : 'solo-openai';
+  const enabledCount = [finalClaudeEnabled, finalOpenaiEnabled].filter(Boolean).length;
+  finalProfile.mode      = enabledCount >= 2 ? 'dual' : finalClaudeEnabled ? 'solo-claude' : 'solo-openai';
   finalProfile.bias      = chosenBias;
   finalProfile.workStyle = chosenBias;
 
@@ -4476,6 +4997,7 @@ const SCREENS = {
   welcome:          welcomeScreen,
   main:             mainScreen,
   'new-session':    newSessionScreen,
+  'palette-help':   paletteHelpScreen,
   settings:         settingsScreen,
   team:             teamScreen,
   'import-picker':  importPickerScreen,
@@ -4502,7 +5024,21 @@ async function runScreens(startScreen = 'dashboard') {
     if (current === 'go' && ctx.prompt) {
       const prompt = ctx.prompt;
       const dryRun = ctx.dryRun || false;
-      await cmdGo([prompt], { dryRun });
+      // Haiku tier: dispatch with model override for cheap question answers
+      if (ctx.model === 'haiku') {
+        process.stdout.write('\n');
+        try {
+          const { runPipeline: rp } = await import('../src/pipeline.mjs');
+          const { result } = await rp('go', prompt, { cwd: process.cwd(), dryRun, forceDepth: 'shallow' });
+          if (result?.output) process.stdout.write('\n' + String(result.output).trim() + '\n\n');
+          else process.stdout.write('  (no output)\n\n');
+        } catch (e) {
+          // Fall back to normal dispatch on error
+          await cmdGo([prompt], { dryRun });
+        }
+      } else {
+        await cmdGo([prompt], { dryRun });
+      }
       current = 'main';
       ctx = {};
       continue;
@@ -4515,7 +5051,7 @@ async function runScreens(startScreen = 'dashboard') {
       current = result?.next || 'exit';
       // Pass through context (e.g. selected session, typed prompt, openPRs) to next screen
       ctx = result?.session   ? { session: result.session }
-          : result?.prompt    ? { prompt: result.prompt }
+          : result?.prompt    ? { prompt: result.prompt, model: result.model }
           : result?.openPRs   ? { openPRs: result.openPRs }
           : {};
     } catch (e) {
@@ -5011,7 +5547,7 @@ async function main() {
         if (wizardProfile) {
           saveProfile(wizardProfile, { cwd });
           await cmdInstall(cwd);
-          console.log('\n  ✅ Setup complete! Starting dual-brain...\n');
+          // (wizard already printed setup-complete line)
         }
         rl.close();
         await runScreens('main');
@@ -5042,6 +5578,30 @@ async function main() {
   }
 
   if (cmd === 'init') {
+    // init --reset: clear credentials.json and re-run wizard
+    if (args.includes('--reset')) {
+      const cwd = process.cwd();
+      const credPath = join(cwd, '.dualbrain', 'credentials.json');
+      try {
+        if (existsSync(credPath)) {
+          unlinkSync(credPath);
+          console.log('  ✓ credentials.json cleared');
+        }
+        // Also clear setupComplete so wizard re-runs
+        const profilePath = join(cwd, '.dualbrain', 'profile.json');
+        if (existsSync(profilePath)) {
+          const p = JSON.parse(readFileSync(profilePath, 'utf8'));
+          delete p.setupComplete;
+          writeFileSync(profilePath, JSON.stringify(p, null, 2), 'utf8');
+          console.log('  ✓ profile reset — wizard will re-run');
+        }
+      } catch (e) {
+        console.error('  Error during reset:', e.message);
+      }
+      if (!isInteractive) return;
+      // Fall through to run the wizard interactively
+    }
+
     // init --replit: run Replit-specific integration setup
     if (args.includes('--replit')) {
       const cwd = process.cwd();
@@ -5069,7 +5629,7 @@ async function main() {
       if (wizardProfile) {
         saveProfile(wizardProfile, { cwd });
         await cmdInstall(cwd);
-        console.log('\n  ✅ Setup complete! Starting dual-brain...\n');
+        // (wizard already printed setup-complete line)
       }
       rl.close();
       await runScreens('main');