dankgrinder 8.36.0 → 8.37.0

package/lib/grinder.js

@@ -2750,10 +2750,13 @@ async function start(apiKey, apiUrl, opts = {}) {
             const prev = w._lifesavers;
             w._lifesavers = event.lifesaversLeft;
             if (event.lifesaversLeft === 0) {
-              w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
+              w.lastStatus = 'DEAD';
+              w._alert = { type: 'death' };
               w.setCooldown?.('crime', 86400);
               w.setCooldown?.('search', 86400);
               sendWebhook?.('DEATH ALERT (DM)', `**${w.username}** died in DMs! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
+              ui.logEvent(`${c.red}E${c.reset} DEATH — ${w.username} has 0 lifesavers! Crime/search disabled`);
+              ui.draw();
             } else {
               w.log?.('warn', `DEATH in DMs — ${event.lifesaversLeft} lifesavers remaining`);
               if (prev !== event.lifesaversLeft) {
@@ -2761,7 +2764,10 @@ async function start(apiKey, apiUrl, opts = {}) {
                 w.setCooldown?.('search', 60);
               }
               if (event.lifesaversLeft <= 2) {
+                w._alert = { type: 'lowls' };
                 sendWebhook?.('LOW LIFESAVERS', `**${w.username}** has only **${event.lifesaversLeft}** lifesaver(s) left!`, 0xfbbf24);
+                ui.logEvent(`${c.yellow}!${c.reset} ${w.username} — only ${event.lifesaversLeft} lifesavers!`);
+                ui.draw();
               }
             }
           }
@@ -2770,6 +2776,7 @@ async function start(apiKey, apiUrl, opts = {}) {
         if (event.type === 'levelup') {
           if (event.to > 0) {
             w._level = event.to;
+            ui.logEvent(`${c.blue}↑${c.reset} ${w.username} leveled up to ${event.to}`);
           }
         }
       }
@@ -2783,8 +2790,8 @@ async function start(apiKey, apiUrl, opts = {}) {
   const LOGIN_GAP_MAX_MS = Number.isFinite(parsedGapMax) && parsedGapMax >= LOGIN_GAP_MIN_MS ? parsedGapMax : Math.max(parsedGapMin, 150);
   const randomLoginGap = () => LOGIN_GAP_MAX_MS <= LOGIN_GAP_MIN_MS ? LOGIN_GAP_MIN_MS : LOGIN_GAP_MIN_MS + Math.floor(Math.random() * (LOGIN_GAP_MAX_MS - LOGIN_GAP_MIN_MS + 1));
 
-  ui.start(); // show dashboard before login
-  ui.printLogin(`${c.dim}Logging in ${accounts.length} accounts...${c.reset}`);
+  ui.draw(); // draw initial table
+  ui.logEvent(`${c.dim}Logging in ${accounts.length} accounts...${c.reset}`);
   const BATCH_SIZE = 10;
   for (let i = 0; i < accounts.length; i += BATCH_SIZE) {
     if (shutdownCalled) break;
@@ -2799,21 +2806,21 @@ async function start(apiKey, apiUrl, opts = {}) {
           await worker.start();
           if (worker._tokenInvalid) {
             worker.lastStatus = 'invalid token';
-            ui.printLogin(`  ${c.red}✗${c.reset} [${i + idx + 1}] ${acc.label || acc.id}: invalid token`);
+            ui.logEvent(`${c.red}E${c.reset} [${i + idx + 1}] ${acc.label || acc.id} — invalid token`);
           } else if (worker.channel) {
             worker.lastStatus = 'ready';
-            ui.printLogin(`  ${c.green}✓${c.reset} [${i + idx + 1}] ${worker.username}`);
-            ui.render();
+            ui.logEvent(`${c.green}·${c.reset} [${i + idx + 1}] ${worker.username} connected`);
+            ui.draw();
           } else {
             worker.lastStatus = 'timeout';
-            ui.printLogin(`  ${c.yellow}✗${c.reset} [${i + idx + 1}] ${acc.label || acc.id}: timeout`);
+            ui.logEvent(`${c.yellow}·${c.reset} [${i + idx + 1}] ${acc.label || acc.id} — timeout`);
           }
         } catch (e) {
-          ui.printLogin(`  ${c.red}✗${c.reset} [${i + idx + 1}] ERROR: ${e.message}`);
+          ui.logEvent(`${c.red}E${c.reset} [${i + idx + 1}] ERROR: ${e.message}`);
         }
       }));
     } catch (e) {
-      ui.printLogin(`${c.red}BATCH ERROR: ${e.message}${c.reset}`);
+      ui.logEvent(`${c.red}!${c.reset} BATCH ERROR: ${e.message}`);
     }
     if (i + BATCH_SIZE < accounts.length) await new Promise(r => setTimeout(r, randomLoginGap()));
     hintGC();
@@ -2822,32 +2829,32 @@ 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);
-  ui.printLogin(`${c.green}Login complete: ${loginDone}/${accounts.length} connected${c.reset}`);
+  ui.logEvent(`${c.green}·${c.reset} Login: ${loginDone}/${accounts.length} connected`);
   if (invalidWorkers.length > 0) {
-    for (const w of invalidWorkers) ui.printLogin(`  ${c.red}FAIL${c.reset} invalid token: ${w.account.label || w.account.id}`);
+    for (const w of invalidWorkers) ui.logEvent(`${c.red}E${c.reset} invalid token: ${w.account.label || w.account.id}`);
   }
   if (timedOutWorkers.length > 0) {
-    ui.printLogin(`  ${c.yellow}WARN${c.reset} ${timedOutWorkers.length} timed out (will retry in background)`);
+    ui.logEvent(`${c.yellow}~${c.reset} ${timedOutWorkers.length} timed out (will retry in background)`);
   }
-  ui.clearLoginLines();
+  ui.draw();
 
   const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
   // ── Phase 2: Inventory check ────────────────────────────────────
-  ui.printLogin(`${c.dim}Checking inventory...${c.reset}`);
+  ui.logEvent(`${c.dim}Checking inventory...${c.reset}`);
   let invFailed = 0;
   await Promise.all(activeWorkers.map(async (w) => {
     try { await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
     catch { invFailed++; }
   }));
   if (invFailed > 0) {
-    ui.printLogin(`${c.red}Inventory failed for ${invFailed} accounts${c.reset}`);
+    ui.logEvent(`${c.red}!${c.reset} Inventory failed for ${invFailed} accounts`);
   } else {
-    ui.printLogin(`${c.green}Inventory OK${c.reset}`);
+    ui.logEvent(`${c.green}·${c.reset} Inventory OK`);
   }
 
   // ── Phase 2.5: Balance check ───────────────────────────────────
-  ui.printLogin(`${c.dim}Checking balances...${c.reset}`);
+  ui.logEvent(`${c.dim}Checking balances...${c.reset}`);
   for (const w of activeWorkers) {
     try { await w.checkBalance(true); } catch {}
   }
@@ -2856,10 +2863,10 @@ async function start(apiKey, apiUrl, opts = {}) {
     totalCoins += w.stats?.balance || 0;
     totalCoins += w.stats?.bankBalance || 0;
   }
-  ui.printLogin(`Balances: total ${c.green}+⏣${totalCoins.toLocaleString()}${c.reset} across ${activeWorkers.length} accounts`);
+  ui.logEvent(`${c.blue}$${c.reset} Balances: ${c.green}+⏣${totalCoins.toLocaleString()}${c.reset} across ${activeWorkers.length} accounts`);
 
   // ── Phase 2.75: DM history check ────────────────────────────────
-  ui.printLogin(`${c.dim}Checking DM history...${c.reset}`);
+  ui.logEvent(`${c.dim}Checking DM history...${c.reset}`);
   let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [];
   for (const w of activeWorkers) {
     try {
@@ -2877,18 +2884,18 @@ async function start(apiKey, apiUrl, opts = {}) {
       }
     } catch {}
   }
-  if (dmNoLs.length > 0) ui.printLogin(`  ${c.yellow}WARN${c.reset} No lifesavers: ${dmNoLs.join(', ')}`);
+  if (dmNoLs.length > 0) ui.logEvent(`${c.red}E${c.reset} No lifesavers: ${dmNoLs.join(', ')}`);
   const parts = [];
   if (dmDeaths > 0) parts.push(`${dmDeaths} deaths`);
   if (dmLevelUps > 0) parts.push(`${dmLevelUps} level-ups`);
-  ui.printLogin(`DM check: ${parts.length > 0 ? parts.join(', ') : c.green + 'clean' + c.reset}`);
-  ui.clearLoginLines();
+  ui.logEvent(`${c.green}·${c.reset} DM: ${parts.length > 0 ? parts.join(', ') : c.green + 'clean' + c.reset}`);
 
   // ── Phase 3: Start grind loops ───────────────────────────────────
+  ui.logEvent(`${c.green}·${c.reset} Starting ${activeWorkers.length} grind loops...`);
   for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();
   }
-  ui.render();
+  ui.draw();
 
   // Cluster heartbeat — lets other nodes see this node is alive
   if (CLUSTER_ENABLED) {

package/lib/ui.js

@@ -1,131 +1,219 @@
 /**
- * CLI Live Dashboard
- * Renders a terminal table that updates in place every 10s.
- * Shows per-account status, earned coins, commands, and session uptime.
+ * CLI Live Dashboard — compact, colorful, append-only.
+ * Shows top-N active accounts that fit in the window.
+ * Each account has its own color. Events logged below.
  */
 
 let _startTime = Date.now();
 let _workers = [];
 let _isShuttingDown = () => false;
 
-function formatUptime() {
+// ── Dark-theme palette (light/bright colors on dark bg) ───────
+const PALETTE = [
+  '\x1b[38;2;77;212;238m',   // cyan
+  '\x1b[38;2;255;194;77m',   // amber
+  '\x1b[38;2;130;210;100m',  // lime
+  '\x1b[38;2;255;120;200m',  // pink
+  '\x1b[38;2;120;180;255m',  // sky
+  '\x1b[38;2;255;180;80m',   // orange
+  '\x1b[38;2;180;130;255m',  // lavender
+  '\x1b[38;2;100;255;180m',  // teal
+  '\x1b[38;2;255;150;100m',   // peach
+  '\x1b[38;2;150;255;200m',  // mint
+  '\x1b[38;2;255;255;120m',  // yellow
+  '\x1b[38;2;200;150;255m',  // violet
+];
+
+function workerColor(idx) { return PALETTE[idx % PALETTE.length]; }
+
+// ── ANSI helpers ──────────────────────────────────────────────
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[38;2;80;255;120m',
+  red: '\x1b[38;2;255;80;100m',
+  yellow: '\x1b[38;2;255;220;80m',
+  cyan: '\x1b[38;2;80;220;255m',
+  blue: '\x1b[38;2;100;160;255m',
+  gray: '\x1b[38;2;120;130;150m',
+  white: '\x1b[38;2;220;220;240m',
+};
+const DIM = c.dim;
+
+// ── Uptime ───────────────────────────────────────────────────
+function fmtUptime() {
   const s = Math.floor((Date.now() - _startTime) / 1000);
   if (s < 60) return `${s}s`;
   const m = Math.floor(s / 60);
   const h = Math.floor(m / 60);
   const d = Math.floor(h / 24);
-  if (d > 0) return `${d}d ${h % 24}h`;
-  if (h > 0) return `${h}h ${m % 60}m`;
+  if (d > 0) return `${d}d${h % 24}h`;
+  if (h > 0) return `${h}h${m % 60}m`;
   return `${m}m`;
 }
 
-// ANSI helpers
-const c = {
-  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-  green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m',
-  cyan: '\x1b[36m', blue: '\x1b[34m',
-};
-const DIM = c.dim;
+// ── Column widths based on terminal width ────────────────────
+function colWidths(totalW) {
+  const minW = 80;
+  const w = Math.max(totalW, minW);
+  // Columns: # | Status | Account | LastCmd | Cmds | OK% | Earned
+  // Reserve: 1+2+1 + 1+3+1 + 1+16+1 + 1+20+1 + 1+5+1 + 1+3+1 + 1+12+1 = ~72 fixed
+  const fixed = 74; // 1+2+1 + 1+3+1 + 1+16+1 + 1+20+1 + 1+5+1 + 1+3+1 + 1+12+1
+  const extra = Math.max(0, w - fixed);
+  return {
+    status: 3,
+    num: 2,
+    name: 16,
+    lastCmd: 20 + Math.floor(extra * 0.5),
+    cmds: 5,
+    ok: 3,
+    earned: 12,
+  };
+}
 
-function rgb(r, g, b) { return `\x1b[38;2;${r};${g};${b}m`; }
-function lerp(a, b, t) { return Math.round(a + (b - a) * t); }
-function gradientLine(text, from, to) {
-  const fr = Array.isArray(from) ? from[0] : 128;
-  const fg = Array.isArray(from) ? from[1] : 128;
-  const fb = Array.isArray(from) ? from[2] : 128;
-  const tr = Array.isArray(to) ? to[0] : 255;
-  const tg = Array.isArray(to) ? to[1] : 255;
-  const tb = Array.isArray(to) ? to[2] : 255;
-  let out = '';
-  for (let i = 0; i < text.length; i++) {
-    const t = text.length <= 1 ? 0 : i / (text.length - 1);
-    out += `\x1b[38;2;${lerp(fr, tr, t)};${lerp(fg, tg, t)};${lerp(fb, tb, t)}m${text[i]}`;
+// ── Status icon ─────────────────────────────────────────────
+function icon(w) {
+  if (!w.running || !w.channel) return `${c.red}E${c.reset}`;
+  if (w.paused || w.dashboardPaused) return `${c.yellow}P${c.reset}`;
+  if (w._alert) {
+    if (w._alert.type === 'death') return `${c.red}!${c.reset}`;
+    if (w._alert.type === 'lowls') return `${c.yellow}!${c.reset}`;
   }
-  return out + c.reset;
+  if (w._rateLimitHits > (w._prevRateLimits || 0)) return `${c.cyan}~${c.reset}`;
+  return `${c.green}·${c.reset}`;
 }
 
-let _lineCount = 0;
-let _interval = null;
-let _loginLines = 0; // number of login progress lines to clear
-
-function _statusIcon(w) {
-  if (!w.running || !w.channel) return `${c.red}✗${c.reset}`;
-  if (w.paused || w.dashboardPaused) return `${c.yellow}⏸${c.reset}`;
-  if (w.busy || w._invRunning || w._sellRunning) return `${c.cyan}⚙${c.reset}`;
-  if (Date.now() < w.globalCooldownUntil) return `${c.blue}⏳${c.reset}`;
-  return `${c.green}●${c.reset}`;
+// ── Truncate with ellipsis ───────────────────────────────────
+function trunc(str, len) {
+  str = String(str || '');
+  if (str.length <= len) return str;
+  return str.substring(0, len - 1) + '…';
 }
 
-function _render(extraLines = []) {
-  const workers = _workers;
+// ── Draw header ─────────────────────────────────────────────
+function drawHeader(version) {
+  const rows = 8; // banner(3) + 1gap + header(1) + hr(1) + N rows + total(1) + gap(1)
+  const availRows = process.stdout.rows || 40;
+  const visible = Math.min(_workers.length, Math.max(5, availRows - rows));
   const W = Math.min(process.stdout.columns || 120, 120);
-  const lines = [];
-
-  lines.push(`${c.bold}${'─'.repeat(W)}${c.reset}`);
-  lines.push(
-    `  ${c.bold}#${c.reset}  ${c.bold}Account${c.reset}${' '.repeat(Math.max(1, 20 - 7))}` +
-    `${c.bold}Status${c.reset}${' '.repeat(Math.max(1, 14 - 6))}` +
-    `${c.bold}Earned${c.reset}${' '.repeat(Math.max(1, 12 - 5))}` +
-    `${c.bold}Cmds${c.reset}${' '.repeat(Math.max(1, 7 - 4))}` +
-    `${c.bold}OK%${c.reset}`
+
+  const cols = colWidths(W);
+  const hr = '─'.repeat(W);
+
+  const running = _workers.filter(w => w.running && w.channel).length;
+  const paused = _workers.filter(w => w.paused || w.dashboardPaused).length;
+  const active = running + paused;
+
+  // Top bar
+  console.log('');
+  console.log(` ${c.bold}DANK${c.reset}${c.blue}GRINDER${c.reset} ${DIM}v${version}${c.reset}  ${c.green}●${c.reset}online ${DIM}|${c.reset} ${fmtUptime()}  ${c.green}·${c.reset}${running}  ${c.yellow}~${c.reset}${paused}  ${c.dim}Ctrl+C${c.reset}`);
+
+  // Account summary if many
+  if (_workers.length > visible) {
+    console.log(` ${c.dim}${_workers.length} accounts | showing top ${visible} by activity | scroll: web dashboard${c.reset}`);
+  }
+  console.log('');
+
+  // Column headers
+  console.log(
+    ` ${c.bold}#${c.reset} ` +
+    `${c.bold}${trunc('Status', cols.status).padEnd(cols.status)}${c.reset} ` +
+    `${c.bold}${trunc('Account', cols.name).padEnd(cols.name)}${c.reset} ` +
+    `${c.bold}${trunc('Last Command', cols.lastCmd).padEnd(cols.lastCmd)}${c.reset} ` +
+    `${c.bold}${trunc('Cmds', cols.cmds).padStart(cols.cmds)}${c.reset} ` +
+    `${c.bold}${trunc('OK%', cols.ok).padStart(cols.ok)}${c.reset} ` +
+    `${c.bold}${trunc('Earned', cols.earned).padStart(cols.earned)}${c.reset}`
   );
-  lines.push(`${c.bold}${'─'.repeat(W)}${c.reset}`);
-
-  for (let i = 0; i < workers.length; i++) {
-    const w = workers[i];
-    const name = (w.username || '?').substring(0, 20);
-    const status = (w.lastStatus || 'idle').substring(0, 14).padEnd(14);
-    const earned = w.stats.coins > 0 ? `+⏣${w.stats.coins.toLocaleString()}` : DIM + '—' + c.reset;
-    const cmds = String(w.stats.commands || 0);
-    const rate = w.stats.commands > 0 ? Math.round((w.stats.successes / w.stats.commands) * 100) : 0;
-
-    lines.push(
-      `  ${DIM}${String(i + 1).padStart(2)}${c.reset}  ${name.padEnd(20)} ${status}` +
-      `${String(earned).padStart(12)} ${cmds.padStart(6)} ${String(rate).padStart(3)}%`
+  console.log(` ${hr}`);
+
+  return { visible, W, cols };
+}
+
+// ── Sort: running first, then by activity ──────────────────
+function sortedWorkers(visible) {
+  return [..._workers]
+    .sort((a, b) => {
+      // Invalid/timeout at bottom
+      if (!a.channel && !!b.channel) return 1;
+      if (!b.channel && !!a.channel) return -1;
+      // Running/active first
+      const aActive = a.running && a.channel && !a.paused && !a.dashboardPaused;
+      const bActive = b.running && b.channel && !b.paused && !b.dashboardPaused;
+      if (aActive !== bActive) return bActive ? 1 : -1;
+      // Sort by total activity
+      const aScore = (a.stats.commands || 0) + (a.stats.coins || 0);
+      const bScore = (b.stats.commands || 0) + (b.stats.coins || 0);
+      return bScore - aScore;
+    })
+    .slice(0, visible);
+}
+
+// ── Draw all rows ───────────────────────────────────────────
+function drawRows({ visible, W, cols }) {
+  const hr = '─'.repeat(W);
+  const sorted = sortedWorkers(visible);
+
+  for (let si = 0; si < sorted.length; si++) {
+    const w = sorted[si];
+    const wi = _workers.indexOf(w); // original index for color
+    const col = workerColor(wi);
+
+    const earned = w.stats.coins > 0
+      ? `${c.green}+${w.stats.coins.toLocaleString()}${c.reset}`
+      : DIM + '—' + c.reset;
+    const cmds = w.stats.commands || 0;
+    const rate = w.stats.commands > 0
+      ? Math.round((w.stats.successes / w.stats.commands) * 100)
+      : 0;
+
+    process.stdout.write(
+      ` ${icon(w)} ` +
+      `${DIM}${String(wi + 1).padStart(cols.num)}${c.reset} ` +
+      `${col}${trunc(w.username || '?', cols.name).padEnd(cols.name)}${c.reset} ` +
+      `${DIM}${trunc(w.lastStatus || 'idle', cols.lastCmd).padEnd(cols.lastCmd)}${c.reset} ` +
+      `${String(cmds).padStart(cols.cmds)} ` +
+      `${String(rate).padStart(cols.ok)}% ` +
+      `${earned.padStart(cols.earned)}\n`
     );
   }
 
-  for (const el of extraLines) lines.push(el);
-
-  lines.push(`${c.bold}${'─'.repeat(W)}${c.reset}`);
+  console.log(` ${hr}`);
 
   // Totals
-  let totalCoins = 0, totalCmds = 0;
-  for (const w of workers) {
+  let totalCoins = 0, totalCmds = 0, totalOk = 0;
+  for (const w of _workers) {
     totalCoins += w.stats.coins || 0;
     totalCmds += w.stats.commands || 0;
+    totalOk += w.stats.successes || 0;
   }
+  const rate = totalCmds > 0 ? Math.round((totalOk / totalCmds) * 100) : 0;
   const memMB = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
-  lines.push(
-    `  ${c.bold}Total${c.reset}  ` +
-    `${totalCoins > 0 ? c.green + '+⏣' + totalCoins.toLocaleString() + c.reset : DIM + '—' + c.reset}` +
-    `  ${totalCmds} cmds  ${formatUptime()}  ${memMB}MB`
+  const extra = Math.max(0, W - 74);
+  const namePad = 16 + Math.floor(extra * 0.5);
+
+  console.log(
+    ` ${c.bold}Σ${c.reset} ` +
+    `${DIM}${' '.repeat(cols.num)}${c.reset} ` +
+    `${c.bold}${_workers.length} accounts${c.reset}` +
+    `${' '.repeat(Math.max(0, namePad - 12))}` +
+    `${String(totalCmds).padStart(cols.cmds)} ` +
+    `${String(rate).padStart(cols.ok)}% ` +
+    `${totalCoins > 0 ? c.green + '+' + totalCoins.toLocaleString() + c.reset : DIM + '—' + c.reset}` +
+    `${' '.repeat(Math.max(0, cols.earned - String(totalCoins).length - 1))}` +
+    ` ${DIM}${fmtUptime()} | ${memMB}MB${c.reset}`
   );
-  lines.push('');
-
-  // Redraw in place — also clear any login progress lines above
-  const clearLines = _lineCount + _loginLines;
-  if (clearLines > 0) {
-    process.stdout.write(`\x1b[${clearLines}A`);
-    for (let i = 0; i < clearLines; i++) {
-      process.stdout.write(`\x1b[2K\r${i < clearLines - 1 ? '\x1b[1A' : ''}`);
-    }
-  }
-  process.stdout.write(lines.join('\n') + '\n');
-  _lineCount = lines.length - 1;
-  _loginLines = 0;
+  console.log('');
 }
 
-function _clear() {
-  const clearLines = _lineCount + _loginLines;
-  if (clearLines > 0) {
-    process.stdout.write(`\x1b[${clearLines}A`);
-    for (let i = 0; i < clearLines; i++) {
-      process.stdout.write(`\x1b[2K\r${i < clearLines - 1 ? '\x1b[1A' : ''}`);
-    }
-    _lineCount = 0;
-    _loginLines = 0;
-  }
+// ── Event log ────────────────────────────────────────────────
+let _eventCount = 0;
+const MAX_EVENTS = 6;
+
+function logEvent(msg) {
+  const now = new Date();
+  const ts = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+  process.stdout.write(` ${DIM}[${ts}]${c.reset} ${msg}\n`);
+  _eventCount++;
+  if (_eventCount > MAX_EVENTS) _eventCount = MAX_EVENTS;
 }
 
 // ── Public API ────────────────────────────────────────────────
@@ -134,53 +222,26 @@ function init({ workers, isShuttingDown }) {
   _startTime = Date.now();
   _workers = workers;
   _isShuttingDown = isShuttingDown || (() => false);
+  _eventCount = 0;
 }
 
-function drawBanner(version) {
-  const title = `DANKGRINDER v${version}`;
-  const gradient = gradientLine(title, [77, 142, 255], [255, 92, 147]);
-  console.log('');
-  console.log(`  ${gradient}${c.reset}`);
-  console.log(`  ${DIM}Ctrl+C to stop${c.reset}`);
-  console.log('');
-}
+function drawBanner(version) {}
+
+let _interval = null;
 
-// Show dashboard and start the 10s refresh interval
 function start() {
-  if (_workers.length > 30) return;
-  _lineCount = 0;
-  _loginLines = 0;
-  _render();
-  _interval = setInterval(() => {
-    if (_isShuttingDown()) {
-      clearInterval(_interval);
-      _interval = null;
-      return;
-    }
-    _render();
-  }, 10_000);
+  // No periodic refresh — dashboard re-draws on each event
 }
 
-// Immediately re-render the dashboard (use after worker status changes)
-function render() {
+function draw() {
   if (_isShuttingDown()) return;
-  _render();
-}
-
-// Print a login progress line and count it so it gets cleared on next render
-function printLogin(msg) {
-  console.log(msg);
-  _loginLines++;
-}
-
-// Clear login lines and re-render final state
-function clearLoginLines() {
-  _render();
+  const info = drawHeader(require('../package.json').version);
+  drawRows(info);
 }
 
 function stop() {
   if (_interval) { clearInterval(_interval); _interval = null; }
-  _clear();
+  process.stdout.write(c.reset + '\n');
 }
 
-module.exports = { init, drawBanner, start, render, printLogin, clearLoginLines, stop };
+module.exports = { init, drawBanner, start, draw, logEvent, workerColor, stop };

package/package.json

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