dual-brain 0.1.23 → 0.2.0

package/bin/dual-brain.mjs

@@ -54,6 +54,63 @@ async function getFailureMem() {
   return _failureMem;
 }
 
+let _livingDocs = null;
+async function getLivingDocs() {
+  if (!_livingDocs) {
+    try { _livingDocs = await import('../src/living-docs.mjs'); } catch { _livingDocs = {}; }
+  }
+  return _livingDocs;
+}
+
+let _fx = null;
+async function getFx() {
+  if (_fx !== null) return _fx;
+  try {
+    _fx = await import('../src/fx.mjs');
+  } catch {
+    // Fallback stubs when fx.mjs is not yet present
+    const _noop = () => {};
+    const _spinnerStub = (text) => {
+      let _t = text;
+      const _o = {
+        start()      { process.stdout.write(`  … ${_t}\n`); return _o; },
+        succeed(msg) { process.stdout.write(`  ✓ ${msg || _t}\n`); return _o; },
+        fail(msg)    { process.stdout.write(`  ✗ ${msg || _t}\n`); return _o; },
+        warn(msg)    { process.stdout.write(`  ⚠ ${msg || _t}\n`); return _o; },
+        stop()       { return _o; },
+        update(t)    { _t = t; return _o; },
+      };
+      return _o;
+    };
+    _fx = {
+      spinner:         _spinnerStub,
+      success:         (t) => process.stdout.write(`  ✓ ${t}\n`),
+      error:           (t) => process.stdout.write(`  ✗ ${t}\n`),
+      warn:            (t) => process.stdout.write(`  ⚠ ${t}\n`),
+      info:            (t) => process.stdout.write(`  ${t}\n`),
+      dim:             (t) => process.stdout.write(`  ${t}\n`),
+      step:            (cur, tot, t) => process.stdout.write(`\n  [${cur}/${tot}] ${t}\n`),
+      banner:          (t) => process.stdout.write(`\n  ═══ ${t} ═══\n\n`),
+      box:             (content) => process.stdout.write(`${content}\n`),
+      celebrate:       (t) => process.stdout.write(`  ✨ ${t}\n`),
+      loadingSequence: async (steps) => {
+        for (const s of steps) {
+          process.stdout.write(`  … ${s.text}\n`);
+          await new Promise(r => setTimeout(r, Math.min(s.duration || 300, 300)));
+          process.stdout.write(`  ✓ ${s.successText || s.text}\n`);
+        }
+      },
+      gradient:    (t) => t,
+      sleep:       (ms) => new Promise(r => setTimeout(r, ms)),
+      clearScreen: _noop,
+      nl:          () => process.stdout.write('\n'),
+      getMode:     () => 'plain',
+      colors:      {},
+    };
+  }
+  return _fx;
+}
+
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -355,6 +412,12 @@ async function cmdGo(args, opts = {}) {
   const cwd = process.cwd();
   await ensureProfile(cwd);
 
+  // ── Living docs: ensure .dual-brain/ exists on session start ─────────────
+  try {
+    const ld = await getLivingDocs();
+    if (ld.initLivingDocs) ld.initLivingDocs(cwd);
+  } catch { /* non-fatal */ }
+
   if (verbose) console.log('\nDispatching...');
 
   // ── Failure memory: check history before dispatching ──────────────────────
@@ -368,6 +431,13 @@ async function cmdGo(args, opts = {}) {
     } catch { /* non-fatal */ }
   }
 
