dankgrinder 6.1.0 → 6.5.0

package/lib/grinder.js

@@ -219,23 +219,69 @@ function gradientLine(text, from, to) {
   return out + c.reset;
 }
 
+function gradientText(text, from, to) {
+  return gradientLine(text, from, to);
+}
+
 // ── Sparkline graph for earnings trend ───────────────────────
 const SPARK_CHARS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
 function drawSparkline(data, width = 12) {
-  if (!data || data.length === 0) return c.dim + '──────' + c.reset;
+  if (!data || data.length === 0) return c.dim + '·····' + c.reset;
   const recent = data.slice(-width);
   const min = Math.min(...recent);
   const max = Math.max(...recent);
   const range = max - min || 1;
   return recent.map(v => {
     const idx = Math.min(7, Math.floor(((v - min) / range) * 8));
-    const char = SPARK_CHARS[idx] || '▁';
-    return v >= max * 0.9 ? rgb(52, 211, 153) + char + c.reset :
-           v <= min * 1.1 ? rgb(239, 68, 68) + char + c.reset :
-           rgb(139, 92, 246) + char + c.reset;
+    const ch = SPARK_CHARS[idx] || '▁';
+    const t = (v - min) / range;
+    // Gradient from red->yellow->green based on relative value
+    const r = t < 0.5 ? 239 : lerp(251, 52, (t - 0.5) * 2);
+    const g = t < 0.5 ? lerp(68, 191, t * 2) : lerp(191, 211, (t - 0.5) * 2);
+    const b = t < 0.5 ? lerp(68, 36, t * 2) : lerp(36, 153, (t - 0.5) * 2);
+    return rgb(r, g, b) + ch + c.reset;
   }).join('');
 }
 
