dankgrinder 7.77.0 → 7.79.0

package/lib/grinder.js

@@ -3,6 +3,7 @@ const Redis = require('ioredis');
 const commands = require('./commands');
 const { setDashboardActive, isCV2, ensureCV2, stripAnsi } = require('./commands/utils');
 const rawLogger = require('./rawLogger');
+const terminal = require('./terminal');
 const {
   BloomFilter, RingBuffer, TokenBucket, EMA, SlidingWindowCounter,
   AhoCorasick, LRUCache, StringPool, AsyncBatchQueue, JitterBackoff,
@@ -338,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}`,
@@ -1623,6 +1635,8 @@ class AccountWorker {
       // ── Death / lifesaver detection in command responses ──
       if (resultLower.includes('you died') || resultLower.includes('lifesaver protected')) {
         this.log('error', `DEATH DETECTED during ${cmdName}!`);
+        terminal.flashEvent('death', `💀 ${this.username} died — ${lsCount === 0 ? '0 lifesavers!' : (lsCount > 0 ? `${lsCount} lifesavers left` : 'check DM')}`);
+        terminal.markWorkerDirty(this.idx);
         // Check for lifesaver count in the response
         const lsMatch = result.match(/(\d+)\s*life\s*saver/i);
         const lsCount = lsMatch ? parseInt(lsMatch[1]) : -1;
@@ -1639,6 +1653,8 @@ class AccountWorker {
             await redis.set(`dkg:lifesavers:${this.account.id}`, String(lsCount), 'EX', 86400);
             this.log('warn', `Lifesaver used! ${lsCount} remaining.`);
             if (lsCount <= 2) {
+              terminal.flashEvent('lowls', `⚠ ${this.username} low lifesavers: ${lsCount} left`);
+              terminal.markWorkerDirty(this.idx);
               sendWebhook('LOW LIFESAVERS', `**${this.username}** has only **${lsCount}** lifesaver(s) left!`, 0xfbbf24);
             }
           }
@@ -1758,6 +1774,8 @@ class AccountWorker {
       this.setStatus(formattedResult);
       await sendLog(this.username, cmdName, result, 'success');
       reportEarnings(this.account.id, this.username, earned, spent, cmdName);
+      terminal.markWorkerDirty(this.idx);
+      if (earned > 0) terminal.flashEvent('success', `⚔ ${this.username} ${cmdName}: +⏣ ${earned.toLocaleString()}`);
 
       // Auto-sell fish every 5 fishing rounds
       if (cmdName === 'fish') {
@@ -2844,6 +2862,8 @@ async function start(apiKey, apiUrl, opts = {}) {
               w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
               w.setCooldown?.('crime', 86400);
               w.setCooldown?.('search', 86400);
+              terminal.flashEvent('death', `💀 ${w.username} DEATH in DM — 0 lifesavers!`);
+              terminal.markWorkerDirty(w.idx);
               sendWebhook?.('DEATH ALERT (DM)', `**${w.username}** died in DMs! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
             } else {
               w.log?.('warn', `DEATH in DMs — ${event.lifesaversLeft} lifesavers remaining`);
@@ -2861,6 +2881,8 @@ async function start(apiKey, apiUrl, opts = {}) {
         if (event.type === 'levelup') {
           if (event.to > 0) {
             w._level = event.to;
+            terminal.flashEvent('levelup', `⬆️ ${w.username} leveled up to Lv.${event.to}`);
+            terminal.markWorkerDirty(w.idx);
           }
         }
       }
@@ -2876,8 +2898,12 @@ async function start(apiKey, apiUrl, opts = {}) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
+  // ── Terminal renderer init ─────────────────────────────────────
+  terminal.setVersion(PKG_VERSION);
+  terminal.init({ workers, startTime });
+  terminal.startPhase(`Connecting ${accounts.length} accounts to Discord`);
+
   // ── Phase 1: Login accounts ─────────────────────────────────────────
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  Logging in ${accounts.length} account(s)...`);
   const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '50'), 10);
   const parsedGapMax = Number.parseInt(String(process.env.LOGIN_GAP_MAX_MS || '150'), 10);
   const LOGIN_GAP_MIN_MS = Number.isFinite(parsedGapMin) && parsedGapMin >= 0 ? parsedGapMin : 50;
@@ -2894,6 +2920,7 @@ async function start(apiKey, apiUrl, opts = {}) {
       workers.push(worker);
       workerMap.set(acc.id, worker);
       await worker.start();
+      terminal.updateProgress(workers.length, accounts.length);
     }));
     if (i + BATCH_SIZE < accounts.length) await new Promise(r => setTimeout(r, randomLoginGap()));
     hintGC();
@@ -2902,8 +2929,9 @@ async function start(apiKey, apiUrl, opts = {}) {
   const loginDone = workers.filter(w => !w._tokenInvalid && w.channel).length;
   const invalidWorkers = workers.filter(w => w._tokenInvalid);
   const timedOutWorkers = workers.filter(w => !w.channel && !w._tokenInvalid);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${loginDone}/${accounts.length} accounts connected`);