+  // ── Dispatch visualization ─────────────────────────────────────────────────
+  const fxGo = await getFx();
+  let dispatchSpinner = null;
+  if (fxGo) {
+    dispatchSpinner = fxGo.spinner(`Dispatching agent...`).start();
+  }
+
   const { plan, result } = await runPipeline('go', prompt, {
     files,
     cwd,
@@ -375,6 +445,11 @@ async function cmdGo(args, opts = {}) {
     dryRun,
   });
 
+  if (dispatchSpinner) {
+    const model = plan?._decision?.model || plan?._decision?.provider || 'agent';
+    dispatchSpinner.succeed(`Agent dispatched: ${prompt.slice(0, 50)}`);
+  }
+
   if (dryRun) {
     // formatExecutionPlan already printed by pipeline when verbose/dryRun=true
     console.log('\n(dry-run — not executing)');
@@ -385,6 +460,7 @@ async function cmdGo(args, opts = {}) {
 
   // Display result — dual-brain vs single-provider
   if (result.consensus) {
+    if (fxGo) fxGo.celebrate('Task complete!');
     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}`);
@@ -408,6 +484,16 @@ async function cmdGo(args, opts = {}) {
       nextAction:   null,
     }, cwd);
 
+    // ── Living docs: record completed session action ───────────────────────
+    try {
+      const ld = await getLivingDocs();
+      if (ld.appendAction) ld.appendAction({
+        type: 'task', intent: prompt, status: 'completed',
+        owner: plan?._decision?.provider ?? 'claude',
+        files, result: result.consensus || 'dual-brain complete',
+      }, cwd);
+    } catch { /* non-fatal */ }
+
     // Clear failure memory on success
     if (failureMem.clearFailures) {
       try { await failureMem.clearFailures(prompt, cwd); } catch { /* non-fatal */ }
@@ -428,9 +514,15 @@ async function cmdGo(args, opts = {}) {
   } else {
     const succeeded = result.status === 'completed';
     const statusLine = succeeded ? 'Done' : `Failed (exit ${result.exitCode})`;
+    if (succeeded && fxGo) {
+      fxGo.celebrate('Task complete!');
+    }
     console.log(`\n${statusLine}${result.durationMs != null ? ` in ${(result.durationMs / 1000).toFixed(1)}s` : ''}`);
     if (result.summary) console.log(result.summary);
-    if (result.error)   process.stderr.write(`${result.error}\n`);
+    if (result.error) {
+      if (fxGo) fxGo.error(result.error);
+      else process.stderr.write(`${result.error}\n`);
+    }
 
     // Receipt
     const receipt = await getReceipt();
@@ -459,6 +551,17 @@ async function cmdGo(args, opts = {}) {
       nextAction:   null,
     }, cwd);
 
+    // ── Living docs: record completed session action ───────────────────────
+    try {
+      const ld = await getLivingDocs();
+      if (ld.appendAction) ld.appendAction({
+        type: 'task', intent: prompt, status: succeeded ? 'completed' : 'failed',
+        owner: plan?._decision?.provider ?? 'claude',
+        files: result.filesChanged || files,
+        result: result.summary || (succeeded ? 'completed' : `exit ${result.exitCode}`),
+      }, cwd);
+    } catch { /* non-fatal */ }
+
     if (!succeeded) {
       // Record failure memory
       if (failureMem.recordFailure) {
@@ -505,6 +608,9 @@ async function cmdThink(args) {
   const cwd = process.cwd();
   await ensureProfile(cwd);
 
+  const fxThink = await getFx();
+  if (fxThink) fxThink.info('Round 1: GPT analyzing...');
+
   const { result, verification } = await runPipeline('think', question, {
     cwd,
     verbose: true,
@@ -513,12 +619,17 @@ async function cmdThink(args) {
   if (!result) return;
 
   if (result.consensus) {
+    if (fxThink) fxThink.success('Round 1 complete');
     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}`);
   } else {
+    if (fxThink) fxThink.success('Round 1 complete');
     if (result.summary) console.log(`\n${result.summary}`);
-    if (result.error)   process.stderr.write(`${result.error}\n`);
+    if (result.error) {
+      if (fxThink) fxThink.error(result.error);
+      else process.stderr.write(`${result.error}\n`);
+    }
     if (result.status && result.status !== 'completed') process.exit(1);
   }
 
@@ -670,12 +781,15 @@ async function cmdStatus(args = []) {
   const { states } = getHealth(cwd);
   const sessionStats = getSessionStats(cwd);
 
+  const fxSt = await getFx();
+
   console.log('=== Dual-Brain Status ===\n');
 
   // Providers + health
   console.log('Providers:');
   if (providers.length === 0) {
-    console.log('  (none configured — run: dual-brain init)');
+    if (fxSt) fxSt.warn('(none configured — run: dual-brain init)');
+    else console.log('  (none configured — run: dual-brain init)');
   } else {
     for (const p of providers) {
       const label = p.name === 'claude' ? 'Claude' : 'OpenAI';
@@ -686,7 +800,8 @@ async function cmdStatus(args = []) {
 
       const planStr = p.plan ? `  plan=${p.plan}` : '';
       if (provStates.length === 0) {
-        console.log(`  ${label}${planStr}  status=healthy  calls=${sess.calls}  tokens=${sess.tokens}`);
+        const line = `  ${label}${planStr}  status=healthy  calls=${sess.calls}  tokens=${sess.tokens}`;
+        if (fxSt) fxSt.success(line.trim()); else console.log(line);
       } else {
         for (const [k, st] of provStates) {
           const modelClass = k.split(':').slice(1).join(':');
@@ -695,7 +810,14 @@ async function cmdStatus(args = []) {
             const remaining = remainingCooldownMinutes(p.name, modelClass, cwd);
             statusStr = remaining > 0 ? `hot (retry in ${remaining}m)` : 'hot (cooling)';
           }
-          console.log(`  ${label}${planStr}  model=${modelClass}  status=${statusStr}  calls=${sess.calls}  tokens=${sess.tokens}`);
+          const line = `  ${label}${planStr}  model=${modelClass}  status=${statusStr}  calls=${sess.calls}  tokens=${sess.tokens}`;
+          if (fxSt) {
+            if (st.status === 'hot') fxSt.warn(line.trim());
+            else if (st.status === 'down') fxSt.error(line.trim());
+            else fxSt.success(line.trim());
+          } else {
+            console.log(line);
+          }
         }
       }
     }
@@ -1007,14 +1129,14 @@ async function welcomeScreen(rl, ask) {
   }
   console.log('');
 
-  // --- Detect data-tools / replit-tools sessions ---
+  // --- Detect replit-tools sessions ---
   const env = detectEnvironment();
   const existingSessions = importReplitSessions(cwd);
   if (env.hasReplitTools) {
-    detectedLines.push(`  data-tools detected`);
+    detectedLines.push(`  replit-tools detected`);
   }
   if (existingSessions.length > 0) {
-    detectedLines.push(`  ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} found from data-tools`);
+    detectedLines.push(`  ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} found from replit-tools`);
   }
 
   // --- Detect replit-tools ---
@@ -1054,7 +1176,7 @@ async function welcomeScreen(rl, ask) {
   console.log('  [Enter] Save and go');
   console.log('  [c]     Customize work style');
   if (existingSessions.length > 0) {
-    console.log(`  [i]     Import ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} from data-tools`);
+    console.log(`  [i]     Import ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} from replit-tools`);
   }
   if (!rt.installed) {
     console.log('');
@@ -1066,7 +1188,7 @@ async function welcomeScreen(rl, ask) {
   const choice = (await ask('  Choice: ')).trim().toLowerCase();
 
   if (choice === 'i' && existingSessions.length > 0) {
-    console.log(`\n  Importing ${existingSessions.length} sessions from data-tools...\n`);
+    console.log(`\n  Importing ${existingSessions.length} sessions from replit-tools...\n`);
     const recent = existingSessions.slice(0, 5);
     for (const sess of recent) {
       console.log(`  ${sess.age.padEnd(6)}  ${sess.name}`);
@@ -1483,12 +1605,20 @@ function detectInterruptedWork(sessions, cwd) {
  * Shows: "● Claude  ● OpenAI  ⚖️  Balanced"
  * Uses ANSI color codes for the dots — no dollar amounts or usage bars.
  */
-function buildProviderStatusLine(profile, auth, maxWidth = 54) {
-  const GREEN = '●';
-  const RED   = '●';
+function buildProviderStatusLine(profile, auth, envReport = null) {
+  const GREEN = '\x1b[32m●\x1b[0m';
+  const RED   = '\x1b[31m●\x1b[0m';
+
+  // Use envReport secrets when available; fall back to auth detection
+  const claudeAvailable = envReport
+    ? envReport.secrets.ANTHROPIC_API_KEY || auth.claude.found
+    : auth.claude.found;
+  const openaiAvailable = envReport
+    ? envReport.secrets.OPENAI_API_KEY || auth.openai.found
+    : auth.openai.found;
 
-  const claudeDot = auth.claude.found ? GREEN : RED;
-  const openaiDot = auth.openai.found ? GREEN : RED;
+  const claudeDot = claudeAvailable ? GREEN : RED;
+  const openaiDot = openaiAvailable ? GREEN : RED;
 
   const WORK_STYLE_LABELS = {
     'auto':          '⚡ Fast',
@@ -1498,30 +1628,11 @@ function buildProviderStatusLine(profile, auth, maxWidth = 54) {
     'solo-claude':   '⚡ Fast',
     'solo-openai':   '⚡ Fast',
   };
-  const WORK_STYLE_TIPS = {
-    'auto':          'adapts routing by task risk',
-    'cost-saver':    'single model, minimal reviews',
-    'balanced':      'smart routing, reviews when needed',
-    'quality-first': 'dual-brain on everything important',
-    'solo-claude':   'Claude only, no GPT dispatch',
-    'solo-openai':   'OpenAI only, no Claude dispatch',
-  };
   const bias  = profile?.bias || profile?.mode || 'balanced';
   const label = WORK_STYLE_LABELS[bias] || '⚖️  Balanced';
-  const fullTip = WORK_STYLE_TIPS[bias] || 'smart routing, reviews when needed';
-
-  // Trim tip to fit within box width (measure visible chars: strip ANSI + variation selectors)
-  const labelPlain = label.replace(/[︀-️]/g, '').replace(/[[0-9;]*m/g, '');
-  const prefixLen = ('● Claude  ● OpenAI  ' + labelPlain + ' — ').length;
-  const tipMax = maxWidth - prefixLen;
-  const tip = tipMax >= 6
-    ? (fullTip.length > tipMax ? fullTip.slice(0, tipMax - 1) + '…' : fullTip)
-    : '';
 
-  const suffix = tip ? ` — ${tip}` : '';
-  return `${claudeDot} Claude  ${openaiDot} OpenAI  ${label}${suffix}`;
+  return `${claudeDot} Claude     ${openaiDot} OpenAI     ${label}`;
 }
-
 /**
  * Render a box row padded to inner width W (stripping ANSI for length calculation).
  * Returns a string like: "│ content padded to W │"
@@ -1544,6 +1655,13 @@ async function mainScreen(rl, ask) {
   const profile = loadProfile(cwd);
   const auth    = await detectAuth();
 
+  // ── Dashboard load animation (full mode only) ─────────────────────────────
+  const fx = await getFx();
+  let dashSpinner = null;
+  if (fx && fx.getMode && fx.getMode() === 'full') {
+    dashSpinner = fx.spinner('Loading dashboard...').start();
+  }
+
   const claudeSub = profile?.providers?.claude;
   const openaiSub = profile?.providers?.openai;
 
@@ -1591,7 +1709,7 @@ async function mainScreen(rl, ask) {
     return ageMs >= 7 * 86400000;
   }).length;
 
-  // Detect data-tools version
+  // Detect replit-tools version
   const rtMain    = detectReplitTools(cwd);
   const dtVersion = (rtMain.installed && rtMain.version) ? rtMain.version : null;
 
@@ -1609,25 +1727,6 @@ async function mainScreen(rl, ask) {
 
   const row = (content) => makeBoxRow(content, W);
 
-  // ── Header: one line above the box ────────────────────────────────────────
-  process.stdout.write(`\n🧠 dual-brain v${version}\n`);
-  {
-    let gitName = '';
-    try {
-      const { execSync } = await import('node:child_process');
-      gitName = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
-    } catch { /* ignore */ }
-    if (gitName) {
-      const hour = new Date().getHours();
-      let greet;
-      if (hour >= 5 && hour <= 11)  greet = 'Good morning';
-      else if (hour >= 12 && hour <= 16) greet = 'Good afternoon';
-      else if (hour >= 17 && hour <= 21) greet = 'Good evening';
-      else                               greet = 'Late night';
-      process.stdout.write(`\x1b[2m${greet}, ${gitName}\x1b[0m\n`);
-    }
-  }
-
   // ── Continuation card (interrupted work) ─────────────────────────────────
   if (interrupted) {
     const ctop = `┌${'─'.repeat(boxW - 2)}┐`;
@@ -1706,15 +1805,82 @@ async function mainScreen(rl, ask) {
     // 's' → fall through to normal dashboard
   }
 
-  // ── Status section ────────────────────────────────────────────────────────
-  const providerLine = buildProviderStatusLine(profile, auth, W);
+  // ── Environment awareness (powers Box 1 dots + Box 3) ────────────────────
+  let envReport = null;
+  try {
+    const { scanEnvironment } = await import('../src/awareness.mjs');
+    envReport = scanEnvironment(cwd);
+  } catch { /* non-fatal */ }
+
+  // ── Box 1 — Header row data ─────────────────────────────────────────────
+  const providerLine = buildProviderStatusLine(profile, auth, envReport);
 
-  const statusRows = [row(providerLine)];
-  if (dtVersion) {
-    statusRows.push(row(`\x1b[2m📦 replit-tools v${dtVersion}\x1b[0m`));
+  // ── Box 2 — Workspace: gather git data ───────────────────────────────────
+  let gitBranch       = 'unknown';
+  let gitUncommitted  = 0;
+  let gitAheadCount   = 0;
+  let gitLastMsg      = '';
+  let gitLastAgo      = '';
+
+  try {
+    gitBranch = execSync('git rev-parse --abbrev-ref HEAD 2>/dev/null', {
+      cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe',
+    }).trim() || 'unknown';
+  } catch {}
+
+  try {
+    const status = execSync('git status --porcelain 2>/dev/null', {
+      cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe',
+    });
+    gitUncommitted = status.trim().split('\n').filter(Boolean).length;
+  } catch {}
+
+  try {
+    const aheadOut = execSync('git rev-list @{u}..HEAD 2>/dev/null | wc -l', {
+      cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe',
+    });
+    gitAheadCount = parseInt(aheadOut.trim(), 10) || 0;
+  } catch {}
+
+  try {
+    const logOut = execSync('git log -1 --format="%s|%ct" 2>/dev/null', {
+      cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe',
+    }).trim();
+    if (logOut) {
+      const [msg, ts] = logOut.split('|');
+      gitLastMsg = (msg || '').slice(0, 38);
+      const ageMs  = Date.now() - (parseInt(ts, 10) * 1000);
+      const ageMin = Math.floor(ageMs / 60000);
+      if (ageMin < 60)         gitLastAgo = `${ageMin}m ago`;
+      else if (ageMin < 1440)  gitLastAgo = `${Math.floor(ageMin / 60)}h ago`;
+      else                     gitLastAgo = `${Math.floor(ageMin / 1440)}d ago`;
+    }
+  } catch {}
+
+  // ── Box 2 rows ────────────────────────────────────────────────────────────
+  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'}`));
   }
 
-  // ── Observer observations (top 2, high priority first) ───────────────────
+  // ── Box 3 — Awareness: observer + roadmap + risk ──────────────────────────
+  let awarenessLine1 = '\x1b[2m💡\x1b[0m Ready to work';
+  let awarenessLine2 = '\x1b[2m📋 No roadmap yet\x1b[0m';
+  let awarenessLine3 = '\x1b[32m✓\x1b[0m No risk flags';
+
+  // Line 1: observer data first; fall back to envReport-derived observations
   let quickObservations = [];
   try {
     const observerMod = await import('../src/observer.mjs');
@@ -1724,64 +1890,78 @@ async function mainScreen(rl, ask) {
       const sorted = [...quickState.observations].sort(
         (a, b) => (PRIO[a.priority] ?? 2) - (PRIO[b.priority] ?? 2)
       );
-      quickObservations = sorted.slice(0, 2);
-      for (const obs of quickObservations) {
-        let prefix;
-        if (obs.priority === 'high')   prefix = '🔴';
-        else if (obs.priority === 'medium') prefix = '🟡';
-        else                                prefix = '\x1b[2m💡\x1b[0m';
-        statusRows.push(row(`${prefix} ${obs.message}`));
+      quickObservations = sorted.slice(0, 3);
+      const top = quickObservations[0];
+      if (top) {
+        const prefix = top.priority === 'high' ? '🔴' : top.priority === 'medium' ? '🟡' : '\x1b[2m💡\x1b[0m';
+        awarenessLine1 = `${prefix} ${top.message}`;
+      }
+      const hasHighRisk = quickObservations.some(o => o.priority === 'high');
+      if (hasHighRisk) {
+        awarenessLine3 = '\x1b[31m⚠\x1b[0m  Risk flags detected — run: dual-brain review';
       }
     }
-  } catch { /* non-fatal — module may not exist yet */ }
-
-  // ── Action cards (git state + open PRs) ──────────────────────────────────
-  const repoState  = detectRepoState(cwd);
-  const openPRs    = await detectOpenPRs(cwd);
-  const actionRows = buildActionRows(repoState, row, openPRs);
-
-  // ── High-priority observer action cards ───────────────────────────────────
-  if (quickObservations.some(o => o.priority === 'high')) {
-    const DIM   = '\x1b[2m';
-    const RESET = '\x1b[0m';
-    actionRows.push(row(`${DIM}[r] Security review  [t] Run tests  [c] Commit${RESET}`));
+  } catch { /* non-fatal — observer may not exist */ }
+
+  // If observer produced nothing, derive from envReport
+  if (awarenessLine1 === '\x1b[2m💡\x1b[0m Ready to work' && envReport) {
+    if (envReport.replit?.hasDatabase) {
+      awarenessLine1 = '\x1b[2m💡\x1b[0m PostgreSQL available';
+    } else if (gitUncommitted > 0) {
+      awarenessLine1 = `\x1b[2m💡\x1b[0m ${gitUncommitted} file${gitUncommitted === 1 ? '' : 's'} ready to commit`;
+    } else if (envReport.dualBrain?.hasFailureMemory) {
+      // Check for recent failures
+      try {
+        const failureMem = await getFailureMem();
+        if (failureMem.getRecentFailures) {
+          const recent = failureMem.getRecentFailures(cwd, 2);
+          if (recent?.length > 0) {
+            awarenessLine1 = `\x1b[33m⚠\x1b[0m  ${recent.length} recent failure${recent.length === 1 ? '' : 's'} — check before proceeding`;
+          }
+        }
+      } catch { /* non-fatal */ }
+    }
   }
 
-  // ── Related sessions hint (only when no continuation card is showing) ─────
-  if (!interrupted && recentSessions.length > 0) {
+  // Line 2: roadmap file, then ledger open tasks as fallback
+  try {
+    const roadmapPath = join(cwd, '.dual-brain', 'roadmap.md');
+    if (existsSync(roadmapPath)) {
+      const roadmapText = readFileSync(roadmapPath, 'utf8');
+      const lines = roadmapText.split('\n').filter(Boolean);
+      // Skip heading lines, grab first non-heading line
+      const firstItem = lines.find(l => !l.startsWith('#') && l.trim().length > 0);
+      if (firstItem) {
+        const clean = firstItem.replace(/^[-*>]+\s*/, '').trim().slice(0, 45);
+        awarenessLine2 = `\x1b[2m📋\x1b[0m ${clean}`;
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  if (awarenessLine2 === '\x1b[2m📋 No roadmap yet\x1b[0m') {
     try {
-      const { findRelatedSessions } = await import('../src/session.mjs');
-      const mostRecent = recentSessions[0];
-      // Build a pseudo-prompt from the most recent session's name/objective
-      const recentPrompt = mostRecent.name || '';
-      // Load session index to get files for the most recent session
-      const indexPath = join(cwd, '.dualbrain', 'session-index.json');
-      let recentFiles = [];
-      try {
-        const idx = JSON.parse(readFileSync(indexPath, 'utf8'));
-        recentFiles = idx[mostRecent.id]?.files || [];
-      } catch {}
-      const related = findRelatedSessions(recentPrompt, recentFiles, cwd);
-      if (related.length > 0) {
-        const relAgeLabel = (isoDate) => {
-          if (!isoDate) return '';
-          const diff  = Date.now() - Date.parse(isoDate);
-          const days  = Math.floor(diff / 86400000);
-          const hours = Math.floor(diff / 3600000);
-          if (days >= 1) return `${days}d`;
-          return `${hours}h ago`;
-        };
-        const relatedParts = related.slice(0, 2).map(r => {
-          const age = relAgeLabel(r.date);
-          return age ? `${r.smartName} (${age})` : r.smartName;
-        });
-        const DIM   = '\x1b[2m';
-        const RESET = '\x1b[0m';
-        actionRows.push(row(`${DIM}📎 Related: ${relatedParts.join(', ')}${RESET}`));
+      const { getOpenTasks } = await import('../src/ledger.mjs');
+      const open = getOpenTasks(cwd);
+      if (open.length > 0) {
+        awarenessLine2 = '📋 Next: ' + open[0].intent.slice(0, 45);
       }
     } catch { /* non-fatal */ }
   }
-  // ── End related sessions hint ─────────────────────────────────────────────
+
+  // Line 3: model registry age warning
+  try {
+    const { getRegistryAge } = await import('../src/models.mjs');
+    const age = getRegistryAge();
+    if (age > 30 && awarenessLine3 === '\x1b[32m✓\x1b[0m No risk flags') {
+      awarenessLine3 = `\x1b[33m⚠\x1b[0m  Model registry ${age} days old`;
+    }
+  } catch { /* non-fatal */ }
+
+  const awarenessRows = [
+    row(awarenessLine1),
+    row(awarenessLine2),
+    row(awarenessLine3),
+  ];
 
   // ── Sessions section ──────────────────────────────────────────────────────
   const sessionRows = [];
@@ -1837,23 +2017,28 @@ async function mainScreen(rl, ask) {
     });
   }
 
-  // ── Actions bar — navigation only (pipeline verbs are internal stages, not menu items) ─
-  const actionsContent = 'n New session  / Search  q Quit';
+  // ── Box 5 — Input bar ──────────────────────────────────────────────────
+  const actionsContent = '> type anything...   [s] settings  [t] team  [q] quit';
   const actionsRow     = row(actionsContent);
 
-  // ── Print the full box ────────────────────────────────────────────────────
-  // Include action cards between status and sessions (with separators only when non-empty)
-  const poweredByRow = row('\x1b[2mPowered by dual-brain\x1b[0m');
+  // ── 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,
-    ...statusRows,
-    ...(actionRows.length > 0 ? [sep, ...actionRows] : []),
+    row(`🧠 dual-brain v${version}`),
+    row(providerLine),
+    sep,
+    ...workspaceRows,
+    sep,
+    ...awarenessRows,
     sep,
     ...sessionRows,
     sep,
     actionsRow,
-    sep,
-    poweredByRow,
     bot,
   ];
   // ── Stale session hint ──────────────────────────────────────────────────
@@ -1861,6 +2046,9 @@ async function mainScreen(rl, ask) {
     process.stdout.write(`\x1b[2m${staleCount} stale sessions (>7d) — press s → archive to clean up\x1b[0m\n`);
   }
 
+  // Resolve dashboard spinner before rendering
+  if (dashSpinner) dashSpinner.succeed('Dashboard ready');
+
   process.stdout.write(lines.join('\n') + '\n\n');
 
   // ── Key handling ──────────────────────────────────────────────────────────
@@ -1948,7 +2136,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', 'q', '/', 'i']);
+        const singleKeySet = new Set(['n', 's', 't', 'q', '/', 'i']);
         if (singleKeySet.has(lower)) {
           cleanup();
           process.stdout.write('\n');
@@ -2054,6 +2242,7 @@ async function mainScreen(rl, ask) {
   }
 
   if (choice === 's') { return { next: 'settings' }; }
+  if (choice === 't') { return { next: 'team' }; }
   if (choice === 'i') { return { next: 'import-picker' }; }
   if (choice === 'q' || choice === 'exit') { return { next: 'exit' }; }
 
@@ -2078,7 +2267,7 @@ async function newSessionScreen(rl, ask) {
 async function importPickerScreen() {
   const cwd = process.cwd();
 
-  // Load all available sessions from data-tools
+  // Load all available sessions from replit-tools
   const allSessions = importReplitSessions(cwd);
 
   // Load existing session meta to filter already-imported ones
@@ -2124,9 +2313,9 @@ async function importPickerScreen() {
   if (allSessions.length === 0) {
     process.stdout.write('\n');
     process.stdout.write(top + '\n');
-    process.stdout.write(row('Import from data-tools') + '\n');
+    process.stdout.write(row('Import from replit-tools') + '\n');
     process.stdout.write(sep + '\n');
-    process.stdout.write(row('No data-tools sessions found.') + '\n');
+    process.stdout.write(row('No replit-tools sessions found.') + '\n');
     process.stdout.write(row('Install replit-tools: npm i -g replit-tools') + '\n');
     process.stdout.write(sep + '\n');
     process.stdout.write(row('Press any key to go back...') + '\n');
@@ -2138,7 +2327,7 @@ async function importPickerScreen() {
   if (candidates.length === 0) {
     process.stdout.write('\n');
     process.stdout.write(top + '\n');
-    process.stdout.write(row('Import from data-tools') + '\n');
+    process.stdout.write(row('Import from replit-tools') + '\n');
     process.stdout.write(sep + '\n');
     process.stdout.write(row(`All ${allSessions.length} sessions already imported.`) + '\n');
     process.stdout.write(sep + '\n');
@@ -2161,7 +2350,7 @@ async function importPickerScreen() {
   const renderPicker = () => {
     process.stdout.write('\x1b[2J\x1b[H'); // clear screen
 
-    const headerTitle = 'Import from data-tools';
+    const headerTitle = 'Import from replit-tools';
     const footerLine  = '↑↓ Navigate  Space Toggle  Enter Import  q Back';
 
     process.stdout.write('\n');
@@ -2298,7 +2487,7 @@ async function importPickerScreen() {
   }
   saveSessionMeta(updatedMeta, cwd);
 
-  process.stdout.write(`✓ Imported ${importCount} session${importCount !== 1 ? 's' : ''} from data-tools\n\n`);
+  process.stdout.write(`✓ Imported ${importCount} session${importCount !== 1 ? 's' : ''} from replit-tools\n\n`);
 
   return { next: 'main' };
 }
@@ -2560,22 +2749,89 @@ async function settingsScreen(rl, ask) {
     'balanced':      '⚖️  Balanced',
     'quality-first': '🔥 Full Power',
   };
-  const workStyleLabel = WORK_STYLE_DISPLAY[currentBias] || '⚖️  Balanced';
+
+  // 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';
+  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 _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);
+
+  // Cost efficiency summary (graceful — only shown when data exists)
+  let _stEffScore = null;
+  let _stEffRate  = null;
+  let _stEffTrend = null;
+  let _stEffTier  = null;
+  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('  ');
+    }
+  } catch { /* non-fatal */ }
+
+  const _stTrendIcon = _stEffTrend === 'improving' ? '↗' : _stEffTrend === 'degrading' ? '↘' : '→';
 
   const lines = [
     top,
     row('Settings'),
     sep,
-    row(`[w] Work Style: ${workStyleLabel}`),
-    row('[m] Manage subscriptions'),
-    row('[e] Manage sessions'),
-    row('[i] Import from replit-tools'),
-    row('[d] Switch to data-tools'),
-    row('[?] Help & shortcuts'),
-    row('[x] Diagnostics'),
+    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)`)] : []),
-    row(''),
-    row('[Esc/b] Back to dashboard'),
     bot,
   ];
   process.stdout.write('\n' + lines.join('\n') + '\n\n');
@@ -2583,45 +2839,10 @@ async function settingsScreen(rl, ask) {
   const raw    = (await ask('  Choice: ')).trim();
   const choice = raw.toLowerCase();
 
-  if (choice === 'w') {
-    // Work style picker
-    const wsTop = `  ┌${'─'.repeat(51)}┐`;
-    const wsSep = `  ├${'─'.repeat(51)}┤`;
-    const wsBot = `  └${'─'.repeat(51)}┘`;
-    const wsPad = (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, 51 - vlen));
-    };
-    const wsRow = (s) => `  │ ${wsPad(s)}│`;
-
-    const isFast  = currentBias === 'cost-saver' || currentBias === 'auto' || currentBias === 'solo-claude' || currentBias === 'solo-openai';
-    const isBal   = currentBias === 'balanced';
-    const isFull  = currentBias === 'quality-first';
-
-    console.log('');
-    console.log(wsTop);
-    console.log(wsRow('Work Style'));
-    console.log(wsSep);
-    console.log(wsRow(`  1. ⚡ Fast      — quick, single model${isFast  ? '  ← current' : ''}`));
-    console.log(wsRow(`  2. ⚖️  Balanced  — smart routing${isBal   ? '  ← current' : ''}`));
-    console.log(wsRow(`  3. 🔥 Full Power — dual-brain everything${isFull  ? '  ← current' : ''}`));
-    console.log(wsSep);
-    console.log(wsRow('[Enter] Keep current'));
-    console.log(wsBot);
-    console.log('');
-
-    const wsChoice = (await ask('  Choice [1/2/3/Enter]: ')).trim();
-    const wsMap = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
-    const newBias = wsMap[wsChoice];
+  // Direct work style keys 1/2/3
+  if (choice === '1' || choice === '2' || choice === '3') {
+    const _stWsMap = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
+    const newBias  = _stWsMap[choice];
     if (newBias && newBias !== currentBias) {
       profile.bias = newBias;
       const enabledCount = [
@@ -2631,12 +2852,23 @@ async function settingsScreen(rl, ask) {
       if (enabledCount >= 2) profile.mode = newBias;
       saveProfile(profile, { cwd });
       const newLabel = WORK_STYLE_DISPLAY[newBias] || newBias;
-      console.log(`\n  ✓ Work style set to ${newLabel}\n`);
+      process.stdout.write(`\n  Work style set to ${newLabel}\n\n`);
       await ask('  Press Enter to continue...');
     }
     return { next: 'settings' };
   }
 
+  // Reset calibration to defaults
+  if (choice === 'r') {
+    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');
+      await ask('  Press Enter to continue...');
+    } catch { /* non-fatal */ }
+    return { next: 'settings' };
+  }
+
   if (choice === 'm') { return { next: 'subscriptions' }; }
 
   if (choice === 'e') { return { next: 'sessions' }; }
@@ -2655,7 +2887,7 @@ async function settingsScreen(rl, ask) {
     if (which.status === 0) {
       spawnSync('claude-menu', { stdio: 'inherit' });
     } else {
-      process.stdout.write('\n  data-tools not found — install with: npm i -g replit-tools\n\n');
+      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' };
@@ -2689,6 +2921,105 @@ async function settingsScreen(rl, ask) {
   return { next: 'main' };
 }
 
+// ─── Screen: teamScreen ───────────────────────────────────────────────────────
+
+async function teamScreen(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 top = `┌${'─'.repeat(boxW - 2)}┐`;
+  const sep = `├${'─'.repeat(boxW - 2)}┤`;
+  const bot = `└${'─'.repeat(boxW - 2)}┘`;
+  const row = (content) => makeBoxRow(content, W);
+
+  // Load team from project.json
+  let team = [];
+  let sharedSessions = 0;
+  let teamDecisions = 0;
+  try {
+    const _tmLd = await import('../src/living-docs.mjs');
+    const _tmPs = _tmLd.getProjectState(cwd);
+    if (Array.isArray(_tmPs?.project?.team)) {
+      team = _tmPs.project.team;
+    }
+    // Count decisions with more than one participant as team decisions
+    if (Array.isArray(_tmPs?.recentDecisions)) {
+      teamDecisions = _tmPs.recentDecisions.filter(
+        d => Array.isArray(d?.participants) && d.participants.length > 1
+      ).length;
+    }
+  } catch { /* non-fatal */ }
+
+  // Fall back to git user if no team configured
+  let ownerName = '(you)';
+  if (team.length === 0) {
+    try {
+      const { execSync: _tmExec } = await import('node:child_process');
+      const gitUser = _tmExec('git config user.name 2>/dev/null', {
+        encoding: 'utf8', timeout: 2000, stdio: 'pipe',
+      }).trim();
+      if (gitUser) ownerName = gitUser;
+    } catch { /* non-fatal */ }
+  }
+
+  const memberRows = [];
+  if (team.length === 0) {
+    memberRows.push(row(`  ${ownerName} (owner)`));
+  } else {
+    for (const member of team) {
+      const role = member.role || 'member';
+      memberRows.push(row(`  ${member.name} (${role})`));
+    }
+  }
+
+  const lines = [
+    top,
+    row('Team'),
+    sep,
+    row('Members'),
+    ...memberRows,
+    sep,
+    row(`Shared Sessions: ${sharedSessions}`),
+    row(`Team decisions: ${teamDecisions}`),
+    sep,
+    row('[a] add member  [b] back'),
+    bot,
+  ];
+  process.stdout.write('\n' + lines.join('\n') + '\n\n');
+
+  const raw    = (await ask('  Choice: ')).trim();
+  const choice = raw.toLowerCase();
+
+  if (choice === 'a') {
+    const name = (await ask('  Member name: ')).trim();
+    if (name) {
+      try {
+        const _tmLdAdd = await import('../src/living-docs.mjs');
+        const _tmCur   = _tmLdAdd.getProjectState(cwd);
+        const _tmTeam  = Array.isArray(_tmCur?.project?.team) ? [..._tmCur.project.team] : [];
+        _tmTeam.push({ name, role: 'member', addedAt: new Date().toISOString() });
+        _tmLdAdd.updateProject({ team: _tmTeam }, cwd);
+        process.stdout.write(`\n  Added ${name} to team.\n\n`);
+        await ask('  Press Enter to continue...');
+      } catch {
+        process.stdout.write('\n  Could not save team member.\n\n');
+        await ask('  Press Enter to continue...');
+      }
+    }
+    return { next: 'team' };
+  }
+
+  if (choice === 'b' || choice === 'back' || choice === 'q' || raw === '\x1b') {
+    return { next: 'main' };
+  }
+
+  return { next: 'main' };
+}
+
 
 // ─── Helper: aggregatePlans ───────────────────────────────────────────────────
 
@@ -2873,115 +3204,194 @@ async function subscriptionsScreen(rl, ask) {
 // ─── Onboarding Wizard ───────────────────────────────────────────────────────
 
 /**
- * Streamlined onboarding: auto-detect capabilities, ask ONE question (work style).
- * Replaces the old 5-step wizard with a ~5-second, one-choice flow.
- * @param {{ auth, plans, existingSessions }} detection
+ * 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.
+ *
+ * @param {{ auth, plans, existingSessions }} _detection  (unused — kept for API compat)
  * @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 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)}│`;
+  const fx  = await getFx();
+
+  // ─── 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);
+
+  // ─── Step 2: Environment detection ────────────────────────────────────────
+  fx.step(1, 5, 'Scanning environment');
+  fx.nl();
+
+  // Run capability detection in parallel with the animations
+  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' },
+  ]);
 
-  // ── Use detectCapabilities for broad detection (env vars, ~/.claude, CLI) ──
-  const caps = await detectCapabilities(cwd);
+  // Await actual capability data
+  const caps          = await capsPromise;
   const claudeReady    = caps.claude.available;
   const openaiReady    = caps.openai.available;
   const codexAvailable = caps.codex.available;
 
-  // ── Detect replit-tools ────────────────────────────────────────────────────
+  // 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();
+
+  // ─── Step 3: Detect replit-tools ──────────────────────────────────────────
+  fx.step(2, 5, 'Detecting replit-tools');
+  fx.nl();
+
   const rt = detectReplitTools(cwd);
+  const rtSpinner = fx.spinner('Looking for replit-tools...').start();
+  await fx.sleep(700);
 
-  const GREEN = '\x1b[32m✓\x1b[0m';
-  const RED   = '\x1b[31m✗\x1b[0m';
-  const DIM   = '\x1b[2m';
-  const RESET = '\x1b[0m';
+  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');
+  }
+  fx.nl();
 
-  // ══════════════════════════════════════════════════════════════════════════
-  // Step 1 — Auto-detect capabilities (instant, no spinner)
-  // ══════════════════════════════════════════════════════════════════════════
-  console.log('');
-  console.log(wTop);
-  console.log(wRow(`🧠 Dual-Brain v${version} — First-time Setup`));
-  console.log(wRow(claudeReady
-    ? `${GREEN} Claude Code`
-    : `${RED} Claude Code — not found`));
-  console.log(wRow(openaiReady
-    ? `${GREEN} OpenAI API`
-    : codexAvailable
-      ? `${GREEN} OpenAI / Codex CLI`
-      : `${DIM}○ OpenAI — not configured${RESET}`));
-  console.log(wRow(rt.installed
-    ? `${GREEN} replit-tools`
-    : `${DIM}○ replit-tools — not found${RESET}`));
-  console.log(wBottom);
-
-  // ── Edge cases: communicate honestly, but always let them proceed ──────────
-  console.log('');
-  if (!claudeReady && !openaiReady && !codexAvailable) {
-    console.log('  No AI providers detected — configure OPENAI_API_KEY or use');
-    console.log('  within Claude Code. You can still continue and set up later.');
-    console.log('');
-  } else if (claudeReady && !openaiReady && !codexAvailable) {
-    console.log(`  ${DIM}Tip: Add OPENAI_API_KEY for dual-brain collaboration${RESET}`);
-    console.log('');
-  } else if (!claudeReady && (openaiReady || codexAvailable)) {
-    console.log(`  ${DIM}Note: Use within Claude Code for full dual-brain${RESET}`);
-    console.log('');
+  // ─── 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();
+
+    // 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();
+
+    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();
 
-  // ══════════════════════════════════════════════════════════════════════════
-  // Step 2 — ONE question: work style
-  // ══════════════════════════════════════════════════════════════════════════
-  console.log(wTop);
-  console.log(wRow('How do you want to work?'));
-  console.log(wRow(''));
-  console.log(wRow('  1  ⚡ Fast       — single model, quick tasks, skip reviews'));
-  console.log(wRow('  2  ⚖️  Balanced   — smart routing, reviews on important changes'));
-  console.log(wRow('  3  🔥 Full Power  — deep reasoning, dual-brain when it matters'));
-  console.log(wBottom);
-  console.log('');
+  // ─── 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 styleChoice = (await ask('  Choice [2]: ')).trim();
   const styleMap   = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
-  const styleNames = { 'cost-saver': 'Fast', 'balanced': 'Balanced', 'quality-first': 'Full Power' };
+  const styleNames = { 'cost-saver': 'Fast', 'balanced': 'Balanced', 'quality-first': 'Thorough' };
+
+  let styleChoice = '2'; // default
+  const isTTY = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+
+  if (isTTY) {
+    // Raw keypress — single character
+    const { emitKeypressEvents } = await import('node:readline');
+    emitKeypressEvents(process.stdin, rl);
+
+    process.stdout.write('  Choice [2]: ');
+    styleChoice = await 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('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;
+        }
+      };
+
+      process.stdin.on('keypress', onKey);
+    });
+  } else {
+    // Fallback: line-based prompt
+    process.stdout.write('  Choice [2]: ');
+    styleChoice = (await ask('')).trim() || '2';
+  }
+
   const chosenBias = styleMap[styleChoice] || 'balanced';
   const chosenName = styleNames[chosenBias];
+  fx.nl();
 
-  // ── Non-blocking note if metered API detected ──────────────────────────────
+  // Non-blocking note if metered API detected
   if (openaiReady && caps.openai.metered) {
-    console.log(`  ${DIM}OpenAI API key detected — usage is metered, guardrails enabled${RESET}`);
-    console.log('');
+    const DIM = '\x1b[2m'; const RESET = '\x1b[0m';
+    process.stdout.write(`  ${DIM}OpenAI API key detected — usage is metered, guardrails enabled${RESET}\n\n`);
   }
 
-  // ── Done ───────────────────────────────────────────────────────────────────
-  console.log(wTop);
-  console.log(wRow(`${GREEN} Ready — ${chosenName} mode`));
-  console.log(wRow(`  Type a task to start, or press Enter for dashboard`));
-  console.log(wBottom);
-  console.log('');
+  // ─── Step 6: Ready ────────────────────────────────────────────────────────
+  fx.step(5, 5, 'Ready!');
+  fx.nl();
+
+  // Init living docs
+  try {
+    const ld = await getLivingDocs();
+    if (ld.initLivingDocs) ld.initLivingDocs(cwd);
+  } catch { /* non-fatal */ }
+
+  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 ────────────────────────────────────
+  // ─── Build and return the profile object ──────────────────────────────────
   const finalProfile = loadProfile(cwd);
 
   finalProfile.providers.claude = { enabled: claudeReady };
@@ -4026,6 +4436,7 @@ const SCREENS = {
   main:             mainScreen,
   'new-session':    newSessionScreen,
   settings:         settingsScreen,
+  team:             teamScreen,
   'import-picker':  importPickerScreen,
   'pr-triage':      prTriageScreen,
   subscriptions:    subscriptionsScreen,