+// ── Advanced progress bar ────────────────────────────────────
+function progressBar(value, max, width, filledColor, emptyColor) {
+  const pct = max > 0 ? Math.min(1, value / max) : 0;
+  const filled = Math.round(pct * width);
+  const empty = width - filled;
+  const fc = filledColor || [52, 211, 153];
+  const ec = emptyColor || [50, 50, 70];
+  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: '╯',
+  h: '─', v: '│', hBold: '━', vBold: '┃',
+  dtl: '╔', dtr: '╗', dbl: '╚', dbr: '╝', dh: '═', dv: '║',
+  cross: '┼', tee: '├', teeR: '┤', teeD: '┬', teeU: '┴',
+};
+
+function boxTop(w, color) { return color + BOX.dtl + BOX.dh.repeat(w - 2) + BOX.dtr + c.reset; }
+function boxMid(w, color) { return color + BOX.tee + BOX.h.repeat(w - 2) + BOX.teeR + c.reset; }
+function boxBot(w, color) { return color + BOX.dbl + BOX.dh.repeat(w - 2) + BOX.dbr + c.reset; }
+function boxLine(content, w, color) {
+  const stripped = content.replace(/\x1b\[[0-9;]*m/g, '');
+  const pad = Math.max(0, w - 4 - stripped.length);
+  return color + BOX.dv + c.reset + ' ' + content + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
+}
+function thinLine(w) { return '  ' + c.dim + BOX.h.repeat(w - 4) + c.reset; }
+
 const BANNER_RAW = [
   '    ██████╗  █████╗ ███╗   ██╗██╗  ██╗',
   '    ██╔══██╗██╔══██╗████╗  ██║██║ ██╔╝',
@@ -284,24 +330,30 @@ 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(6);
-const MAX_LOGS = 6;
-const RENDER_THROTTLE_MS = 250;
+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(20);
+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`;
+  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();
@@ -326,14 +378,15 @@ function renderDashboard() {
 
   totalBalance = 0; totalCoins = 0; totalCommands = 0;
   let totalErrors = 0;
+  let totalLosses = 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;
+    totalLosses += w.stats.losses || 0;
   }
   const successRate = totalCommands > 0 ? Math.round(((totalCommands - totalErrors) / totalCommands) * 100) : 100;
-  // Track session peak and new high
   if (totalCoins > sessionPeakCoins) {
     sessionPeakCoins = totalCoins;
     isNewHigh = true;
@@ -341,212 +394,225 @@ function renderDashboard() {
   }
 
   const lines = [];
-  const tw = Math.min(process.stdout.columns || 80, 78);
-  const thinBar = c.dim + '─'.repeat(tw) + c.reset;
-  const bar = rgb(139, 92, 246) + c.bold + '━'.repeat(tw) + c.reset;
-  const doubleBar = rgb(139, 92, 246) + '╔' + '═'.repeat(tw - 2) + '╗' + c.reset;
-  const doubleBarMid = rgb(139, 92, 246) + '╠' + '═'.repeat(tw - 2) + '╣' + c.reset;
-  const doubleBarBot = rgb(139, 92, 246) + '╚' + '═'.repeat(tw - 2) + '╝' + c.reset;
-
-  // Header with title, stats, and mode
-  lines.push(doubleBar);
-  const cmdCount = AccountWorker.COMMAND_MAP.length;
+  const tw = Math.max(Math.min(process.stdout.columns || 80, 90), 60);
+  const accent = rgb(139, 92, 246);
+  const accentDim = rgb(90, 60, 170);
+  const green = rgb(52, 211, 153);
+  const blue = rgb(96, 165, 250);
+  const pink = rgb(236, 72, 153);
+  const gold = rgb(255, 215, 0);
+  const orange = rgb(251, 146, 60);
+  const cyan = rgb(34, 211, 238);
+  const red = rgb(239, 68, 68);
+  const yellow = rgb(251, 191, 36);
+  const white = c.white;
+  const dim = c.dim;
+  const RE_ANSI = /\x1b\[[0-9;]*m/g;
+
+  // ━━━ HEADER BOX ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  lines.push(boxTop(tw, accent));
+
+  // Title line with animated spinner
+  const spin = getSpinner('braille');
+  const titleGrad = gradientText('DankGrinder', [192, 132, 252], [52, 211, 153]);
+  const verStr = `${dim}v${PKG_VERSION}${c.reset}`;
+  lines.push(boxLine(`${c.bold}${titleGrad}${c.reset}  ${verStr}  ${green}${spin}${c.reset}`, tw, accent));
+
+  // Info bar
   const activeCount = workers.filter(w => w.running && !w.paused && !w.dashboardPaused).length;
-  const mode = CLUSTER_ENABLED ? `${rgb(34, 211, 238)}Cluster${c.reset}` : `${c.dim}Standalone${c.reset}`;
-
-  // Animated spinner and gradient title
-  const spinners = ['◐', '◓', '◑', '◒'];
-  const spinner = spinners[Math.floor(Date.now() / 250) % 4];
-  const animatedSpinner = `${rgb(52, 211, 153)}${spinner}${c.reset}`;
-  const gradientTitle = gradientLine('DankGrinder', [192, 132, 252], [34, 211, 238]);
-
-  // Network quality indicator (based on recent latency/errors)
-  const netQuality = workers.length > 0
-    ? workers.reduce((s, w) => s + (w._lastPing < 200 ? 1 : w._lastPing < 500 ? 0.5 : 0), 0) / workers.length
-    : 1;
-  const netIcon = netQuality > 0.8 ? `${rgb(52, 211, 153)}◉${c.reset}` :
-                  netQuality > 0.5 ? `${rgb(251, 191, 36)}◉${c.reset}` :
-                  `${rgb(239, 68, 68)}◉${c.reset}`;
-  const netLabel = netQuality > 0.8 ? `${c.dim}good${c.reset}` :
-                   netQuality > 0.5 ? `${c.dim}fair${c.reset}` :
-                   `${c.dim}poor${c.reset}`;
-
-  lines.push(`  ${c.bold}${gradientTitle}${c.reset} ${c.dim}v${PKG_VERSION}${c.reset}`);
-  lines.push(`  ${mode}  ${c.dim}·${c.reset}  ${netIcon} ${netLabel}  ${c.dim}·${c.reset}  ${c.white}${cmdCount} commands${c.reset}  ${c.dim}·${c.reset}  ${animatedSpinner} ${rgb(52, 211, 153)}${activeCount}${c.reset}${c.dim}/${c.reset}${c.white}${workers.length}${c.reset} ${c.dim}live${c.reset}`);
-
-  // Stats row 1: Balance & Earnings
-  lines.push(doubleBarMid);
-  const liveIcon = rgb(52, 211, 153) + '●' + c.reset;
-  const balStr = `${rgb(192, 132, 252)}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}`;
-  const earnStr = `${rgb(52, 211, 153)}▲ ${formatCoins(totalCoins)}${c.reset}`;
+  const pausedCount = workers.filter(w => w.paused || w.dashboardPaused).length;
+  const recovCount = workers.filter(w => w._recoveryAttempts > 0 && w._errorCooldownUntil > Date.now()).length;
+  const mode = CLUSTER_ENABLED ? `${cyan}CLUSTER${c.reset}` : `${dim}STANDALONE${c.reset}`;
+  const cmdCount = AccountWorker.COMMAND_MAP.length;
+
+  // Net quality
+  const netQ = workers.length > 0
+    ? workers.reduce((s, w) => s + (w._lastPing < 200 ? 1 : w._lastPing < 500 ? 0.5 : 0), 0) / workers.length : 1;
+  const netDot = netQ > 0.8 ? `${green}◉${c.reset}` : netQ > 0.5 ? `${yellow}◉${c.reset}` : `${red}◉${c.reset}`;
+  const netLbl = netQ > 0.8 ? `${green}GOOD${c.reset}` : netQ > 0.5 ? `${yellow}FAIR${c.reset}` : `${red}POOR${c.reset}`;
+
+  lines.push(boxLine(`${mode}  ${dim}|${c.reset}  ${netDot} ${netLbl}  ${dim}|${c.reset}  ${blue}${cmdCount}${c.reset} ${dim}cmds${c.reset}  ${dim}|${c.reset}  ${green}${activeCount}${c.reset}${dim}/${c.reset}${white}${workers.length}${c.reset} ${dim}live${c.reset}${pausedCount > 0 ? `  ${yellow}${pausedCount} paused${c.reset}` : ''}${recovCount > 0 ? `  ${orange}${recovCount} recovering${c.reset}` : ''}`, tw, accent));
+
+  // ━━━ STATS SECTION ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  const midLine = accent + BOX.tee + BOX.h.repeat(tw - 2) + BOX.teeR + c.reset;
+  lines.push(midLine);
+
+  // Balance card
+  const balIcon = `${gold}⟐${c.reset}`;
+  const balVal = `${c.bold}${gold}⏣ ${formatCoins(totalBalance)}${c.reset}`;
+  const peakTag = isNewHigh ? ` ${red}${c.bold}<< NEW HIGH >>${c.reset}` : '';
+  lines.push(boxLine(`${balIcon}  ${dim}BALANCE${c.reset}  ${balVal}${peakTag}`, tw, accent));
+
+  // Earnings card with sparkline
   const elapsedHrs = (Date.now() - startTime) / 3_600_000;
-  const coinsPerHr = elapsedHrs > 0.01 ? Math.round(totalCoins / elapsedHrs) : 0;
-  const rateLabel = `${rgb(52, 211, 153)}${formatCoins(coinsPerHr)}/h${c.reset}`;
-
-  // Stats row 2: Commands & Performance
-  const cmdStr = `${rgb(96, 165, 250)}${totalCommands}${c.reset}${c.dim} cmds${c.reset}`;
-  const rateStr = successRate >= 95
-    ? `${rgb(52, 211, 153)}● ${successRate}%${c.reset}`
-    : successRate >= 80 ? `${rgb(251, 191, 36)}● ${successRate}%${c.reset}`
-    : `${rgb(239, 68, 68)}● ${successRate}%${c.reset}`;
+  const perHr = elapsedHrs > 0.01 ? Math.round(totalCoins / elapsedHrs) : 0;
+  const earnIcon = `${green}▲${c.reset}`;
+  const earnVal = `${c.bold}${green}+⏣ ${formatCoins(totalCoins)}${c.reset}`;
+  const hrRate = `${dim}(${c.reset}${green}${formatCoins(perHr)}/h${c.reset}${dim})${c.reset}`;
+  // Sample sparkline
+  const now = Date.now();
+  if (now - lastEarningsSample > 8000) { earningsHistory.push(totalCoins); lastEarningsSample = now; }
+  const spark = drawSparkline(earningsHistory.toArray(), 20);
+  lines.push(boxLine(`${earnIcon}  ${dim}EARNED${c.reset}   ${earnVal} ${hrRate}  ${spark}`, tw, accent));
+
+  // Peak earnings
+  const peakIcon = `${orange}★${c.reset}`;
+  lines.push(boxLine(`${peakIcon}  ${dim}PEAK${c.reset}     ${c.bold}${orange}⏣ ${formatCoins(sessionPeakCoins)}${c.reset}  ${dim}this session${c.reset}`, tw, accent));
+
+  // Performance metrics line
   const cpmVal = globalCmdRate.getRate().toFixed(1);
-  const cpmStr = `${rgb(34, 211, 238)}${cpmVal}${c.reset}${c.dim}/m${c.reset}`;
+  const srColor = successRate >= 95 ? green : successRate >= 80 ? yellow : red;
+  const srBar = progressBar(successRate, 100, 8, successRate >= 95 ? [52, 211, 153] : successRate >= 80 ? [251, 191, 36] : [239, 68, 68]);
+  const perfIcon = `${blue}◆${c.reset}`;
+  lines.push(boxLine(`${perfIcon}  ${dim}PERF${c.reset}     ${blue}${totalCommands}${c.reset} ${dim}cmds${c.reset}  ${srColor}${successRate}%${c.reset} ${srBar}  ${cyan}${cpmVal}${c.reset}${dim}/min${c.reset}  ${yellow}◷${c.reset} ${yellow}${formatUptime()}${c.reset}`, tw, accent));
 
-  // Stats row 3: Uptime & Memory
-  const upStr = `${rgb(251, 191, 36)}◷ ${formatUptime()}${c.reset}`;
+  // Memory line
   const memMB = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
-  const memPct = Math.min(100, (memMB / 1024) * 100);
-  const memBarWidth = Math.floor((memPct / 100) * 10);
-  const memBar = rgb(52, 211, 153) + '▅'.repeat(memBarWidth) + c.dim + '▅'.repeat(10 - memBarWidth) + c.reset;
-  const memColor = memMB > 900 ? rgb(239, 68, 68) : memMB > 600 ? rgb(251, 191, 36) : rgb(52, 211, 153);
-  const memStr = `${memColor}${memMB}MB${c.reset} ${memBar}`;
+  const memColor = memMB > 900 ? [239, 68, 68] : memMB > 600 ? [251, 191, 36] : [52, 211, 153];
+  const memBar = progressBar(memMB, 1024, 12, memColor, [40, 40, 55]);
+  const memIcon = `${dim}≡${c.reset}`;
+  lines.push(boxLine(`${memIcon}  ${dim}MEM${c.reset}      ${rgb(memColor[0], memColor[1], memColor[2])}${memMB}MB${c.reset} ${memBar}`, tw, accent));
 
-  // Sample earnings for sparkline every 10 seconds
-  const now = Date.now();
-  if (now - lastEarningsSample > 10000) {
-    earningsHistory.push(totalCoins);
-    lastEarningsSample = now;
-  }
-  const sparkline = drawSparkline(earningsHistory.toArray(), 16);
-  const peakIndicator = isNewHigh ? `${rgb(255, 100, 100)} 🚀 NEW HIGH!${c.reset}` : '';
-
-  lines.push(`  ${liveIcon} ${balStr}  ${c.dim}│${c.reset}  ${earnStr} ${c.dim}(${c.reset}${rateLabel}${c.dim})${c.reset}${peakIndicator}`);
-  lines.push(`  ${cmdStr} ${c.dim}(${c.reset}${rateStr}${c.dim})${c.reset}  ${c.dim}│${c.reset}  ${cpmStr}  ${c.dim}│${c.reset}  ${upStr}`);
-  lines.push(`  ${c.dim}Peak:${c.reset} ${rgb(255, 215, 0)}⏣ ${formatCoins(sessionPeakCoins)}${c.reset}  ${c.dim}│${c.reset}  Trend: ${sparkline}  ${c.dim}│${c.reset}  ${memStr}`);
-  lines.push(thinBar);
-
-  // Worker rows — paginated for 10K+ accounts
-  // Renders up to MAX_VISIBLE_WORKERS rows individually, then shows
-  // a compact summary for the rest. This keeps terminal responsive.
-  const MAX_VISIBLE_WORKERS = 30;
-  const nameWidth = Math.min(18, tw > 70 ? 18 : 12);
-  const statusWidth = Math.max(18, tw - nameWidth - 42);
-  const RE_ANSI_STRIP = /\x1b\[[0-9;]*m/g;
-
-  // Find top 3 earners for highlighting
+  // ━━━ ACCOUNTS TABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  lines.push(midLine);
+
+  const nameW = Math.min(20, tw > 75 ? 20 : 14);
+  const statusW = Math.max(20, tw - nameW - 44);
+
+  // Column headers with gradient
+  const colHead = `  ${dim}##${c.reset}  ${dim}STS${c.reset}  ${gradientText('Account', [139, 92, 246], [96, 165, 250])}${' '.repeat(Math.max(0, nameW - 7))}  ${dim}Balance${c.reset}     ${dim}Earned${c.reset}       ${dim}Activity${c.reset}`;
+  lines.push(boxLine(colHead, tw, accent));
+  lines.push(boxLine(`${dim}${'─'.repeat(tw - 6)}${c.reset}`, tw, accent));
+
+  // Top 3 earners
   const topEarners = [...workers]
     .filter(w => w.running && (w.stats.coins || 0) > 0)
     .sort((a, b) => (b.stats.coins || 0) - (a.stats.coins || 0))
     .slice(0, 3);
-  const topEarnerIds = new Set(topEarners.map(w => w.account.id));
-
-  // Column headers
-  lines.push(`  ${c.dim}#${c.reset}  ${c.dim}Account${' '.repeat(nameWidth - 5)}${c.reset}  ${c.dim}Balance${c.reset}    ${c.dim}Earned${c.reset}     ${c.dim}Status${c.reset}`);
-  lines.push(`  ${c.dim}${'─'.repeat(tw - 4)}${c.reset}`);
-
-  const renderWorkerRow = (wk, index) => {
-    const pos = `${c.dim}#${c.reset}${c.bold}${(index + 1).toString().padStart(2, ' ')}${c.reset}`;
-    const rawStatus = (wk.lastStatus || 'idle').replace(RE_ANSI_STRIP, '');
-    const last = rawStatus.substring(0, statusWidth);
-
-    let dot, stateLabel;
-    const isRecovering = wk._recoveryAttempts > 0 && wk._errorCooldownUntil > Date.now();
-    if (!wk.running) {
-      dot = `${rgb(239, 68, 68)}○${c.reset}`;
-      stateLabel = `${c.dim}offline${c.reset}`;
-    } else if (isRecovering) {
-      const sLeft = Math.ceil((wk._errorCooldownUntil - Date.now()) / 1000);
-      dot = `${rgb(251, 191, 36)}↻${c.reset}`;
-      stateLabel = `${rgb(251, 191, 36)}recovering #${wk._recoveryAttempts} (${sLeft}s)${c.reset}`;
+  const topIds = new Set(topEarners.map(w => w.account.id));
+
+  const MAX_VIS = 30;
+
+  const renderRow = (wk, idx) => {
+    // Use original account number (wk.idx) so removed accounts leave visible gaps
+    const origNum = wk.idx + 1;
+    const num = `${dim}${origNum.toString().padStart(2)}${c.reset}`;
+    const rawStat = (wk.lastStatus || 'idle').replace(RE_ANSI, '');
+    const statTxt = rawStat.substring(0, statusW);
+
+    // Status indicator with animations
+    let sts, statLabel;
+    const isRecov = wk._recoveryAttempts > 0 && wk._errorCooldownUntil > Date.now();
+    if (wk._tokenInvalid) {
+      sts = `${red}✗${c.reset}`;
+      statLabel = `${red}TOKEN INVALID${c.reset}`;
+    } else if (!wk.running) {
+      sts = `${dim}○${c.reset}`;
+      statLabel = `${dim}offline${c.reset}`;
+    } else if (isRecov) {
+      const sL = Math.ceil((wk._errorCooldownUntil - Date.now()) / 1000);
+      sts = `${orange}${getSpinner('braille')}${c.reset}`;
+      statLabel = `${orange}recovering #${wk._recoveryAttempts} (${sL}s)${c.reset}`;
     } else if (wk.paused) {
-      dot = `${rgb(239, 68, 68)}⏸${c.reset}`;
-      stateLabel = `${rgb(239, 68, 68)}PAUSED${c.reset}`;
+      sts = `${red}⏸${c.reset}`;
+      statLabel = `${red}PAUSED${c.reset}`;
     } else if (wk.dashboardPaused) {
-      dot = `${rgb(251, 191, 36)}⏸${c.reset}`;
-      stateLabel = `${rgb(251, 191, 36)}paused${c.reset}`;
+      sts = `${yellow}⏸${c.reset}`;
+      statLabel = `${yellow}paused (user)${c.reset}`;
     } else if (wk.busy) {
-      dot = `${rgb(251, 191, 36)}◉${c.reset}`;
-      stateLabel = `${c.dim}${last}${c.reset}`;
+      sts = `${green}${getSpinner('pulse')}${c.reset}`;
+      statLabel = `${dim}${statTxt}${c.reset}`;
     } else {
-      dot = `${rgb(52, 211, 153)}●${c.reset}`;
-      stateLabel = `${c.dim}${last}${c.reset}`;
+      sts = `${green}●${c.reset}`;
+      statLabel = `${dim}${statTxt}${c.reset}`;
     }
 
-    // Top earner medal
-    let medal = '  ';
-    if (topEarnerIds.has(wk.account.id)) {
+    // Medal for top earners
+    let medal = ' ';
+    if (topIds.has(wk.account.id)) {
       const rank = topEarners.findIndex(e => e.account.id === wk.account.id);
-      medal = rank === 0 ? `${rgb(255, 215, 0)}🥇${c.reset}` : rank === 1 ? `${rgb(192, 192, 192)}🥈${c.reset}` : `${rgb(205, 127, 50)}🥉${c.reset}`;
+      // Use text medals instead of emoji for better terminal compat
+      medal = rank === 0 ? `${gold}1st${c.reset}` : rank === 1 ? `${rgb(192, 192, 192)}2nd${c.reset}` : `${rgb(205, 127, 50)}3rd${c.reset}`;
     }
 
-    const name = `${wk.color}${c.bold}${(wk.username || '?').substring(0, nameWidth)}${c.reset}`;
+    const name = `${wk.color}${c.bold}${(wk.username || '?').substring(0, nameW).padEnd(nameW)}${c.reset}`;
+
+    // Balance with icon
     const bal = wk.stats.balance > 0
-      ? `${rgb(251, 191, 36)}⏣${c.reset} ${c.white}${formatCoins(wk.stats.balance).padStart(8)}${c.reset}`
-      : `${c.dim}⏣        -${c.reset}`;
-
-    // Enhanced progress bar for earned coins
-    const earnedNum = wk.stats.coins || 0;
-    const earnedBarWidth = earnedNum > 0 ? Math.min(5, Math.max(1, Math.floor(Math.log10(earnedNum + 1)))) : 0;
-    const earnedBar = earnedNum > 0
-      ? `${rgb(52, 211, 153)}${'▰'.repeat(earnedBarWidth)}${c.dim}${'▱'.repeat(5 - earnedBarWidth)}${c.reset}`
-      : `${c.dim}▱▱▱▱▱${c.reset}`;
-    const earned = earnedNum > 0
-      ? `${rgb(52, 211, 153)}+${formatCoins(earnedNum)}${c.reset} ${earnedBar}`
-      : `${c.dim}+0${c.reset} ${earnedBar}`;
-
-    lines.push(`  ${pos} ${medal}${dot} ${name.padEnd(nameWidth + wk.color.length + c.bold.length + c.reset.length + 2)} ${bal}  ${earned}  ${stateLabel}`);
+      ? `${gold}⏣${c.reset}${white}${formatCoins(wk.stats.balance).padStart(9)}${c.reset}`
+      : `${dim}⏣        -${c.reset}`;
+
+    // Earnings with mini progress
+    const earnNum = wk.stats.coins || 0;
+    const earnBarW = earnNum > 0 ? Math.min(6, Math.max(1, Math.floor(Math.log10(earnNum + 1)))) : 0;
+    const earnBar = progressBar(earnBarW, 6, 6, [52, 211, 153], [40, 40, 55]);
+    const earned = earnNum > 0
+      ? `${green}+${formatCoins(earnNum).padEnd(7)}${c.reset}${earnBar}`
+      : `${dim}  -     ${c.reset}${progressBar(0, 6, 6)}`;
+
+    lines.push(boxLine(`${num}  ${sts}${medal.padEnd(medal.length > 1 ? 3 : 1)}  ${name}  ${bal}  ${earned}  ${statLabel}`, tw, accent));
   };
 
-  if (workers.length <= MAX_VISIBLE_WORKERS) {
-    for (let i = 0; i < workers.length; i++) renderWorkerRow(workers[i], i);
+  if (workers.length <= MAX_VIS) {
+    for (let i = 0; i < workers.length; i++) renderRow(workers[i], i);
   } else {
-    // Pagination: show first MAX_VISIBLE_WORKERS, summarize rest
-    for (let i = 0; i < MAX_VISIBLE_WORKERS; i++) renderWorkerRow(workers[i], i);
-    const remaining = workers.length - MAX_VISIBLE_WORKERS;
-    let hiddenActive = 0, hiddenPaused = 0, hiddenRecovering = 0, hiddenOffline = 0;
-    for (let i = MAX_VISIBLE_WORKERS; i < workers.length; i++) {
+    for (let i = 0; i < MAX_VIS; i++) renderRow(workers[i], i);
+    const rest = workers.length - MAX_VIS;
+    let ha = 0, hp = 0, hr = 0, ho = 0;
+    for (let i = MAX_VIS; i < workers.length; i++) {
       const w = workers[i];
-      if (!w.running) hiddenOffline++;
-      else if (w.paused || w.dashboardPaused) hiddenPaused++;
-      else if (w._recoveryAttempts > 0 && w._errorCooldownUntil > Date.now()) hiddenRecovering++;
-      else hiddenActive++;
-    }
-    const parts = [`${c.dim}┃${c.reset}  ${c.dim}... +${remaining} more${c.reset}`];
-    if (hiddenActive > 0) parts.push(`${rgb(52, 211, 153)}● ${hiddenActive} active${c.reset}`);
-    if (hiddenPaused > 0) parts.push(`${rgb(251, 191, 36)}⏸ ${hiddenPaused} paused${c.reset}`);
-    if (hiddenRecovering > 0) parts.push(`${rgb(251, 191, 36)}↻ ${hiddenRecovering} recovering${c.reset}`);
-    if (hiddenOffline > 0) parts.push(`${c.dim}○ ${hiddenOffline} offline${c.reset}`);
-    lines.push(`  ${parts.join(`  ${c.dim}·${c.reset}  `)}`);
-  }
-
-  // Recovery & status summary line with enhanced styling
-  const recoveringCount = workers.filter(w => w._recoveryAttempts > 0 && w._errorCooldownUntil > Date.now()).length;
-  const pausedCount = workers.filter(w => w.paused).length;
+      if (!w.running) ho++;
+      else if (w.paused || w.dashboardPaused) hp++;
+      else if (w._recoveryAttempts > 0 && w._errorCooldownUntil > Date.now()) hr++;
+      else ha++;
+    }
+    const parts = [`${dim}... +${rest} more${c.reset}`];
+    if (ha > 0) parts.push(`${green}● ${ha}${c.reset}`);
+    if (hp > 0) parts.push(`${yellow}⏸ ${hp}${c.reset}`);
+    if (hr > 0) parts.push(`${orange}↻ ${hr}${c.reset}`);
+    if (ho > 0) parts.push(`${dim}○ ${ho}${c.reset}`);
+    lines.push(boxLine(`    ${parts.join(`  ${dim}·${c.reset}  `)}`, tw, accent));
+  }
+
+  // ━━━ HEALTH SUMMARY ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   const totalRecoveries = workers.reduce((s, w) => s + (w._totalRecoveries || 0), 0);
   const totalDisconnects = workers.reduce((s, w) => s + (w._disconnectCount || 0), 0);
-  if (recoveringCount > 0 || pausedCount > 0 || totalRecoveries > 0 || totalDisconnects > 0) {
-    const parts = [];
-    if (recoveringCount > 0) parts.push(`${rgb(251, 191, 36)}↻ ${recoveringCount} recovering${c.reset}`);
-    if (pausedCount > 0) parts.push(`${rgb(239, 68, 68)}⏸ ${pausedCount} paused${c.reset}`);
-    if (totalRecoveries > 0) parts.push(`${c.dim}${totalRecoveries} auto-recovered${c.reset}`);
-    if (totalDisconnects > 0) parts.push(`${c.dim}${totalDisconnects} reconnects${c.reset}`);
-    lines.push(`  ${c.dim}┃${c.reset}  ${parts.join(`  ${c.dim}·${c.reset}  `)}`);
+  if (recovCount > 0 || pausedCount > 0 || totalRecoveries > 0 || totalDisconnects > 0) {
+    lines.push(boxLine(`${dim}${'─'.repeat(tw - 6)}${c.reset}`, tw, accent));
+    const hParts = [];
+    if (recovCount > 0) hParts.push(`${orange}${getSpinner('braille')} ${recovCount} recovering${c.reset}`);
+    if (pausedCount > 0) hParts.push(`${red}⏸ ${pausedCount} paused${c.reset}`);
+    if (totalRecoveries > 0) hParts.push(`${dim}${totalRecoveries} auto-healed${c.reset}`);
+    if (totalDisconnects > 0) hParts.push(`${dim}${totalDisconnects} reconnects${c.reset}`);
+    lines.push(boxLine(`${dim}HEALTH${c.reset}   ${hParts.join(`  ${dim}·${c.reset}  `)}`, tw, accent));
   }
 
-  // Cluster info line with enhanced styling
+  // Cluster info
   if (CLUSTER_ENABLED) {
     const nodeShort = NODE_ID.substring(0, 12);
     const claimedCount = workers.filter(w => w.running).length;
-    lines.push(`  ${rgb(34, 211, 238)}╔${c.reset}${c.dim} Cluster: ${nodeShort} · ${claimedCount} claimed ${c.reset}${rgb(34, 211, 238)}╗${c.reset}`);
+    lines.push(boxLine(`${cyan}CLUSTER${c.reset}  ${dim}node:${c.reset}${cyan}${nodeShort}${c.reset}  ${dim}claimed:${c.reset}${white}${claimedCount}${c.reset}`, tw, accent));
   }
 
-  // Log section
+  // ━━━ LIVE LOG FEED ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   const logEntries = recentLogs.toArray();
   if (logEntries.length > 0) {
-    lines.push(thinBar);
+    lines.push(midLine);
+    const logTitle = gradientText(' LIVE FEED ', [139, 92, 246], [52, 211, 153]);
+    lines.push(boxLine(`${logTitle}`, tw, accent));
     for (const entry of logEntries) {
-      lines.push(`  ${c.dim}${entry}${c.reset}`);
+      lines.push(boxLine(`${dim}${entry}${c.reset}`, tw, accent));
     }
   }
 
-  lines.push(doubleBarBot);
+  // ━━━ FOOTER ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  lines.push(boxBot(tw, accent));
 
-  // Absolute cursor home — always draw from row 1
+  // Render
   process.stdout.write('\x1b[H');
   for (const line of lines) {
     process.stdout.write(c.clearLine + '\r' + line + '\n');
   }
-  // Erase everything below the dashboard (clears ghost bars, trailing lines)
   process.stdout.write('\x1b[J');
   dashboardLines = lines.length;
   dashboardRendering = false;
@@ -2400,22 +2466,37 @@ class AccountWorker {
     if (!this.account.discord_token) { this.log('error', 'No token'); return; }
     if (!this.account.channel_id) { this.log('error', 'No channel'); return; }
 
+    const LOGIN_TIMEOUT_MS = 30_000; // 30s max per account login
+
     return new Promise((resolve) => {
+      let resolved = false;
+      const done = () => { if (!resolved) { resolved = true; resolve(); } };
+
+      // Timeout guard — don't let a single account hang the batch
+      const timeoutId = setTimeout(() => {
+        if (!resolved) {
+          this.log('warn', 'Login timed out after 30s — will retry in background');
+          done();
+          // Retry login in background after timeout
+          this._retryLoginBackground();
+        }
+      }, LOGIN_TIMEOUT_MS);
+
       this.client.on('ready', async () => {
+        clearTimeout(timeoutId);
         this.username = this.client.user.tag || this.username;
         this.avatarUrl = this.client.user.displayAvatarURL?.({ format: 'png', dynamic: true, size: 128 }) || null;
-        try {
-          await fetch(`${API_URL}/api/grinder/status`, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ account_id: this.account.id, discord_username: this.username, avatar_url: this.avatarUrl }),
-          });
-        } catch { /* silent */ }
+        // Report status non-blocking
+        fetch(`${API_URL}/api/grinder/status`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ account_id: this.account.id, discord_username: this.username, avatar_url: this.avatarUrl }),
+        }).catch(() => {});
 
         this.channel = await this.client.channels.fetch(this.account.channel_id).catch(() => null);
         if (!this.channel) {
           this.log('error', `Channel not found`);
-          resolve(); return;
+          done(); return;
         }
 
         const enabledCmds = [
@@ -2438,49 +2519,108 @@ class AccountWorker {
         this.log('success', `#${chName} · ${enabledCmds.length} cmds`);
         this.setStatus('starting...');
 
-        // Load daily/weekly/monthly done state from Redis
-        if (redis) {
-          for (const cmd of ['daily', 'weekly', 'monthly', 'drops']) {
-            try {
-              const val = await redis.get(`dkg:done:${this.account.id}:${cmd}`);
-              if (val) {
-                const ttlSec = await redis.ttl(`dkg:done:${this.account.id}:${cmd}`);
-                if (ttlSec > 0) {
-                  this.doneToday.set(cmd, Date.now() + ttlSec * 1000);
-                  this.log('info', `${cmd} already claimed (${Math.round(ttlSec / 3600)}h remaining)`);
-                }
-              }
-            } catch {}
+        // Load daily/weekly/monthly done state from Redis (non-blocking for login speed)
+        this._loadRedisState().catch(() => {});
+
+        // Reduced settle time — 200ms is enough for most gateways
+        await new Promise(r => setTimeout(r, 200));
+        done();
+      });
+
+      // Handle login errors so they don't hang
+      this.client.on('error', (err) => {
+        if (!resolved) {
+          clearTimeout(timeoutId);
+          const msg = (err?.message || '').toLowerCase();
+          if (msg.includes('token_invalid') || msg.includes('invalid token') || msg.includes('401')) {
+            this.log('error', `✗ TOKEN INVALID — this token is no longer valid`);
+            this.paused = true;
+            this._tokenInvalid = true;
+          } else {
+            this.log('error', `Login error: ${err?.message || err}`);
           }
-          // Load cached balance from Redis
-          try {
-            const balData = await redis.get(`dkg:bal:${this.account.id}`);
-            if (balData) {
-              const { wallet, bank } = JSON.parse(balData);
-              if (wallet > 0 || bank > 0) {
-                this.stats.balance = wallet;
-                this.stats.bankBalance = bank;
-                await fetch(`${API_URL}/api/grinder/status`, {
-                  method: 'POST',
-                  headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-                  body: JSON.stringify({ account_id: this.account.id, balance: wallet, bank_balance: bank, total_balance: wallet + bank }),
-                }).catch(() => {});
-              }
-            }
-          } catch {}
+          done();
         }
-
-        // Let Discord gateway settle (reduced for faster startup)
-        await new Promise(r => setTimeout(r, 500));
-        resolve();
       });
 
       // Attach auto-recovery event listeners before login
       this._attachRecoveryListeners();
-      this.client.login(this.account.discord_token);
+      this.client.login(this.account.discord_token).catch((err) => {
+        clearTimeout(timeoutId);
+        const msg = (err?.message || '').toLowerCase();
+        if (msg.includes('token_invalid') || msg.includes('invalid token') || msg.includes('401') || msg.includes('incorrect login')) {
+          this.log('error', `✗ TOKEN INVALID — check this account's token`);
+          this.paused = true;
+          this._tokenInvalid = true;
+          // Report invalid status to API
+          fetch(`${API_URL}/api/grinder/status`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, active: false, status: 'token_invalid' }),
+          }).catch(() => {});
+          sendWebhook('Token Invalid', `**${this.account.label || this.account.id}** has an invalid Discord token.`, 0xef4444);
+        } else {
+          this.log('error', `Login failed: ${err?.message || 'unknown error'}`);
+        }
+        done();
+      });
     });
   }
 
