dual-brain 7.1.28 → 7.1.29

package/bin/dual-brain.mjs

@@ -62,6 +62,55 @@ async function getLivingDocs() {
   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));
@@ -382,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,
@@ -389,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)');
@@ -399,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}`);
@@ -452,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();
@@ -540,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,
@@ -548,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);
   }
 
@@ -705,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';
@@ -721,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(':');
@@ -730,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);
+          }
         }
       }
     }
@@ -1568,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;
 
@@ -1952,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 ──────────────────────────────────────────────────────────
@@ -3078,115 +3175,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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.1.28",
+  "version": "7.1.29",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -80,6 +80,7 @@
     "src/install-hooks.mjs",
     "src/update-check.mjs",
     "src/prompt-intel.mjs",
+    "src/fx.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",

package/src/fx.mjs

@@ -0,0 +1,276 @@
+// fx.mjs — zero-dependency animated shell effects for dual-brain CLI
+
+const isTTY = process.stdout.isTTY && !process.env.CI;
+const hasColor = isTTY && !process.env.NO_COLOR;
+const isUnicode = process.platform !== 'win32' || process.env.WT_SESSION;
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  bgGreen: '\x1b[42m',
+  bgRed: '\x1b[41m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  clearLine: '\x1b[2K',
+  cursorUp: '\x1b[1A',
+  cursorHide: '\x1b[?25l',
+  cursorShow: '\x1b[?25h',
+  saveCursor: '\x1b[s',
+  restoreCursor: '\x1b[u'
+};
+
+function color(text, ...styles) {
+  if (!hasColor) return text;
+  return styles.join('') + text + c.reset;
+}
+
+export const colors = c;
+
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export function clearScreen() {
+  if (isTTY) process.stdout.write('\x1b[2J\x1b[H');
+}
+
+export function nl(n = 1) {
+  process.stdout.write('\n'.repeat(n));
+}
+
+export function getMode() {
+  if (process.env.CI) return 'ci';
+  if (!process.stdout.isTTY) return 'plain';
+  if (process.env.DUAL_BRAIN_FX === 'subtle') return 'subtle';
+  return 'full';
+}
+
+export function spinner(text) {
+  const frames = isUnicode ? ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'] : ['|','/','-','\\'];
+  let i = 0, interval = null, currentText = text;
+
+  return {
+    start() {
+      if (!isTTY) { process.stdout.write(currentText + '\n'); return this; }
+      process.stdout.write(c.cursorHide);
+      interval = setInterval(() => {
+        process.stdout.write(`\r${c.clearLine}  ${color(frames[i % frames.length], c.cyan)} ${currentText}`);
+        i++;
+      }, 80);
+      return this;
+    },
+    update(newText) { currentText = newText; return this; },
+    succeed(msg) {
+      if (interval) clearInterval(interval);
+      const sym = isUnicode ? '✓' : '+';
+      process.stdout.write(`\r${c.clearLine}  ${color(sym, c.green)} ${msg || currentText}\n`);
+      if (isTTY) process.stdout.write(c.cursorShow);
+      return this;
+    },
+    fail(msg) {
+      if (interval) clearInterval(interval);
+      const sym = isUnicode ? '✗' : 'x';
+      process.stdout.write(`\r${c.clearLine}  ${color(sym, c.red)} ${msg || currentText}\n`);
+      if (isTTY) process.stdout.write(c.cursorShow);
+      return this;
+    },
+    warn(msg) {
+      if (interval) clearInterval(interval);
+      const sym = isUnicode ? '⚠' : '!';
+      process.stdout.write(`\r${c.clearLine}  ${color(sym, c.yellow)} ${msg || currentText}\n`);
+      if (isTTY) process.stdout.write(c.cursorShow);
+      return this;
+    },
+    stop() {
+      if (interval) clearInterval(interval);
+      process.stdout.write(`\r${c.clearLine}`);
+      if (isTTY) process.stdout.write(c.cursorShow);
+      return this;
+    }
+  };
+}
+
+export function progress(current, total, label = '', width = 30) {
+  const pct = Math.min(1, current / total);
+  if (!isTTY) {
+    process.stdout.write(`${Math.round(pct * 100)}% ${label}\n`);
+    return;
+  }
+  const filled = Math.round(pct * width);
+  const empty = width - filled;
+  const bar = isUnicode
+    ? color('█'.repeat(filled) + '░'.repeat(empty), c.cyan)
+    : color('#'.repeat(filled) + '-'.repeat(empty), c.cyan);
+  const pctStr = String(Math.round(pct * 100)).padStart(3) + '%';
+  process.stdout.write(`\r${c.clearLine}  ${bar}  ${color(pctStr, c.bold)} ${label}`);
+  if (current >= total) process.stdout.write('\n');
+}
+
+export function success(text) {
+  const sym = isUnicode ? '✓' : '+';
+  process.stdout.write(`  ${color(sym, c.green)} ${text}\n`);
+}
+
+export function error(text) {
+  const sym = isUnicode ? '✗' : 'x';
+  process.stdout.write(`  ${color(sym, c.red)} ${text}\n`);
+}
+
+export function warn(text) {
+  const sym = isUnicode ? '⚠' : '!';
+  process.stdout.write(`  ${color(sym, c.yellow)} ${text}\n`);
+}
+
+export function info(text) {
+  const sym = isUnicode ? 'ℹ' : 'i';
+  process.stdout.write(`  ${color(sym, c.blue)} ${text}\n`);
+}
+
+export function dim(text) {
+  process.stdout.write(`${color(text, c.gray)}\n`);
+}
+
+export function step(current, total, text) {
+  if (!isUnicode) {
+    process.stdout.write(`  [${current}/${total}] ${text}\n`);
+    return;
+  }
+  const dots = [];
+  for (let i = 1; i <= total; i++) {
+    if (i < current) dots.push(color('●', c.green));
+    else if (i === current) dots.push(color('●', c.cyan));
+    else dots.push(color('○', c.gray));
+  }
+  process.stdout.write(`  ${dots.join(' ')}  ${color(`Step ${current} of ${total}`, c.bold)} · ${text}\n`);
+}
+
+export function banner(text) {
+  const pkg = 'DUAL-BRAIN';
+  const inner = `  ${isUnicode ? '🧠' : '**'}  ${pkg}  ${text}   `;
+  const width = inner.length + 2;
+  if (!isUnicode || !hasColor) {
+    process.stdout.write(`\n  +${'='.repeat(width - 2)}+\n  | ${inner} |\n  +${'='.repeat(width - 2)}+\n\n`);
+    return;
+  }
+  const top =    `  ╔${'═'.repeat(width)}╗`;
+  const mid =    `  ║${inner}║`;
+  const bot =    `  ╚${'═'.repeat(width)}╝`;
+  process.stdout.write(`\n${color(top, c.cyan, c.bold)}\n${color(mid, c.cyan, c.bold)}\n${color(bot, c.cyan, c.bold)}\n\n`);
+}
+
+export function box(content, options = {}) {
+  const { color: colorName = 'cyan', padding = 1, title = '' } = options;
+  const ansiColor = c[colorName] || c.cyan;
+  const lines = Array.isArray(content) ? content : content.split('\n');
+  const innerWidth = Math.max(...lines.map(l => stripAnsi(l).length), title ? stripAnsi(title).length : 0) + padding * 2;
+
+  function draw(text, ansi) {
+    if (!hasColor) return text;
+    return ansi + text + c.reset;
+  }
+
+  const titleStr = title ? ` ${title} ` : '';
+  const topFill = '─'.repeat(Math.max(0, innerWidth - stripAnsi(titleStr).length));
+  const top = isUnicode
+    ? draw(`┌${titleStr}${'─'.repeat(Math.floor(topFill.length / 2))}${'─'.repeat(Math.ceil(topFill.length / 2))}┐`, ansiColor)
+    : draw(`+${titleStr}${'-'.repeat(topFill.length)}+`, ansiColor);
+  const bot = isUnicode
+    ? draw(`└${'─'.repeat(innerWidth)}┘`, ansiColor)
+    : draw(`+${'-'.repeat(innerWidth)}+`, ansiColor);
+
+  process.stdout.write(`  ${top}\n`);
+  for (const line of lines) {
+    const pad = ' '.repeat(padding);
+    const visible = stripAnsi(line).length;
+    const right = ' '.repeat(Math.max(0, innerWidth - padding - visible));
+    const border = isUnicode ? draw('│', ansiColor) : draw('|', ansiColor);
+    process.stdout.write(`  ${border}${pad}${line}${right}${border}\n`);
+  }
+  process.stdout.write(`  ${bot}\n`);
+}
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+export function gradient(text, fromColor = 196, toColor = 226) {
+  if (!hasColor) return process.stdout.write(text + '\n');
+  const chars = [...text];
+  const result = chars.map((ch, i) => {
+    const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
+    const colorIdx = Math.round(fromColor + t * (toColor - fromColor));
+    return `\x1b[38;5;${colorIdx}m${ch}`;
+  }).join('') + c.reset;
+  process.stdout.write(result + '\n');
+}
+
+export async function celebrate(text) {
+  const sym = isUnicode ? '✨' : '*';
+  if (!isTTY || getMode() === 'ci' || getMode() === 'plain') {
+    process.stdout.write(`  ${sym} ${text} ${sym}\n`);
+    return;
+  }
+  process.stdout.write(`\r${c.clearLine}  ${color(`${sym} ${text} ${sym}`, c.bgGreen, c.bold)}`);
+  await sleep(100);
+  process.stdout.write(`\r${c.clearLine}  ${color(`${sym} ${text} ${sym}`, c.green, c.bold)}\n`);
+}
+
+export async function loadingSequence(steps) {
+  for (const s of steps) {
+    const sp = spinner(s.text).start();
+    await sleep(s.duration || 800);
+    sp.succeed(s.successText || s.text);
+  }
+}
+
+export async function agentDispatch(model, task) {
+  const mode = getMode();
+  if (mode === 'ci' || mode === 'plain') {
+    process.stdout.write(`Dispatching ${model}...\n`);
+    process.stdout.write(`Agent dispatched: ${task}\n`);
+    return;
+  }
+  const sp = spinner(`Dispatching ${color(model, c.cyan)}...`).start();
+  await sleep(mode === 'subtle' ? 0 : 600);
+  sp.succeed(`Agent dispatched: ${task}`);
+}
+
+export async function thinkRound(round, provider, question) {
+  const mode = getMode();
+  const providerLabel = color(provider, c.magenta);
+  const roundLabel = color(`Round ${round}`, c.bold);
+
+  if (mode === 'ci' || mode === 'plain') {
+    process.stdout.write(`Dual-Brain Think · ${roundLabel} · ${provider} analyzing: ${question}\n`);
+    return;
+  }
+
+  const title = `Dual-Brain Think · ${roundLabel}`;
+  const titleVisible = stripAnsi(title);
+  const width = Math.max(titleVisible.length + 4, question.length + 4, 36);
+  const topFill = '─'.repeat(Math.max(0, width - titleVisible.length - 2));
+
+  if (isUnicode && hasColor) {
+    process.stdout.write(`  ${color(`╭─ ${title} ${'─'.repeat(topFill.length)}╮`, c.cyan)}\n`);
+    process.stdout.write(`  ${color('│', c.cyan)} ${isUnicode ? '🤖' : '>>'} ${providerLabel} analyzing...${' '.repeat(Math.max(0, width - 4 - stripAnsi(provider).length - 13))}${color('│', c.cyan)}\n`);
+    process.stdout.write(`  ${color(`╰${'─'.repeat(width)}╯`, c.cyan)}\n`);
+  } else {
+    process.stdout.write(`  +-- ${title} --+\n`);
+    process.stdout.write(`  | ${provider} analyzing: ${question}\n`);
+    process.stdout.write(`  +${'─'.repeat(width + 2)}+\n`);
+  }
+
+  const sp = spinner(`${provider} thinking on: ${question}`).start();
+  await sleep(mode === 'subtle' ? 0 : 900);
+  sp.succeed(`${provider} analysis complete`);
+}