dankgrinder 7.78.0 → 7.79.0

package/lib/grinder.js

@@ -339,6 +339,17 @@ function colorBanner() {
 
 // ── Simple Logging ─────────────────────────────────────────────
 function log(type, msg, label) {
+  // Route grinding logs through terminal flash events when active
+  if (terminal._active) {
+    const clean = stripAnsi(String(msg || '')).substring(0, 120);
+    const tagClean = stripAnsi(String(label || ''));
+    terminal.flashEvent(
+      type === 'error' ? 'death' : type === 'warn' ? 'warn' : 'info',
+      `${tagClean ? tagClean + ' ' : ''}${clean}`
+    );
+    return;
+  }
+
   const colorIcons = {
     info: `${c.dim}·${c.reset}`, success: `${rgb(52, 211, 153)}✓${c.reset}`,
     error: `${rgb(239, 68, 68)}✗${c.reset}`, warn: `${rgb(251, 191, 36)}!${c.reset}`,

package/lib/terminal.js

@@ -1,29 +1,13 @@
 /**
  * terminal.js — Modern animated terminal renderer for DankGrinder
  *
- * Design goals:
- * - Single-line-per-account rows (scales to 10k+ accounts)
- * - Virtual window: only renders visible slice of accounts
+ * 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 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                                       │
- *  └──────────────────────────────────────────────────────────────────────────────┘
+ * - Graceful degradation: falls back to plain console.log if not TTY
  */
 
 const READY = (() => {
@@ -40,51 +24,39 @@ const A = {
   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
+  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
   rgb: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
 
   // Cursor
-  save: '\x1b7',
-  restore: '\x1b8',
-  hide: '\x1b[?25l',
-  show: '\x1b[?25h',
+  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
+  // 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',
 };
 
 // ── Color scheme ────────────────────────────────────────────────────────────
@@ -92,60 +64,63 @@ const A = {
 const C = {
   header: A.purple,
   headerDim: A.rgb(100, 70, 180),
-  border: A.rgb(60, 50, 90),
-  borderDim: A.rgb(40, 35, 60),
+  border: A.rgb(55, 45, 85),
+  borderDim: A.rgb(35, 30, 55),
 
-  rowDefault: A.white,
-  rowAlt: A.rgb(30, 28, 45),
-  rowHighlight: A.rgb(25, 23, 40),
-
-  name: A.rgb(255, 255, 255),
+  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,    // 🟢 grinding
-  statusPaused: A.crimson,    // 🔴 paused
-  statusWarning: A.orange,     // 🟡 warning
-  statusOffline: A.slate,      // ⚫ offline
-  statusConnecting: A.yellow,  // 🟡 connecting
+  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,
 
-  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),
+  // Box styles
+  topLeft: '╭', topRight: '╮',
+  botLeft: '╰', botRight: '╯',
+  h: '─', v: '│',
 };
 
 // ── Spinner frames ──────────────────────────────────────────────────────────
 
-const SPINNERS = {
-  dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠿'],
-  moon: ['🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘'],
-  arrows: ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙'],
-  pulse: ['▓', '▒', '░', '▒'],
-};
+const SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠿'];
+
+// ── stdout capture during startup ─────────────────────────────────────────
+
+let _origWrite = null;
+let _captureActive = false;
+let _captureBuf = [];
+
+function _captureWrite(chunk) {
+  if (_captureActive) {
+    _captureBuf.push(String(chunk));
+    return;
+  }
+  return _origWrite.call(process.stdout, chunk);
+}
 
 // ── Terminal Renderer ────────────────────────────────────────────────────────
 
 class Terminal {
   constructor() {
     this.workers = [];
-    this.events = [];           // recent event feed (last N events)
-    this.MAX_EVENTS = 5;
+    this.events = [];
+    this.MAX_EVENTS = 4;
 
     this.phaseName = '';
     this.phaseFrame = 0;
@@ -157,44 +132,54 @@ class Terminal {
     this._renderTimer = null;
     this._startTime = 0;
 
-    // Virtual window state
     this.windowStart = 0;
-    this.windowSize = 10;
-    this.scrollLocked = false;   // true = auto-follow most active worker
+    this.windowSize = 8;
+    this._followIdx = -1;
 
     this._lineCount = 0;
     this._active = false;
     this._shutdown = false;
 
-    // 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`;
+
+    // ── Startup capture ──
+    this._capturing = false;
+    this._origLog = null;
+    this._phaseProgressDone = 0;
+    this._phaseProgressTotal = 0;
   }
 
   // ── 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);
+      // Override stdout.write to capture everything during startup
+      _origWrite = process.stdout.write.bind(process.stdout);
+      process.stdout.write = _captureWrite;
+      this._capturing = true;
+      _captureActive = true;
+      _captureBuf = [];
+
+      // Also override console.log temporarily
+      this._origLog = console.log;
+      console.log = (...args) => {
+        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);
+        } else {
+          _captureWrite(args.join(' ') + '\n');
+        }
+      };
+
       process.stdout.on('resize', this._onResize.bind(this));
       this._drawStartupScreen();
-    } else {
-      console.log(`${C.header}🚀 DankGrinder starting...${A.reset}`);
     }
   }
 
@@ -203,46 +188,56 @@ class Terminal {
   startPhase(name) {
     this.phaseName = name;
     this.phaseFrame = 0;
+    this._phaseProgressDone = 0;
+    this._phaseProgressTotal = 0;
+
     if (!READY) {
-      console.log(`  ${A.dim}⟳${A.reset} ${name}...`);
+      console.log(`  ⟳ ${name}...`);
       return;
     }
     if (this.phaseTimer) clearInterval(this.phaseTimer);
     this.phaseTimer = setInterval(() => {
-      this.phaseFrame = (this.phaseFrame + 1) % SPINNERS.dots.length;
+      this.phaseFrame = (this.phaseFrame + 1) % SPIN.length;
       this._redrawPhaseSpinner();
     }, 120);
     this._redrawPhaseSpinner();
   }
 
   updateProgress(done, total) {
+    this._phaseProgressDone = done;
+    this._phaseProgressTotal = total;
     if (!READY) return;
-    this._writePhaseProgress(done, total);
+    this._redrawProgressBar();
   }
 
   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 ? `${C.header}✓${A.reset}` : `${A.crimson}✗${A.reset}`;
-      console.log(`  ${icon} ${name}`);
+      const icon = ok ? `✓ ${name}` : `✗ ${name}`;
+      console.log(`  ${icon}`);
       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(
+    const line = `  ${icon}  ${name}`;
+    const w = this._w;
+
+    // Clear spinner + progress rows, show result
+    this._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}` +
+      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.restore
     );
-    // Clear spinner line
-    process.stdout.write(this._cursor(3, 1) + A.clearLine);
   }
 
   flashEvent(type, msg) {
@@ -266,50 +261,75 @@ class Terminal {
   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();
+    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
+      _captureBuf = [];
+
+      // Full screen clear + scrollback clear
+      this._write(A.eraseAll);
+
+      // Draw live view
+      this._drawLiveView();
+
+      // Reset dirty flags so we don't redraw header every frame
+      this.dirtyWorkers.clear();
+      this.dirtyEvents = false;
+      this.dirtyStats = false;
+
+      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._followWorkerIdx = -1;  // manual scroll cancels auto-follow
+    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);
     }
   }
 
-  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;
-    }
-  }
-
   shutdown(summary = {}) {
     this._shutdown = true;
     if (this._renderTimer) { clearInterval(this._renderTimer); this._renderTimer = null; }
     if (this._phaseTimer) { clearInterval(this._phaseTimer); this._phaseTimer = null; }
 
-    process.stdout.write(A.show);
-
-    if (!READY) {
-      this._printSummaryPlain(summary);
-      return;
+    // Restore stdout state
+    if (READY && _origWrite) {
+      process.stdout.write = _origWrite;
+      _origWrite = null;
+    }
+    if (this._origLog) {
+      console.log = this._origLog;
+      this._origLog = null;
     }
 
-    // Move to clean area below any existing output
-    const cols = this._w;
+    this._write(A.show);
+
+    const w = this._w;
     const { totalCoins = 0, totalCmds = 0, totalSuccess = 0,
             workers = [], uptime = 0, memMB = 0 } = summary;
 
@@ -319,45 +339,68 @@ class Terminal {
     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`;
+    out += A.eraseAll + A.home + A.save;
+
+    // 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}`;
+
+    // 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 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}`;
+      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}`;
     }
 
-    row++; // blank row
-    out += `${this._at(row++, 1)}${bar}`;
-
-    // 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}`;
+    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;
 
-    process.stdout.write(out);
-    setTimeout(() => {}, 100);
+    this._write(out);
   }
 
   // ── Internal ────────────────────────────────────────────────────────────
@@ -366,10 +409,9 @@ class Terminal {
     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);
+      this.windowSize = Math.max(3, this._h - 11);
     } catch (_) {
-      this._w = 80; this._h = 24; this.windowSize = 10;
+      this._w = 80; this._h = 24; this.windowSize = 8;
     }
   }
 
