dankgrinder 7.79.0 → 7.81.0

package/lib/grinder.js

@@ -2761,11 +2761,6 @@ async function start(apiKey, apiUrl, opts = {}) {
   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 || '';
 
@@ -2773,15 +2768,14 @@ async function start(apiKey, apiUrl, opts = {}) {
   let hasZlib = false;
   try { require('zlib-sync'); hasZlib = true; } catch {}
 
-  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}`
-  );
-  log('info', `${c.dim}Fetching accounts...${c.reset}`);
+  // Init terminal FIRST — captures all subsequent console.log output
+  terminal.setVersion(PKG_VERSION);
+  terminal.init({ workers: [], startTime });
+
+  if (CLOUD_MODE) {
+    console.log(`${rgb(139, 92, 246)}🌥️  Starting in CLOUD MODE — grinding all cloud-enabled accounts${c.reset}`);
+  }
+  terminal.startPhase('Fetching accounts...');
 
   const fetchOpts = CLOUD_MODE ? { cloud: true } : {};
   let data = await fetchConfig(4, 2000, fetchOpts);
@@ -2792,9 +2786,11 @@ 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) {
@@ -2839,10 +2835,6 @@ 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);
@@ -2887,16 +2879,7 @@ async function start(apiKey, apiUrl, opts = {}) {
         }
       }
     });
-    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('');
 
   // ── Terminal renderer init ─────────────────────────────────────
   terminal.setVersion(PKG_VERSION);

package/lib/terminal.js

@@ -1,154 +1,161 @@
 /**
- * terminal.js — Modern animated terminal renderer for DankGrinder
+ * terminal.js — Polished animated terminal renderer for DankGrinder
  *
- * Key design:
- * - stdout capture during startup → buffer prevents bleed-through
- * - When setActive() called: clear screen + replay buffer, then normal
- * - After activation: all w.log() routed through flashEvent()
- * - Virtual window: single-line per account (scales to 10k+)
- * - 4 FPS render loop with dirty-row tracking (no flicker)
- * - Graceful degradation: falls back to plain console.log if not TTY
+ * Features:
+ * - Animated startup phases with multi-element spinners
+ * - Live leaderboard with coin-based rank medals (🥇🥈🥉)
+ * - Accounts stay in fixed positions, medals update live
+ * - Pulsing status indicators for active accounts
+ * - Dark theme: deep purple borders, vibrant accent colors
+ * - 4 FPS render loop, dirty-row only, no flicker
+ * - Graceful fallback: plain console.log if not a TTY
  */
 
+'use strict';
+
 const READY = (() => {
-  try {
-    return process.stdout.isTTY && !process.env.NO_TERM;
-  } catch (_) { return false; }
+  try { return !!process.stdout.isTTY && !process.env.NO_TERM; } catch (_) { return false; }
 })();
 
-// ── ANSI Helpers ────────────────────────────────────────────────────────────
+// ── ANSI helpers ────────────────────────────────────────────────────────────
 
 const A = {
   reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  italic: '\x1b[3m',
-
-  black: '\x1b[30m', red: '\x1b[31m', green: '\x1b[32m',
-  yellow: '\x1b[33m', blue: '\x1b[34m', magenta: '\x1b[35m',
-  cyan: '\x1b[36m', white: '\x1b[37m',
-
-  bgBlack: '\x1b[40m', bgRed: '\x1b[41m', bgGreen: '\x1b[42m',
-  bgYellow: '\x1b[43m', bgBlue: '\x1b[44m', bgMagenta: '\x1b[45m',
-  bgCyan: '\x1b[46m', bgWhite: '\x1b[47m',
-
-  // True-color RGB
+  bold:  '\x1b[1m',
+  dim:   '\x1b[2m',
   rgb: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
-
-  // Cursor
-  save: '\x1b7', restore: '\x1b8',
-  hide: '\x1b[?25l', show: '\x1b[?25h',
-  up: (n = 1) => `\x1b[${n}A`,
-  down: (n = 1) => `\x1b[${n}B`,
-  clear: '\x1b[2J',
-  clearLine: '\x1b[2K',
-  home: '\x1b[H',
-
-  // Erase in display (clears scrollback too)
   eraseAll: '\x1b[3J\x1b[2J\x1b[H',
-
-  // 256-color shortcuts
-  purple: '\x1b[38;5;141m',
-  pink: '\x1b[38;5;205m',
-  orange: '\x1b[38;5;214m',
-  teal: '\x1b[38;5;44m',
-  lime: '\x1b[38;5;82m',
-  crimson: '\x1b[38;5;196m',
-  slate: '\x1b[38;5;245m',
-  gold: '\x1b[38;5;220m',
-  emerald: '\x1b[38;5;48m',
+  clearLine: '\x1b[2K',
+  save: '\x1b7',
+  restore: '\x1b8',
+  hide: '\x1b[?25l',
+  show: '\x1b[?25h',
 };
 
-// ── Color scheme ────────────────────────────────────────────────────────────
+// ── Palette ─────────────────────────────────────────────────────────────────
 
 const C = {
-  header: A.purple,
-  headerDim: A.rgb(100, 70, 180),
-  border: A.rgb(55, 45, 85),
-  borderDim: A.rgb(35, 30, 55),
-
-  name: A.rgb(220, 215, 255),
-  nameDim: A.slate,
-  coins: A.gold,
-  level: A.cyan,
-  lifesavers: A.pink,
-  lifesaversLow: A.crimson,
-  lifesaversMid: A.orange,
-
-  statusActive: A.emerald,
-  statusPaused: A.crimson,
-  statusWarning: A.orange,
-  statusOffline: A.slate,
-  statusConnecting: A.yellow,
-
-  cmdSuccess: A.emerald,
-  cmdError: A.crimson,
-  cmdEvent: A.purple,
-  cmdWarn: A.orange,
-  cmdInfo: A.slate,
-
-  statLabel: A.slate,
-  statValue: A.white,
-
-  // Box styles
-  topLeft: '╭', topRight: '╮',
-  botLeft: '╰', botRight: '╯',
-  h: '─', v: '│',
+  border:    A.rgb(55, 42, 95),
+  borderDim: A.rgb(38, 28, 65),
+  borderMid: A.rgb(80, 65, 130),
+
+  text:      A.rgb(205, 200, 230),
+  textDim:   A.rgb(90, 85, 115),
+  textFaint: A.rgb(55, 50, 75),
+
+  purple:    A.rgb(167, 139, 250),  // vivid lavender
+  cyan:      A.rgb(34, 211, 238),    // vivid cyan
+  gold:      A.rgb(251, 191, 36),    // vivid gold
+  green:     A.rgb(52, 211, 153),   // vivid green
+  pink:      A.rgb(244, 114, 182),   // vivid pink
+  orange:    A.rgb(251, 146, 60),    // vivid orange
+  red:       A.rgb(248, 113, 113),   // vivid red
+  blue:      A.rgb(96, 165, 250),    // vivid blue
+
+  // Rank medal colors
+  rank1: A.rgb(255, 215, 0),
+  rank2: A.rgb(192, 192, 192),
+  rank3: A.rgb(205, 127, 50),
+
+  // Per-account accent colors (cycles)
+  ACCT: [
+    A.rgb(167, 139, 250),  // lavender
+    A.rgb(103, 232, 249),  // sky cyan
+    A.rgb(253, 186, 116),  // peach
+    A.rgb(167, 243, 208),  // mint
+    A.rgb(252, 165, 201),  // rose
+    A.rgb(165, 243, 252),  // light cyan
+    A.rgb(196, 181, 253),  // light purple
+    A.rgb(147, 226, 226),  // light teal
+  ],
 };
 
+// ── Box-drawing ─────────────────────────────────────────────────────────────
+
+const TL='╭', TR='╮', BL='╰', BR='╯', H='─', V='│';
+
 // ── Spinner frames ──────────────────────────────────────────────────────────
 
-const SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠿'];
+// Dot spinner for phase labels
+const SPIN_DOTS = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠿'];
 
-// ── stdout capture during startup ─────────────────────────────────────────
+// Block spinner for progress
+const SPIN_BLOCK = ['▏','▎','�','▌','▋','▊','▉','▊'];
+
+// Pulse frames for active indicators
+const PULSE = ['●', '◉', '◎', '○'];
+
+// ── stdout capture ──────────────────────────────────────────────────────────
 
 let _origWrite = null;
 let _captureActive = false;
 let _captureBuf = [];
 
-function _captureWrite(chunk) {
-  if (_captureActive) {
-    _captureBuf.push(String(chunk));
-    return;
-  }
+function _capWrite(chunk) {
+  if (_captureActive) { _captureBuf.push(String(chunk)); return; }
   return _origWrite.call(process.stdout, chunk);
 }
 
-// ── Terminal Renderer ────────────────────────────────────────────────────────
+// ── ANSI utils ─────────────────────────────────────────────────────────────
+
+function ansiLen(s) {
+  let len = 0, i = 0;
+  const str = String(s);
+  while (i < str.length) {
+    if (str.charCodeAt(i) === 0x1b && str[i+1] === '[') {
+      let j = i+2;
+      while (j < str.length && str[j] !== 'm') j++;
+      i = j + 1;
+    } else { len++; i++; }
+  }
+  return len;
+}
+
+function rpad(s, w) { return s + ' '.repeat(Math.max(0, w - ansiLen(s))); }
+
+// ── Rank helpers ───────────────────────────────────────────────────────────
+
+const MEDALS = ['🥇','🥈','🥉'];
+
+function coinRank(wk, workers) {
+  const c = wk.stats?.coins || 0;
+  let r = 1;
+  for (const w of workers) {
+    if ((w.stats?.coins || 0) > c) r++;
+  }
+  return r;
+}
+
+// ── Terminal ───────────────────────────────────────────────────────────────
 
 class Terminal {
   constructor() {
-    this.workers = [];
-    this.events = [];
-    this.MAX_EVENTS = 4;
+    this.workers    = [];
+    this.events     = [];
+    this.MAX_EVENTS = 3;
 
-    this.phaseName = '';
+    this.phase      = '';
     this.phaseFrame = 0;
-    this.phaseTimer = null;
+    this.phaseTimer  = null;
+    this.phaseDone   = 0;
+    this.phaseTotal  = 0;
 
     this.dirtyWorkers = new Set();
-    this.dirtyEvents = false;
-    this.dirtyStats = true;
+    this.dirtyStats   = true;
     this._renderTimer = null;
-    this._startTime = 0;
+    this._startTime   = 0;
+    this._active      = false;
+    this._shutdown    = false;
+    this._origLog    = null;
 
+    this._w = 110;
+    this._h = 35;
     this.windowStart = 0;
-    this.windowSize = 8;
-    this._followIdx = -1;
+    this.windowSize  = 8;
 
-    this._lineCount = 0;
-    this._active = false;
-    this._shutdown = false;
-
-    this._w = 80;
-    this._h = 24;
-    this._resizeTimer = null;
-
-    // ── Startup capture ──
-    this._capturing = false;
-    this._origLog = null;
-    this._phaseProgressDone = 0;
-    this._phaseProgressTotal = 0;
+    // Pulse animation state
+    this._pulseFrame = 0;
+    this._pulseTimer = null;
   }
 
   // ── Public API ──────────────────────────────────────────────────────────
@@ -159,26 +166,21 @@ class Terminal {
     this._updateSize();
 
     if (READY) {
-      // Override stdout.write to capture everything during startup
       _origWrite = process.stdout.write.bind(process.stdout);
-      process.stdout.write = _captureWrite;
-      this._capturing = true;
+      process.stdout.write = _capWrite;
       _captureActive = true;
       _captureBuf = [];
-
-      // Also override console.log temporarily
       this._origLog = console.log;
       console.log = (...args) => {
+        const s = args.join(' ');
         if (this._active) {
-          // After activation, route to flashEvent
-          const msg = args.join(' ').replace(/\x1b\[[0-9;]*m/g, '').substring(0, 120);
-          if (msg.trim()) this.flashEvent('info', msg);
+          const clean = s.replace(/\x1b\[[0-9;]*m/g, '').substring(0, 100);
+          if (clean.trim()) this.flashEvent('info', clean);
         } else {
-          _captureWrite(args.join(' ') + '\n');
+          _capWrite(s + '\n');
         }
       };
-
-      process.stdout.on('resize', this._onResize.bind(this));
+      process.stdout.on('resize', () => this._onResize());
       this._drawStartupScreen();
     }
   }
@@ -186,63 +188,52 @@ class Terminal {
   setVersion(v) { this._version = v; }
 
   startPhase(name) {
-    this.phaseName = name;
+    this.phase = name;
+    this.phaseDone = 0;
+    this.phaseTotal = 0;
     this.phaseFrame = 0;
-    this._phaseProgressDone = 0;
-    this._phaseProgressTotal = 0;
-
-    if (!READY) {
-      console.log(`  ⟳ ${name}...`);
-      return;
-    }
+    if (!READY) return;
     if (this.phaseTimer) clearInterval(this.phaseTimer);
     this.phaseTimer = setInterval(() => {
-      this.phaseFrame = (this.phaseFrame + 1) % SPIN.length;
-      this._redrawPhaseSpinner();
-    }, 120);
-    this._redrawPhaseSpinner();
+      this.phaseFrame = (this.phaseFrame + 1) % SPIN_DOTS.length;
+      this._renderPhase();
+    }, 80);
+    this._renderPhase();
   }
 
   updateProgress(done, total) {
-    this._phaseProgressDone = done;
-    this._phaseProgressTotal = total;
+    this.phaseDone = done;
+    this.phaseTotal = total;
     if (!READY) return;
-    this._redrawProgressBar();
+    this._renderProgress();
   }
 
   endPhase(name, ok = true) {
     if (this.phaseTimer) { clearInterval(this.phaseTimer); this.phaseTimer = null; }
-    this.phaseName = '';
-    this._phaseProgressDone = 0;
-    this._phaseProgressTotal = 0;
-
     if (!READY) {
-      const icon = ok ? `✓ ${name}` : `✗ ${name}`;
-      console.log(`  ${icon}`);
+      const icon = ok ? `${C.green}✓${A.reset}` : `${C.red}✗${A.reset}`;
+      console.log(`  ${icon}  ${name}`);
       return;
     }
-    const icon = ok ? `${C.header}✓${A.reset}` : `${A.crimson}✗${A.reset}`;
-    const line = `  ${icon}  ${name}`;
+    const icon = ok ? `${C.green}✓${A.reset}` : `${C.red}✗${A.reset}`;
+    const label = `${icon}  ${name}`;
+    // Write to rows 5 (phase) and 7 (progress) with result
     const w = this._w;
-
-    // Clear spinner + progress rows, show result
+    const V = C.border;
+    const line = rpad(`  ${label}`, w - 3);
     this._write(
-      A.save +
-      this._cursor(6, 1) + A.clearLine +
-      this._cursor(7, 1) + A.clearLine +
-      this._cursor(8, 1) + A.clearLine +
-      this._cursor(9, 1) + A.clearLine +
-      this._cursor(10, 1) + A.clearLine +
-      this._cursor(11, 1) + A.clearLine +
-      this._cursor(12, 1) + A.clearLine +
-      `${this._rpad(line, w)}` +
+      `${A.save}` +
+      this._at(5, 1) + A.clearLine +
+      `${V} ${line} ${V}${A.reset}` +
+      this._at(7, 1) + A.clearLine +
+      `${V} ${rpad('', w - 3)} ${V}${A.reset}` +
       A.restore
     );
   }
 
   flashEvent(type, msg) {
     const now = new Date();
-    const ts = `${A.dim}${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}${A.reset}`;
+    const ts = `${C.textDim}${String(now.getMinutes()).padStart(2,'0')}:${String(now.getSeconds()).padStart(2,'0')}${A.reset}`;
     this.events.unshift({ ts, type, msg, id: Date.now() });
     if (this.events.length > this.MAX_EVENTS) this.events.pop();
     this.dirtyEvents = true;
@@ -255,7 +246,8 @@ class Terminal {
   }
 
   markWorkerDirty(idx) {
-    this.dirtyWorkers.add(idx);
+    this.dirtyWorkers = new Set(this.workers.map((_, i) => i));
+    this.dirtyStats = true;
   }
 
   setActive() {
@@ -263,464 +255,416 @@ class Terminal {
     this._active = true;
 
     if (READY) {
-      // ── Stop capturing, fully clear screen, draw live view ──
       _captureActive = false;
-      this._capturing = false;
-
-      // Restore stdout.write first
-      if (_origWrite) {
-        process.stdout.write = _origWrite;
-        _origWrite = null;
-      }
-      if (this._origLog) {
-        console.log = this._origLog;
-        this._origLog = null;
-      }
-
-      // Discard all buffered startup output — we only want the live view
+      if (_origWrite) { process.stdout.write = _origWrite; _origWrite = null; }
+      if (this._origLog) { console.log = this._origLog; this._origLog = null; }
       _captureBuf = [];
 
-      // Full screen clear + scrollback clear
-      this._write(A.eraseAll);
-
-      // Draw live view
+      this._write(A.eraseAll + A.hide);
       this._drawLiveView();
-
-      // Reset dirty flags so we don't redraw header every frame
       this.dirtyWorkers.clear();
       this.dirtyEvents = false;
       this.dirtyStats = false;
 
+      // Start pulse animation for active status indicators
+      if (this._pulseTimer) clearInterval(this._pulseTimer);
+      this._pulseTimer = setInterval(() => {
+        this._pulseFrame = (this._pulseFrame + 1) % PULSE.length;
+        this.dirtyStats = true; // pulse affects account rows
+      }, 400);
+
       this._startRenderLoop();
     } else {
-      // Non-TTY: restore console.log
-      if (this._origLog) {
-        console.log = this._origLog;
-        this._origLog = null;
-      }
-    }
-  }
-
-  scrollBy(delta) {
-    if (!READY || this._shutdown) return;
-    const max = Math.max(0, this.workers.length - this.windowSize);
-    this.windowStart = Math.max(0, Math.min(max, this.windowStart + delta));
-    this._followIdx = -1;
-    this.dirtyWorkers = new Set();
-    for (let i = this.windowStart; i < this.windowStart + this.windowSize; i++) {
-      if (i < this.workers.length) this.dirtyWorkers.add(i);
+      if (this._origLog) { console.log = this._origLog; this._origLog = null; }
     }
   }
 
   shutdown(summary = {}) {
     this._shutdown = true;
     if (this._renderTimer) { clearInterval(this._renderTimer); this._renderTimer = null; }
-    if (this._phaseTimer) { clearInterval(this._phaseTimer); this._phaseTimer = null; }
-
-    // Restore stdout state
-    if (READY && _origWrite) {
-      process.stdout.write = _origWrite;
-      _origWrite = null;
-    }
-    if (this._origLog) {
-      console.log = this._origLog;
-      this._origLog = null;
-    }
+    if (this._pulseTimer) { clearInterval(this._pulseTimer); this._pulseTimer = null; }
+    if (this.phaseTimer) { clearInterval(this.phaseTimer); this.phaseTimer = null; }
 
+    if (READY && _origWrite) { process.stdout.write = _origWrite; _origWrite = null; }
+    if (this._origLog) { console.log = this._origLog; this._origLog = null; }
     this._write(A.show);
 
-    const w = this._w;
     const { totalCoins = 0, totalCmds = 0, totalSuccess = 0,
             workers = [], uptime = 0, memMB = 0 } = summary;
 
-    const b = C.border;
-    const h = C.header;
-    const g = C.statValue;
-    const dim = A.dim;
-    const r = A.reset;
-
-    let out = '';
-    out += A.eraseAll + A.home + A.save;
+    const w = this._w;
+    let out = A.eraseAll;
 
-    // Box top
-    out += `${this._at(1, 1)}${b}${C.topLeft}${'─'.repeat(w - 2)}${C.topRight}${r}`;
-    out += `${this._at(2, 1)}${b}${C.v} ${h}${A.bold} ⬡  DANKGRINDER — Session Summary ${r}${' '.repeat(Math.max(0, w - 40))}${C.v}${r}`;
-    out += `${this._at(3, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`;
+    // Top bar
+    out += this._boxTop();
+    out += this._statsBar();
+    out += this._sep();
 
     // Column headers
-    const hdr = [
-      `${h}#${r}`, `${h}ACCOUNT${r}`, `${h}COINS${r}`,
-      `${h}LV${r}`, `${h}♥${r}`, `${h}CMDS${r}`,
-      `${h}OK%${r}`, `${h}STATUS${r}`,
-    ].join(`  `);
-    out += `${this._at(4, 1)}${b} ${this._rpad(hdr, w - 4)} ${C.v}${r}`;
-    out += `${this._at(5, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`;
-
-    // Per-account rows
-    let row = 6;
-    for (let i = 0; i < workers.length && row < this._h - 3; i++) {
-      const wk = workers[i];
-      const rate = wk.stats?.commands > 0
-        ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
-        : '0%';
-      const ls = wk._lifesavers ?? '?';
-      const lsColor = ls === 0 ? C.lifesaversLow : ls <= 2 ? C.lifesaversMid : C.lifesavers;
-      const statusIcon = (!wk.running || wk._tokenInvalid) ? '⚫ offline'
-        : wk.paused || wk.dashboardPaused ? '🔴 paused'
-        : '🟢 active';
-
-      const line = [
-        `${g}${String(i + 1).padEnd(2)}${r}`,
-        `${C.name}${A.bold}${(wk.username || '?').substring(0, 18).padEnd(19)}${r}`,
-        `${C.coins}⏣${(wk.stats?.coins || 0).toLocaleString().padStart(8)}${r}`,
-        `${C.level}Lv.${wk._level ?? '?'}${r}`,
-        `${lsColor}♥${String(ls).padStart(2)}${r}`,
-        `${g}${String(wk.stats?.commands || 0).padStart(4)}cmds${r}`,
-        `${g}${rate.padStart(4)}${r}`,
-        `${g}${statusIcon}${r}`,
-      ].join('  ');
-      out += `${this._at(row++, 1)}${b} ${this._rpad(line, w - 4)} ${C.v}${r}`;
+    out += `${this._row(4, this._colHdr())}`;
+    out += this._sep();
+
+    // Account rows
+    let row = 5;
+    for (let i = 0; i < workers.length && row < this._h - 4; i++) {
+      out += `${this._row(row++, this._accountLine(workers[i], i, workers))}`;
     }
 
-    row++; // blank
-    out += `${this._at(row++, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`;
-
-    // Totals row
-    const totalRate = totalCmds > 0 ? `${((totalSuccess / totalCmds) * 100).toFixed(0)}%` : '0%';
-    const uptimeStr = this._fmtUptime(uptime);
-    const totalLine = [
-      `${h}💰 TOTAL:${r}`,
-      `${C.coins}${A.bold}⏣ ${totalCoins.toLocaleString()}${r}`,
-      `${dim}${totalCmds} cmds${r}`,
-      `${dim}${totalRate} OK${r}`,
-      `${dim}${uptimeStr}${r}`,
-      `${dim}${memMB}MB RAM${r}`,
-    ].join('   ');
-    out += `${this._at(row++, 1)}${b} ${this._rpad(totalLine, w - 4)} ${C.v}${r}`;
-    out += `${this._at(row, 1)}${b}${C.botLeft}${'─'.repeat(w - 2)}${C.botRight}${r}`;
-    out += A.restore + A.show;
+    out += this._sep();
+    row++;
+    out += `${this._row(row++, this._totalLine(totalCoins, totalCmds, totalSuccess, uptime, memMB))}`;
+    out += this._boxBot();
 
     this._write(out);
   }
 
-  // ── Internal ────────────────────────────────────────────────────────────
+  // ── Startup Screen ──────────────────────────────────────────────────────
 
-  _updateSize() {
-    try {
-      this._w = process.stdout.columns || 80;
-      this._h = process.stdout.rows || 24;
-      this.windowSize = Math.max(3, this._h - 11);
-    } catch (_) {
-      this._w = 80; this._h = 24; this.windowSize = 8;
-    }
-  }
+  _drawStartupScreen() {
+    const w = this._w;
+    let out = A.eraseAll;
 
-  _onResize() {
-    if (this._resizeTimer) clearTimeout(this._resizeTimer);
-    this._resizeTimer = setTimeout(() => {
-      this._updateSize();
-      if (this._active) {
-        this._write(A.eraseAll);
-        this._drawLiveView();
-      }
-    }, 100);
-  }
+    // Top border
+    out += `${this._at(1,1)}${C.border}${TL}${'─'.repeat(w-2)}${TR}${A.reset}\n`;
 
-  _ansiLen(s) {
-    let len = 0, i = 0;
-    const str = String(s);
-    while (i < str.length) {
-      if (str.charCodeAt(i) === 0x1b && str[i + 1] === '[') {
-        let j = i + 2;
-        while (j < str.length && str[j] !== 'm') j++;
-        i = j + 1;
-      } else { len++; i++; }
-    }
-    return len;
-  }
+    // Version title
+    const title = ` ⬡  DANKGRINDER v${this._version || '?'}  `;
+    out += `${this._at(2,1)}${C.border}${V} ${C.purple}${A.bold}${title}${rpad('', w - ansiLen(title) - 4)}${V}${A.reset}\n`;
 
-  _rpad(s, width) {
-    return s + ' '.repeat(Math.max(0, width - this._ansiLen(s)));
-  }
+    // Subtitle with version info
+    const sub = `${C.textDim}24 commands  ·  Auto-Recovery  ·  Loss Limiter${A.reset}`;
+    out += `${this._at(3,1)}${C.border}${V} ${sub}${rpad('', w - ansiLen(sub) - 4)}${V}${A.reset}\n`;
 
-  _cursor(row) { return `\x1b[${row};1H`; }
-  _at(row, col) { return `\x1b[${row};${col}H`; }
-  _write(str) { if (str) process.stdout.write(str); }
+    out += `${this._at(4,1)}${C.border}${V}${'─'.repeat(w-2)}${V}${A.reset}\n`;
 
-  _fmtUptime(ms) {
-    if (!ms) return '0s';
-    const s = Math.floor(ms / 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`;
-    return `${Math.floor(h / 24)}d ${h % 24}h`;
-  }
+    // Spinner + phase label (row 5)
+    out += `${this._at(5,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-  _fmtCoins(n) {
-    if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-    if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
-    return String(n);
-  }
+    // Progress bar (row 7)
+    out += `${this._at(7,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-  _buildAccountRow(wk, idx) {
-    const w = this._w;
-    const ls = wk._lifesavers ?? '?';
-    const lsColor = ls === 0 ? C.lifesaversLow : ls <= 2 ? C.lifesaversMid : C.lifesavers;
-    const rate = wk.stats?.commands > 0
-      ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
-      : '0%';
+    // Checkmarks / status area (row 9)
+    out += `${this._at(9,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-    let statusDot, statusText, rowBg;
-    if (!wk.running || wk._tokenInvalid) {
-      statusDot = '⚫'; statusText = 'offline';
-    } else if (wk.paused || wk.dashboardPaused) {
-      statusDot = '🔴'; statusText = 'paused';
-    } else if (wk.lastStatus?.includes('claim') || wk.lastStatus?.includes('daily')) {
-      statusDot = '🟡'; statusText = 'claiming';
-    } else {
-      statusDot = '🟢'; statusText = 'grinding';
-    }
+    // Spacer
+    out += `${this._at(11,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-    const line = [
-      `${C.header}${idx + 1}.${A.reset}`,
-      `${C.name}${A.bold}${(wk.username || '?').substring(0, 18).padEnd(19)}${A.reset}`,
-      `${C.coins}⏣${this._fmtCoins(wk.stats?.coins || 0).padStart(7)}${A.reset}`,
-      `${C.level}Lv.${String(wk._level ?? '?').padStart(3)}${A.reset}`,
-      `${lsColor}♥${String(ls).padStart(2)}${A.reset}`,
-      `${C.statValue}${String(wk.stats?.commands || 0).padStart(4)}cmds${A.reset}`,
-      `${C.statValue}${rate.padStart(5)}${A.reset}`,
-      `${statusDot} ${statusText}`.padEnd(14),
-      `${A.dim}${(wk.lastStatus || '').substring(0, 22).padEnd(22)}${A.reset}`,
-    ].join('  ');
+    // Bottom border
+    out += `${this._at(12,1)}${C.border}${BL}${'─'.repeat(w-2)}${BR}${A.reset}\n`;
 
-    return this._rpad(line, w);
-  }
-
-  _drawStartupScreen() {
-    const w = this._w;
-    const b = C.border;
-    const h = C.header;
-    const dim = A.dim;
-    const r = A.reset;
-
-    let out = '';
-    out += A.eraseAll + A.home;
-    out += `${this._at(1, 1)}${b}${C.topLeft}${'─'.repeat(w - 2)}${C.topRight}${r}`;
-    out += `${this._at(2, 1)}${b} ${h}${A.bold} ⬡  DANKGRINDER v${this._version || '?'} ${r}${'─'.repeat(Math.max(0, w - 28 - (this._version || '').length))}${r}`;
-    out += `${this._at(3, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`;
-    // Status bar placeholder
-    out += `${this._at(4, 1)}${b}${' '.repeat(w - 2)}${r}`;
-    out += `${this._at(5, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`;
-    // Spinner area
-    out += `${this._at(7, 1)}${b}${' '.repeat(w - 2)}${r}`;
-    out += `${this._at(8, 1)}${b}${' '.repeat(w - 2)}${r}`;
-    out += `${this._at(9, 1)}${b}${' '.repeat(w - 2)}${r}`;
-    out += `${this._at(10, 1)}${b}${' '.repeat(w - 2)}${r}`;
-    out += `${this._at(11, 1)}${b}${' '.repeat(w - 2)}${r}`;
-    out += `${this._at(12, 1)}${b}${' '.repeat(w - 2)}${r}`;
     // Footer
-    out += `${this._at(14, 1)}${b}${C.botLeft}${'─'.repeat(w - 2)}${C.botRight}${r}`;
-    out += `${this._at(15, 1)}${b} ${dim}Starting up...${r}${' '.repeat(Math.max(0, w - 18))}${r}`;
+    const hint = `${C.textDim}Initializing...${A.reset}`;
+    out += `${this._at(13,1)}${C.border}${V} ${hint}${rpad('', w - ansiLen(hint) - 4)}${V}${A.reset}\n`;
 
     this._write(out);
   }
 
-  _redrawPhaseSpinner() {
-    if (!READY || !this._phaseName) return;
-    const frame = SPIN[this.phaseFrame];
-    const line = `  ${frame}  ${this.phaseName}...`;
+  _renderPhase() {
+    if (!READY || !this.phase) return;
     const w = this._w;
-    const b = C.border;
-    const r = A.reset;
+    const V = C.border;
+    const dot = SPIN_DOTS[this.phaseFrame];
+    const label = `  ${dot}  ${this.phase}  `;
+    const line = rpad(label, w - 3);
     this._write(
-      A.save +
-      this._cursor(8, 1) + A.clearLine +
-      `${b} ${line}${' '.repeat(Math.max(0, w - this._ansiLen(line) - 3))}${r}` +
+      `${A.save}` +
+      `${this._at(5,1)}${A.clearLine}` +
+      `${V} ${line} ${V}${A.reset}` +
       A.restore
     );
   }
 
-  _redrawProgressBar() {
-    if (!READY || !this._phaseName) return;
-    const { done, total } = { done: this._phaseProgressDone, total: this._phaseProgressTotal };
+  _renderProgress() {
+    if (!READY) return;
     const w = this._w;
-    const h = C.header;
-    const dim = A.dim;
-    const r = A.reset;
-
-    const barW = Math.max(10, w - 35);
+    const V = C.border;
+    const { done, total } = { done: this.phaseDone, total: this.phaseTotal };
+    const barW = Math.max(16, w - 40);
     const filled = total > 0 ? Math.round((done / total) * barW) : 0;
-    const bar = `${h}${'█'.repeat(filled)}${dim}${'░'.repeat(barW - filled)}${r}`;
-    const label = ` ${done}/${total} `;
-    const line = bar + label;
+    const block = SPIN_BLOCK[this.phaseFrame % SPIN_BLOCK.length];
+
+    // Filled bar with gradient: gold on left, purple on right
+    const filledPart = filled > 0
+      ? `${C.gold}${'█'.repeat(Math.max(1, filled - 1))}${C.green}${block}${A.reset}`
+      : '';
+    const emptyPart = barW - filled > 0
+      ? `${C.borderDim}${'░'.repeat(Math.max(0, barW - filled))}${A.reset}`
+      : '';
+
+    const pct = total > 0 ? `${Math.round((done / total) * 100)}%` : '';
+    const label = ` ${pct} `;
+    const bar = `${filledPart}${emptyPart}${C.textDim}${label}${A.reset}`;
+    const line = rpad(`  ${bar}`, w - 3);
+
     this._write(
-      A.save +
-      this._cursor(9, 1) + A.clearLine +
-      `${C.border} ${line}${' '.repeat(Math.max(0, w - this._ansiLen(line) - 3))}${r}` +
+      `${A.save}` +
+      `${this._at(7,1)}${A.clearLine}` +
+      `${V} ${line} ${V}${A.reset}` +
       A.restore
     );
   }
 
+  // ── Live View ─────────────────────────────────────────────────────────
+
   _drawLiveView() {
-    this._drawHeader();
-    this._drawAccounts();
-    this._drawEvents();
-    this._drawFooter();
+    let out = A.eraseAll;
+    out += this._boxTop();
+    out += this._statsBar();
+    out += this._sep();
+    out += `${this._row(4, this._colHdr())}`;
+    out += this._sep();
+    this._topRow = 5;
+    out += this._accountRows();
+    const sepRow = this._topRow + Math.min(this.windowSize, this.workers.length);
+    out += `${this._at(sepRow,1)}${C.border}${V}${'─'.repeat(this._w-2)}${V}${A.reset}\n`;
+    this._eventRow = sepRow + 1;
+    out += this._eventFeed();
+    out += this._boxBot();
+    this._write(out);
   }
 
-  _drawHeader() {
+  _boxTop() {
     const w = this._w;
-    const b = C.border;
-    const h = C.header;
-    const g = C.statValue;
-    const dim = A.dim;
-    const r = A.reset;
+    let o = '';
+    o += `${this._at(1,1)}${C.border}${TL}${'─'.repeat(w-2)}${TR}${A.reset}\n`;
+    const title = ` ⬡  DANKGRINDER v${this._version || '?'} `;
+    o += `${this._at(2,1)}${C.border}${V} ${C.purple}${A.bold}${title}${rpad('', w - ansiLen(title) - 4)}${V}${A.reset}\n`;
+    o += `${this._at(3,1)}${C.border}${V}${'─'.repeat(w-2)}${V}${A.reset}\n`;
+    return o;
+  }
 
-    // Title bar
-    const titleText = ` ⬡  DANKGRINDER v${this._version || '?'} `;
-    const titlePad = Math.max(0, w - 2 - this._ansiLen(titleText));
-    this._write(`${this._at(1, 1)}${b}${C.topLeft}${'─'.repeat(w - 2)}${C.topRight}${r}`);
-    this._write(`${this._at(2, 1)}${b} ${h}${A.bold}${titleText}${r}${' '.repeat(titlePad)} ${C.v}${r}`);
-    this._write(`${this._at(3, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`);
+  _boxBot() {
+    const w = this._w;
+    const hint = `${C.textDim}↑↓ scroll   Ctrl+C quit${A.reset}`;
+    let o = '';
+    o += `${this._at(this._footerRow,1)}${C.border}${BL}${'─'.repeat(w-2)}${BR}${A.reset}\n`;
+    o += `${this._at(this._footerRow+1,1)}${C.border}${V} ${hint}${rpad('', w - ansiLen(hint) - 4)}${V}${A.reset}\n`;
+    return o;
+  }
 
-    // Stats bar
-    const stats = this._buildStatsLine();
-    const statsPad = Math.max(0, w - 2 - this._ansiLen(stats) - 2);
-    this._write(`${this._at(4, 1)}${b} ${stats}${' '.repeat(statsPad)} ${C.v}${r}`);
-    this._write(`${this._at(5, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`);
+  _sep() {
+    const w = this._w;
+    return `${C.border}${V}${'─'.repeat(w-2)}${V}${A.reset}\n`;
+  }
 
-    this._accountsRow = 6;
+  _row(r, content) {
+    const w = this._w;
+    return `${this._at(r,1)}${C.border}${V} ${content}${rpad('', w - ansiLen(content) - 4)} ${V}${A.reset}\n`;
+  }
+
+  _statsBar() {
+    const w = this._w;
+    const stats = this._buildStats();
+    return `${this._row(4, stats)}`;
   }
 
-  _buildStatsLine() {
+  _buildStats() {
     let totalCoins = 0, totalCmds = 0, totalSuccess = 0, totalLs = 0;
     let paused = 0, active = 0;
 
     for (const wk of this.workers) {
-      totalCoins += wk.stats?.coins || 0;
-      totalCmds += wk.stats?.commands || 0;
-      totalSuccess += wk.stats?.successes || 0;
+      totalCoins   += wk.stats?.coins    || 0;
+      totalCmds    += wk.stats?.commands || 0;
+      totalSuccess += wk.stats?.successes|| 0;
       if (wk._lifesavers != null) totalLs += wk._lifesavers;
       if (wk.running && !wk._tokenInvalid) {
-        if (wk.paused || wk.dashboardPaused) paused++;
-        else active++;
+        if (wk.paused || wk.dashboardPaused) paused++; else active++;
       }
     }
-
     const uptime = this._fmtUptime(Date.now() - this._startTime);
-    const rate = totalCmds > 0 ? ((totalSuccess / totalCmds) * 100).toFixed(0) : '0';
-
-    return [
-      `${A.dim}⏱${A.reset} ${C.statValue}${uptime}${A.reset}`,
-      `${A.dim}⬡${A.reset} ${C.statValue}${this.workers.length}${A.reset} ${A.dim}accounts${A.reset}`,
-      `${C.coins}⏣${A.reset} ${C.statValue}${totalCoins.toLocaleString()}${A.reset}`,
-      `${A.dim}⚡${A.reset} ${C.statValue}${totalCmds}${A.reset} ${A.dim}cmds${A.reset}`,
-      `${A.dim}📊${A.reset} ${C.statValue}${rate}%${A.reset}`,
-      `${C.lifesavers}♥${A.reset} ${C.statValue}${totalLs}${A.reset}`,
-      `${C.statusActive}🟢${A.reset} ${C.statValue}${active}${A.reset}`,
-      `${C.statusPaused}🔴${A.reset} ${C.statValue}${paused}${A.reset}`,
-    ].join(`  │  `);
+    const rate   = totalCmds > 0 ? `${((totalSuccess / totalCmds) * 100).toFixed(0)}%` : '0%';
+
+    const items = [
+      [`⏱`, uptime,     C.textDim],
+      [`⬡`, `${this.workers.length} accounts`, C.textDim],
+      [`⏣`, totalCoins.toLocaleString(), C.gold],
+      [`⚡`, `${totalCmds} cmds`, C.textDim],
+      [`📊`, `${rate} ok`,   C.textDim],
+      [`♥`,  `${totalLs}`,  C.pink],
+      [`🟢`, `${active}`,    C.green],
+      [`🔴`, `${paused}`,    C.red],
+    ];
+
+    return items.map(([icon, val, col]) =>
+      `${C.textDim}${icon}${A.reset} ${col}${val}${A.reset}`
+    ).join(`  ${C.borderDim}│${A.reset}  `);
   }
 
-  _drawAccounts() {
-    const w = this._w;
-    const b = C.border;
-    const h = C.header;
-    const r = A.reset;
-
-    // Column headers
+  _colHdr() {
     const cols = [
-      `${h}#${r}`, `${h}ACCOUNT${r}`, `${h}COINS${r}`,
-      `${h}LV${r}`, `${h}♥${r}`, `${h}CMDS${r}`,
-      `${h}OK%${r}`, `${h}STATUS${r}`,
-    ].join(`  `);
-    this._write(`${this._at(this._accountsRow, 1)}${b} ${this._rpad(cols, w - 4)} ${C.v}${r}`);
-    this._write(`${this._at(this._accountsRow + 1, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`);
-
-    const visible = this.workers.slice(this.windowStart, this.windowStart + this.windowSize);
+      `${C.purple}#`,
+      `${C.purple}ACCOUNT`,
+      `${C.purple}COINS`,
+      `${C.purple}LV`,
+      `${C.purple}♥`,
+      `${C.purple}OK%`,
+      `${C.purple}STATUS`,
+    ];
+    return cols.join('  ');
+  }
+
+  _accountRows() {
+    let out = '';
     for (let i = 0; i < this.windowSize; i++) {
-      const row = this._accountsRow + 2 + i;
-      if (row > this._h - 4) break;
-      if (i < visible.length) {
-        const line = this._buildAccountRow(visible[i], this.windowStart + i);
-        this._write(`${this._at(row, 1)}${b} ${line} ${C.v}${r}`);
+      const wkIdx = this.windowStart + i;
+      const row = this._topRow + i;
+      if (row > this._h - 5) break;
+      if (wkIdx < this.workers.length) {
+        out += `${this._row(row, this._accountLine(this.workers[wkIdx], wkIdx, this.workers))}`;
       } else {
-        this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
+        out += `${this._row(row, '')}`;
       }
     }
-    this._eventsRow = this._accountsRow + 2 + Math.min(this.windowSize, this.workers.length);
+    return out;
   }
 
-  _drawEvents() {
-    const w = this._w;
-    const b = C.border;
-    const dim = A.dim;
-    const r = A.reset;
+  _accountLine(wk, idx, workers) {
+    const rank = coinRank(wk, workers);
+    const pos  = rank - 1;  // 0-indexed
+    const isActive = wk.running && !wk._tokenInvalid && !wk.paused && !wk.dashboardPaused;
+    const ls = wk._lifesavers ?? '?';
+    const rate = wk.stats?.commands > 0
+      ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
+      : '0%';
 
-    if (this._eventsRow > this._h - 4) return;
-    this._write(`${this._at(this._eventsRow, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`);
+    // Rank badge
+    const medal = pos < 3 ? MEDALS[pos] : null;
+    const rankColor = pos === 0 ? C.rank1 : pos === 1 ? C.rank2 : pos === 2 ? C.rank3 : null;
+    const acctColor = C.ACCT[idx % C.ACCT.length];
+
+    // Color based on rank (top 3 get medal color, rest get account color)
+    const mainColor = isActive
+      ? (rankColor || acctColor)
+      : C.textFaint;
+
+    const dimColor = isActive ? C.textDim : C.textFaint;
+    const goldColor = isActive ? C.gold : C.textDim;
+    const cyanColor = isActive ? C.cyan : C.textDim;
+    const lsColor = isActive
+      ? (ls === 0 ? C.red : ls <= 2 ? C.orange : C.pink)
+      : C.textDim;
+
+    // Status with pulse for active
+    let dot, statusText;
+    if (!wk.running || wk._tokenInvalid) {
+      dot = `${C.textFaint}⚫${A.reset}`; statusText = `${C.textFaint}offline${A.reset}`;
+    } else if (wk.paused || wk.dashboardPaused) {
+      dot = `${C.red}🔴${A.reset}`; statusText = `${C.red}paused${A.reset}`;
+    } else {
+      const pulse = PULSE[this._pulseFrame];
+      dot = `${C.green}${pulse}${A.reset}`; statusText = `${C.green}active${A.reset}`;
+    }
+
+    // Account name — truncate with care
+    const rawName = wk.username || '?';
+    const nameDisplay = rawName.length > 20
+      ? rawName.substring(0, 17) + '...'
+      : rawName;
+
+    // Coins display
+    const coins = (wk.stats?.coins || 0).toLocaleString();
+    const sign = (wk.stats?.coins || 0) >= 0 ? '+' : '';
+    const coinDisplay = `${goldColor}${sign}⏣${coins}${A.reset}`;
+
+    // Current command (minimal)
+    const cmd = (wk.lastStatus || '—').replace(/\x1b\[[0-9;]*m/g, '').substring(0, 14);
+
+    // Build rank badge
+    const rankBadge = medal
+      ? `${rankColor}${A.bold}${medal}${A.reset}`
+      : `${dimColor}${rank}th${A.reset}`;
+
+    // Account name with subtle glow for top 3
+    const nameBadge = pos < 3
+      ? `${mainColor}${A.bold}${nameDisplay}${A.reset}`
+      : `${mainColor}${nameDisplay}${A.reset}`;
+
+    const parts = [
+      rankBadge,
+      nameBadge,
+      coinDisplay,
+      `${cyanColor}Lv.${String(wk._level ?? '?').padStart(3)}${A.reset}`,
+      `${lsColor}♥${String(ls).padStart(2)}${A.reset}`,
+      `${dimColor}${rate.padStart(5)}${A.reset}`,
+      `${dot} ${statusText}`,
+      `${dimColor}${cmd}`,
+    ];
+
+    return parts.join('  ');
+  }
 
-    const visible = this.events.slice(0, Math.min(this.MAX_EVENTS, this._h - this._eventsRow - 3));
+  _eventFeed() {
+    let out = '';
+    const visible = this.events.slice(0, Math.min(this.MAX_EVENTS, this._h - this._eventRow - 3));
     for (let i = 0; i < visible.length; i++) {
-      const row = this._eventsRow + 1 + i;
-      if (row > this._h - 2) break;
+      const row = this._eventRow + i;
+      if (row > this._h - 3) break;
       const e = visible[i];
-      const typeColor = e.type === 'death' ? C.cmdError
-        : e.type === 'lowls' ? C.cmdWarn
-        : e.type === 'levelup' ? C.cmdSuccess
-        : e.type === 'success' ? C.cmdSuccess
-        : C.cmdInfo;
-      const line = ` ${dim}${e.ts}${A.reset} ${typeColor}${e.msg}${A.reset}`;
-      this._write(`${this._at(row, 1)}${b} ${this._rpad(line, w - 4)} ${C.v}${r}`);
+      const color = e.type === 'death'   ? C.red
+        : e.type === 'lowls'  ? C.orange
+        : e.type === 'levelup'? C.cyan
+        : e.type === 'success'? C.green
+        : C.textDim;
+      out += this._row(row, ` ${e.ts}  ${color}${e.msg}${A.reset}`);
     }
-    this._footerRow = this._eventsRow + 1 + visible.length;
+    this._footerRow = this._eventRow + visible.length;
+    return out;
   }
 
-  _drawFooter() {
-    const w = this._w;
-    const b = C.border;
-    const dim = A.dim;
-    const r = A.reset;
-    if (this._footerRow > this._h - 1) this._footerRow = this._h - 2;
-    this._write(`${this._at(this._footerRow, 1)}${b}${C.botLeft}${'─'.repeat(w - 2)}${C.botRight}${r}`);
-    const hint = `${dim}↑↓ scroll${r}`;
-    this._write(`${this._at(this._footerRow + 1, 1)}${b} ${hint}${' '.repeat(Math.max(0, w - 2 - this._ansiLen(hint)))}${r}`);
+  _totalLine(totalCoins, totalCmds, totalSuccess, uptime, memMB) {
+    const rate = totalCmds > 0 ? `${((totalSuccess / totalCmds) * 100).toFixed(0)}%` : '0%';
+    const items = [
+      [`💰`, `${C.gold}${A.bold}TOTAL:${A.reset}`, `${C.gold}${A.bold}⏣${totalCoins.toLocaleString()}${A.reset}`],
+      [`⚡`, `${C.textDim}${totalCmds} cmds${A.reset}`, `${C.textDim}${rate} ok${A.reset}`],
+      [`⏱`, `${C.textDim}${this._fmtUptime(uptime)}${A.reset}`, `${C.textDim}${memMB}MB${A.reset}`],
+    ];
+    return items.map(([, label, val]) => `${label} ${val}`).join('     ');
   }
 
+  // ── Render loop ───────────────────────────────────────────────────────
+
   _render() {
     if (!READY || this._shutdown || !this._active) return;
 
-    // Only update stats line (row 4) when dirty — don't redraw whole header
     if (this.dirtyStats) {
+      // Update stats bar (row 4)
+      const stats = this._buildStats();
       const w = this._w;
-      const b = C.border;
-      const stats = this._buildStatsLine();
-      const statsPad = Math.max(0, w - 2 - this._ansiLen(stats) - 2);
-      this._write(`${this._at(4, 1)}${b} ${stats}${' '.repeat(statsPad)} ${C.v}${A.reset}`);
+      const V = C.border;
+      this._write(
+        `${this._at(4,1)}${V} ${rpad(stats, w-4)} ${V}${A.reset}`
+      );
+      // Re-draw account rows to update pulse/status
+      for (let i = 0; i < this.windowSize; i++) {
+        const wkIdx = this.windowStart + i;
+        const row = this._topRow + i;
+        if (row > this._h - 5) break;
+        if (wkIdx < this.workers.length) {
+          const line = this._accountLine(this.workers[wkIdx], wkIdx, this.workers);
+          this._write(`${this._at(row,1)}${C.border}${V} ${rpad(line, w-4)} ${V}${A.reset}`);
+        }
+      }
       this.dirtyStats = false;
     }
 
     if (this.dirtyWorkers.size > 0) {
       const w = this._w;
-      const b = C.border;
-      const r = A.reset;
-      for (const idx of this.dirtyWorkers) {
-        const localIdx = idx - this.windowStart;
-        const row = this._accountsRow + 2 + localIdx;
-        if (row < this._accountsRow + 2 || row > this._h - 4) continue;
-        if (idx < this.workers.length) {
-          const line = this._buildAccountRow(this.workers[idx], idx);
-          this._write(`${this._at(row, 1)}${b} ${line} ${C.v}${r}`);
+      const V = C.border;
+      for (const wkIdx of this.dirtyWorkers) {
+        const localRow = wkIdx - this.windowStart;
+        const row = this._topRow + localRow;
+        if (row < this._topRow || row > this._h - 5) continue;
+        if (wkIdx < this.workers.length) {
+          const line = this._accountLine(this.workers[wkIdx], wkIdx, this.workers);
+          this._write(`${this._at(row,1)}${C.border}${V} ${rpad(line, w-4)} ${V}${A.reset}`);
         } else {
-          this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
+          this._write(`${this._at(row,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}`);
         }
       }
     }
 
     if (this.dirtyEvents) {
-      this._drawEvents();
+      this._write(this._eventFeed());
     }
 
     this.dirtyWorkers.clear();
@@ -729,10 +673,44 @@ class Terminal {
 
   _startRenderLoop() {
     if (this._renderTimer) clearInterval(this._renderTimer);
-    this._renderTimer = setInterval(() => {
-      this.dirtyStats = true; // always refresh uptime/stats
-      this._render();
-    }, 250);
+    this._renderTimer = setInterval(() => this._render(), 250);
+  }
+
+  // ── Internals ──────────────────────────────────────────────────────────
+
+  _updateSize() {
+    try {
+      this._w = process.stdout.columns || 110;
+      this._h = process.stdout.rows || 35;
+      this.windowSize = Math.max(4, this._h - 11);
+    } catch (_) {
+      this._w = 110; this._h = 35; this.windowSize = 17;
+    }
+  }
+
+  _onResize() {
+    clearTimeout(this._resizeTimer);
+    this._resizeTimer = setTimeout(() => {
+      this._updateSize();
+      if (this._active) {
+        this._write(A.eraseAll);
+        this._drawLiveView();
+      }
+    }, 100);
+  }
+
+  _at(r, c) { return `\x1b[${r};${c}H`; }
+  _write(s) { if (s) process.stdout.write(s); }
+
+  _fmtUptime(ms) {
+    if (!ms) return '0s';
+    const s = Math.floor(ms / 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`;
+    return `${Math.floor(h/24)}d ${h%24}h`;
   }
 }
 

package/package.json

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