+  terminal.endPhase(`${loginDone}/${accounts.length} accounts connected`, true);
   if (invalidWorkers.length > 0) {
+    terminal.flashEvent('error', `${invalidWorkers.length} accounts have INVALID tokens`);
     log('warn', `${rgb(239, 68, 68)}${invalidWorkers.length} account(s) have INVALID tokens`);
     for (const w of invalidWorkers) log('error', `  ${w.account.label || w.account.id} — token invalid or expired`);
   }
@@ -2912,24 +2940,31 @@ async function start(apiKey, apiUrl, opts = {}) {
   const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
   // ── Phase 2: Inventory check ─────────────────────────────────────
-  console.log(`  ${rgb(34, 211, 238)}·${c.reset}  Checking inventory (${activeWorkers.length} accounts)...`);
+  terminal.startPhase('Checking inventory');
+  terminal.updateProgress(0, activeWorkers.length);
   let invDone = 0, invFailed = 0;
   await Promise.all(activeWorkers.map(async (w) => {
     try { await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
     catch { invFailed++; return; }
     invDone++;
+    terminal.updateProgress(invDone, activeWorkers.length);
   }));
 
   if (invFailed > 0) {
+    terminal.endPhase(`Inventory: ${invFailed} failed`, false);
     console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  Inventory: ${invFailed} failed — not starting grind loops`);
     return;
   }
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  Inventory: ${invDone}/${activeWorkers.length} clear`);
+  terminal.endPhase(`Inventory: ${invDone} clear`);
 
   // ── Phase 2.5: Balance check ────────────────────────────────────
-  console.log(`  ${rgb(251, 191, 36)}·${c.reset}  Checking balance (${activeWorkers.length} accounts)...`);
+  terminal.startPhase('Checking balance');
+  terminal.updateProgress(0, activeWorkers.length);
+  let balDone = 0;
   await Promise.all(activeWorkers.map(async (w) => {
     try { await w.checkBalance(true); } catch {}
+    balDone++;
+    terminal.updateProgress(balDone, activeWorkers.length);
   }));
 
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
@@ -2938,13 +2973,16 @@ async function start(apiKey, apiUrl, opts = {}) {
     totalBank += w.stats?.bankBalance || 0;
     if (w._lifesavers === 0) noLifesaverAccounts.push(w.username || w.account.label);
   }
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  Balance: ${c.green}⏣ ${(totalWallet + totalBank).toLocaleString()}${c.reset} ${c.dim}(wallet: ⏣ ${totalWallet.toLocaleString()} + bank: ⏣ ${totalBank.toLocaleString()})${c.reset}`);
+  terminal.endPhase(`Balance: ⏣ ${(totalWallet + totalBank).toLocaleString()}`);
   if (noLifesaverAccounts.length > 0) {
+    terminal.flashEvent('warn', `${noLifesaverAccounts.length} accounts have 0 LIFESAVERS`);
     console.log(`  ${rgb(239, 68, 68)}⚠${c.reset}  ${noLifesaverAccounts.length} account(s) have 0 LIFESAVERS — crime/search disabled`);
   }
 
   // ── Phase 2.75: DM history check ────────────────────────────────
-  console.log(`  ${rgb(139, 92, 246)}·${c.reset}  Checking DM history...`);
+  terminal.startPhase('Checking DM history');
+  terminal.updateProgress(0, activeWorkers.length);
+  let dmDone = 0;
   let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [], dmUnknown = [];
   for (const w of activeWorkers) {
     try {
@@ -2956,8 +2994,11 @@ async function start(apiKey, apiUrl, opts = {}) {
       if (dm.currentLevel > 0) w._level = dm.currentLevel;
       if (dm.lifesavers >= 0) w._lifesavers = dm.lifesavers;
     } catch {}
+    dmDone++;
+    terminal.updateProgress(dmDone, activeWorkers.length);
   }
   if (dmNoLs.length > 0) {
+    terminal.flashEvent('warn', `No lifesavers: ${dmNoLs.join(', ')}`);
     log('warn', `⚠ No lifesavers: ${dmNoLs.join(', ')}`);
     for (const w of activeWorkers) {
       if (dmNoLs.includes(w.username) && redis) {
@@ -2975,17 +3016,16 @@ async function start(apiKey, apiUrl, opts = {}) {
   if (dmDeaths > 0) dmSummaryParts.push(`${dmDeaths} deaths`);
   if (dmLevelUps > 0) dmSummaryParts.push(`${dmLevelUps} level-ups`);
   if (dmUnknown.length > 0) dmSummaryParts.push(`${dmUnknown.length} pending`);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  DM check: ${dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean'}`);
+  terminal.endPhase(`DM check: ${dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean'}`);
 
   // ── Phase 3: Start grind loops ───────────────────────────────────
-  console.log(`  ${rgb(139, 92, 246)}>>>${c.reset}  Starting grind loops...`);
-  // Phase 3: Start all grind loops (only for valid workers)
+  terminal.startPhase(`🚀 Launching ${activeWorkers.length} grinders!`);
   for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();
   }