+  /** Load Redis cached state in background (non-blocking) */
+  async _loadRedisState() {
+    if (!redis) return;
+    for (const cmd of ['daily', 'weekly', 'monthly', 'drops']) {
+      try {
+        const val = await redis.get(`dkg:done:${this.account.id}:${cmd}`);
+        if (val) {
+          const ttlSec = await redis.ttl(`dkg:done:${this.account.id}:${cmd}`);
+          if (ttlSec > 0) {
+            this.doneToday.set(cmd, Date.now() + ttlSec * 1000);
+            this.log('info', `${cmd} already claimed (${Math.round(ttlSec / 3600)}h remaining)`);
+          }
+        }
+      } catch {}
+    }
+    // Load cached balance from Redis
+    try {
+      const balData = await redis.get(`dkg:bal:${this.account.id}`);
+      if (balData) {
+        const { wallet, bank } = JSON.parse(balData);
+        if (wallet > 0 || bank > 0) {
+          this.stats.balance = wallet;
+          this.stats.bankBalance = bank;
+          await fetch(`${API_URL}/api/grinder/status`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, balance: wallet, bank_balance: bank, total_balance: wallet + bank }),
+          }).catch(() => {});
+        }
+      }
+    } catch {}
+  }
+
+  /** Retry login in background after a timeout */
+  async _retryLoginBackground() {
+    await new Promise(r => setTimeout(r, 5000));
+    if (this.client && !this.running) {
+      this.log('info', 'Retrying login in background...');
+      try {
+        this.client.destroy();
+        this.client = createLeanClient();
+        this._attachRecoveryListeners();
+        await this.client.login(this.account.discord_token);
+        this.channel = await this.client.channels.fetch(this.account.channel_id).catch(() => null);
+        if (this.channel) {
+          this.username = this.client.user?.tag || this.username;
+          this.log('success', `Background login OK`);
+        }
+      } catch (err) {
+        this.log('error', `Background login failed: ${err?.message || err}`);
+      }
+    }
+  }
+
   stop() {
     this.running = false;
     this.paused = false;
@@ -2596,6 +2736,22 @@ async function start(apiKey, apiUrl) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
+  // ── Animated loading bar helper ──────────────────────────────
+  const barW = Math.min(40, (process.stdout.columns || 80) - 30);
+  let loginDone = 0;
+  const drawLoginProgress = () => {
+    const pct = accounts.length > 0 ? loginDone / accounts.length : 0;
+    const filled = Math.round(pct * barW);
+    const empty = barW - filled;
+    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+    const bar = rgb(139, 92, 246) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(empty) + c.reset;
+    const pctStr = `${Math.round(pct * 100)}%`;
+    process.stdout.write(`\r  ${rgb(139, 92, 246)}${spin}${c.reset}  ${dim}Logging in...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${loginDone}${c.reset}${dim}/${c.reset}${c.white}${accounts.length}${c.reset}  ${dim}${pctStr}${c.reset}  `);
+  };
+
+  // Progress animation timer
+  const progressInterval = setInterval(drawLoginProgress, 80);
+
   // Phase 1: Login all accounts (optimized for speed)
   const LOGIN_PROGRESS_EVERY = 10;
   // Reduced delays: 50-150ms between logins (faster startup for 1k+ accounts)
@@ -2610,38 +2766,80 @@ async function start(apiKey, apiUrl) {
   };
 
   // Parallel login in batches of 10 to avoid rate limits while being fast
+  // Within each batch, stagger logins by 100-600ms to avoid gateway flood
   const BATCH_SIZE = 10;
   for (let i = 0; i < accounts.length; i += BATCH_SIZE) {
     if (shutdownCalled) break;
     const batch = accounts.slice(i, Math.min(i + BATCH_SIZE, accounts.length));
 
-    // Login batch in parallel
+    // Staggered parallel login: fire each login with a small jitter delay
     await Promise.all(batch.map(async (acc, idx) => {
+      // Stagger within batch: 0ms for first, 100-600ms for subsequent
+      if (idx > 0) {
+        const jitter = 100 + Math.floor(Math.random() * 500);
+        await new Promise(r => setTimeout(r, jitter));
+      }
       const worker = new AccountWorker(acc, i + idx);
       workers.push(worker);
       workerMap.set(acc.id, worker);
       await worker.start();
+      loginDone++;
     }));
 
     // Small gap between batches
     if (i + BATCH_SIZE < accounts.length) {
       const gapMs = randomLoginGap();
-      log('info', `${c.dim}Logged in ${Math.min(i + BATCH_SIZE, accounts.length)}/${accounts.length}...${c.reset}`);
       await new Promise(r => setTimeout(r, gapMs));
     }
 
     hintGC();
   }
 
-  // Phase 2: Run inventory on ALL accounts in parallel (must complete before grinding)
-  log('info', `${c.dim}Checking inventory for ${workers.length} accounts...${c.reset}`);
+  clearInterval(progressInterval);
+  // Clear the progress line and show done
+  process.stdout.write(`\r${c.clearLine}`);
+  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Login complete${c.reset}  ${rgb(52, 211, 153)}${loginDone}/${accounts.length}${c.reset} ${dim}accounts connected${c.reset}`);
+  console.log('');
+
+  // Login summary: show invalid tokens clearly
+  const invalidWorkers = workers.filter(w => w._tokenInvalid);
+  const timedOutWorkers = workers.filter(w => !w.channel && !w._tokenInvalid);
+  if (invalidWorkers.length > 0) {
+    console.log('');
+    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 (will retry in background)`);
+  }
+
+  // Filter out workers with invalid tokens from grinding
+  const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
-  // Parallel inventory checks with single-line progress
+  // Phase 2: Run inventory on ALL valid accounts in parallel (must complete before grinding)
+  console.log(`  ${rgb(139, 92, 246)}${BRAILLE_SPIN[0]}${c.reset}  ${dim}Checking inventory for ${c.reset}${c.bold}${activeWorkers.length}${c.reset}${dim} accounts...${c.reset}`);
+
+  // Animated inventory progress
   let invDone = 0;
   let invFailed = 0;
