dankgrinder 7.83.0 → 8.1.0

package/lib/grinder.js

@@ -3,7 +3,7 @@ const Redis = require('ioredis');
 const commands = require('./commands');
 const { setDashboardActive, isCV2, ensureCV2, stripAnsi } = require('./commands/utils');
 const rawLogger = require('./rawLogger');
-const terminal = require('./terminal');
+const { renderDashboard: renderDashboardImpl } = require('./dashboard');
 const {
   BloomFilter, RingBuffer, TokenBucket, EMA, SlidingWindowCounter,
   AhoCorasick, LRUCache, StringPool, AsyncBatchQueue, JitterBackoff,
@@ -95,20 +95,10 @@ const c = {
 };
 
 const WORKER_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
+// Unique marker written to stdout so we can query cursor position via DSR response
+const MARKER = '\x1b[6n\x1b[@@MARKER@@';
 const DANK_MEMER_ID = '270904126974590976';
 
-
-// Simple uptime formatter
-function formatUptime() {
-  const s = Math.floor((Date.now() - startTime) / 1000);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m ${s % 60}s`;
-  const h = Math.floor(m / 60);
-  if (h < 24) return `${h}h ${m % 60}m`;
-  const d = Math.floor(h / 24);
-  return `${d}d ${h % 24}h`;
-}
 // ── Safe options for search/crime ──────────────────────────
 // Object.freeze → V8 marks these as immutable, enabling inline caching
 // and preventing accidental mutation across 10K worker instances.
@@ -130,8 +120,6 @@ let API_URL = '';
 let REDIS_URL = process.env.REDIS_URL || '';
 let redis = null;
 let workers = [];
-let startTime = 0;
-let shutdownCalled = false;
 
 // ── Cluster Mode Config ──────────────────────────────────────
 // NODE_ID uniquely identifies this process in a multi-node cluster.
@@ -145,25 +133,10 @@ const CLUSTER_PREFIX = 'dkg:cluster:';
 function initRedis() {
   if (!redis && REDIS_URL) {
     try {
-      redis = new Redis(REDIS_URL, {
-        maxRetriesPerRequest: 3,
-        retryStrategy: (times) => times > 5 ? null : Math.min(times * 500, 3000),
-        lazyConnect: true,
-      });
-      redis.connect().catch((e) => {
-        // Only warn once — don't spam on persistent connection failures
-        if (!redis || redis.status === 'wait') {
-          console.warn(`[Redis] connection failed: ${e.message} — continuing without Redis`);
-        }
-      });
-      redis.on('error', (e) => {
-        // Suppress common transient errors from spamming stderr
-        const msg = e?.message || '';
-        if (msg.includes('ETIMEDOUT') || msg.includes('ECONNRESET') || msg.includes('ENOTFOUND') || msg.includes('connect')) return;
-        console.error(`[Redis] error: ${msg}`);
-      });
+      redis = new Redis(REDIS_URL, { maxRetriesPerRequest: null, lazyConnect: true });
+      redis.connect().catch(() => {});
     } catch (e) {
-      // Redis optional — continue without it
+      console.error('Redis connection failed', e);
     }
   }
 }
@@ -285,6 +258,17 @@ function progressBar(value, max, width, filledColor, emptyColor) {
   return rgb(fc[0], fc[1], fc[2]) + '█'.repeat(filled) + rgb(ec[0], ec[1], ec[2]) + '░'.repeat(empty) + c.reset;
 }
 
+// ── Animated braille spinner frames ──────────────────────────
+const BRAILLE_SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const BLOCK_SPIN = ['▉', '▊', '▋', '▌', '▍', '▎', '▏', '▎', '▍', '▌', '▋', '▊'];
+const PULSE_CHARS = ['○', '◎', '●', '◉', '●', '◎'];
+function getSpinner(type = 'braille') {
+  const now = Math.floor(Date.now() / 80);
+  if (type === 'block') return BLOCK_SPIN[now % BLOCK_SPIN.length];
+  if (type === 'pulse') return PULSE_CHARS[now % PULSE_CHARS.length];
+  return BRAILLE_SPIN[now % BRAILLE_SPIN.length];
+}
+
 // ── Box drawing helpers ──────────────────────────────────────
 const BOX = {
   tl: '╭', tr: '╮', bl: '╰', br: '╯',
@@ -337,28 +321,123 @@ function colorBanner() {
   return out;
 }
 
-// ── Simple Logging ─────────────────────────────────────────────
-function log(type, msg, label) {
-  // Route grinding logs through terminal flash events when active
-  if (terminal._active) {
-    const clean = stripAnsi(String(msg || '')).substring(0, 120);
-    const tagClean = stripAnsi(String(label || ''));
-    terminal.flashEvent(
-      type === 'error' ? 'death' : type === 'warn' ? 'warn' : 'info',
-      `${tagClean ? tagClean + ' ' : ''}${clean}`
-    );
-    return;
+// ── Live Dashboard State ─────────────────────────────────────
+let dashboardLines = 0;
+let dashboardStarted = false;
+let dashboardRendering = false;
+let lastRenderTime = 0;
+let renderPending = false;
+let totalBalance = 0;
+let totalCoins = 0;
+let totalCommands = 0;
+let startTime = Date.now();
+let shutdownCalled = false;
+let sessionPeakCoins = 0;
+let isNewHigh = false;
+// RingBuffer: O(1) push, bounded memory, no array shifting or GC pressure
+const recentLogs = new RingBuffer(8);
+const MAX_LOGS = 8;
+const RENDER_THROTTLE_MS = 200;
+// Earnings history for sparkline (sample every 10 seconds)
+const earningsHistory = new RingBuffer(30);
+let lastEarningsSample = 0;
+// Per-command stats tracking
+const cmdStats = new Map();
+// Coins per minute history for rate graph
+const cpmHistory = new RingBuffer(20);
+let lastCpmSample = 0;
+
+function formatUptime() {
+  const s = Math.floor((Date.now() - startTime) / 1000);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  if (h > 0) return `${h}h ${m}m ${sec}s`;
+  if (m > 0) return `${m}m ${sec}s`;
+  return `${sec}s`;
+}
+
+function formatCoins(n) {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(2)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toLocaleString();
+}
+
+function scheduleRender() {
+  if (renderPending || !dashboardStarted) return;
+  const now = Date.now();
+  const elapsed = now - lastRenderTime;
+  if (elapsed >= RENDER_THROTTLE_MS) {
+    renderDashboard();
+  } else {
+    renderPending = true;
+    setTimeout(() => { renderPending = false; renderDashboard(); }, RENDER_THROTTLE_MS - elapsed);
   }
+}
+
+// ── Dashboard ──────────────────────────────────────────────────────────────────
+// Thin wrapper: aggregates stats then delegates to ./dashboard.js
+function renderDashboard() {
+  if (!dashboardStarted || workers.length === 0 || dashboardRendering || shutdownCalled) return;
+  dashboardRendering = true;
+  lastRenderTime = Date.now();
+
+  // Aggregate session totals
+  totalBalance = 0; totalCoins = 0; totalCommands = 0;
+  let totalErrors = 0;
+  for (const w of workers) {
+    totalBalance += (w.stats.balance || 0) + (w.stats.bankBalance || 0);
+    totalCoins   += w.stats.coins || 0;
+    totalCommands += w.stats.commands || 0;
+    totalErrors  += w.stats.errors || 0;
+  }
+  if (totalCoins > sessionPeakCoins) {
+    sessionPeakCoins = totalCoins;
+    isNewHigh = true;
+    setTimeout(() => { isNewHigh = false; }, 3000);
+  }
+
+  // Pass all state into the dashboard module
+  const newLines = renderDashboardImpl({
+    workers, dashboardStarted, dashboardRendering, dashboardLines,
+    totalBalance, totalCoins, totalCommands, startTime,
+    sessionPeakCoins, isNewHigh, recentLogs, globalCmdRate,
+    earningsHistory, lastEarningsSample,
+    CLOUD_MODE, CLUSTER_ENABLED, PKG_VERSION,
+    AccountWorker, PULSE_CHARS, getSpinner, gradientText,
+    rgb, c, BOX,
+  });
+
+  if (newLines != null) dashboardLines = Math.max(dashboardLines, newLines);
+  dashboardRendering = false;
+}
 
-  const colorIcons = {
-    info: `${c.dim}·${c.reset}`, success: `${rgb(52, 211, 153)}✓${c.reset}`,
-    error: `${rgb(239, 68, 68)}✗${c.reset}`, warn: `${rgb(251, 191, 36)}!${c.reset}`,
-    cmd: `${rgb(168, 85, 247)}▸${c.reset}`, coin: `${rgb(251, 191, 36)}$${c.reset}`,
-    buy: `${rgb(59, 130, 246)}♦${c.reset}`, bal: `${rgb(52, 211, 153)}◈${c.reset}`,
-    debug: `${c.dim}·${c.reset}`,
+function log(type, msg, label) {
+  const time = new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  const icons = {
+    info: '·', success: '✓', error: '✗', warn: '!',
+    cmd: '▸', coin: '$', buy: '♦', bal: '◈', debug: '·',
   };
-  const tagCol = label ? `${label} ` : '';
-  console.log(`  ${colorIcons[type] || colorIcons.info}  ${tagCol}${msg}`);
+  const tagRaw = label ? label.replace(/\x1b\[[0-9;]*m/g, '').substring(0, 12) : '';
+  const stripped = msg.replace(/\x1b\[[0-9;]*m/g, '');
+  const tw = Math.max(process.stdout.columns || 80, 60);
+  if (dashboardStarted) {
+    const maxLen = tw - 8;
+    const entry = `${time} ${icons[type] || '·'} ${tagRaw ? tagRaw + ' ' : ''}${stripped}`;
+    recentLogs.push(entry.substring(0, maxLen));
+    scheduleRender();
+  } else {
+    const colorIcons = {
+      info: `${c.dim}·${c.reset}`, success: `${rgb(52, 211, 153)}✓${c.reset}`,
+      error: `${rgb(239, 68, 68)}✗${c.reset}`, warn: `${rgb(251, 191, 36)}!${c.reset}`,
+      cmd: `${rgb(168, 85, 247)}▸${c.reset}`, coin: `${rgb(251, 191, 36)}$${c.reset}`,
+      buy: `${rgb(59, 130, 246)}♦${c.reset}`, bal: `${rgb(52, 211, 153)}◈${c.reset}`,
+      debug: `${c.dim}·${c.reset}`,
+    };
+    const tagCol = label ? `${label} ` : '';
+    console.log(`  ${colorIcons[type] || colorIcons.info}  ${tagCol}${msg}`);
+  }
 }
 
 async function fetchConfig(retries = 3, delayMs = 1500, opts = {}) {
@@ -790,6 +869,7 @@ class AccountWorker {
 
   setStatus(text) {
     this.lastStatus = stripAnsi(String(text || '')).replace(/\s+/g, ' ').trim();
+    if (dashboardStarted) scheduleRender();
   }
 
   waitForDankMemer(timeout = 15000) {
@@ -1402,32 +1482,34 @@ class AccountWorker {
 
       // Update Redis with findings
       if (redis) {
-        try {
-          if (currentLevel > 0) {
-            await redis.set(`dkg:level:${this.account.id}`, String(currentLevel), 'EX', 2592000);
-            this._level = currentLevel;
-          }
-          if (lastLifesaverCount >= 0) {
-            await redis.set(`dkg:lifesavers:${this.account.id}`, String(lastLifesaverCount), 'EX', 86400);
-            this._lifesavers = lastLifesaverCount;
-            if (lastLifesaverCount === 0) {
-              await redis.set(`raw:alert:no-lifesaver:${dm.id}`, '1', 'EX', 86400);
-              await redis.set(`raw:alert:no-lifesaver:${this.channel?.id}`, '1', 'EX', 86400);
-            }
+        if (currentLevel > 0) {
+          await redis.set(`dkg:level:${this.account.id}`, String(currentLevel), 'EX', 2592000);
+          this._level = currentLevel;
+          // Only log to terminal during startup — after dashboardStarted, go to live feed
+          if (dashboardStarted) this.log('info', `DM level: ${c.bold}${currentLevel}${c.reset}`);
+        }
+        if (lastLifesaverCount >= 0) {
+          await redis.set(`dkg:lifesavers:${this.account.id}`, String(lastLifesaverCount), 'EX', 86400);
+          this._lifesavers = lastLifesaverCount;
+          if (lastLifesaverCount === 0) {
+            await redis.set(`raw:alert:no-lifesaver:${dm.id}`, '1', 'EX', 86400);
+            await redis.set(`raw:alert:no-lifesaver:${this.channel?.id}`, '1', 'EX', 86400);
+            if (dashboardStarted) this.log('error', `${c.red}0 LIFESAVERS! Crime/Search will be disabled.${c.reset}`);
           }
-        } catch { /* Redis errors non-fatal */ }
+        }
       }
 
-      return { deaths, levelUps, currentLevel, lifesavers: lastLifesaverCount, dmChannelId: dm.id };
-    } catch (e) {
-      lastError = e;
-      if (attempt < maxRetries - 1) {
-        await new Promise(r => setTimeout(r, delays[attempt]));
+        return { deaths, levelUps, currentLevel, lifesavers: lastLifesaverCount, dmChannelId: dm.id };
+      } catch (e) {
+        lastError = e;
+        if (attempt < maxRetries - 1) {
+          await new Promise(r => setTimeout(r, delays[attempt]));
+        }
       }
     }
+    if (dashboardStarted) this.log('debug', `DM check failed after ${maxRetries} attempts: ${lastError.message}`);
+    return { deaths: 0, levelUps: 0, currentLevel: 0, lifesavers: -1 };
   }
-  return { deaths: 0, levelUps: 0, currentLevel: 0, lifesavers: -1 };
-}
 
   // ── Run Single Command ──────────────────────────────────────
   // Each modular command handler sends the command, waits for response,
@@ -1635,8 +1717,6 @@ class AccountWorker {
       // ── Death / lifesaver detection in command responses ──
       if (resultLower.includes('you died') || resultLower.includes('lifesaver protected')) {
         this.log('error', `DEATH DETECTED during ${cmdName}!`);
-        terminal.flashEvent('death', `💀 ${this.username} died — ${lsCount === 0 ? '0 lifesavers!' : (lsCount > 0 ? `${lsCount} lifesavers left` : 'check DM')}`);
-        terminal.markWorkerDirty(this.idx);
         // Check for lifesaver count in the response
         const lsMatch = result.match(/(\d+)\s*life\s*saver/i);
         const lsCount = lsMatch ? parseInt(lsMatch[1]) : -1;
@@ -1653,8 +1733,6 @@ class AccountWorker {
             await redis.set(`dkg:lifesavers:${this.account.id}`, String(lsCount), 'EX', 86400);
             this.log('warn', `Lifesaver used! ${lsCount} remaining.`);
             if (lsCount <= 2) {
-              terminal.flashEvent('lowls', `⚠ ${this.username} low lifesavers: ${lsCount} left`);
-              terminal.markWorkerDirty(this.idx);
               sendWebhook('LOW LIFESAVERS', `**${this.username}** has only **${lsCount}** lifesaver(s) left!`, 0xfbbf24);
             }
           }
@@ -1774,8 +1852,6 @@ class AccountWorker {
       this.setStatus(formattedResult);
       await sendLog(this.username, cmdName, result, 'success');
       reportEarnings(this.account.id, this.username, earned, spent, cmdName);
-      terminal.markWorkerDirty(this.idx);
-      if (earned > 0) terminal.flashEvent('success', `⚔ ${this.username} ${cmdName}: +⏣ ${earned.toLocaleString()}`);
 
       // Auto-sell fish every 5 fishing rounds
       if (cmdName === 'fish') {
@@ -2759,23 +2835,34 @@ async function start(apiKey, apiUrl, opts = {}) {
   API_KEY = apiKey;
   API_URL = apiUrl || process.env.DANKGRINDER_URL || 'http://localhost:3000';
   const CLOUD_MODE = opts.cloud === true;
-  startTime = Date.now();
 
+  if (CLOUD_MODE) {
+    // In cloud mode, API_KEY is the CLOUD_ADMIN_KEY — not used for user auth.
+    // Per-account keys are fetched per-account from /api/cloud/grinders.
+    console.log('🌥️  Starting in CLOUD MODE — grinding all cloud-enabled accounts');
+  }
   REDIS_URL = process.env.REDIS_URL || '';
   WEBHOOK_URL = process.env.WEBHOOK_URL || '';
 
+  process.stdout.write('\x1b[2J\x1b[H');
+  const tw = Math.min(process.stdout.columns || 80, 78);
+  const bar = c.dim + '─'.repeat(tw) + c.reset;
+
   // Detect zlib-sync availability
   let hasZlib = false;
   try { require('zlib-sync'); hasZlib = true; } catch {}
 
-  // Init terminal FIRST — captures all subsequent console.log output
-  terminal.setVersion(PKG_VERSION);
-  terminal.init({ workers: [], startTime });
+  console.log(colorBanner());
+  console.log(
+    `  ${rgb(139, 92, 246)}v${PKG_VERSION}${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${c.white}${AccountWorker.COMMAND_MAP.length} Commands${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${rgb(34, 211, 238)}${CLOUD_MODE ? 'Cloud Mode' : (CLUSTER_ENABLED ? 'Cluster Mode' : 'Standalone')}${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}Auto-Recovery${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${rgb(251, 191, 36)}Loss Limiter${c.reset}`
+  );
+  console.log(bar);
 
-  if (CLOUD_MODE) {
-    console.log(`${rgb(139, 92, 246)}🌥️  Starting in CLOUD MODE — grinding all cloud-enabled accounts${c.reset}`);
-  }
-  terminal.startPhase('Fetching accounts...');
+  log('info', `${c.dim}Fetching accounts...${c.reset}`);
 
   const fetchOpts = CLOUD_MODE ? { cloud: true } : {};
   let data = await fetchConfig(4, 2000, fetchOpts);
@@ -2786,11 +2873,9 @@ async function start(apiKey, apiUrl, opts = {}) {
     data = await fetchConfig(4, 2000, fetchOpts);
   }
   if (data && data.error) {
-    terminal.endPhase(`API error: ${data.error}`, false);
     log('error', `${data.error}`);
     return;
   }
-  terminal.endPhase(`API connected — ${data.accounts?.length || 0} accounts`);
 
   // Cloud mode: post heartbeat every 30s
   if (CLOUD_MODE) {
@@ -2835,9 +2920,13 @@ async function start(apiKey, apiUrl, opts = {}) {
     }
   }
 
+  const checks = [];
+  checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}API${c.reset}`);
+  if (REDIS_URL) checks.push(redis ? `${rgb(52, 211, 153)}✓${c.reset} ${c.white}Redis${c.reset}` : `${rgb(251, 191, 36)}○${c.reset} ${c.dim}Redis (connecting...)${c.reset}`);
+
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
-    rawLogger.init(redis);
+    rawLogger.init(REDIS_URL).catch(() => {});
     // Listen for DM events across all accounts — update worker state + dashboard LIVE
     rawLogger.onDmEvent((event, raw) => {
       const channelId = raw.channel_id;
@@ -2854,8 +2943,6 @@ async function start(apiKey, apiUrl, opts = {}) {
               w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
               w.setCooldown?.('crime', 86400);
               w.setCooldown?.('search', 86400);
-              terminal.flashEvent('death', `💀 ${w.username} DEATH in DM — 0 lifesavers!`);
-              terminal.markWorkerDirty(w.idx);
               sendWebhook?.('DEATH ALERT (DM)', `**${w.username}** died in DMs! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
             } else {
               w.log?.('warn', `DEATH in DMs — ${event.lifesaversLeft} lifesavers remaining`);
@@ -2868,25 +2955,132 @@ async function start(apiKey, apiUrl, opts = {}) {
               }
             }
           }
+          scheduleRender();
         }
 
         if (event.type === 'levelup') {
           if (event.to > 0) {
             w._level = event.to;
-            terminal.flashEvent('levelup', `⬆️ ${w.username} leveled up to Lv.${event.to}`);
-            terminal.markWorkerDirty(w.idx);
+            scheduleRender();
           }
         }
       }
     });
+    checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}RawLog${c.reset}`);
   }
+  if (hasZlib) checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}zlib${c.reset}`);
+  if (WEBHOOK_URL) checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}Webhook${c.reset}`);
+  if (CLUSTER_ENABLED) {
+    checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${rgb(34, 211, 238)}Cluster${c.reset} ${c.dim}(${NODE_ID.substring(0, 12)})${c.reset}`);
+  }
+  checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}${accounts.length} Account${accounts.length > 1 ? 's' : ''}${c.reset}`);
+  console.log(`  ${checks.join('   ')}`);
+  console.log('');
+
+  // ── Phase 1: Login with per-account inline rendering ─────────────────────────
+  const startupTw = process.stdout.columns || 90;
+  const colNum = 4;    // "  #"
+  const colSts = 3;    // "ST"
+  const colName = Math.min(24, Math.max(12, Math.floor(startupTw * 0.25)));
+  const colGuild = Math.min(18, Math.max(8, Math.floor(startupTw * 0.2)));
+  const colCmds = 8;
+  const loginVis = colNum + colSts + colName + colGuild + colCmds + 10;
+
+  const loginStates = accounts.map((acc, i) => ({
+    name: acc.label || acc.id || '?',
+    done: false,
+    failed: false,
+    worker: null,
+  }));
 
-  // ── Terminal renderer init ─────────────────────────────────────
-  terminal.setVersion(PKG_VERSION);
-  terminal.init({ workers, startTime });
-  terminal.startPhase(`Connecting ${accounts.length} accounts to Discord`);
+  let loginLines = [];
+  loginLines.push(`  ${'─'.repeat(loginVis)}`);
+  for (let i = 0; i < loginStates.length; i++) {
+    const s = loginStates[i];
+    const num = `${c.dim}${(i + 1).toString().padStart(colNum - 1)}${c.reset}`;
+    const name = s.name.substring(0, colName).padEnd(colName);
+    const guild = c.dim + '···'.padEnd(colGuild) + c.reset;
+    const cmds = c.dim + '···'.padEnd(colCmds) + c.reset;
+    loginLines.push(`  ${num}  ${c.dim}··${c.reset}  ${name}  ${guild}  ${cmds}`);
+  }
+  loginLines.push(`  ${'─'.repeat(loginVis)}`);
+  for (const l of loginLines) console.log(l);
+
+  // Dynamically capture the starting row of the login table via DSR.
+  // Write MARKER to stderr (not stdout) to avoid PTY cooked-mode echoing
+  // of the visible "@MARKER@@" text portion, which was causing the DSR
+  // response to be swallowed or delayed.
+  let loginBaseRow = 1;
+  const captureLoginRow = () => new Promise(resolve => {
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        loginBaseRow = parseInt(m[1], 10) + 1;
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
+    setTimeout(resolve, 50);
+  });
+  await captureLoginRow();
+
+  let loginPending = new Array(accounts.length).fill(true);
+  const moveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
+
+  const drawLoginSpinners = () => {
+    for (let i = 0; i < loginPending.length; i++) {
+      if (!loginPending[i]) continue;
+      const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+      const num = `${c.dim}${(i + 1).toString().padStart(colNum - 1)}${c.reset}`;
+      const name = loginStates[i].name.substring(0, colName).padEnd(colName);
+      const guild = c.dim + 'logging in...'.substring(0, colGuild) + c.reset;
+      const cmds = c.dim + '···'.padEnd(colCmds) + c.reset;
+      const row = loginBaseRow + 1 + i; // +1 skips the top border line
+      moveToRow(row);
+      process.stdout.write(`  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${guild}  ${cmds}\x1b[K`);
+    }
+    // Move cursor back to bottom to avoid overwriting the bottom border
+    const lastRow = loginBaseRow + 1 + accounts.length + 1;
+    moveToRow(lastRow);
+  };
+  const loginSpinnerInterval = setInterval(drawLoginSpinners, 80);
+
+  const finalizeLoginLine = (idx, worker) => {
+    if (!loginPending[idx]) return;
+    loginPending[idx] = false;
+    const s = loginStates[idx];
+    s.done = true;
+    s.worker = worker;
+
+    const num = `${c.dim}${(idx + 1).toString().padStart(colNum - 1)}${c.reset}`;
+    const name = (worker.username || s.name || '?').substring(0, colName).padEnd(colName);
+    let sts, guild, cmds;
+    if (worker._tokenInvalid) {
+      sts = `${rgb(239, 68, 68)}✗${c.reset}`;
+      guild = 'INVALID'.padEnd(colGuild);
+      cmds = '···'.padEnd(colCmds);
+      s.failed = true;
+    } else if (worker.channel) {
+      sts = `${rgb(52, 211, 153)}✓${c.reset}`;
+      const gn = (worker.channel.guild?.name || worker.channel.guild?.id || 'DM').substring(0, colGuild);
+      guild = gn.padEnd(colGuild);
+      cmds = `${worker.stats?.commands || 0}`.padEnd(colCmds);
+    } else {
+      sts = `${rgb(251, 146, 60)}⏳${c.reset}`;
+      guild = 'timeout'.padEnd(colGuild);
+      cmds = '···'.padEnd(colCmds);
+    }
+    const row = loginBaseRow + 1 + idx; // +1 skips the top border line
+    moveToRow(row);
+    process.stdout.write(`  ${num}  ${sts}  ${name}  ${c.dim}${guild}${c.reset}  ${c.dim}${cmds}${c.reset}\x1b[K`);
+  };
 
-  // ── Phase 1: Login accounts ─────────────────────────────────────────
   const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '50'), 10);
   const parsedGapMax = Number.parseInt(String(process.env.LOGIN_GAP_MAX_MS || '150'), 10);
   const LOGIN_GAP_MIN_MS = Number.isFinite(parsedGapMin) && parsedGapMin >= 0 ? parsedGapMin : 50;
@@ -2902,70 +3096,203 @@ async function start(apiKey, apiUrl, opts = {}) {
       const worker = new AccountWorker(acc, i + idx);
       workers.push(worker);
       workerMap.set(acc.id, worker);
+      loginStates[i + idx].worker = worker;
       await worker.start();
-      terminal.updateProgress(workers.length, accounts.length);
+      finalizeLoginLine(i + idx, worker);
     }));
     if (i + BATCH_SIZE < accounts.length) await new Promise(r => setTimeout(r, randomLoginGap()));
     hintGC();
   }
 