-
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  All grind loops started — ${activeWorkers.length} accounts active`);
-  console.log(`  v${PKG_VERSION}  |  press Ctrl+C to stop`);
+  terminal.endPhase(`${activeWorkers.length} grinders active`);
+  terminal.setWorkers(workers);
+  terminal.setActive();
 
   // Cluster heartbeat — lets other nodes see this node is alive
   if (CLUSTER_ENABLED) {
@@ -3052,35 +3092,26 @@ async function start(apiKey, apiUrl, opts = {}) {
     sigintHandled = true;
     shutdownCalled = true;
     setDashboardActive(false);
-    process.stdout.write('\x1b[?25h'); // show cursor
-
-    const tw = process.stdout.columns || 80;
-    const sepBar = rgb(139, 92, 246) + c.bold + '─'.repeat(tw - 4) + c.reset;
-    console.log('');
-    console.log(`  ${rgb(251, 191, 36)}${c.bold}Session Summary${c.reset}`);
-    console.log(sepBar);
 
-    // Collect stats from all workers (including rotated-out ones)
-    let finalCoins = 0;
-    let finalCmds = 0;
+    // Collect stats for summary
+    let finalCoins = 0, finalCmds = 0, totalSuccess = 0;
     for (const wk of workers) {
-      const rate = wk.stats.commands > 0 ? ((wk.stats.successes / wk.stats.commands) * 100).toFixed(0) : 0;
-      console.log(
-        `  ${wk.color}${c.bold}${(wk.username || '?').padEnd(18)}${c.reset}` +
-        `  ${rgb(52, 211, 153)}+⏣ ${wk.stats.coins.toLocaleString().padStart(8)}${c.reset}` +
-        `  ${c.dim}${wk.stats.commands.toString().padStart(4)} cmds${c.reset}` +
-        `  ${c.dim}${rate}% success${c.reset}`
-      );
       finalCoins += wk.stats.coins || 0;
       finalCmds += wk.stats.commands || 0;
+      totalSuccess += wk.stats.successes || 0;
     }
-    console.log(sepBar);
-
     const memFinal = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
-    const avgEarn = globalEarningsEMA.get();
-    const cpm = globalCmdRate.getRate().toFixed(1);
-    console.log(`  ${rgb(251, 191, 36)}${c.bold}Total: +⏣ ${finalCoins.toLocaleString()}${c.reset} ${c.dim}in ${formatUptime()} | ${finalCmds} cmds | ~${cpm} cmd/m | ${memFinal}MB | avg earn ⏣ ${Math.round(avgEarn)}${c.reset}`);
-    console.log('');
+    const uptimeMs = Date.now() - startTime;
+
+    // Show beautiful session summary via terminal renderer
+    terminal.shutdown({
+      totalCoins: finalCoins,
+      totalCmds: finalCmds,
+      totalSuccess: finalCmds > 0 ? ((totalSuccess / finalCmds) * 100).toFixed(0) : 0,
+      workers,
+      uptime: uptimeMs,
+      memMB: memFinal,
+    });
 
     // Release all cluster claims before stopping workers
     const releasePromises = workers.map(wk => releaseClaim(wk.account.id).catch(() => {}));
@@ -3096,22 +3127,14 @@ async function start(apiKey, apiUrl, opts = {}) {
 
     const totalRecoveries = workers.reduce((sum, wk) => sum + (wk._totalRecoveries || 0), 0);
     const totalDisconnects = workers.reduce((sum, wk) => sum + (wk._disconnectCount || 0), 0);
-    const totalRateLimits = workers.reduce((sum, wk) => sum + (wk._rateLimitHits || 0), 0);
 
     const webhookMsg = `+⏣ ${finalCoins.toLocaleString()} | ${finalCmds} cmds | ${formatUptime()}` +
       (totalRecoveries > 0 ? ` | ${totalRecoveries} auto-recoveries` : '') +
       (CLUSTER_ENABLED ? ` | node: ${NODE_ID.substring(0, 12)}` : '');
     sendWebhook('Session Ended', webhookMsg, 0x8b5cf6);
 
-    if (totalRecoveries > 0 || totalDisconnects > 0) {
-      console.log(`  ${c.dim}Recovery stats: ${totalRecoveries} auto-recoveries, ${totalDisconnects} disconnects, ${totalRateLimits} rate limits${c.reset}`);
-    }
-    if (CLUSTER_ENABLED) {
-      console.log(`  ${c.dim}Cluster node: ${NODE_ID} — claims released${c.reset}`);
-    }
-
     if (redis) { try { redis.disconnect(); } catch {} }
-    setTimeout(() => process.exit(0), 1500);
+    setTimeout(() => process.exit(0), 500);
   });
 }
 

package/lib/terminal.js

@@ -0,0 +1,739 @@
+/**
+ * terminal.js — Modern 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
+ */
+
+const READY = (() => {
+  try {
+    return process.stdout.isTTY && !process.env.NO_TERM;
+  } catch (_) { return false; }
+})();
+
+// ── 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
+  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',
+};
+
+// ── Color scheme ────────────────────────────────────────────────────────────
+
+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: '│',
+};
+
+// ── Spinner frames ──────────────────────────────────────────────────────────
+
+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 = [];
+    this.MAX_EVENTS = 4;
+
+    this.phaseName = '';
+    this.phaseFrame = 0;
+    this.phaseTimer = null;
+
+    this.dirtyWorkers = new Set();
+    this.dirtyEvents = false;
+    this.dirtyStats = true;
+    this._renderTimer = null;
+    this._startTime = 0;
+
+    this.windowStart = 0;
+    this.windowSize = 8;
+    this._followIdx = -1;
+
+    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;
+  }
+
+  // ── Public API ──────────────────────────────────────────────────────────
+
+  init(opts = {}) {
+    this._startTime = opts.startTime || Date.now();
+    this.workers = opts.workers || [];
+    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;
+      _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();
+    }
+  }
+
+  setVersion(v) { this._version = v; }
+
+  startPhase(name) {
+    this.phaseName = name;
+    this.phaseFrame = 0;
+    this._phaseProgressDone = 0;
+    this._phaseProgressTotal = 0;
+
+    if (!READY) {
+      console.log(`  ⟳ ${name}...`);
+      return;
+    }
+    if (this.phaseTimer) clearInterval(this.phaseTimer);
+    this.phaseTimer = setInterval(() => {
+      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._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 ? `✓ ${name}` : `✗ ${name}`;
+      console.log(`  ${icon}`);
+      return;
+    }
+    const icon = ok ? `${C.header}✓${A.reset}` : `${A.crimson}✗${A.reset}`;
+    const line = `  ${icon}  ${name}`;
+    const w = this._w;
+
+    // Clear spinner + progress rows, show result
+    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.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}`;
+    this.events.unshift({ ts, type, msg, id: Date.now() });
+    if (this.events.length > this.MAX_EVENTS) this.events.pop();
+    this.dirtyEvents = true;
+  }
+
+  setWorkers(workers) {
+    this.workers = workers;
+    this.dirtyWorkers = new Set(workers.map((_, i) => i));
+    this.dirtyStats = true;
+  }
+
+  markWorkerDirty(idx) {
+    this.dirtyWorkers.add(idx);
+  }
+
+  setActive() {
+    if (this._active) return;
+    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
+      _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._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);
+    }
+  }
+
+  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;
+    }
+
+    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;
+
+    // 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 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
+    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;
+
+    this._write(out);
+  }
+
+  // ── Internal ────────────────────────────────────────────────────────────
+
+  _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;
+    }
+  }
+
+  _onResize() {
+    if (this._resizeTimer) clearTimeout(this._resizeTimer);
+    this._resizeTimer = setTimeout(() => {
+      this._updateSize();
+      if (this._active) {
+        this._write(A.eraseAll);
+        this._drawLiveView();
+      }
+    }, 100);
+  }
+
+  _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;
+  }
+
+  _rpad(s, width) {
+    return s + ' '.repeat(Math.max(0, width - this._ansiLen(s)));
+  }
+
+  _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';
+    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`;
+  }
+
+  _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);
+  }
+
+  _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%';
+
+    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';
+    }
+
+    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('  ');
+
+    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}`;
+
+    this._write(out);
+  }
+
+  _redrawPhaseSpinner() {
+    if (!READY || !this._phaseName) return;
+    const frame = SPIN[this.phaseFrame];
+    const line = `  ${frame}  ${this.phaseName}...`;
+    const w = this._w;
+    const b = C.border;
+    const r = A.reset;
+    this._write(
+      A.save +
+      this._cursor(8, 1) + A.clearLine +
+      `${b} ${line}${' '.repeat(Math.max(0, w - this._ansiLen(line) - 3))}${r}` +
+      A.restore
+    );
+  }
+
+  _redrawProgressBar() {
+    if (!READY || !this._phaseName) return;
+    const { done, total } = { done: this._phaseProgressDone, total: this._phaseProgressTotal };
+    const w = this._w;
+    const h = C.header;
+    const dim = A.dim;
+    const r = A.reset;
+
+    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;
+    this._write(
+      A.save +
+      this._cursor(9, 1) + A.clearLine +
+      `${C.border} ${line}${' '.repeat(Math.max(0, w - this._ansiLen(line) - 3))}${r}` +
+      A.restore
+    );
+  }
+
+  _drawLiveView() {
+    this._drawHeader();
+    this._drawAccounts();
+    this._drawEvents();
+    this._drawFooter();
+  }
+
+  _drawHeader() {
+    const w = this._w;
+    const b = C.border;
+    const h = C.header;
+    const g = C.statValue;
+    const dim = A.dim;
+    const r = A.reset;
+
+    // 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();
+    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() {
+    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;
+      if (wk._lifesavers != null) totalLs += wk._lifesavers;
+      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';
+
+    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(`  │  `);
+  }
+
+  _drawAccounts() {
+    const w = this._w;
+    const b = C.border;
+    const h = C.header;
+    const r = A.reset;
+
+    // Column headers
+    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);
+    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}`);
+      } else {
+        this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
+      }
+    }
+    this._eventsRow = this._accountsRow + 2 + Math.min(this.windowSize, this.workers.length);
+  }
+
+  _drawEvents() {
+    const w = this._w;
+    const b = C.border;
+    const dim = A.dim;
+    const r = A.reset;
+
+    if (this._eventsRow > this._h - 4) return;
+    this._write(`${this._at(this._eventsRow, 1)}${b}${C.h}${'─'.repeat(w - 2)}${C.h}${r}`);
+
+    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 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 + visible.length;
+  }
+
+  _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}`);
+  }
+
+  _render() {
+    if (!READY || this._shutdown || !this._active) return;
+
+    // Only update stats line (row 4) when dirty — don't redraw whole header
+    if (this.dirtyStats) {
+      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;
+      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}`);
+        } else {
+          this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
+        }
+      }
+    }
+
+    if (this.dirtyEvents) {
+      this._drawEvents();
+    }
+
+    this.dirtyWorkers.clear();
+    this.dirtyEvents = false;
+  }
+
+  _startRenderLoop() {
+    if (this._renderTimer) clearInterval(this._renderTimer);
+    this._renderTimer = setInterval(() => {
+      this.dirtyStats = true; // always refresh uptime/stats
+      this._render();
+    }, 250);
+  }
+}
+
+module.exports = new Terminal();

package/package.json

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