-  const total = workers.length;
+  const total = activeWorkers.length;
+  const invBarW = Math.min(40, (process.stdout.columns || 80) - 30);
+
+  const drawInvProgress = () => {
+    const pct = total > 0 ? invDone / total : 0;
+    const filled = Math.round(pct * invBarW);
+    const empty = invBarW - filled;
+    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+    const bar = rgb(34, 211, 238) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(empty) + c.reset;
+    process.stdout.write(`\r  ${rgb(34, 211, 238)}${spin}${c.reset}  ${dim}Inventory...${c.reset}    ${bar}  ${c.bold}${rgb(52, 211, 153)}${invDone}${c.reset}${dim}/${c.reset}${c.white}${total}${c.reset}  ${dim}${Math.round(pct * 100)}%${c.reset}  `);
+  };
 
-  await Promise.all(workers.map(async (w, i) => {
+  const invProgressInterval = setInterval(drawInvProgress, 80);
+
+  await Promise.all(activeWorkers.map(async (w, i) => {
     try {
       const invRes = await w.checkInventory({
         force: true,
@@ -2656,19 +2854,23 @@ async function start(apiKey, apiUrl) {
     }
   }));
 
-  // Final summary
-  log('success', `Inventory: ${invDone}/${total} done${invFailed > 0 ? `, ${c.yellow}${invFailed} failed${c.reset}` : ''}`);
+  clearInterval(invProgressInterval);
+  process.stdout.write(`\r${c.clearLine}`);
 
+  // Final summary
   if (invFailed > 0) {
-    log('error', `${c.red}Inventory phase incomplete: ${invDone}/${workers.length} complete, ${invFailed} failed/incomplete. Not starting grind loops.${c.reset}`);
+    console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  ${c.bold}Inventory incomplete${c.reset}  ${rgb(52, 211, 153)}${invDone}${c.reset}${dim}/${c.reset}${c.white}${total}${c.reset} done, ${rgb(239, 68, 68)}${invFailed} failed${c.reset}`);
+    log('error', `${c.red}Not starting grind loops — ${invFailed} accounts failed inventory.${c.reset}`);
     return;
   }
 
-  const invSummaryColor = invFailed > 0 ? c.yellow : c.green;
-  log('success', `${c.dim}Inventory phase complete: ${invSummaryColor}${invDone}/${workers.length}${c.reset}${c.dim} done${invFailed > 0 ? `, ${c.yellow}${invFailed} failed${c.reset}${c.dim}` : ''}. Starting grind loops...${c.reset}`);
+  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Inventory complete${c.reset}  ${rgb(52, 211, 153)}${invDone}/${total}${c.reset} ${dim}all clear${c.reset}`);
+  console.log('');
+  console.log(`  ${rgb(139, 92, 246)}${c.bold}>>>${c.reset}  ${gradientText('Starting grind loops...', [139, 92, 246], [52, 211, 153])}`);
+  console.log('');
 
-  // Phase 3: Start all grind loops
-  for (const w of workers) {
+  // Phase 3: Start all grind loops (only for valid workers)
+  for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();
   }
 
@@ -2682,6 +2884,13 @@ async function start(apiKey, apiUrl) {
   process.stdout.write(c.hide);
   dashboardLines = 0;
 
+  // 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();
 
@@ -2830,10 +3039,17 @@ function setupKeyboardShortcuts() {
     process.stdin.resume();
     process.stdin.setEncoding('utf8');
 
-    // Modern styled keyboard shortcuts with box drawing
-    console.log(`\n  ${rgb(139, 92, 246)}╭${c.reset}${c.dim}${'─'.repeat(50)}${c.reset}${rgb(139, 92, 246)}╮${c.reset}`);
-    console.log(`  ${rgb(139, 92, 246)}│${c.reset}  ${c.bold}Shortcuts:${c.reset}  ${c.dim}p${c.reset}=pause  ${c.dim}r${c.reset}=resume  ${c.dim}s${c.reset}=status  ${c.dim}q${c.reset}=quit  ${c.dim}?${c.reset}=help  ${rgb(139, 92, 246)}│${c.reset}`);
-    console.log(`  ${rgb(139, 92, 246)}╰${c.reset}${c.dim}${'─'.repeat(50)}${c.reset}${rgb(139, 92, 246)}╯${c.reset}`);
+    // 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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dankgrinder",
-  "version": "6.1.0",
+  "version": "6.5.0",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"