+  clearInterval(loginSpinnerInterval);
   const loginDone = workers.filter(w => !w._tokenInvalid && w.channel).length;
   const invalidWorkers = workers.filter(w => w._tokenInvalid);
   const timedOutWorkers = workers.filter(w => !w.channel && !w._tokenInvalid);
-  terminal.endPhase(`${loginDone}/${accounts.length} accounts connected`, true);
+  console.log(`\r\x1b[2K  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Login complete${c.reset}  ${rgb(52, 211, 153)}${loginDone}${c.reset}${c.dim}/${c.reset}${c.white}${accounts.length}${c.reset} ${c.dim}accounts connected${c.reset}`);
+  console.log('');
   if (invalidWorkers.length > 0) {
-    terminal.flashEvent('error', `${invalidWorkers.length} accounts have INVALID tokens`);
-    log('warn', `${rgb(239, 68, 68)}${invalidWorkers.length} account(s) have INVALID tokens`);
-    for (const w of invalidWorkers) log('error', `  ${w.account.label || w.account.id} — token invalid or expired`);
+    log('warn', `${rgb(239, 68, 68)}${invalidWorkers.length} account(s) have INVALID tokens:${c.reset}`);
+    for (const w of invalidWorkers) log('error', `  ✗ ${w.account.label || w.account.id} — token is invalid or expired`);
+    console.log('');
   }