@@ -378,52 +420,32 @@ class Terminal {
     this._resizeTimer = setTimeout(() => {
       this._updateSize();
       if (this._active) {
-        this._clearScreen();
+        this._write(A.eraseAll);
         this._drawLiveView();
       }
     }, 100);
   }
 
   _ansiLen(s) {
-    // Fast ANSI strip — just count escape sequences by looking for \x1b[
-    let len = 0;
-    let i = 0;
+    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++;
-      }
+      } else { len++; i++; }
     }
     return len;
   }
 
   _rpad(s, width) {
-    const len = this._ansiLen(s);
-    const pad = width > len ? width - len : 0;
-    return s + (pad > 0 ? ' '.repeat(pad) : '');
+    return s + ' '.repeat(Math.max(0, width - this._ansiLen(s)));
   }
 
-  _cursor(row, col) {
-    // Position cursor at absolute row/col (1-indexed)
-    return `\x1b[${row};${col}H`;
-  }
-
-  _at(row, col) {
-    return `\x1b[${row};${col}H`;
-  }
-
-  _write(str) {
-    process.stdout.write(str);
-  }
-
-  _ansi(s, code) { return `${code}${s}${A.reset}`; }
-  _bold(s) { return `${A.bold}${s}${A.reset}`; }
-  _dim(s) { return `${A.dim}${s}${A.reset}`; }
+  _cursor(row) { return `\x1b[${row};1H`; }
+  _at(row, col) { return `\x1b[${row};${col}H`; }
+  _write(str) { if (str) process.stdout.write(str); }
 
   _fmtUptime(ms) {
     if (!ms) return '0s';
@@ -433,8 +455,7 @@ class Terminal {
     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`;
+    return `${Math.floor(h / 24)}d ${h % 24}h`;
   }
 
   _fmtCoins(n) {
@@ -445,53 +466,35 @@ class Terminal {
 
   _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);
+    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%';
 
-    // 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;
+      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'; rowBg = '';
+      statusDot = '🟢'; statusText = 'grinding';
     }
 
-    // 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%';
-
-    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,
+    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),
-      `${this._dim(cmd)}`,
-    ];
+      `${A.dim}${(wk.lastStatus || '').substring(0, 22).padEnd(22)}${A.reset}`,
+    ].join('  ');
 
-    // Join and pad to screen width
-    const line = parts.join('  ');
     return this._rpad(line, w);
   }
 
@@ -499,94 +502,68 @@ class Terminal {
     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 = (c) => `${b}${c.repeat(w - 2)}${r}`;
-
-    // Figure out how many rows we need for the spinner
-    const spinnerRow = 3;
-    const progressRow = 5;
-    const readyRow = 7;
-
     let out = '';
-    out += `${A.clear}${A.home}`;
+    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}`;
 
-    // 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;
+    if (!READY || !this._phaseName) return;
+    const frame = SPIN[this.phaseFrame];
+    const line = `  ${frame}  ${this.phaseName}...`;
     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;
     this._write(
-      `${A.save}` +
-      `${this._cursor(6, 1)}` +
-      `${b}${padded}${r}` +
-      `${A.restore}`
+      A.save +
+      this._cursor(8, 1) + A.clearLine +
+      `${b} ${line}${' '.repeat(Math.max(0, w - this._ansiLen(line) - 3))}${r}` +
+      A.restore
     );
   }
 
-  _writePhaseProgress(done, total) {
-    if (!READY) {
-      console.log(`  ${A.dim}  → ${done}/${total}${A.reset}`);
-      return;
-    }
+  _redrawProgressBar() {
+    if (!READY || !this._phaseName) return;
+    const { done, total } = { done: this._phaseProgressDone, total: this._phaseProgressTotal };
     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 barW = Math.max(10, w - 35);
+    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 pad = w - this._ansiLen(line) - 2;
-
+    const line = bar + label;
     this._write(
-      `${A.save}` +
-      `${this._cursor(6, 1)}` +
-      `${b}${line}${' '.repeat(Math.max(0, pad))}${r}` +
-      `${A.restore}`
+      A.save +
+      this._cursor(9, 1) + A.clearLine +
+      `${C.border} ${line}${' '.repeat(Math.max(0, w - this._ansiLen(line) - 3))}${r}` +
+      A.restore
     );
   }
 
-  _clearScreen() {
-    this._write(`${A.clear}${A.home}`);
-  }
-
   _drawLiveView() {
-    if (!READY) return;
     this._drawHeader();
     this._drawAccounts();
     this._drawEvents();
@@ -601,94 +578,79 @@ class Terminal {
     const dim = A.dim;
     const r = A.reset;
 
-    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
-    const title = ` ⬡  DANKGRINDER v${this._version || '?'} `;
-    const titlePad = w - 2 - this._ansiLen(title);
-
-    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;
+    // 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}`);
 
     // 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}`);
+    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}`);
+
+    this._accountsRow = 6;
   }
 
   _buildStatsLine() {
-    const g = C.statValue;
-    const dim = A.dim;
-    const h = C.header;
-    const coins = C.coins;
-
     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;
       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 || Date.now()));
-    const rate = totalCmds > 0 ? ((totalSuccess / totalCmds) * 100).toFixed(0) : 0;
+    const uptime = this._fmtUptime(Date.now() - this._startTime);
+    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('   ');
+      `${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(`  │  `);
   }
 
   _drawAccounts() {
     const w = this._w;
     const b = C.border;
-    const dim = A.dim;
+    const h = C.header;
     const r = A.reset;
-    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
-
-    const visible = this.workers.slice(this.windowStart, this.windowStart + this.windowSize);
 
-    // Column header
+    // Column headers
     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}`);
+      `${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}`);
 
-    // Worker rows
+    const visible = this.workers.slice(this.windowStart, this.windowStart + this.windowSize);
     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 wk = visible[i];
-        const line = this._buildAccountRow(wk, this.windowStart + i);
-        this._write(`${this._at(row, 1)}${b}${line}${r}`);
+        const line = this._buildAccountRow(visible[i], this.windowStart + i);
+        this._write(`${this._at(row, 1)}${b} ${line} ${C.v}${r}`);
       } else {
         this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
       }
     }
-    this._eventsRow = this._accountsRow + 2 + this.windowSize + 1;
+    this._eventsRow = this._accountsRow + 2 + Math.min(this.windowSize, this.workers.length);
   }
 
   _drawEvents() {
@@ -696,25 +658,24 @@ class Terminal {
     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}`);
+    this._write(`${this._at(this._eventsRow, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`);
 
-    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 visible = this.events.slice(0, Math.min(this.MAX_EVENTS, this._h - this._eventsRow - 3));
+    for (let i = 0; i < visible.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}`);
+      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}`);
     }
