dankgrinder 7.78.0 → 7.81.0

package/lib/terminal.js

@@ -1,253 +1,239 @@
 /**
- * terminal.js — Modern animated terminal renderer for DankGrinder
+ * terminal.js — Polished animated terminal renderer for DankGrinder
  *
- * Design goals:
- * - Single-line-per-account rows (scales to 10k+ accounts)
- * - Virtual window: only renders visible slice of accounts
- * - 4 FPS render loop with dirty-row tracking (no flicker)
- * - Graceful degradation: falls back to console.log if not a TTY
- * - Graceful mode: Ctrl+C always restores cursor + shows summary
- *
- * Layout (fixed row heights, live-updated):
- *
- *  ┌─ DANKGRINDER v7.77.0 ─────────────────────────────────────────────────────┐
- *  │ ⏱ 00:32   ⬡ 5 accounts   ⏣ 47,230   ⚡ 12 cmd/m   📊 89% success            │
- *  ├─ ACCOUNTS ──────────────────────────────────────────────────────────────────┤
- *  │ 💎 alice_99    ⏣ 12,450  L:24  ♥3  34cmds  🟢 grinding   ⚔ adventure        │
- *  │ 💎 bob_trades  ⏣  8,920  L:18  ♥5  28cmds  🟢 grinding   🐟 fishing        │
- *  │ 💎 crypto_king ⏣  5,100  L:31  ♥0  19cmds  🟡 depositing  💰 beg           │
- *  │ 💎 diamond_h.. ⏣  3,780  L:12  ♥8  14cmds  🟢 grinding   🌾 farm           │
- *  │ 💎 moon_wallet ⏣  1,200  L:9   ♥2   8cmds  🔴 paused     ⚠ captcha        │
- *  ├─ EVENTS ────────────────────────────────────────────────────────────────────┤
- *  │ 00:32 ⚔ alice_99 adventure: +⏣ 850                                         │
- *  │ 00:31 💀 crypto_king DEATH — 0 lifesavers! crime/search disabled             │
- *  │ 00:30 ⬆️ bob_trades leveled up to Lv.19                                     │
- *  │ 00:28 🌾 diamond_hands farm: +⏣ 2,100                                       │
- *  └──────────────────────────────────────────────────────────────────────────────┘
+ * 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',
-
-  // 256-color RGB shortcuts
+  bold:  '\x1b[1m',
+  dim:   '\x1b[2m',
   rgb: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
-
-  // Cursor
+  eraseAll: '\x1b[3J\x1b[2J\x1b[H',
+  clearLine: '\x1b[2K',
   save: '\x1b7',
   restore: '\x1b8',
   hide: '\x1b[?25l',
   show: '\x1b[?25h',
-  up: (n = 1) => `\x1b[${n}A`,
-  down: (n = 1) => `\x1b[${n}B`,
-  right: (n = 1) => `\x1b[${n}C`,
-  left: (n = 1) => `\x1b[${n}D`,
-  col: (n) => `\x1b[${n}G`,
-  clear: '\x1b[2J',
-  clearLine: '\x1b[2K',
-  home: '\x1b[H',
-
-  // 256-color palette
-  purple: '\x1b[38;5;141m',   // #8b5cf6
-  pink: '\x1b[38;5;205m',    // #ff5c93
-  orange: '\x1b[38;5;214m',  // #ff9f43
-  teal: '\x1b[38;5;44m',     // #2dd4bf
-  lime: '\x1b[38;5;82m',     // #4cd137
-  crimson: '\x1b[38;5;196m',  // #ff4757
-  slate: '\x1b[38;5;245m',    // #a0a0b0
-  gold: '\x1b[38;5;220m',     // #ffc233
-  emerald: '\x1b[38;5;48m',  // #2ed573
 };
 
-// ── Color scheme ────────────────────────────────────────────────────────────
+// ── Palette ─────────────────────────────────────────────────────────────────
 
 const C = {
-  header: A.purple,
-  headerDim: A.rgb(100, 70, 180),
-  border: A.rgb(60, 50, 90),
-  borderDim: A.rgb(40, 35, 60),
-
-  rowDefault: A.white,
-  rowAlt: A.rgb(30, 28, 45),
-  rowHighlight: A.rgb(25, 23, 40),
-
-  name: A.rgb(255, 255, 255),
-  nameDim: A.slate,
-
-  coins: A.gold,
-  level: A.cyan,
-  lifesavers: A.pink,
-  lifesaversLow: A.crimson,
-  lifesaversMid: A.orange,
-
-  statusActive: A.emerald,    // 🟢 grinding
-  statusPaused: A.crimson,    // 🔴 paused
-  statusWarning: A.orange,     // 🟡 warning
-  statusOffline: A.slate,      // ⚫ offline
-  statusConnecting: A.yellow,  // 🟡 connecting
-
-  cmdSuccess: A.emerald,
-  cmdError: A.crimson,
-  cmdEvent: A.purple,
-  cmdWarn: A.orange,
-
-  statLabel: A.slate,
-  statValue: A.white,
-
-  headerBg: A.rgb(20, 15, 35),
-  rowBg1: '',
-  rowBg2: A.rgb(25, 22, 38),
-  rowBgPaused: A.rgb(40, 15, 20),
-  rowBgWarning: A.rgb(40, 35, 15),
-  rowBgDeath: A.rgb(50, 15, 15),
+  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 SPINNERS = {
-  dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠿'],
-  moon: ['🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘'],
-  arrows: ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙'],
-  pulse: ['▓', '▒', '░', '▒'],
-};
+// Dot spinner for phase labels
+const SPIN_DOTS = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠿'];
+
+// 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 _capWrite(chunk) {
+  if (_captureActive) { _captureBuf.push(String(chunk)); return; }
+  return _origWrite.call(process.stdout, chunk);
+}
+
+// ── 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 Renderer ────────────────────────────────────────────────────────
+// ── Terminal ───────────────────────────────────────────────────────────────
 
 class Terminal {
   constructor() {
-    this.workers = [];
-    this.events = [];           // recent event feed (last N events)
-    this.MAX_EVENTS = 5;
+    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;
 
-    // Virtual window state
+    this._w = 110;
+    this._h = 35;
     this.windowStart = 0;
-    this.windowSize = 10;
-    this.scrollLocked = false;   // true = auto-follow most active worker
-
-    this._lineCount = 0;
-    this._active = false;
-    this._shutdown = false;
+    this.windowSize  = 8;
 
-    // Row offsets (set during render)
-    this._headerRow = 0;
-    this._statsRow = 0;
-    this._accountsRow = 0;
-    this._eventsRow = 0;
-    this._footerRow = 0;
-
-    // ── Scroll position state ──
-    this._followWorkerIdx = -1;  // -1 = follow newest active worker
-
-    this._w = 80;
-    this._h = 24;
-    this._resizeTimer = null;
-    this._col = (n) => `\x1b[${n}G`;
+    // Pulse animation state
+    this._pulseFrame = 0;
+    this._pulseTimer = null;
   }
 
   // ── Public API ──────────────────────────────────────────────────────────
 
   init(opts = {}) {
-    if (opts.startTime) this._startTime = opts.startTime;
+    this._startTime = opts.startTime || Date.now();
     this.workers = opts.workers || [];
     this._updateSize();
 
     if (READY) {
-      process.stdout.write(A.hide);
-      process.stdout.on('resize', this._onResize.bind(this));
+      _origWrite = process.stdout.write.bind(process.stdout);
+      process.stdout.write = _capWrite;
+      _captureActive = true;
+      _captureBuf = [];
+      this._origLog = console.log;
+      console.log = (...args) => {
+        const s = args.join(' ');
+        if (this._active) {
+          const clean = s.replace(/\x1b\[[0-9;]*m/g, '').substring(0, 100);
+          if (clean.trim()) this.flashEvent('info', clean);
+        } else {
+          _capWrite(s + '\n');
+        }
+      };
+      process.stdout.on('resize', () => this._onResize());
       this._drawStartupScreen();
-    } else {
-      console.log(`${C.header}🚀 DankGrinder starting...${A.reset}`);
     }
   }
 
   setVersion(v) { this._version = v; }
 
   startPhase(name) {
-    this.phaseName = name;
+    this.phase = name;
+    this.phaseDone = 0;
+    this.phaseTotal = 0;
     this.phaseFrame = 0;
-    if (!READY) {
-      console.log(`  ${A.dim}⟳${A.reset} ${name}...`);
-      return;
-    }
+    if (!READY) return;
     if (this.phaseTimer) clearInterval(this.phaseTimer);
     this.phaseTimer = setInterval(() => {
-      this.phaseFrame = (this.phaseFrame + 1) % SPINNERS.dots.length;
-      this._redrawPhaseSpinner();
-    }, 120);
-    this._redrawPhaseSpinner();
+      this.phaseFrame = (this.phaseFrame + 1) % SPIN_DOTS.length;
+      this._renderPhase();
+    }, 80);
+    this._renderPhase();
   }
 
   updateProgress(done, total) {
+    this.phaseDone = done;
+    this.phaseTotal = total;
     if (!READY) return;
-    this._writePhaseProgress(done, total);
+    this._renderProgress();
   }
 
   endPhase(name, ok = true) {
     if (this.phaseTimer) { clearInterval(this.phaseTimer); this.phaseTimer = null; }
     if (!READY) {
-      const icon = ok ? `${C.header}✓${A.reset}` : `${A.crimson}✗${A.reset}`;
-      console.log(`  ${icon} ${name}`);
+      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 frame = SPINNERS.dots[0];
-    const cols = this._w;
-    const label = `  ${frame}  ${name}`;
-    const pad = cols - this._ansiLen(label) - 4;
-    process.stdout.write(
-      A.save +
-      this._cursor(2, 1) +
-      A.clearLine +
-      `${A.save}${A.home}` +
-      `${label}${pad > 0 ? ' '.repeat(pad) : ''}` +
-      `${this._rpad('', cols - this._ansiLen(`  ${icon}  ${name}`) - 2)}${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;
+    const V = C.border;
+    const line = rpad(`  ${label}`, w - 3);
+    this._write(
+      `${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
     );
-    // Clear spinner line
-    process.stdout.write(this._cursor(3, 1) + A.clearLine);
   }
 
   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;
@@ -260,560 +246,471 @@ class Terminal {
   }
 
   markWorkerDirty(idx) {
-    this.dirtyWorkers.add(idx);
+    this.dirtyWorkers = new Set(this.workers.map((_, i) => i));
+    this.dirtyStats = true;
   }
 
   setActive() {
     if (this._active) return;
     this._active = true;
-    if (!READY) return;
-
-    // Clear startup, draw live view
-    process.stdout.write(A.clear + A.home);
-    this._drawLiveView();
-    this._startRenderLoop();
-  }
-
-  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._followWorkerIdx = -1;  // manual scroll cancels auto-follow
-    this.dirtyWorkers = new Set();
-    for (let i = this.windowStart; i < this.windowStart + this.windowSize; i++) {
-      if (i < this.workers.length) this.dirtyWorkers.add(i);
-    }
-  }
 
-  followWorker(idx) {
-    this._followWorkerIdx = idx;
-    this.scrollLocked = true;
-    // Ensure the worker is visible
-    if (idx < this.windowStart) {
-      this.windowStart = idx;
-    } else if (idx >= this.windowStart + this.windowSize) {
-      this.windowStart = idx - this.windowSize + 1;
+    if (READY) {
+      _captureActive = false;
+      if (_origWrite) { process.stdout.write = _origWrite; _origWrite = null; }
+      if (this._origLog) { console.log = this._origLog; this._origLog = null; }
+      _captureBuf = [];
+
+      this._write(A.eraseAll + A.hide);
+      this._drawLiveView();
+      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 {
+      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; }
+    if (this._pulseTimer) { clearInterval(this._pulseTimer); this._pulseTimer = null; }
+    if (this.phaseTimer) { clearInterval(this.phaseTimer); this.phaseTimer = null; }
 
-    process.stdout.write(A.show);
+    if (READY && _origWrite) { process.stdout.write = _origWrite; _origWrite = null; }
+    if (this._origLog) { console.log = this._origLog; this._origLog = null; }
+    this._write(A.show);
 
-    if (!READY) {
-      this._printSummaryPlain(summary);
-      return;
-    }
-
-    // Move to clean area below any existing output
-    const cols = 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;
-
-    const sep = (c) => `${b}${c.repeat(cols - 2)}${r}`;
-    const bar = `${b}${'─'.repeat(cols - 2)}${r}`;
-    const icon = (e) => `${h}${e}${r}`;
-
-    let out = '';
-    out += `${A.clear}${A.home}`;
-    out += `${A.save}`;
-
-    // Box title
-    out += `${this._at(1, 1)}${bar}`;
-    out += `${this._at(2, 1)}${b} ${h}${A.bold}⬡  DANKGRINDER — Session Summary${r} ${b}${'─'.repeat(Math.max(0, cols - 37))}${r}`;
-    out += `${this._at(3, 1)}${bar}`;
-
-    // Per-account summary
-    let row = 4;
-    for (const wk of workers) {
-      const coins = `+⏣ ${(wk.stats?.coins || 0).toLocaleString()}`;
-      const cmds = `${wk.stats?.commands || 0}cmds`;
-      const rate = wk.stats?.commands > 0
-        ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
-        : '0%';
-      const ls = wk._lifesavers ?? '?';
-      const lv = wk._level ?? '?';
-      const line = ` ${icon('💎')} ${g}${A.bold}${(wk.username || '?').padEnd(18)}${r}  ${C.coins}${coins}${r}  ${dim}${cmds}${r}  ${g}${rate} OK${r}  ${C.level}Lv.${lv}${r}  ${C.lifesavers}♥${ls}${r}`;
-      out += `${this._at(row++, 1)}${b}${this._rpad(line, cols - 2)}${r}`;
-    }
-
-    row++; // blank row
-    out += `${this._at(row++, 1)}${bar}`;
+    const w = this._w;
+    let out = A.eraseAll;
 
-    // Totals
-    const totalLine = ` ${icon('💰')} ${h}${A.bold}Total:${r}  ${C.coins}${A.bold}⏣ ${totalCoins.toLocaleString()}${r}  ${dim}${totalCmds} cmds${r}  ${g}${totalSuccess}% OK${r}  ${dim}${this._fmtUptime(uptime)}${r}  ${dim}${memMB}MB${r}`;
-    out += `${this._at(row++, 1)}${b}${this._rpad(totalLine, cols - 2)}${r}`;
-    out += `${this._at(row++, 1)}${sep('─')}`;
-    out += `${A.restore}`;
-    out += `${A.show}`;
+    // Top bar
+    out += this._boxTop();
+    out += this._statsBar();
+    out += this._sep();
 
-    process.stdout.write(out);
-    setTimeout(() => {}, 100);
-  }
+    // Column headers
+    out += `${this._row(4, this._colHdr())}`;
+    out += this._sep();
 
-  // ── Internal ────────────────────────────────────────────────────────────
-
-  _updateSize() {
-    try {
-      this._w = process.stdout.columns || 80;
-      this._h = process.stdout.rows || 24;
-      // Window size: leave room for header (3 rows) + stats (2) + events footer (3) + border (2)
-      this.windowSize = Math.max(3, this._h - 12);
-    } catch (_) {
-      this._w = 80; this._h = 24; this.windowSize = 10;
+    // 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))}`;
     }
-  }
 
-  _onResize() {
-    if (this._resizeTimer) clearTimeout(this._resizeTimer);
-    this._resizeTimer = setTimeout(() => {
-      this._updateSize();
-      if (this._active) {
-        this._clearScreen();
-        this._drawLiveView();
-      }
-    }, 100);
-  }
-
-  _ansiLen(s) {
-    // Fast ANSI strip — just count escape sequences by looking for \x1b[
-    let len = 0;
-    let 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;
-  }
+    out += this._sep();
+    row++;
+    out += `${this._row(row++, this._totalLine(totalCoins, totalCmds, totalSuccess, uptime, memMB))}`;
+    out += this._boxBot();
 
-  _rpad(s, width) {
-    const len = this._ansiLen(s);
-    const pad = width > len ? width - len : 0;
-    return s + (pad > 0 ? ' '.repeat(pad) : '');
-  }
-
-  _cursor(row, col) {
-    // Position cursor at absolute row/col (1-indexed)
-    return `\x1b[${row};${col}H`;
+    this._write(out);
   }
 
-  _at(row, col) {
-    return `\x1b[${row};${col}H`;
-  }
+  // ── Startup Screen ──────────────────────────────────────────────────────
 
-  _write(str) {
-    process.stdout.write(str);
-  }
+  _drawStartupScreen() {
+    const w = this._w;
+    let out = A.eraseAll;
 
-  _ansi(s, code) { return `${code}${s}${A.reset}`; }
-  _bold(s) { return `${A.bold}${s}${A.reset}`; }
-  _dim(s) { return `${A.dim}${s}${A.reset}`; }
+    // Top border
+    out += `${this._at(1,1)}${C.border}${TL}${'─'.repeat(w-2)}${TR}${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`;
-    const d = Math.floor(h / 24);
-    return `${d}d ${h % 24}h`;
-  }
+    // 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`;
 
-  _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);
-  }
+    // 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`;
 
-  _buildAccountRow(wk, idx) {
-    const w = this._w;
-    // Row layout (all in one line):
-    // #N 💎 username  ⏣coins  Lv.N  ♥N  Ncmds  ● status  ⚔ current_cmd
-    // We need to fit within `w` columns, truncate username if needed
-
-    const num = `${idx + 1}.`.padEnd(3);
-    const username = (wk.username || '?').substring(0, 16).padEnd(17);
-    const coins = `⏣${this._fmtCoins(wk.stats?.coins || 0)}`.padEnd(8);
-    const level = `Lv.${wk._level ?? '?'}`.padEnd(5);
-    const ls = wk._lifesavers ?? '?';
-    const lifesaversColor = ls === 0 ? C.lifesaversLow
-      : ls <= 2 ? C.lifesaversMid
-      : C.lifesavers;
-    const lifesavers = `${lifesaversColor}♥${ls}`.padEnd(4);
-    const cmds = `${wk.stats?.commands || 0}cmds`.padEnd(7);
-
-    // Status dot + text
-    let statusDot, statusText, rowBg;
-    if (!wk.running || wk._tokenInvalid) {
-      statusDot = '⚫'; statusText = 'offline'; rowBg = C.rowBgPaused;
-    } else if (wk.paused) {
-      statusDot = '🔴'; statusText = 'paused'; rowBg = C.rowBgPaused;
-    } else if (wk.dashboardPaused) {
-      statusDot = '🟠'; statusText = 'dashboard'; rowBg = C.rowBgWarning;
-    } else {
-      statusDot = '🟢'; statusText = 'grinding'; rowBg = '';
-    }
+    out += `${this._at(4,1)}${C.border}${V}${'─'.repeat(w-2)}${V}${A.reset}\n`;
 
-    // Current command
-    const cmd = (wk.lastStatus || '').substring(0, 20).padEnd(21);
-    const successRate = wk.stats?.commands > 0
-      ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
-      : '0%';
+    // Spinner + phase label (row 5)
+    out += `${this._at(5,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-    const parts = [
-      `${C.header}${num}${A.reset}`,
-      `${C.name}${username}${A.reset}`,
-      `${C.coins}${coins}${A.reset}`,
-      `${C.level}${level}${A.reset}`,
-      `${lifesaversColor}${lifesavers}${A.reset}`,
-      `${C.statValue}${cmds}${A.reset}`,
-      `${C.statValue}${successRate}`.padEnd(5) + A.reset,
-      `${statusDot} ${statusText}`.padEnd(14),
-      `${this._dim(cmd)}`,
-    ];
+    // Progress bar (row 7)
+    out += `${this._at(7,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-    // Join and pad to screen width
-    const line = parts.join('  ');
-    return this._rpad(line, w);
-  }
+    // Checkmarks / status area (row 9)
+    out += `${this._at(9,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-  _drawStartupScreen() {
-    const w = this._w;
-    const b = C.border;
-    const h = C.header;
-    const g = C.statValue;
-    const dim = A.dim;
-    const r = A.reset;
+    // Spacer
+    out += `${this._at(11,1)}${C.border}${V}${rpad('', w-2)}${V}${A.reset}\n`;
 
-    const sep = (c) => `${b}${c.repeat(w - 2)}${r}`;
+    // Bottom border
+    out += `${this._at(12,1)}${C.border}${BL}${'─'.repeat(w-2)}${BR}${A.reset}\n`;
 
-    // Figure out how many rows we need for the spinner
-    const spinnerRow = 3;
-    const progressRow = 5;
-    const readyRow = 7;
+    // Footer
+    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`;
 
-    let out = '';
-    out += `${A.clear}${A.home}`;
-
-    // Title box
-    const titleText = ` ⬡  DANKGRINDER v${this._version || '?'} `;
-    const titlePad = w - 2 - this._ansiLen(titleText);
-    out += `${this._at(1, 1)}${sep('─')}`;
-    out += `${this._at(2, 1)}${b} ${h}${A.bold}${titleText}${r}${b}${'─'.repeat(Math.max(0, titlePad))}${r}`;
-    out += `${this._at(3, 1)}${sep('─')}`;
-
-    // Spinner + phase text
-    out += `${this._at(5, 1)}${b}${' '.repeat(w - 2)}${r}`;
-    out += `${this._at(6, 1)}${b}${' '.repeat(w - 2)}${r}`;
-
-    // Footer hint
-    out += `${this._at(8, 1)}${sep('─')}`;
-    const hint = `${dim}Starting up...${r}`;
-    out += `${this._at(9, 1)}${b} ${hint}${' '.repeat(Math.max(0, w - 2 - this._ansiLen(hint)))}${r}`;
-    out += `${this._at(10, 1)}${sep('─')}`;
-
-    this._lineCount = 10;
     this._write(out);
   }
 
-  _redrawPhaseSpinner() {
-    if (!READY) return;
-    const frame = SPINNERS.dots[this.phaseFrame];
-    const label = this.phaseName;
+  _renderPhase() {
+    if (!READY || !this.phase) return;
     const w = this._w;
-
-    const line = ` ${frame}  ${label}...`;
-    const pad = w - this._ansiLen(line) - 2;
-    const padded = line + (pad > 0 ? ' '.repeat(pad) : '');
-
-    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(6, 1)}` +
-      `${b}${padded}${r}` +
-      `${A.restore}`
+      `${this._at(5,1)}${A.clearLine}` +
+      `${V} ${line} ${V}${A.reset}` +
+      A.restore
     );
   }
 
-  _writePhaseProgress(done, total) {
-    if (!READY) {
-      console.log(`  ${A.dim}  → ${done}/${total}${A.reset}`);
-      return;
-    }
+  _renderProgress() {
+    if (!READY) return;
     const w = this._w;
-    const b = C.border;
-    const h = C.header;
-    const dim = A.dim;
-    const r = A.reset;
-    const barLen = Math.max(10, w - 30);
-    const filled = Math.round((done / total) * barLen);
-    const empty = barLen - filled;
-
-    const bar = `${h}${'█'.repeat(filled)}${dim}${'░'.repeat(empty)}${r}`;
-    const label = ` ${done}/${total} `;
-    const line = `${bar} ${label}`;
-    const pad = w - this._ansiLen(line) - 2;
+    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 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(6, 1)}` +
-      `${b}${line}${' '.repeat(Math.max(0, pad))}${r}` +
-      `${A.restore}`
+      `${this._at(7,1)}${A.clearLine}` +
+      `${V} ${line} ${V}${A.reset}` +
+      A.restore
     );
   }
 
-  _clearScreen() {
-    this._write(`${A.clear}${A.home}`);
-  }
+  // ── Live View ─────────────────────────────────────────────────────────
 
   _drawLiveView() {
-    if (!READY) return;
-    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;
-
-    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
+    let o = '';
+    o += `${this._at(1,1)}${C.border}${TL}${'─'.repeat(w-2)}${TR}${A.reset}\n`;
     const title = ` ⬡  DANKGRINDER v${this._version || '?'} `;
-    const titlePad = w - 2 - this._ansiLen(title);
+    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;
+  }
 
-    this._headerRow = 1;
-    this._write(`${this._at(1, 1)}${sep}`);
-    this._write(`${this._at(2, 1)}${b} ${h}${A.bold}${title}${r}${b}${'─'.repeat(Math.max(0, titlePad))}${r}`);
-    this._write(`${this._at(3, 1)}${sep}`);
-    this._statsRow = 4;
+  _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;
+  }
+
+  _sep() {
+    const w = this._w;
+    return `${C.border}${V}${'─'.repeat(w-2)}${V}${A.reset}\n`;
+  }
 
-    // Stats bar
-    const stats = this._buildStatsLine();
-    this._write(`${this._at(4, 1)}${b}${this._rpad(' ' + stats, w - 2)}${r}`);
-    this._accountsRow = 5;
-    this._write(`${this._at(5, 1)}${sep}`);
+  _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`;
   }
 
-  _buildStatsLine() {
-    const g = C.statValue;
-    const dim = A.dim;
-    const h = C.header;
-    const coins = C.coins;
+  _statsBar() {
+    const w = this._w;
+    const stats = this._buildStats();
+    return `${this._row(4, stats)}`;
+  }
 
+  _buildStats() {
     let totalCoins = 0, totalCmds = 0, totalSuccess = 0, totalLs = 0;
-    let pausedCount = 0, activeCount = 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) {}
-      else if (wk.paused || wk.dashboardPaused) pausedCount++;
-      else activeCount++;
+      if (wk.running && !wk._tokenInvalid) {
+        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%';
+
+    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],
+    ];
 
-    const uptime = this._fmtUptime(Date.now() - (this._startTime || Date.now()));
-    const rate = totalCmds > 0 ? ((totalSuccess / totalCmds) * 100).toFixed(0) : 0;
-
-    return [
-      `${dim}⏱${A.reset} ${g}${uptime}${A.reset}`,
-      `${dim}⬡${A.reset} ${g}${this.workers.length}${A.reset} ${dim}accounts${A.reset}`,
-      `${coins}⏣${A.reset} ${g}${totalCoins.toLocaleString()}${A.reset}`,
-      `${dim}⚡${A.reset} ${g}${totalCmds}${A.reset} ${dim}cmds${A.reset}`,
-      `${dim}📊${A.reset} ${g}${rate}%${A.reset}`,
-      `${C.lifesavers}♥${A.reset} ${g}${totalLs}${A.reset}`,
-      `${h}🟢${A.reset} ${g}${activeCount}${A.reset} ${h}🔴${A.reset} ${g}${pausedCount}${A.reset}`,
-    ].join('   ');
+    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 dim = A.dim;
-    const r = A.reset;
-    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
-
-    const visible = this.workers.slice(this.windowStart, this.windowStart + this.windowSize);
-
-    // Column header
+  _colHdr() {
     const cols = [
-      `${C.header}#${A.reset}`,
-      `${C.header}ACCOUNT${A.reset}`,
-      `${C.header}COINS${A.reset}`,
-      `${C.header}LV${A.reset}`,
-      `${C.header}♥${A.reset}`,
-      `${C.header}CMDS${A.reset}`,
-      `${C.header}OK%${A.reset}`,
-      `${C.header}STATUS${A.reset}`,
-      `${C.header}CURRENT${A.reset}`,
-    ].join('  ');
-    this._write(`${this._at(this._accountsRow, 1)}${b}${this._rpad(' ' + cols, w - 2)}${r}`);
-    this._write(`${this._at(this._accountsRow + 1, 1)}${sep}`);
-
-    // Worker rows
-    for (let i = 0; i < this.windowSize; i++) {
-      const row = this._accountsRow + 2 + i;
-      if (row > this._h - 4) break;
+      `${C.purple}#`,
+      `${C.purple}ACCOUNT`,
+      `${C.purple}COINS`,
+      `${C.purple}LV`,
+      `${C.purple}♥`,
+      `${C.purple}OK%`,
+      `${C.purple}STATUS`,
+    ];
+    return cols.join('  ');
+  }
 
-      if (i < visible.length) {
-        const wk = visible[i];
-        const line = this._buildAccountRow(wk, this.windowStart + i);
-        this._write(`${this._at(row, 1)}${b}${line}${r}`);
+  _accountRows() {
+    let out = '';
+    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) {
+        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 + this.windowSize + 1;
+    return out;
   }
 
-  _drawEvents() {
-    const w = this._w;
-    const b = C.border;
-    const dim = A.dim;
-    const r = A.reset;
-    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
-
-    if (this._eventsRow > this._h - 4) return;
-    this._write(`${this._at(this._eventsRow, 1)}${sep}`);
-
-    const visibleEvents = this.events.slice(0, Math.min(this.MAX_EVENTS, this._h - this._eventsRow - 3));
-    for (let i = 0; i < visibleEvents.length; i++) {
-      const row = this._eventsRow + 1 + i;
-      if (row > this._h - 2) break;
-      const evt = visibleEvents[i];
-      const typeColor = evt.type === 'error' || evt.type === 'death' ? C.cmdError
-        : evt.type === 'warn' || evt.type === 'lowls' ? C.cmdWarn
-        : evt.type === 'success' || evt.type === 'levelup' ? C.cmdSuccess
-        : C.cmdEvent;
-
-      const line = ` ${dim}${evt.ts}${A.reset} ${typeColor}${evt.msg}${A.reset}`;
-      this._write(`${this._at(row, 1)}${b}${this._rpad(line, w - 2)}${r}`);
+  _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%';
+
+    // 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}`;
     }
-    this._footerRow = this._eventsRow + 1 + visibleEvents.length;
-  }
 
-  _drawFooter() {
-    const w = this._w;
-    const b = C.border;
-    const dim = A.dim;
-    const r = A.reset;
-    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
+    // 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}`;
 
-    if (this._footerRow > this._h - 1) this._footerRow = this._h - 2;
-    this._write(`${this._at(this._footerRow, 1)}${sep}`);
+    // Current command (minimal)
+    const cmd = (wk.lastStatus || '—').replace(/\x1b\[[0-9;]*m/g, '').substring(0, 14);
 
-    const hint = `${dim}↑↓ scroll · j/k navigate · Ctrl+C quit${r}`;
-    this._write(`${this._at(this._footerRow + 1, 1)}${b} ${hint}${' '.repeat(Math.max(0, w - 2 - this._ansiLen(hint)))}${r}`);
+    // 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('  ');
+  }
+
+  _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._eventRow + i;
+      if (row > this._h - 3) break;
+      const e = visible[i];
+      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._eventRow + visible.length;
+    return out;
   }
 
+  _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;
 
-    // Auto-follow newest active worker
-    if (this._followWorkerIdx >= 0 && this._followWorkerIdx < this.workers.length) {
-      const target = this._followWorkerIdx;
-      if (target < this.windowStart) {
-        this.windowStart = target;
-        this.dirtyWorkers = new Set();
-        for (let i = this.windowStart; i < this.windowStart + this.windowSize; i++) {
-          if (i < this.workers.length) this.dirtyWorkers.add(i);
-        }
-      } else if (target >= this.windowStart + this.windowSize) {
-        this.windowStart = target - this.windowSize + 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.dirtyStats) {
+      // Update stats bar (row 4)
+      const stats = this._buildStats();
+      const w = this._w;
+      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}`);
         }
       }
-    }
-
-    // Redraw everything on resize changes
-    if (this.dirtyStats) {
-      this._drawHeader();
-      this.dirtyWorkers = new Set(this.workers.map((_, i) => i));
+      this.dirtyStats = false;
     }
 
     if (this.dirtyWorkers.size > 0) {
       const w = this._w;
-      const b = C.border;
-      const r = A.reset;
-      const sep = `${b}${'─'.repeat(w - 2)}${r}`;
-
-      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}${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._drawFooter();
+      this._write(this._eventFeed());
     }
 
     this.dirtyWorkers.clear();
     this.dirtyEvents = false;
-    this.dirtyStats = false;
   }
 
   _startRenderLoop() {
     if (this._renderTimer) clearInterval(this._renderTimer);
-    this._renderTimer = setInterval(() => this._render(), 250); // 4 FPS
+    this._renderTimer = setInterval(() => this._render(), 250);
   }
 
-  _printSummaryPlain(summary) {
-    const { totalCoins = 0, totalCmds = 0, totalSuccess = 0,
-            workers = [], uptime = 0, memMB = 0 } = summary;
-    const b = '═'.repeat(60);
-    console.log('');
-    console.log(`  ${'═'.repeat(60)}`);
-    console.log(`  ⬡  DANKGRINDER — Session Summary`);
-    console.log(`  ${'─'.repeat(60)}`);
-    for (const wk of workers) {
-      const rate = wk.stats?.commands > 0
-        ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
-        : '0%';
-      console.log(
-        `  💎 ${(wk.username || '?').padEnd(18)}  +⏣ ${(wk.stats?.coins || 0).toLocaleString().padStart(8)}  ` +
-        `${(wk.stats?.commands || 0)}cmds  ${rate}  ♥${wk._lifesavers ?? '?'}  Lv.${wk._level ?? '?'}`
-      );
+  // ── 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;
     }
-    console.log(`  ${'─'.repeat(60)}`);
-    console.log(`  💰 Total: ⏣ ${totalCoins.toLocaleString()}  ${totalCmds}cmds  ${totalSuccess}%OK  ${this._fmtUptime(uptime)}  ${memMB}MB`);
-    console.log(`  ${'═'.repeat(60)}`);
-    console.log('');
+  }
+
+  _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`;
   }
 }