-  if (timedOutWorkers.length > 0) log('warn', `${timedOutWorkers.length} account(s) timed out during login`);
+  if (timedOutWorkers.length > 0) log('warn', `${timedOutWorkers.length} account(s) timed out during login (will retry in background)`);
 
   const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
-  // ── Phase 2: Inventory check ─────────────────────────────────────
-  terminal.startPhase('Checking inventory');
-  terminal.updateProgress(0, activeWorkers.length);
-  let invDone = 0, invFailed = 0;
-  await Promise.all(activeWorkers.map(async (w) => {
-    try { await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
-    catch { invFailed++; return; }
-    invDone++;
-    terminal.updateProgress(invDone, activeWorkers.length);
+  // ── Phase 2: Inventory check — spinner for pending count, results inline ─────────
+  const iColNum = 4;
+  const iColName = Math.min(22, Math.max(12, Math.floor(startupTw * 0.22)));
+  const iColItems = 8;
+  const iColVal = 16;
+  const invVis = 7 + iColNum + iColName + iColItems + iColVal + 12;
+
+  // Print a unique marker, query its position, then overwrite it with the table
+  // Set up stdin handler BEFORE writing MARKER (same fix as Phase 1 — avoids race)
+  let invBaseRow = 1;
+  const captureRow = () => new Promise(resolve => {
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        invBaseRow = parseInt(m[1], 10) + 1; // +1: first account row is after marker
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
+    setTimeout(resolve, 50);
+  });
+  await captureRow();
+
+  // Now print the inventory table starting at invBaseRow
+  const invMoveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
+  console.log(`  ${'─'.repeat(invVis)}`);
+  for (let i = 0; i < activeWorkers.length; i++) {
+    const w = activeWorkers[i];
+    const num = `${c.dim}${(i + 1).toString().padStart(iColNum - 1)}${c.reset}`;
+    const name = (w.username || w.account.label || '?').substring(0, iColName).padEnd(iColName);
+    console.log(`  ${num}  ${c.dim}··${c.reset}  ${name}  ${c.dim}${'checking...'.padEnd(iColItems)}${c.reset}  ${c.dim}${'···'.padEnd(iColVal)}${c.reset}`);
+  }
+  console.log(`  ${'─'.repeat(invVis)}`);
+
+  let invDone = 0, invFailed = 0, invPending = activeWorkers.length;
+  const drawInvProgress = () => {
+    if (invPending === 0) return;
+    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+    const pct = activeWorkers.length > 0 ? ((activeWorkers.length - invPending) / activeWorkers.length) : 0;
+    const barW = Math.min(20, startupTw - 40);
+    const filled = Math.round(pct * barW);
+    const bar = rgb(34, 211, 238) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(barW - filled) + c.reset;
+    const pctStr = `${Math.round(pct * 100)}%`;
+    invMoveToRow(invBaseRow);
+    process.stdout.write(`  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Inventory...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - invPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  ${c.dim}${pctStr}${c.reset}  \x1b[K`);
+  };
+  const invSpinnerInterval = setInterval(drawInvProgress, 80);
+
+  await Promise.all(activeWorkers.map(async (w, i) => {
+    const num = `${c.dim}${(i + 1).toString().padStart(iColNum - 1)}${c.reset}`;
+    const name = (w.username || w.account.label || '?').substring(0, iColName).padEnd(iColName);
+    let invRes;
+    try { invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
+    catch { invRes = { ok: false }; }
+    invPending--;
+    const items = invRes?.ok ? (invRes.result?.items?.length || 0) : 0;
+    const val = invRes?.ok ? (invRes.result?.totalValue || 0) : 0;
+    const sts = invRes?.ok ? `${rgb(52, 211, 153)}✓${c.reset}` : `${rgb(239, 68, 68)}✗${c.reset}`;
+    const itemStr = `${items}`.padEnd(iColItems);
+    const valStr = invRes?.ok ? `${c.green}⏣${val.toLocaleString()}${c.reset}` : `${c.dim}···${c.reset}`;
+    const row = invBaseRow + 1 + i;
+    invMoveToRow(row);
+    process.stdout.write(`  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
+    if (invRes?.ok) invDone++; else invFailed++;
   }));
 
+  clearInterval(invSpinnerInterval);
+  process.stdout.write(`\r\x1b[2K`);
+
   if (invFailed > 0) {
-    terminal.endPhase(`Inventory: ${invFailed} failed`, false);
-    console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  Inventory: ${invFailed} failed — not starting grind loops`);
+    console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  ${c.bold}Inventory incomplete${c.reset}  ${rgb(52, 211, 153)}${invDone}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset} ${c.dim}done, ${rgb(239, 68, 68)}${invFailed} failed${c.reset}`);
+    log('error', `${c.red}Not starting grind loops — ${invFailed} accounts failed inventory.${c.reset}`);
     return;
   }
-  terminal.endPhase(`Inventory: ${invDone} clear`);
+  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Inventory complete${c.reset}  ${rgb(52, 211, 153)}${invDone}/${activeWorkers.length}${c.reset} ${c.dim}all clear${c.reset}`);
+  console.log('');
+
+  // ── Phase 2.5: Balance check — inline table, single spinner for progress ─────────
+  const bColNum = 4;
+  const bColName = Math.min(22, Math.max(12, Math.floor(startupTw * 0.22)));
+  const bColWallet = 12;
+  const bColBank = 12;
+  const bColTotal = 14;
+  const bColLs = 4;
+  const balVis = 7 + bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 14;
+
+  // Capture starting row for balance phase
+  // Set up stdin handler BEFORE writing MARKER (same fix — avoids race + PTY echo)
+  let balBaseRow = 1;
+  const balCaptureRow = () => new Promise(resolve => {
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        balBaseRow = parseInt(m[1], 10) + 1;
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
+    setTimeout(resolve, 50);
+  });
+  await balCaptureRow();
+
+  const balMoveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
+  console.log(`  ${'─'.repeat(balVis)}`);
+  for (let i = 0; i < activeWorkers.length; i++) {
+    const w = activeWorkers[i];
+    const num = `${c.dim}${(i + 1).toString().padStart(bColNum - 1)}${c.reset}`;
+    const name = (w.username || w.account.label || '?').substring(0, bColName).padEnd(bColName);
+    console.log(`  ${num}  ${c.dim}··${c.reset}  ${name}  ${c.dim}${'checking'.padEnd(bColWallet)}${c.reset}  ${c.dim}${'···'.padEnd(bColBank)}${c.reset}  ${c.dim}${'···'.padEnd(bColTotal)}${c.reset}  ${c.dim}♥?${c.reset}`);
+  }
+  console.log(`  ${'─'.repeat(balVis)}`);
+
+  let balDone = 0, balPending = activeWorkers.length;
+  const drawBalProgress = () => {
+    if (balPending === 0) return;
+    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+    const pct = activeWorkers.length > 0 ? ((activeWorkers.length - balPending) / activeWorkers.length) : 0;
+    const barW = Math.min(20, startupTw - 40);
+    const filled = Math.round(pct * barW);
+    const bar = rgb(251, 191, 36) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(barW - filled) + c.reset;
+    balMoveToRow(balBaseRow);
+    process.stdout.write(`  ${rgb(251, 191, 36)}${spin}${c.reset}  ${c.dim}Balance...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - balPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  \x1b[K`);
+  };
+  const balSpinnerInterval = setInterval(drawBalProgress, 80);
 
-  // ── Phase 2.5: Balance check ────────────────────────────────────
-  terminal.startPhase('Checking balance');
-  terminal.updateProgress(0, activeWorkers.length);
-  let balDone = 0;
-  await Promise.all(activeWorkers.map(async (w) => {
+  await Promise.all(activeWorkers.map(async (w, i) => {
     try { await w.checkBalance(true); } catch {}
+    balPending--;
+    const num = `${c.dim}${(i + 1).toString().padStart(bColNum - 1)}${c.reset}`;
+    const name = (w.username || w.account.label || '?').substring(0, bColName).padEnd(bColName);
+    const wallet = w.stats?.balance || 0;
+    const bank = w.stats?.bankBalance || 0;
+    const ls = w._lifesavers ?? '?';
+    const lsColor = ls === 0 ? rgb(239, 68, 68) : ls <= 2 ? rgb(251, 191, 36) : rgb(52, 211, 153);
+    const walletStr = `${c.green}⏣${wallet.toLocaleString()}${c.reset}`;
+    const bankStr = `${c.cyan}⏣${bank.toLocaleString()}${c.reset}`;
+    const totalStr = `${c.bold}⏣${(wallet + bank).toLocaleString()}${c.reset}`;
+    const row = balBaseRow + 1 + i;
+    balMoveToRow(row);
+    process.stdout.write(`  ${num}  ${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${walletStr.padEnd(bColWallet + 4)}  ${bankStr.padEnd(bColBank + 4)}  ${totalStr.padEnd(bColTotal + 3)}  ${lsColor}♥${ls}${c.reset}\x1b[K`);
     balDone++;
-    terminal.updateProgress(balDone, activeWorkers.length);
   }));
 
+  clearInterval(balSpinnerInterval);
+  process.stdout.write(`\r\x1b[2K`);
+
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
   for (const w of activeWorkers) {
     totalWallet += w.stats?.balance || 0;
     totalBank += w.stats?.bankBalance || 0;
     if (w._lifesavers === 0) noLifesaverAccounts.push(w.username || w.account.label);
   }
-  terminal.endPhase(`Balance: ⏣ ${(totalWallet + totalBank).toLocaleString()}`);
+  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Balance${c.reset}  Total: ${c.bold}${c.green}⏣ ${(totalWallet + totalBank).toLocaleString()}${c.reset} ${c.dim}(wallet: ⏣ ${totalWallet.toLocaleString()} + bank: ⏣ ${totalBank.toLocaleString()})${c.reset}`);
   if (noLifesaverAccounts.length > 0) {
-    terminal.flashEvent('warn', `${noLifesaverAccounts.length} accounts have 0 LIFESAVERS`);
-    console.log(`  ${rgb(239, 68, 68)}⚠${c.reset}  ${noLifesaverAccounts.length} account(s) have 0 LIFESAVERS — crime/search disabled`);
+    console.log(`  ${rgb(239, 68, 68)}⚠${c.reset}  ${c.bold}${c.red}WARNING: ${noLifesaverAccounts.length} account(s) have 0 LIFESAVERS!${c.reset} Crime/Search disabled for: ${noLifesaverAccounts.join(', ')}`);
   }
+  console.log('');
+
 
-  // ── Phase 2.75: DM history check ────────────────────────────────
-  terminal.startPhase('Checking DM history');
-  terminal.updateProgress(0, activeWorkers.length);
-  let dmDone = 0;
+  // Phase 2.75: Check DM history for deaths/level-ups (sequential, fast)
+  const dmCheckPulse = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+  console.log(`  ${rgb(139, 92, 246)}${dmCheckPulse}${c.reset}  ${c.dim}Checking DM history...${c.reset}`);
   let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [], dmUnknown = [];
   for (const w of activeWorkers) {
     try {
@@ -2974,15 +3301,28 @@ async function start(apiKey, apiUrl, opts = {}) {
       if (dm.levelUps > 0) dmLevelUps += dm.levelUps;
       if (dm.lifesavers === 0) dmNoLs.push(w.username);
       if (dm.lifesavers === -1) dmUnknown.push(w.username);
+      // Store level and lifesaver for dashboard
       if (dm.currentLevel > 0) w._level = dm.currentLevel;
       if (dm.lifesavers >= 0) w._lifesavers = dm.lifesavers;
+      const parts = [];
+      if (dm.currentLevel > 0) parts.push(`Lv${dm.currentLevel}`);
+      if (dm.deaths > 0) parts.push(`${rgb(239, 68, 68)}${dm.deaths} deaths${c.reset}`);
+      if (dm.lifesavers >= 0) {
+        const lc = dm.lifesavers === 0 ? rgb(239, 68, 68) : dm.lifesavers <= 2 ? rgb(251, 191, 36) : rgb(52, 211, 153);
+        parts.push(`${lc}♥${dm.lifesavers}${c.reset}`);
+      } else {
+        // Unknown lifesavers — pulse to show pending
+        const pulse = PULSE_CHARS[Math.floor(Date.now() / 400) % PULSE_CHARS.length];
+        parts.push(`${D}${pulse}♥?${c.reset}`);
+      }
+      if (parts.length > 0) {
+        recentLogs.push({ ts: Date.now(), username: w.username, color: w.color, command: 'dm check', response: parts.join('  '), status: 'ok' });
+      }
     } catch {}
-    dmDone++;
-    terminal.updateProgress(dmDone, activeWorkers.length);
   }
   if (dmNoLs.length > 0) {
-    terminal.flashEvent('warn', `No lifesavers: ${dmNoLs.join(', ')}`);
-    log('warn', `⚠ No lifesavers: ${dmNoLs.join(', ')}`);
+    recentLogs.push({ ts: Date.now(), username: 'system', color: rgb(239, 68, 68), command: 'dm check', response: `⚠ No lifesavers: ${dmNoLs.join(', ')}`, status: 'warn' });
+    // Set Redis keys to block crime/search
     for (const w of activeWorkers) {
       if (dmNoLs.includes(w.username) && redis) {
         try {
@@ -2993,22 +3333,45 @@ async function start(apiKey, apiUrl, opts = {}) {
     }
   }
   if (dmUnknown.length > 0) {
-    log('warn', `⚠ Lifesavers unknown — live monitor: ${dmUnknown.join(', ')}`);
+    recentLogs.push({ ts: Date.now(), username: 'system', color: rgb(251, 191, 36), command: 'dm check', response: `⚠ Lifesavers unknown — live monitor: ${dmUnknown.join(', ')}`, status: 'warn' });
+    // Crime/search on these accounts will be skipped via safety hold until the live
+    // DM gateway listener detects a death (→ sets count) or confirms clean.
   }
   const dmSummaryParts = [];
   if (dmDeaths > 0) dmSummaryParts.push(`${dmDeaths} deaths`);
   if (dmLevelUps > 0) dmSummaryParts.push(`${dmLevelUps} level-ups`);
   if (dmUnknown.length > 0) dmSummaryParts.push(`${dmUnknown.length} pending`);
-  terminal.endPhase(`DM check: ${dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean'}`);
+  recentLogs.push({ ts: Date.now(), username: 'system', color: rgb(52, 211, 153), command: 'dm check', response: dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean — no deaths or level-ups', status: 'ok' });
+  console.log('');
+
+  console.log(`  ${rgb(139, 92, 246)}${c.bold}>>>${c.reset}  ${gradientText('Starting grind loops...', [139, 92, 246], [52, 211, 153])}`);
+
+  // DEBUG: activeWorkers confirmed
 
-  // ── Phase 3: Start grind loops ───────────────────────────────────
-  terminal.startPhase(`🚀 Launching ${activeWorkers.length} grinders!`);
+  // Phase 3: Start all grind loops (only for valid workers)
   for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();
   }
-  terminal.endPhase(`${activeWorkers.length} grinders active`);
-  terminal.setWorkers(workers);
-  terminal.setActive();
+
+  startTime = Date.now();
+  dashboardStarted = true;
+  setDashboardActive(true);
+
+  // Clear screen and position cursor at top-left before dashboard takes over
+  process.stdout.write('\x1b[2J\x1b[H');
+
+  // Setup keyboard shortcuts
+  setupKeyboardShortcuts();
+
+  // Re-render on terminal resize so layout adapts to window size
+  process.stdout.on('resize', () => {
+    process.stdout.write('\x1b[2J\x1b[H');
+    dashboardLines = 0;
+    scheduleRender();
+  });
+
+  setInterval(() => scheduleRender(), 1000);
+  scheduleRender();
 
   // Cluster heartbeat — lets other nodes see this node is alive
   if (CLUSTER_ENABLED) {
@@ -3065,7 +3428,7 @@ async function start(apiKey, apiUrl, opts = {}) {
       const before = workers.length;
       // Keep ALL workers visible — never remove from array (user wants to see gaps)
       // Only clean up workerMap entries for accounts fully removed from API
-      if (workers.length !== before) { /* workers changed */ }
+      if (workers.length !== before) scheduleRender();
     } catch {}
   }, 10_000);
 
@@ -3074,27 +3437,44 @@ async function start(apiKey, apiUrl, opts = {}) {
     if (sigintHandled) return;
     sigintHandled = true;
     shutdownCalled = true;
+    dashboardStarted = false;
     setDashboardActive(false);
+    process.stdout.write(c.show);
 
-    // Collect stats for summary
-    let finalCoins = 0, finalCmds = 0, totalSuccess = 0;
+    if (dashboardLines > 0) {
+      process.stdout.write(c.cursorUp(dashboardLines));
+      for (let i = 0; i < dashboardLines; i++) {
+        process.stdout.write(c.clearLine + '\r\n');
+      }
+      process.stdout.write(c.cursorUp(dashboardLines));
+    }
+
+    const sepBar = rgb(139, 92, 246) + c.bold + '═'.repeat(tw) + c.reset;
+    console.log('');
+    console.log(`  ${rgb(251, 191, 36)}${c.bold}Session Summary${c.reset}`);
+    console.log(sepBar);
+
+    // Collect stats from all workers (including rotated-out ones)
+    let finalCoins = 0;
+    let finalCmds = 0;
     for (const wk of workers) {
+      const rate = wk.stats.commands > 0 ? ((wk.stats.successes / wk.stats.commands) * 100).toFixed(0) : 0;
+      console.log(
+        `  ${wk.color}${c.bold}${(wk.username || '?').padEnd(18)}${c.reset}` +
+        `  ${rgb(52, 211, 153)}+⏣ ${wk.stats.coins.toLocaleString().padStart(8)}${c.reset}` +
+        `  ${c.dim}${wk.stats.commands.toString().padStart(4)} cmds${c.reset}` +
+        `  ${c.dim}${rate}% success${c.reset}`
+      );
       finalCoins += wk.stats.coins || 0;
       finalCmds += wk.stats.commands || 0;
-      totalSuccess += wk.stats.successes || 0;
     }
+    console.log(sepBar);
+
     const memFinal = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
-    const uptimeMs = Date.now() - startTime;
-
-    // Show beautiful session summary via terminal renderer
-    terminal.shutdown({
-      totalCoins: finalCoins,
-      totalCmds: finalCmds,
-      totalSuccess: finalCmds > 0 ? ((totalSuccess / finalCmds) * 100).toFixed(0) : 0,
-      workers,
-      uptime: uptimeMs,
-      memMB: memFinal,
-    });
+    const avgEarn = globalEarningsEMA.get();
+    const cpm = globalCmdRate.getRate().toFixed(1);
+    console.log(`  ${rgb(251, 191, 36)}${c.bold}Total: +⏣ ${finalCoins.toLocaleString()}${c.reset} ${c.dim}in ${formatUptime()} | ${finalCmds} cmds | ~${cpm} cmd/m | ${memFinal}MB | avg earn ⏣ ${Math.round(avgEarn)}${c.reset}`);
+    console.log('');
 
     // Release all cluster claims before stopping workers
     const releasePromises = workers.map(wk => releaseClaim(wk.account.id).catch(() => {}));
@@ -3110,19 +3490,99 @@ async function start(apiKey, apiUrl, opts = {}) {
 
     const totalRecoveries = workers.reduce((sum, wk) => sum + (wk._totalRecoveries || 0), 0);
     const totalDisconnects = workers.reduce((sum, wk) => sum + (wk._disconnectCount || 0), 0);
+    const totalRateLimits = workers.reduce((sum, wk) => sum + (wk._rateLimitHits || 0), 0);
 
     const webhookMsg = `+⏣ ${finalCoins.toLocaleString()} | ${finalCmds} cmds | ${formatUptime()}` +
       (totalRecoveries > 0 ? ` | ${totalRecoveries} auto-recoveries` : '') +
       (CLUSTER_ENABLED ? ` | node: ${NODE_ID.substring(0, 12)}` : '');
     sendWebhook('Session Ended', webhookMsg, 0x8b5cf6);
 
+    if (totalRecoveries > 0 || totalDisconnects > 0) {
+      console.log(`  ${c.dim}Recovery stats: ${totalRecoveries} auto-recoveries, ${totalDisconnects} disconnects, ${totalRateLimits} rate limits${c.reset}`);
+    }
+    if (CLUSTER_ENABLED) {
+      console.log(`  ${c.dim}Cluster node: ${NODE_ID} — claims released${c.reset}`);
+    }
+
     if (redis) { try { redis.disconnect(); } catch {} }
-    setTimeout(() => process.exit(0), 500);
+    setTimeout(() => process.exit(0), 1500);
   });
 }
 
 // ══════════════════════════════════════════════════════════════
-// Keyboard shortcuts removed — no display to update
+// ═  Keyboard Shortcuts (Quality of Life)
+// ══════════════════════════════════════════════════════════════
+// Single-key shortcuts for common actions
+function setupKeyboardShortcuts() {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    // Premium styled keyboard shortcuts with gradient box
+    const accent = rgb(139, 92, 246);
+    const dim = c.dim;
+    const kw = 60;
+    console.log('');
+    console.log(`  ${accent}╭${'─'.repeat(kw)}╮${c.reset}`);
+    console.log(`  ${accent}│${c.reset}  ${gradientText('KEYBOARD SHORTCUTS', [192, 132, 252], [52, 211, 153])}${' '.repeat(kw - 20)}${accent}│${c.reset}`);
+    console.log(`  ${accent}├${'─'.repeat(kw)}┤${c.reset}`);
+    console.log(`  ${accent}│${c.reset}  ${rgb(96, 165, 250)}P${c.reset} ${dim}Pause all${c.reset}    ${rgb(52, 211, 153)}R${c.reset} ${dim}Resume all${c.reset}    ${rgb(251, 191, 36)}S${c.reset} ${dim}Status${c.reset}    ${rgb(239, 68, 68)}Q${c.reset} ${dim}Quit${c.reset}${' '.repeat(Math.max(0, kw - 54))}${accent}│${c.reset}`);
+    console.log(`  ${accent}╰${'─'.repeat(kw)}╯${c.reset}`);
+    console.log('');
+
+    process.stdin.on('data', (key) => {
+      const k = key.toString().toLowerCase();
+
+      // Ctrl+C or q = quit
+      if (k === '\u0003' || k === 'q') {
+        process.stdout.write(c.show);
+        console.log(`\n\n  ${c.yellow}Shutting down gracefully...${c.reset}`);
+        process.emit('SIGINT');
+        return;
+      }
+
+      // p = pause all accounts
+      if (k === 'p') {
+        let count = 0;
+        workers.forEach(w => { if (w.running && !w.paused) { w.paused = true; count++; } });
+        recentLogs.push(`>> PAUSED ${count} accounts (press R to resume)`);
+        scheduleRender();
+        return;
+      }
+
+      // r = resume all accounts
+      if (k === 'r') {
+        let count = 0;
+        workers.forEach(w => { if (w.paused) { w.paused = false; count++; } });
+        recentLogs.push(`>> RESUMED ${count} accounts`);
+        scheduleRender();
+        return;
+      }
+
+      // s = show status summary (pushed to log feed)
+      if (k === 's') {
+        const active = workers.filter(w => w.running && !w.paused).length;
+        const paused = workers.filter(w => w.paused).length;
+        const invalid = workers.filter(w => w._tokenInvalid).length;
+        const offline = workers.filter(w => !w.running && !w._tokenInvalid).length;
+        const recovering = workers.filter(w => w._recoveryAttempts > 0 && w._errorCooldownUntil > Date.now()).length;
+        const totalEarn = workers.reduce((s, w) => s + (w.stats.coins || 0), 0);
+        recentLogs.push(`>> STATUS: ${active} active, ${paused} paused, ${invalid} invalid, ${offline} offline, ${recovering} recovering`);
+        recentLogs.push(`>> EARNINGS: +${formatCoins(totalEarn)} this session | BALANCE: ${formatCoins(totalBalance)}`);
+        scheduleRender();
+        return;
+      }
+
+      // ? or h = show help
+      if (k === '?' || k === 'h') {
+        recentLogs.push('>> SHORTCUTS: P=pause R=resume S=status Q=quit ?=help');
+        scheduleRender();
+        return;
+      }
+    });
+  }
+}
 
 // Export the start function for CLI
 module.exports = { start };