-    this._footerRow = this._eventsRow + 1 + visibleEvents.length;
+    this._footerRow = this._eventsRow + 1 + visible.length;
   }
 
   _drawFooter() {
@@ -722,56 +683,36 @@ class Terminal {
     const b = C.border;
     const dim = A.dim;
     const r = A.reset;
-    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
-
     if (this._footerRow > this._h - 1) this._footerRow = this._h - 2;
-    this._write(`${this._at(this._footerRow, 1)}${sep}`);
-
-    const hint = `${dim}↑↓ scroll · j/k navigate · Ctrl+C quit${r}`;
+    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}`);
   }
 
   _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);
-        }
-      }
-    }
-
-    // Redraw everything on resize changes
+    // Only update stats line (row 4) when dirty — don't redraw whole header
     if (this.dirtyStats) {
-      this._drawHeader();
-      this.dirtyWorkers = new Set(this.workers.map((_, i) => i));
+      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}`);
+      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}`);
+          this._write(`${this._at(row, 1)}${b} ${line} ${C.v}${r}`);
         } else {
           this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
         }
@@ -780,40 +721,18 @@ class Terminal {
 
     if (this.dirtyEvents) {
       this._drawEvents();
-      this._drawFooter();
     }
 
     this.dirtyWorkers.clear();
     this.dirtyEvents = false;
-    this.dirtyStats = false;
   }
 
   _startRenderLoop() {
     if (this._renderTimer) clearInterval(this._renderTimer);
-    this._renderTimer = setInterval(() => this._render(), 250); // 4 FPS
-  }
-
-  _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 ?? '?'}`
-      );
-    }
-    console.log(`  ${'─'.repeat(60)}`);
-    console.log(`  💰 Total: ⏣ ${totalCoins.toLocaleString()}  ${totalCmds}cmds  ${totalSuccess}%OK  ${this._fmtUptime(uptime)}  ${memMB}MB`);
-    console.log(`  ${'═'.repeat(60)}`);
-    console.log('');
+    this._renderTimer = setInterval(() => {
+      this.dirtyStats = true; // always refresh uptime/stats
+      this._render();
+    }, 250);
   }
 }
 

package/package.json

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