dankgrinder 4.0.0 → 4.1.1

package/lib/grinder.js

@@ -1,5 +1,6 @@
 const { Client } = require('discord.js-selfbot-v13');
 const Redis = require('ioredis');
+const commands = require('./commands');
 
 // ── Terminal Colors & ANSI ───────────────────────────────────
 const c = {
@@ -36,12 +37,12 @@ const SAFE_CRIME_OPTIONS = [
 
 let API_KEY = '';
 let API_URL = '';
-let REDIS_URL = process.env.REDIS_URL || 'redis://default:qXcezFjDHlCDtakRUZJmvsEzHoBgdLHi@shortline.proxy.rlwy.net:32007';
+let REDIS_URL = process.env.REDIS_URL || '';
 let redis = null;
 const workers = [];
 
 function initRedis() {
-  if (!redis) {
+  if (!redis && REDIS_URL) {
     try {
       redis = new Redis(REDIS_URL, { maxRetriesPerRequest: null, lazyConnect: true });
       redis.connect().catch(() => {});
@@ -51,37 +52,78 @@ function initRedis() {
   }
 }
 
+// ── Truecolor gradient helpers ───────────────────────────────
+function rgb(r, g, b) { return `\x1b[38;2;${r};${g};${b}m`; }
+function bgRgb(r, g, b) { return `\x1b[48;2;${r};${g};${b}m`; }
+function lerp(a, b, t) { return Math.round(a + (b - a) * t); }
+
+function gradientLine(text, from, to) {
+  const chars = [...text];
+  const visible = chars.filter(ch => ch !== ' ').length;
+  let ci = 0, out = '';
+  for (const ch of chars) {
+    if (ch === ' ') { out += ' '; continue; }
+    const t = visible > 1 ? ci / (visible - 1) : 0;
+    out += rgb(lerp(from[0], to[0], t), lerp(from[1], to[1], t), lerp(from[2], to[2], t)) + ch;
+    ci++;
+  }
+  return out + c.reset;
+}
+
+const BANNER_RAW = [
+  '    ██████╗  █████╗ ███╗   ██╗██╗  ██╗',
+  '    ██╔══██╗██╔══██╗████╗  ██║██║ ██╔╝',
+  '    ██║  ██║███████║██╔██╗ ██║█████╔╝ ',
+  '    ██║  ██║██╔══██║██║╚██╗██║██╔═██╗ ',
+  '    ██████╔╝██║  ██║██║ ╚████║██║  ██╗',
+  '    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝',
+  '     ██████╗ ██████╗ ██╗███╗   ██╗██████╗ ███████╗██████╗ ',
+  '    ██╔════╝ ██╔══██╗██║████╗  ██║██╔══██╗██╔════╝██╔══██╗',
+  '    ██║  ███╗██████╔╝██║██╔██╗ ██║██║  ██║█████╗  ██████╔╝',
+  '    ██║   ██║██╔══██╗██║██║╚██╗██║██║  ██║██╔══╝  ██╔══██╗',
+  '    ╚██████╔╝██║  ██║██║██║ ╚████║██████╔╝███████╗██║  ██║',
+  '     ╚═════╝ ╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝',
+];
+
+function colorBanner() {
+  const topColor = [192, 132, 252];
+  const midColor = [139, 92, 246];
+  const botColor = [34, 211, 238];
+  const n = BANNER_RAW.length;
+  let out = '\n';
+  for (let i = 0; i < n; i++) {
+    const t = i / (n - 1);
+    const from = t < 0.5
+      ? [lerp(topColor[0], midColor[0], t * 2), lerp(topColor[1], midColor[1], t * 2), lerp(topColor[2], midColor[2], t * 2)]
+      : [lerp(midColor[0], botColor[0], (t - 0.5) * 2), lerp(midColor[1], botColor[1], (t - 0.5) * 2), lerp(midColor[2], botColor[2], (t - 0.5) * 2)];
+    const to = t < 0.5
+      ? [lerp(236, 168, t * 2), lerp(72, 85, t * 2), lerp(153, 247, t * 2)]
+      : [lerp(168, 6, (t - 0.5) * 2), lerp(85, 182, (t - 0.5) * 2), lerp(247, 212, (t - 0.5) * 2)];
+    out += c.bold + gradientLine(BANNER_RAW[i], from, to) + '\n';
+  }
+  return out;
+}
+
 // ── Live Dashboard State ─────────────────────────────────────
 let dashboardLines = 0;
 let dashboardStarted = false;
+let dashboardRendering = false;
 let totalBalance = 0;
 let totalCoins = 0;
 let totalCommands = 0;
 let startTime = Date.now();
-const recentLogs = []; // Ring buffer of last N log entries
-const MAX_LOGS = 6;
-
-const BANNER = `
-${c.magenta}${c.bold}    ██████╗  █████╗ ███╗   ██╗██╗  ██╗${c.reset}
-${c.magenta}${c.bold}    ██╔══██╗██╔══██╗████╗  ██║██║ ██╔╝${c.reset}
-${c.magenta}${c.bold}    ██║  ██║███████║██╔██╗ ██║█████╔╝ ${c.reset}
-${c.magenta}${c.bold}    ██║  ██║██╔══██║██║╚██╗██║██╔═██╗ ${c.reset}
-${c.magenta}${c.bold}    ██████╔╝██║  ██║██║ ╚████║██║  ██╗${c.reset}
-${c.magenta}${c.bold}    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝${c.reset}
-${c.cyan}${c.bold}     ██████╗ ██████╗ ██╗███╗   ██╗██████╗ ███████╗██████╗${c.reset}
-${c.cyan}${c.bold}    ██╔════╝ ██╔══██╗██║████╗  ██║██╔══██╗██╔════╝██╔══██╗${c.reset}
-${c.cyan}${c.bold}    ██║  ███╗██████╔╝██║██╔██╗ ██║██║  ██║█████╗  ██████╔╝${c.reset}
-${c.cyan}${c.bold}    ██║   ██║██╔══██╗██║██║╚██╗██║██║  ██║██╔══╝  ██╔══██╗${c.reset}
-${c.cyan}${c.bold}    ╚██████╔╝██║  ██║██║██║ ╚████║██████╔╝███████╗██║  ██║${c.reset}
-${c.cyan}${c.bold}     ╚═════╝ ╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝${c.reset}
-`;
+let shutdownCalled = false;
+const recentLogs = [];
+const MAX_LOGS = 4;
 
 function formatUptime() {
   const s = Math.floor((Date.now() - startTime) / 1000);
   const h = Math.floor(s / 3600);
   const m = Math.floor((s % 3600) / 60);
   const sec = s % 60;
-  return `${h}h ${m}m ${sec}s`;
+  if (h > 0) return `${h}h ${m}m`;
+  if (m > 0) return `${m}m ${sec}s`;
+  return `${sec}s`;
 }
 
 function formatCoins(n) {
@@ -91,9 +133,9 @@ function formatCoins(n) {
 }
 
 function renderDashboard() {
-  if (!dashboardStarted || workers.length === 0) return;
+  if (!dashboardStarted || workers.length === 0 || dashboardRendering) return;
+  dashboardRendering = true;
 
-  // Compute totals
   totalBalance = 0; totalCoins = 0; totalCommands = 0;
   for (const w of workers) {
     totalBalance += w.stats.balance || 0;
@@ -102,42 +144,49 @@ function renderDashboard() {
   }
 
   const lines = [];
-  const width = Math.min(process.stdout.columns || 80, 90);
-  const sep = c.dim + '─'.repeat(width) + c.reset;
+  const tw = Math.min(process.stdout.columns || 80, 78);
+  const thinBar = c.dim + '─'.repeat(tw) + c.reset;
+  const thickTop = rgb(139, 92, 246) + c.bold + '═'.repeat(tw) + c.reset;
+  const thickBot = rgb(34, 211, 238) + c.bold + '═'.repeat(tw) + c.reset;
 
-  // Header bar
-  lines.push(sep);
+  lines.push(thickTop);
   lines.push(
-    `  ${c.yellow}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}` +
-    `  ${c.dim}│${c.reset}  ${c.green}+⏣ ${formatCoins(totalCoins)}${c.reset} earned` +
-    `  ${c.dim}│${c.reset}  ${c.white}${totalCommands}${c.reset} cmds` +
-    `  ${c.dim}│${c.reset}  ${c.dim}⏱ ${formatUptime()}${c.reset}`
+    `  ${rgb(192, 132, 252)}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}` +
+    `  ${c.dim}│${c.reset}` +
+    `  ${rgb(52, 211, 153)}${c.bold}+${formatCoins(totalCoins)}${c.reset} ${c.dim}earned${c.reset}` +
+    `  ${c.dim}│${c.reset}` +
+    `  ${c.white}${c.bold}${totalCommands}${c.reset} ${c.dim}cmds${c.reset}` +
+    `  ${c.dim}│${c.reset}` +
+    `  ${rgb(251, 191, 36)}⏱ ${formatUptime()}${c.reset}` +
+    `  ${c.dim}│${c.reset}` +
+    `  ${rgb(52, 211, 153)}●${c.reset} ${c.dim}LIVE${c.reset}`
   );
-  lines.push(sep);
-
-  // Per-account rows
-  for (const w of workers) {
-    const status = w.lastStatus || 'idle';
-    const statusColor = w.running ? (w.busy ? c.yellow : c.green) : c.red;
-    const dot = w.running ? (w.busy ? '◉' : '●') : '○';
-    const bal = w.stats.balance > 0 ? `${c.dim}⏣${c.reset} ${c.white}${formatCoins(w.stats.balance)}${c.reset}` : `${c.dim}⏣ ---${c.reset}`;
-    const earned = w.stats.coins > 0 ? `${c.green}+${formatCoins(w.stats.coins)}${c.reset}` : `${c.dim}+0${c.reset}`;
-    const cmds = `${c.dim}${w.stats.commands}cmd${c.reset}`;
-    const name = `${w.color}${c.bold}${(w.username || 'Account').substring(0, 14).padEnd(14)}${c.reset}`;
-
-    lines.push(
-      `  ${statusColor}${dot}${c.reset} ${name} ${bal}  ${earned}  ${cmds}  ${c.dim}→${c.reset} ${status.substring(0, 35)}`
-    );
+  lines.push(thinBar);
+
+  for (const wk of workers) {
+    const last = (wk.lastStatus || 'idle').substring(0, 32);
+    const dot = wk.running
+      ? (wk.paused ? `${rgb(251, 191, 36)}⏸${c.reset}` : wk.busy ? `${rgb(251, 191, 36)}◉${c.reset}` : `${rgb(52, 211, 153)}●${c.reset}`)
+      : `${rgb(239, 68, 68)}○${c.reset}`;
+    const name = `${wk.color}${c.bold}${(wk.username || '?').substring(0, 16).padEnd(16)}${c.reset}`;
+    const bal = wk.stats.balance > 0
+      ? `${rgb(251, 191, 36)}⏣${c.reset}${c.white}${c.bold}${formatCoins(wk.stats.balance).padStart(7)}${c.reset}`
+      : `${c.dim}⏣      -${c.reset}`;
+    const earned = wk.stats.coins > 0
+      ? `${rgb(52, 211, 153)}+${formatCoins(wk.stats.coins).padStart(6)}${c.reset}`
+      : `${c.dim}     +0${c.reset}`;
+    lines.push(`  ${dot} ${name} ${bal}  ${earned}  ${c.dim}${last}${c.reset}`);
   }
-  lines.push(sep);
 
-  // Scrolling log section (last 6 events)
-  for (const entry of recentLogs) {
-    lines.push(`  ${c.dim}${entry}${c.reset}`);
+  if (recentLogs.length > 0) {
+    lines.push(thinBar);
+    for (const entry of recentLogs) {
+      lines.push(`  ${c.dim}${entry}${c.reset}`);
+    }
   }
-  if (recentLogs.length > 0) lines.push(sep);
 
-  // Move cursor up to overwrite previous dashboard
+  lines.push(thickBot);
+
   if (dashboardLines > 0) {
     process.stdout.write(c.cursorUp(dashboardLines));
   }
@@ -145,30 +194,31 @@ function renderDashboard() {
     process.stdout.write(c.clearLine + '\r' + line + '\n');
   }
   dashboardLines = lines.length;
+  dashboardRendering = false;
 }
 
 function log(type, msg, label) {
-  const time = new Date().toLocaleTimeString('en-US', { hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  const time = new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
   const icons = {
-    info: `│`, success: `✓`, error: `✗`, warn: `!`,
-    cmd: `▸`, coin: `$`, buy: `♦`, bal: `◈`, debug: `⊙`,
+    info: '·', success: '✓', error: '✗', warn: '!',
+    cmd: '▸', coin: '$', buy: '♦', bal: '◈', debug: '·',
   };
-  const tag = label ? `${label} ` : '';
-  const stripped = msg.replace(/\x1b\[[0-9;]*m/g, ''); // Strip ANSI for log buffer
+  const tag = label ? (label.replace(/\x1b\[[0-9;]*m/g, '') + ' ') : '';
+  const stripped = msg.replace(/\x1b\[[0-9;]*m/g, '');
   if (dashboardStarted) {
-    // Add to scrolling log buffer
-    recentLogs.push(`${time}  ${icons[type] || '│'}  ${tag}${stripped}`.substring(0, 80));
+    recentLogs.push(`${time} ${icons[type] || '·'} ${tag}${stripped}`.substring(0, 72));
     while (recentLogs.length > MAX_LOGS) recentLogs.shift();
     renderDashboard();
   } else {
     const colorIcons = {
-      info: `${c.cyan}│${c.reset}`, success: `${c.green}✓${c.reset}`,
-      error: `${c.red}✗${c.reset}`, warn: `${c.yellow}!${c.reset}`,
-      cmd: `${c.magenta}▸${c.reset}`, coin: `${c.yellow}$${c.reset}`,
-      buy: `${c.blue}♦${c.reset}`, bal: `${c.green}◈${c.reset}`,
-      debug: `${c.dim}⊙${c.reset}`,
+      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}`,
+      cmd: `${rgb(168, 85, 247)}▸${c.reset}`, coin: `${rgb(251, 191, 36)}$${c.reset}`,
+      buy: `${rgb(59, 130, 246)}♦${c.reset}`, bal: `${rgb(52, 211, 153)}◈${c.reset}`,
+      debug: `${c.dim}·${c.reset}`,
     };
-    console.log(`  ${c.dim}${time}${c.reset}  ${colorIcons[type] || colorIcons.info}  ${tag}${msg}`);
+    const tagCol = label ? `${label} ` : '';
+    console.log(`  ${colorIcons[type] || colorIcons.info}  ${tagCol}${msg}`);
   }
 }
 
@@ -193,6 +243,17 @@ async function sendLog(accountName, command, response, status) {
   } catch { /* silent */ }
 }
 
+async function reportEarnings(accountId, accountName, earned, spent, command) {
+  if (earned <= 0 && spent <= 0) return;
+  try {
+    await fetch(`${API_URL}/api/grinder/earnings`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ account_id: accountId, account_name: accountName, earned, spent, command }),
+    });
+  } catch { /* silent */ }
+}
+
 function randomDelay(min, max) {
   return new Promise((r) => setTimeout(r, (Math.random() * (max - min) + min) * 1000));
 }
@@ -203,31 +264,21 @@ function safeParseJSON(str, fallback = []) {
   try { return JSON.parse(str || '[]'); } catch { return fallback; }
 }
 
-// ── Coin Parser ──────────────────────────────────────────────
+// ── Coin Parser (conservative — only ⏣ amounts) ─────────────
 function parseCoins(text) {
   if (!text) return 0;
-  const patterns = [
-    /[⏣💰]\s*[\d,]+/g,
-    /\+\s*[\d,]+\s*coins?/gi,
-    /\*\*([\d,]+)\*\*/g,
-    /take\s*[⏣💰]?\s*([\d,]+)/gi,
-    /earned\s*[⏣💰]?\s*([\d,]+)/gi,
-    /found\s*[⏣💰]?\s*([\d,]+)/gi,
-    /got\s*[⏣💰]?\s*([\d,]+)/gi,
-    /won\s*[⏣💰]?\s*([\d,]+)/gi,
-    /gained\s*[⏣💰]?\s*([\d,]+)/gi,
-  ];
-  let total = 0;
-  for (const pat of patterns) {
-    const matches = text.match(pat);
-    if (matches) {
-      for (const m of matches) {
-        const numStr = m.replace(/[^\d]/g, '');
-        if (numStr) total = Math.max(total, parseInt(numStr));
-      }
+  // Only match coins that are clearly ⏣ prefixed  
+  const matches = text.match(/⏣\s*([\d,]+)/g);
+  if (!matches) return 0;
+  let best = 0;
+  for (const m of matches) {
+    const numStr = m.replace(/[^\d]/g, '');
+    if (numStr) {
+      const val = parseInt(numStr);
+      if (val > 0 && val < 10000000) best = Math.max(best, val); // Cap at 10M sanity
     }
   }
-  return total;
+  return best;
 }
 
 function getFullText(msg) {
@@ -253,7 +304,7 @@ function getAllButtons(msg) {
     for (const row of msg.components) {
       if (row.components) {
         for (const comp of row.components) {
-          if (comp.type === 2) buttons.push(comp);
+          if (comp.type === 2 || comp.type === 'BUTTON') buttons.push(comp);
         }
       }
     }
@@ -267,7 +318,7 @@ function getAllSelectMenus(msg) {
     for (const row of msg.components) {
       if (row.components) {
         for (const comp of row.components) {
-          if (comp.type === 3) menus.push(comp);
+          if (comp.type === 3 || comp.type === 'SELECT_MENU' || comp.type === 'STRING_SELECT') menus.push(comp);
         }
       }
     }
@@ -275,6 +326,18 @@ function getAllSelectMenus(msg) {
   return menus;
 }
 
+// Safe button click — tries .click() first, falls back to msg.clickButton()
+async function safeClickButton(msg, button) {
+  if (typeof button.click === 'function') {
+    return button.click();
+  }
+  // Fallback: use message.clickButton with customId
+  if (button.customId && typeof msg.clickButton === 'function') {
+    return msg.clickButton(button.customId);
+  }
+  throw new Error('No click method available on button');
+}
+
 function pickSafeButton(buttons, safeList) {
   if (!buttons || buttons.length === 0) return null;
   if (safeList && safeList.length > 0) {
@@ -309,6 +372,68 @@ function debugMessage(msg, label) {
   }
 }
 
+// ══════════════════════════════════════════════════════════════
+// ═  Min-Heap Priority Queue for Command Scheduling
+// ══════════════════════════════════════════════════════════════
+
+class MinHeap {
+  constructor() { this.heap = []; }
+
+  push(item) {
+    this.heap.push(item);
+    this._bubbleUp(this.heap.length - 1);
+  }
+
+  pop() {
+    if (this.heap.length === 0) return null;
+    const top = this.heap[0];
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this._sinkDown(0);
+    }
+    return top;
+  }
+
+  peek() {
+    return this.heap.length > 0 ? this.heap[0] : null;
+  }
+
+  get size() { return this.heap.length; }
+
+  _bubbleUp(i) {
+    while (i > 0) {
+      const parent = (i - 1) >> 1;
+      if (this.heap[i].nextRunAt < this.heap[parent].nextRunAt ||
+          (this.heap[i].nextRunAt === this.heap[parent].nextRunAt && this.heap[i].priority > this.heap[parent].priority)) {
+        [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];
+        i = parent;
+      } else break;
+    }
+  }
+
+  _sinkDown(i) {
+    const n = this.heap.length;
+    while (true) {
+      let smallest = i;
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      if (left < n && (this.heap[left].nextRunAt < this.heap[smallest].nextRunAt ||
+          (this.heap[left].nextRunAt === this.heap[smallest].nextRunAt && this.heap[left].priority > this.heap[smallest].priority))) {
+        smallest = left;
+      }
+      if (right < n && (this.heap[right].nextRunAt < this.heap[smallest].nextRunAt ||
+          (this.heap[right].nextRunAt === this.heap[smallest].nextRunAt && this.heap[right].priority > this.heap[smallest].priority))) {
+        smallest = right;
+      }
+      if (smallest !== i) {
+        [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];
+        i = smallest;
+      } else break;
+    }
+  }
+}
+
 // ══════════════════════════════════════════════════════════════
 // ═  Worker: one per Discord account
 // ══════════════════════════════════════════════════════════════
@@ -328,15 +453,23 @@ class AccountWorker {
     this.lastRunTime = {};
     this.cycleCount = 0;
     this.lastCommandRun = 0;
+    this.paused = false;
+    this.globalCooldownUntil = 0;
+    this.commandQueue = null;
+    this.lastHealthCheck = Date.now();
   }
 
   get tag() { return `${this.color}${c.bold}${this.username}${c.reset}`; }
-  log(type, msg) { log(type, msg, this.tag); }
 
-  // Update the live dashboard status for this worker
+  log(type, msg) {
+    const stripped = msg.replace(/\x1b\[[0-9;]*m/g, '');
+    this.lastStatus = stripped.substring(0, 40);
+    log(type, msg, this.tag);
+  }
+
   setStatus(text) {
     this.lastStatus = text;
-    renderDashboard();
+    if (dashboardStarted) renderDashboard();
   }
 
   waitForDankMemer(timeout = 15000) {
@@ -347,19 +480,39 @@ class AccountWorker {
         resolve(null);
       }, timeout);
       const self = this;
+      function cleanup() {
+        clearTimeout(timer);
+        self.client.removeListener('messageCreate', handler);
+        self.client.removeListener('messageUpdate', updateHandler);
+      }
       function handler(msg) {
         if (msg.author.id === DANK_MEMER_ID && msg.channel.id === self.channel.id) {
-          clearTimeout(timer);
-          self.client.removeListener('messageCreate', handler);
-          self.client.removeListener('messageUpdate', updateHandler);
+          // If message has no content and no embeds, Dank Memer may populate via edit
+          const hasContent = (msg.content && msg.content.length > 0) || (msg.embeds && msg.embeds.length > 0) || (msg.components && msg.components.length > 0);
+          if (!hasContent) {
+            // Wait for the edit with actual content (up to 3s)
+            const editTimer = setTimeout(() => { cleanup(); resolve(msg); }, 3000);
+            function editHandler(oldMsg, newMsg) {
+              if (newMsg.id === msg.id) {
+                clearTimeout(editTimer);
+                self.client.removeListener('messageUpdate', editHandler);
+                cleanup();
+                resolve(newMsg);
+              }
+            }
+            self.client.on('messageUpdate', editHandler);
+            // Remove original handlers since we're now specifically looking for this msg's edit
+            self.client.removeListener('messageCreate', handler);
+            self.client.removeListener('messageUpdate', updateHandler);
+            return;
+          }
+          cleanup();
           resolve(msg);
         }
       }
       function updateHandler(oldMsg, newMsg) {
         if (newMsg.author?.id === DANK_MEMER_ID && newMsg.channel?.id === self.channel.id) {
-          clearTimeout(timer);
-          self.client.removeListener('messageCreate', handler);
-          self.client.removeListener('messageUpdate', updateHandler);
+          cleanup();
           resolve(newMsg);
         }
       }
@@ -473,7 +626,7 @@ class AccountWorker {
       }
 
       this.log('buy', `Clicking Buy ${itemName}...`);
-      try { await buyBtn.click(); } catch (e) {
+      try { await safeClickButton(response, buyBtn); } catch (e) {
         this.log('error', `Buy click failed: ${e.message}`);
         if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
         return false;
@@ -560,383 +713,13 @@ class AccountWorker {
     }
   }
 
-  // ══════════════════════════════════════════════════════════════
-  // ═  COMMAND HANDLERS
-  // ══════════════════════════════════════════════════════════════
-
-  async handleSearch(response) {
-    if (!response) return null;
-    debugMessage(response, 'SEARCH');
-    const buttons = getAllButtons(response);
-    if (buttons.length === 0) return getFullText(response).substring(0, 80);
-    const userSafe = safeParseJSON(this.account.search_answers, []);
-    const btn = pickSafeButton(buttons, userSafe);
-    if (btn) {
-      await humanDelay();
-      try {
-        await btn.click();
-        const followUp = await this.waitForDankMemer(10000);
-        if (followUp) {
-          const text = getFullText(followUp);
-          const coins = parseCoins(text);
-          if (coins > 0) { this.stats.coins += coins; return `${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-          if (text.toLowerCase().includes('nothing')) return `${btn.label} → found nothing`;
-          return `${btn.label} → done`;
-        }
-        return `Clicked: ${btn.label}`;
-      } catch { return null; }
-    }
-    return 'No safe option found';
-  }
-
-  async handleCrime(response) {
-    if (!response) return null;
-    debugMessage(response, 'CRIME');
-    const buttons = getAllButtons(response);
-    if (buttons.length === 0) return getFullText(response).substring(0, 80);
-    const userSafe = safeParseJSON(this.account.crime_answers, []);
-    const btn = pickSafeButton(buttons, userSafe);
-    if (btn) {
-      await humanDelay();
-      try {
-        await btn.click();
-        const followUp = await this.waitForDankMemer(10000);
-        if (followUp) {
-          const text = getFullText(followUp);
-          const coins = parseCoins(text);
-          if (coins > 0) { this.stats.coins += coins; return `${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-          return `${btn.label} → done`;
-        }
-        return `Clicked: ${btn.label}`;
-      } catch { return null; }
-    }
-    return 'No safe option found';
-  }
-
-  async handleHighLow(response) {
-    if (!response) return null;
-    debugMessage(response, 'HIGHLOW');
-    const text = getFullText(response);
-    const match = text.match(/number.*?(\d+)/i) || text.match(/(\d+)/);
-    const buttons = getAllButtons(response);
-    if (match && buttons.length >= 2) {
-      const num = parseInt(match[1]);
-      await humanDelay();
-      let targetBtn;
-      if (num > 50) targetBtn = buttons.find((b) => (b.label || '').toLowerCase().includes('lower')) || buttons[1];
-      else if (num < 50) targetBtn = buttons.find((b) => (b.label || '').toLowerCase().includes('higher')) || buttons[0];
-      else {
-        const jackpot = buttons.find((b) => (b.label || '').toLowerCase().includes('jackpot'));
-        targetBtn = jackpot || buttons[Math.floor(Math.random() * 2)];
-      }
-      try {
-        await targetBtn.click();
-        const followUp = await this.waitForDankMemer(10000);
-        if (followUp) {
-          const ftText = getFullText(followUp);
-          const coins = parseCoins(ftText);
-          if (coins > 0) { this.stats.coins += coins; return `${num} → ${targetBtn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-          const moreButtons = getAllButtons(followUp);
-          if (moreButtons.length >= 2) return await this.handleHighLow(followUp);
-          return `${num} → ${targetBtn.label}`;
-        }
-        return `${num} → ${targetBtn.label}`;
-      } catch { return null; }
-    }
-    if (buttons.length > 0) {
-      const btn = buttons[Math.floor(Math.random() * buttons.length)];
-      await humanDelay();
-      try { await btn.click(); } catch {}
-      return `Clicked: ${btn.label || 'button'}`;
-    }
-    return null;
-  }
-
-  async handleScratch(response) {
-    if (!response) return null;
-    debugMessage(response, 'SCRATCH');
-    const buttons = getAllButtons(response);
-    if (buttons.length === 0) {
-      const text = getFullText(response);
-      const coins = parseCoins(text);
-      if (coins > 0) { this.stats.coins += coins; return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-      return text.substring(0, 60) || 'done';
-    }
-    let lastResponse = response;
-    for (let i = 0; i < Math.min(buttons.length, 9); i++) {
-      const btn = buttons[i];
-      if (btn && !btn.disabled) {
-        await humanDelay(300, 700);
-        try {
-          await btn.click();
-          const followUp = await this.waitForDankMemer(5000);
-          if (followUp) lastResponse = followUp;
-        } catch { break; }
-      }
-    }
-    const finalText = getFullText(lastResponse);
-    const coins = parseCoins(finalText);
-    if (coins > 0) { this.stats.coins += coins; return `scratch → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-    return 'scratch done';
-  }
-
-  async handleAdventure(response) {
-    if (!response) return null;
-    debugMessage(response, 'ADVENTURE');
-    let current = response;
-    let rounds = 0;
-    const MAX_ROUNDS = 15;
-    while (current && rounds < MAX_ROUNDS) {
-      const buttons = getAllButtons(current);
-      if (buttons.length === 0) break;
-      const safeButtons = buttons.filter((b) => !b.disabled && b.style !== 4);
-      const btn = safeButtons.length > 0 ? safeButtons[Math.floor(Math.random() * safeButtons.length)] : buttons.find((b) => !b.disabled);
-      if (!btn) break;
-      await humanDelay(500, 1500);
-      try {
-        await btn.click();
-        const followUp = await this.waitForDankMemer(10000);
-        if (followUp) { current = followUp; rounds++; } else break;
-      } catch { break; }
-    }
-    const finalText = getFullText(current);
-    // Parse next adventure time from footer
-    const nextMatch = finalText.match(/next adventure.*?(\d+)/i);
-    if (nextMatch) {
-      const nextSec = parseInt(nextMatch[1]) * 60;
-      this.log('info', `Next adventure in ${c.yellow}${nextMatch[1]}m${c.reset}`);
-      await this.setCooldown('adventure', nextSec);
-    }
-    const coins = parseCoins(finalText);
-    if (coins > 0) { this.stats.coins += coins; return `adventure (${rounds} rounds) → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-    return `adventure done (${rounds} rounds)`;
-  }
-
-  // ── BlackJack Handler ─────────────────────────────────────
-  async handleBlackjack(response) {
-    if (!response) return null;
-    debugMessage(response, 'BLACKJACK');
-    let current = response;
-    const MAX_ROUNDS = 10;
-    for (let i = 0; i < MAX_ROUNDS; i++) {
-      const text = getFullText(current);
-      const buttons = getAllButtons(current);
-      if (buttons.length === 0) break;
-      // Parse player total from embed - look for patterns like "Total: 15" or "Value: **15**"
-      const totalMatch = text.match(/total[:\s]*\**(\d+)\**/i) || text.match(/value[:\s]*\**(\d+)\**/i);
-      const playerTotal = totalMatch ? parseInt(totalMatch[1]) : 0;
-      let targetBtn;
-      if (playerTotal >= 17 || playerTotal === 0) {
-        targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('stand')) || buttons[1];
-      } else {
-        targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('hit')) || buttons[0];
-      }
-      if (!targetBtn || targetBtn.disabled) break;
-      await humanDelay(500, 1200);
-      try {
-        await targetBtn.click();
-        const followUp = await this.waitForDankMemer(8000);
-        if (followUp) {
-          current = followUp;
-          const fButtons = getAllButtons(current);
-          if (fButtons.length === 0 || fButtons.every(b => b.disabled)) break;
-        } else break;
-      } catch { break; }
-    }
-    const finalText = getFullText(current);
-    const coins = parseCoins(finalText);
-    if (coins > 0) { this.stats.coins += coins; return `blackjack → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-    if (finalText.toLowerCase().includes('won')) return 'blackjack → won';
-    if (finalText.toLowerCase().includes('lost') || finalText.toLowerCase().includes('bust')) return 'blackjack → lost';
-    return 'blackjack done';
-  }
-
-  // ── Trivia Handler ────────────────────────────────────────
-  async handleTrivia(response) {
-    if (!response) return null;
-    debugMessage(response, 'TRIVIA');
-    const buttons = getAllButtons(response);
-    if (buttons.length === 0) return getFullText(response).substring(0, 80);
-    // Pick a random answer (we don't have a trivia DB - random has ~25% chance)
-    const clickable = buttons.filter(b => !b.disabled);
-    const btn = clickable[Math.floor(Math.random() * clickable.length)];
-    if (btn) {
-      await humanDelay(1000, 3000);
-      try {
-        await btn.click();
-        const followUp = await this.waitForDankMemer(8000);
-        if (followUp) {
-          const text = getFullText(followUp);
-          const coins = parseCoins(text);
-          if (coins > 0) { this.stats.coins += coins; return `trivia → ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-          if (text.toLowerCase().includes('correct')) return `trivia → ${btn.label} → correct`;
-          return `trivia → ${btn.label} → wrong`;
-        }
-      } catch {}
-    }
-    return 'trivia done';
-  }
-
-  // ── Work Shift Handler ────────────────────────────────────
-  async handleWorkShift(response) {
-    if (!response) return null;
-    debugMessage(response, 'WORK');
-    let current = response;
-    const MAX_ROUNDS = 5;
-    for (let i = 0; i < MAX_ROUNDS; i++) {
-      const buttons = getAllButtons(current);
-      const text = getFullText(current);
-      // Work shift mini-games: word scramble, memory, typing, etc.
-      // Try to click any available non-disabled button
-      if (buttons.length === 0) break;
-      const clickable = buttons.filter(b => !b.disabled);
-      if (clickable.length === 0) break;
-      // For word-type games, look for the correct button
-      const btn = clickable[0]; // Just pick first available
-      await humanDelay(500, 1500);
-      try {
-        await btn.click();
-        const followUp = await this.waitForDankMemer(8000);
-        if (followUp) { current = followUp; } else break;
-      } catch { break; }
-    }
-    const finalText = getFullText(current);
-    const coins = parseCoins(finalText);
-    if (coins > 0) { this.stats.coins += coins; return `work → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-    return 'work done';
-  }
-
-  // ── Generic Command Handler (beg, hunt, dig, farm, tidy, etc.) ──
-  async handleGenericCommand(response) {
-    if (!response) return null;
-    debugMessage(response, 'GENERIC');
-    const text = getFullText(response);
-    const coins = parseCoins(text);
-    const neededItem = this.needsItem(text);
-    if (neededItem) {
-      this.log('warn', `Missing ${c.bold}${neededItem}${c.reset} — auto-buying...`);
-      const bought = await this.buyItem(neededItem);
-      if (bought) return `auto-bought ${neededItem}`;
-      return `need ${neededItem} (couldn't buy)`;
-    }
-    // Handle buttons if present (e.g., postmemes, farm choices)
-    const buttons = getAllButtons(response);
-    if (buttons.length > 0) {
-      const btn = buttons.find((b) => !b.disabled) || buttons[0];
-      if (btn) {
-        await humanDelay();
-        try {
-          await btn.click();
-          const followUp = await this.waitForDankMemer(8000);
-          if (followUp) {
-            const fText = getFullText(followUp);
-            const fCoins = parseCoins(fText);
-            if (fCoins > 0) { this.stats.coins += fCoins; return `${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`; }
-            // Check if followUp also has buttons (multi-step)
-            const nextButtons = getAllButtons(followUp);
-            if (nextButtons.length > 0) {
-              const nextBtn = nextButtons.find(b => !b.disabled);
-              if (nextBtn) {
-                await humanDelay();
-                try { await nextBtn.click(); } catch {}
-              }
-            }
-          }
-        } catch {}
-      }
-    }
-    // Handle select menus (some commands use dropdowns)
-    const menus = getAllSelectMenus(response);
-    if (menus.length > 0) {
-      const menu = menus[0];
-      const options = menu.options || [];
-      if (options.length > 0) {
-        const opt = options[Math.floor(Math.random() * options.length)];
-        try {
-          await response.selectMenu(menu.customId, [opt.value]);
-          const followUp = await this.waitForDankMemer(8000);
-          if (followUp) {
-            const fText = getFullText(followUp);
-            const fCoins = parseCoins(fText);
-            if (fCoins > 0) { this.stats.coins += fCoins; return `${opt.label} → ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`; }
-          }
-        } catch {}
-      }
-    }
-    if (coins > 0) { this.stats.coins += coins; return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-    return text.substring(0, 60) || 'done';
-  }
-
-  // ── Simple Gambling (cointoss, roulette, slots, snakeeyes) ──
-  async handleSimpleGamble(response) {
-    if (!response) return null;
-    debugMessage(response, 'GAMBLE');
-    const text = getFullText(response);
-    const coins = parseCoins(text);
-    // Check buttons (some gambling has buttons)
-    const buttons = getAllButtons(response);
-    if (buttons.length > 0) {
-      const btn = buttons.find(b => !b.disabled);
-      if (btn) {
-        await humanDelay();
-        try {
-          await btn.click();
-          const followUp = await this.waitForDankMemer(8000);
-          if (followUp) {
-            const fText = getFullText(followUp);
-            const fCoins = parseCoins(fText);
-            if (fCoins > 0) { this.stats.coins += fCoins; return `${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`; }
-            if (fText.toLowerCase().includes('won')) return `${c.green}won${c.reset}`;
-            if (fText.toLowerCase().includes('lost')) return `${c.red}lost${c.reset}`;
-          }
-        } catch {}
-      }
-    }
-    if (coins > 0) { this.stats.coins += coins; return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
-    if (text.toLowerCase().includes('won')) return `${c.green}won${c.reset}`;
-    if (text.toLowerCase().includes('lost')) return `${c.red}lost${c.reset}`;
-    return text.substring(0, 60) || 'done';
-  }
-
-  // ── Deposit Handler ────────────────────────────────────────
-  async handleDeposit(response) {
-    if (!response) return null;
-    const text = getFullText(response);
-    const coins = parseCoins(text);
-    if (text.toLowerCase().includes('deposited')) {
-      return `deposited ${c.green}⏣ ${coins.toLocaleString()}${c.reset}`;
-    }
-    return text.substring(0, 60) || 'deposit done';
-  }
-
-  // ── Alert Handler ─────────────────────────────────────────
-  async handleAlert(response) {
-    if (!response) return null;
-    debugMessage(response, 'ALERT');
-    const buttons = getAllButtons(response);
-    // Click any dismiss/accept/ok button
-    const btn = buttons.find(b => !b.disabled && ['ok', 'dismiss', 'accept', 'got it', 'continue'].some(s => (b.label || '').toLowerCase().includes(s)));
-    if (btn) {
-      await humanDelay();
-      try { await btn.click(); } catch {}
-      return `alert dismissed`;
-    }
-    if (buttons.length > 0) {
-      const first = buttons.find(b => !b.disabled);
-      if (first) {
-        await humanDelay();
-        try { await first.click(); } catch {}
-      }
-    }
-    return 'alert handled';
-  }
-
   // ── Run Single Command ──────────────────────────────────────
+  // Each modular command handler sends the command, waits for response,
+  // handles Hold Tight / cooldowns / item-buying internally.
   async runCommand(cmdName, prefix) {
     let cmdString;
     const betAmount = this.account.bet_amount || 1000;
 
-    // Build the command string
     switch (cmdName) {
       case 'dep max':     cmdString = `${prefix} dep max`; break;
       case 'blackjack':   cmdString = `${prefix} bj ${betAmount}`; break;
@@ -948,65 +731,85 @@ class AccountWorker {
       default:            cmdString = `${prefix} ${cmdName}`;
     }
 
-    this.log('cmd', `${c.white}${c.bold}${cmdString}${c.reset}`);
+    if (shutdownCalled || !this.running) return;
     this.stats.commands++;
 
+    const cmdOpts = {
+      channel: this.channel,
+      waitForDankMemer: (timeout) => this.waitForDankMemer(timeout),
+      client: this.client,
+      safeAnswers: cmdName === 'search' ? safeParseJSON(this.account.search_answers, []) :
+                   cmdName === 'crime' ? safeParseJSON(this.account.crime_answers, []) : [],
+      betAmount,
+      accountId: this.account.id,
+      redis,
+    };
+
     try {
-      await this.channel.send(cmdString);
-      const response = await this.waitForDankMemer();
+      let cmdResult;
+      switch (cmdName) {
+        case 'beg':         cmdResult = await commands.runBeg(cmdOpts); break;
+        case 'search':      cmdResult = await commands.runSearch(cmdOpts); break;
+        case 'crime':       cmdResult = await commands.runCrime(cmdOpts); break;
+        case 'hl':          cmdResult = await commands.runHighLow(cmdOpts); break;
+        case 'pm':          cmdResult = await commands.runPostMemes(cmdOpts); break;
+        case 'hunt':        cmdResult = await commands.runHunt(cmdOpts); break;
+        case 'dig':         cmdResult = await commands.runDig(cmdOpts); break;
+        case 'fish':        cmdResult = await commands.runFish(cmdOpts); break;
+        case 'scratch':     cmdResult = await commands.runScratch(cmdOpts); break;
+        case 'adventure':   cmdResult = await commands.runAdventure(cmdOpts); break;
+        case 'blackjack':   cmdResult = await commands.runBlackjack(cmdOpts); break;
+        case 'trivia':      cmdResult = await commands.runTrivia(cmdOpts); break;
+        case 'work shift':  cmdResult = await commands.runWorkShift(cmdOpts); break;
+        case 'coinflip':    cmdResult = await commands.runCoinflip(cmdOpts); break;
+        case 'roulette':    cmdResult = await commands.runRoulette(cmdOpts); break;
+        case 'slots':       cmdResult = await commands.runSlots(cmdOpts); break;
+        case 'snakeeyes':   cmdResult = await commands.runSnakeeyes(cmdOpts); break;
+        case 'dep max':     cmdResult = await commands.runDeposit(cmdOpts); break;
+        case 'alert':       cmdResult = await commands.runAlert(cmdOpts); break;
+        default:            cmdResult = await commands.runGeneric({ ...cmdOpts, cmdString, cmdName }); break;
+      }
 
-      if (!response) {
-        this.log('warn', `No response for ${cmdString}`);
-        this.stats.errors++;
-        await sendLog(this.username, cmdString, 'timeout', 'timeout');
+      const result = cmdResult.result || 'done';
+      const resultLower = result.toLowerCase();
+
+      // Rate limit detection
+      if (resultLower.includes('slow down') || resultLower.includes('rate limit') || resultLower.includes('too fast')) {
+        this.log('warn', `${c.yellow}⚠ Rate limited!${c.reset} Setting 60s global cooldown for ${this.username}`);
+        this.globalCooldownUntil = Date.now() + 60000;
+        await this.setCooldown(cmdName, 60);
         return;
       }
 
-      // Check for cooldown messages
-      const responseText = getFullText(response).toLowerCase();
-      if (responseText.includes('already claimed') || 
-          (responseText.includes('wait') && responseText.includes('before')) ||
-          responseText.includes('cooldown') || responseText.includes('slow down') || 
-          responseText.includes('come back') || responseText.includes('already used') ||
-          responseText.includes('try again in')) {
-        this.log('warn', `${cmdName} on cooldown`);
-        // Try to parse remaining cooldown from text
-        const timeMatch = responseText.match(/(\d+)\s*(second|minute|hour|day)/i);
-        if (timeMatch) {
-          let secs = parseInt(timeMatch[1]);
-          const unit = timeMatch[2].toLowerCase();
-          if (unit.startsWith('minute')) secs *= 60;
-          if (unit.startsWith('hour')) secs *= 3600;
-          if (unit.startsWith('day')) secs *= 86400;
-          await this.setCooldown(cmdName, secs + 5);
-          this.log('info', `Set cooldown for ${cmdName}: ${secs}s`);
-        }
-        await sendLog(this.username, cmdString, 'on cooldown', 'cooldown');
+      // Captcha/verification detection — pause immediately
+      if (resultLower.includes('captcha') || resultLower.includes('verification') ||
+          resultLower.includes('are you human') || resultLower.includes("prove you're not a bot")) {
+        this.log('error', `${c.red}${c.bold}🚨 CAPTCHA/VERIFICATION DETECTED for ${this.username}!${c.reset}`);
+        this.log('error', `${c.red}URGENT: Worker PAUSED. Re-enable manually from the dashboard.${c.reset}`);
+        this.paused = true;
+        await sendLog(this.username, cmdString, 'CAPTCHA DETECTED — worker paused', 'error');
         return;
       }
 
-      let result;
-      switch (cmdName) {
-        case 'search':      result = await this.handleSearch(response); break;
-        case 'crime':       result = await this.handleCrime(response); break;
-        case 'hl':          result = await this.handleHighLow(response); break;
-        case 'scratch':     result = await this.handleScratch(response); break;
-        case 'adventure':   result = await this.handleAdventure(response); break;
-        case 'blackjack':   result = await this.handleBlackjack(response); break;
-        case 'trivia':      result = await this.handleTrivia(response); break;
-        case 'work shift':  result = await this.handleWorkShift(response); break;
-        case 'coinflip':
-        case 'roulette':
-        case 'slots':
-        case 'snakeeyes':   result = await this.handleSimpleGamble(response); break;
-        case 'dep max':     result = await this.handleDeposit(response); break;
-        case 'alert':       result = await this.handleAlert(response); break;
-        default:            result = await this.handleGenericCommand(response); break;
+      const earned = Math.max(0, cmdResult.coins || 0);
+      const spent = Math.max(0, cmdResult.lost || 0);
+      if (earned > 0) this.stats.coins += earned;
+      if (cmdResult.nextCooldownSec) await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
+
+      if (cmdResult.holdTightReason) {
+        const reason = cmdResult.holdTightReason;
+        this.log('warn', `Hold Tight caused by /${reason} — setting 35s cooldown on "${reason}"`);
+        const reasonMap = { postmemes: 'pm', highlow: 'hl', blackjack: 'bj', 'work shift': 'work shift' };
+        const mappedCmd = reasonMap[reason] || reason;
+        await this.setCooldown(mappedCmd, 35);
+        await this.setCooldown(cmdName, 35);
       }
 
       this.stats.successes++;
-      this.log('success', `${c.dim}${cmdString}${c.reset} → ${result || 'done'}`);
-      await sendLog(this.username, cmdString, result || 'done', 'success');
+      const shortResult = result.substring(0, 50).replace(/\n/g, ' ');
+      this.setStatus(`${cmdName} → ${shortResult}`);
+      await sendLog(this.username, cmdString, result, 'success');
+      reportEarnings(this.account.id, this.username, earned, spent, cmdName);
     } catch (err) {
       this.stats.errors++;
       this.log('error', `${cmdString} failed: ${err.message}`);
@@ -1032,130 +835,215 @@ class AccountWorker {
     // Stats are shown in the live dashboard, no-op here
   }
 
+  // ── Command Map (shared across ticks, used to build the heap) ──
+  static COMMAND_MAP = [
+    { key: 'cmd_beg', cmd: 'beg', cdKey: 'cd_beg', defaultCd: 40, priority: 5 },
+    { key: 'cmd_search', cmd: 'search', cdKey: 'cd_search', defaultCd: 25, priority: 4 },
+    { key: 'cmd_hl', cmd: 'hl', cdKey: 'cd_hl', defaultCd: 10, priority: 3 },
+    { key: 'cmd_pm', cmd: 'pm', cdKey: 'cd_pm', defaultCd: 20, priority: 3 },
+    { key: 'cmd_crime', cmd: 'crime', cdKey: 'cd_crime', defaultCd: 40, priority: 2 },
+    { key: 'cmd_hunt', cmd: 'hunt', cdKey: 'cd_hunt', defaultCd: 20, priority: 1 },
+    { key: 'cmd_dig', cmd: 'dig', cdKey: 'cd_dig', defaultCd: 20, priority: 1 },
+    { key: 'cmd_fish', cmd: 'fish', cdKey: 'cd_fish', defaultCd: 20, priority: 1 },
+    { key: 'cmd_farm', cmd: 'farm', cdKey: 'cd_farm', defaultCd: 10, priority: 2 },
+    { key: 'cmd_tidy', cmd: 'tidy', cdKey: 'cd_tidy', defaultCd: 40, priority: 1 },
+    { key: 'cmd_blackjack', cmd: 'blackjack', cdKey: 'cd_blackjack', defaultCd: 3, priority: 3 },
+    { key: 'cmd_cointoss', cmd: 'coinflip', cdKey: 'cd_cointoss', defaultCd: 2, priority: 3 },
+    { key: 'cmd_roulette', cmd: 'roulette', cdKey: 'cd_roulette', defaultCd: 3, priority: 3 },
+    { key: 'cmd_slots', cmd: 'slots', cdKey: 'cd_slots', defaultCd: 3, priority: 3 },
+    { key: 'cmd_snakeeyes', cmd: 'snakeeyes', cdKey: 'cd_snakeeyes', defaultCd: 3, priority: 3 },
+    { key: 'cmd_trivia', cmd: 'trivia', cdKey: 'cd_trivia', defaultCd: 10, priority: 2 },
+    { key: 'cmd_use', cmd: 'use', cdKey: 'cd_use', defaultCd: 10, priority: 1 },
+    { key: 'cmd_drops', cmd: 'drops', cdKey: 'cd_drops', defaultCd: 60, priority: 2 },
+    { key: 'cmd_stream', cmd: 'stream', cdKey: 'cd_stream', defaultCd: 600, priority: 8 },
+    { key: 'cmd_deposit', cmd: 'dep max', cdKey: 'cd_deposit', defaultCd: 60, priority: 7 },
+    { key: 'cmd_daily', cmd: 'daily', cdKey: 'cd_daily', defaultCd: 86400, priority: 10 },
+    { key: 'cmd_weekly', cmd: 'weekly', cdKey: 'cd_weekly', defaultCd: 604800, priority: 10 },
+    { key: 'cmd_monthly', cmd: 'monthly', cdKey: 'cd_monthly', defaultCd: 2592000, priority: 10 },
+    { key: 'cmd_work', cmd: 'work shift', cdKey: 'cd_work', defaultCd: 3600, priority: 8 },
+    { key: 'cmd_scratch', cmd: 'scratch', cdKey: 'cd_scratch', defaultCd: 3600, priority: 6 },
+    { key: 'cmd_adventure', cmd: 'adventure', cdKey: 'cd_adventure', defaultCd: 300, priority: 6 },
+    { key: 'cmd_alert', cmd: 'alert', cdKey: 'cd_alert', defaultCd: 300, priority: 9 },
+  ];
+
+  buildCommandQueue() {
+    const heap = new MinHeap();
+    const now = Date.now();
+    const enabled = AccountWorker.COMMAND_MAP.filter(
+      ci => this.account[ci.key] === true || this.account[ci.key] === 1
+    );
+    for (const info of enabled) {
+      heap.push({ cmd: info.cmd, nextRunAt: now, priority: info.priority, info });
+    }
+    return heap;
+  }
+
+  // ── Health Check: verify Discord client is still connected ──
+  async healthCheck() {
+    if (!this.running || shutdownCalled) return;
+    const now = Date.now();
+    if (now - this.lastHealthCheck < 60000) return;
+    this.lastHealthCheck = now;
+
+    if (!this.client.ws || this.client.ws.status !== 0) {
+      this.log('warn', `${c.yellow}⚠ Discord client disconnected. Attempting reconnect...${c.reset}`);
+      try {
+        this.client.destroy();
+        await this.client.login(this.account.discord_token);
+        this.channel = await this.client.channels.fetch(this.account.channel_id).catch(() => null);
+        if (this.channel) {
+          this.log('success', 'Reconnected successfully.');
+        } else {
+          this.log('error', 'Reconnected but channel not found.');
+        }
+      } catch (e) {
+        this.log('error', `Reconnect failed: ${e.message}`);
+      }
+    }
+  }
+
   // ── Main Non-Blocking Grind Scheduler ───────────────────────
   async tick() {
-    if (!this.running) return;
+    if (!this.running || shutdownCalled) return;
+    if (this.paused) {
+      this.setStatus(`${c.red}${c.bold}PAUSED (captcha/verification)${c.reset}`);
+      this.tickTimeout = setTimeout(() => this.tick(), 5000);
+      return;
+    }
     if (this.busy) {
-      this.tickTimeout = setTimeout(() => this.tick(), 1000);
+      this.tickTimeout = setTimeout(() => this.tick(), 2000);
+      return;
+    }
+
+    // Global rate-limit cooldown
+    const now = Date.now();
+    if (now < this.globalCooldownUntil) {
+      const waitSec = Math.ceil((this.globalCooldownUntil - now) / 1000);
+      this.setStatus(`${c.yellow}rate limited (${waitSec}s)${c.reset}`);
+      this.tickTimeout = setTimeout(() => this.tick(), 2000);
       return;
     }
 
-    const commandMap = [
-      // Grinding commands (high frequency)
-      { key: 'cmd_beg', cmd: 'beg', cdKey: 'cd_beg', defaultCd: 40, priority: 5 },
-      { key: 'cmd_search', cmd: 'search', cdKey: 'cd_search', defaultCd: 25, priority: 4 },
-      { key: 'cmd_hl', cmd: 'hl', cdKey: 'cd_hl', defaultCd: 10, priority: 3 },
-      { key: 'cmd_pm', cmd: 'pm', cdKey: 'cd_pm', defaultCd: 20, priority: 3 },
-      { key: 'cmd_crime', cmd: 'crime', cdKey: 'cd_crime', defaultCd: 40, priority: 2 },
-      { key: 'cmd_hunt', cmd: 'hunt', cdKey: 'cd_hunt', defaultCd: 20, priority: 1 },
-      { key: 'cmd_dig', cmd: 'dig', cdKey: 'cd_dig', defaultCd: 20, priority: 1 },
-      { key: 'cmd_fish', cmd: 'fish', cdKey: 'cd_fish', defaultCd: 20, priority: 1 },
-      { key: 'cmd_farm', cmd: 'farm', cdKey: 'cd_farm', defaultCd: 10, priority: 2 },
-      { key: 'cmd_tidy', cmd: 'tidy', cdKey: 'cd_tidy', defaultCd: 40, priority: 1 },
-      // Gambling
-      { key: 'cmd_blackjack', cmd: 'blackjack', cdKey: 'cd_blackjack', defaultCd: 3, priority: 3 },
-      { key: 'cmd_cointoss', cmd: 'coinflip', cdKey: 'cd_cointoss', defaultCd: 2, priority: 3 },
-      { key: 'cmd_roulette', cmd: 'roulette', cdKey: 'cd_roulette', defaultCd: 3, priority: 3 },
-      { key: 'cmd_slots', cmd: 'slots', cdKey: 'cd_slots', defaultCd: 3, priority: 3 },
-      { key: 'cmd_snakeeyes', cmd: 'snakeeyes', cdKey: 'cd_snakeeyes', defaultCd: 3, priority: 3 },
-      // Medium cooldown
-      { key: 'cmd_trivia', cmd: 'trivia', cdKey: 'cd_trivia', defaultCd: 10, priority: 2 },
-      { key: 'cmd_use', cmd: 'use', cdKey: 'cd_use', defaultCd: 10, priority: 1 },
-      { key: 'cmd_drops', cmd: 'drops', cdKey: 'cd_drops', defaultCd: 60, priority: 2 },
-      { key: 'cmd_stream', cmd: 'stream', cdKey: 'cd_stream', defaultCd: 600, priority: 8 },
-      // Economy
-      { key: 'cmd_deposit', cmd: 'dep max', cdKey: 'cd_deposit', defaultCd: 60, priority: 7 },
-      // Long cooldown / special
-      { key: 'cmd_daily', cmd: 'daily', cdKey: 'cd_daily', defaultCd: 86400, priority: 10 },
-      { key: 'cmd_weekly', cmd: 'weekly', cdKey: 'cd_weekly', defaultCd: 604800, priority: 10 },
-      { key: 'cmd_monthly', cmd: 'monthly', cdKey: 'cd_monthly', defaultCd: 2592000, priority: 10 },
-      { key: 'cmd_work', cmd: 'work shift', cdKey: 'cd_work', defaultCd: 3600, priority: 8 },
-      { key: 'cmd_scratch', cmd: 'scratch', cdKey: 'cd_scratch', defaultCd: 3600, priority: 6 },
-      { key: 'cmd_adventure', cmd: 'adventure', cdKey: 'cd_adventure', defaultCd: 300, priority: 6 },
-      // System
-      { key: 'cmd_alert', cmd: 'alert', cdKey: 'cd_alert', defaultCd: 300, priority: 9 },
-    ];
-
-    const enabledCommands = commandMap.filter((ci) => this.account[ci.key] === true || this.account[ci.key] === 1);
-    
-    if (enabledCommands.length === 0) {
+    // Periodic health check
+    try { await this.healthCheck(); } catch (e) {
+      this.log('error', `Health check error: ${e.message}`);
+    }
+
+    // Rebuild queue if it doesn't exist or is empty (e.g. after config refresh)
+    if (!this.commandQueue || this.commandQueue.size === 0) {
+      this.commandQueue = this.buildCommandQueue();
+    }
+
+    if (this.commandQueue.size === 0) {
       this.tickTimeout = setTimeout(() => this.tick(), 15000);
       return;
     }
 
-    let nextCmdToRun = null;
-    let highestPriority = -1;
+    // Peek the top item — is it ready?
+    const top = this.commandQueue.peek();
+    if (top.nextRunAt > now) {
+      const waitMs = Math.min(top.nextRunAt - now, 2000);
+      this.setStatus(`${c.dim}waiting for cooldowns...${c.reset}`);
+      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
+      return;
+    }
 
-    for (const info of enabledCommands) {
-      const ready = await this.isCooldownReady(info.cmd);
-      if (ready && info.priority > highestPriority) {
-        nextCmdToRun = info;
-        highestPriority = info.priority;
-      }
+    // Pop the command, check Redis cooldown as a secondary gate
+    const item = this.commandQueue.pop();
+    const ready = await this.isCooldownReady(item.cmd);
+    if (!ready) {
+      const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
+      item.nextRunAt = now + cd * 1000;
+      this.commandQueue.push(item);
+      this.tickTimeout = setTimeout(() => this.tick(), 100);
+      return;
     }
 
-    if (nextCmdToRun) {
-      this.busy = true;
-      const cd = (this.account[nextCmdToRun.cdKey] || nextCmdToRun.defaultCd);
-      const jitter = 1 + Math.random() * 3; 
-      const totalWait = cd + jitter;
-      
-      // Optimistic lock via Redis
-      await this.setCooldown(nextCmdToRun.cmd, totalWait); 
-      
-      // Global Jitter between commands
-      const now = Date.now();
-      const timeSinceLastCmd = now - (this.lastCommandRun || 0);
-      const globalJitter = 1500 + Math.random() * 1500;
-      if (timeSinceLastCmd < globalJitter) {
-        await new Promise(r => setTimeout(r, globalJitter - timeSinceLastCmd));
-      }
+    this.busy = true;
+    const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
+    const jitter = 1 + Math.random() * 3;
+    const totalWait = cd + jitter;
 
-      const prefix = this.account.use_slash ? '/' : 'pls';
-      this.setStatus(`${c.white}pls ${nextCmdToRun.cmd}${c.reset}`);
-      await this.runCommand(nextCmdToRun.cmd, prefix);
-      
-      this.lastCommandRun = Date.now();
-      // Re-apply cooldown based on actual finish time
-      await this.setCooldown(nextCmdToRun.cmd, totalWait);
-      
-      this.busy = false;
-      this.cycleCount++;
+    await this.setCooldown(item.cmd, totalWait);
 
-      if (this.cycleCount > 0 && this.cycleCount % 10 === 0) this.printStats();
-      if (this.cycleCount > 0 && this.cycleCount % 20 === 0) {
-        this.busy = true;
-        await this.checkBalance();
-        this.busy = false;
-      }
+    // Global jitter between commands
+    const timeSinceLastCmd = now - (this.lastCommandRun || 0);
+    const globalJitter = 1500 + Math.random() * 1500;
+    if (timeSinceLastCmd < globalJitter) {
+      await new Promise(r => setTimeout(r, globalJitter - timeSinceLastCmd));
+    }
 
-      this.tickTimeout = setTimeout(() => this.tick(), 100);
-    } else {
-      this.setStatus(`${c.dim}waiting for cooldowns...${c.reset}`);
-      this.tickTimeout = setTimeout(() => this.tick(), 1000);
+    const prefix = this.account.use_slash ? '/' : 'pls';
+    this.setStatus(`${c.white}pls ${item.cmd}${c.reset}`);
+    await this.runCommand(item.cmd, prefix);
+
+    this.lastCommandRun = Date.now();
+    await this.setCooldown(item.cmd, totalWait);
+
+    // Push the command back into the heap with its next available time
+    item.nextRunAt = Date.now() + totalWait * 1000;
+    this.commandQueue.push(item);
+
+    this.busy = false;
+    this.cycleCount++;
+
+    if (this.cycleCount > 0 && this.cycleCount % 10 === 0) this.printStats();
+    if (this.cycleCount > 0 && this.cycleCount % 20 === 0) {
+      this.busy = true;
+      await this.checkBalance();
+      this.busy = false;
     }
+
+    this.tickTimeout = setTimeout(() => this.tick(), 100);
   }
 
   async grindLoop() {
     if (this.running) return;
     this.running = true;
     this.busy = false;
+    this.paused = false;
     this.cycleCount = 0;
     this.lastCommandRun = 0;
+    this.commandQueue = this.buildCommandQueue();
+    this.lastHealthCheck = Date.now();
 
     this.configInterval = setInterval(async () => {
       if (!this.running) return;
       await this.refreshConfig();
+
+      // Dashboard can un-pause a captcha-paused worker by re-activating it
+      if (this.account.active && this.paused) {
+        this.log('success', 'Account re-activated from dashboard! Resuming from captcha pause...');
+        this.paused = false;
+        this.busy = false;
+      }
+
       if (!this.account.active && !this.busy) {
         this.log('warn', 'Account deactivated from dashboard. Pausing...');
         this.busy = true;
-      } else if (this.account.active && this.busy) {
+      } else if (this.account.active && this.busy && !this.paused) {
         this.log('success', 'Account re-activated! Resuming...');
         this.busy = false;
       }
+
+      // Rebuild the command queue on config refresh so newly enabled/disabled commands take effect
+      this.commandQueue = this.buildCommandQueue();
     }, 15000);
 
-    this.tick();
+    const safeTickLoop = async () => {
+      try {
+        await this.tick();
+      } catch (err) {
+        this.log('error', `Unhandled tick error: ${err.message}`);
+        this.busy = false;
+        await new Promise(r => setTimeout(r, 5000));
+        if (this.running && !shutdownCalled) {
+          this.tickTimeout = setTimeout(() => safeTickLoop(), 100);
+        }
+      }
+    };
+
+    safeTickLoop();
   }
 
   async refreshConfig() {
@@ -1172,10 +1060,8 @@ class AccountWorker {
   }
 
   async start() {
-    if (!this.account.discord_token) { this.log('error', 'No Discord token.'); return; }
-    if (!this.account.channel_id) { this.log('error', 'No channel ID.'); return; }
-
-    this.log('info', 'Connecting...');
+    if (!this.account.discord_token) { this.log('error', 'No token'); return; }
+    if (!this.account.channel_id) { this.log('error', 'No channel'); return; }
 
     return new Promise((resolve) => {
       this.client.on('ready', async () => {
@@ -1188,41 +1074,33 @@ class AccountWorker {
           });
         } catch { /* silent */ }
 
-        this.log('success', `Logged in! ${c.dim}(${this.client.guilds.cache.size} servers)${c.reset}`);
         this.channel = await this.client.channels.fetch(this.account.channel_id).catch(() => null);
-
         if (!this.channel) {
-          this.log('error', `Channel ${this.account.channel_id} not found`);
+          this.log('error', `Channel not found`);
           resolve(); return;
         }
 
-        this.log('info', `Channel: ${c.white}#${this.channel.name || this.account.channel_id}${c.reset}`);
-
-        const ALL_CMDS = [
-          { key: 'cmd_hunt', label: 'hunt' }, { key: 'cmd_dig', label: 'dig' },
-          { key: 'cmd_fish', label: 'fish' }, { key: 'cmd_beg', label: 'beg' },
-          { key: 'cmd_search', label: 'search' }, { key: 'cmd_hl', label: 'hl' },
-          { key: 'cmd_crime', label: 'crime' }, { key: 'cmd_pm', label: 'pm' },
-          { key: 'cmd_daily', label: 'daily' }, { key: 'cmd_weekly', label: 'weekly' },
-          { key: 'cmd_monthly', label: 'monthly' }, { key: 'cmd_work', label: 'work' },
-          { key: 'cmd_stream', label: 'stream' }, { key: 'cmd_scratch', label: 'scratch' },
-          { key: 'cmd_adventure', label: 'adventure' }, { key: 'cmd_farm', label: 'farm' },
-          { key: 'cmd_tidy', label: 'tidy' }, { key: 'cmd_blackjack', label: 'bj' },
-          { key: 'cmd_cointoss', label: 'coinflip' }, { key: 'cmd_roulette', label: 'roulette' },
-          { key: 'cmd_slots', label: 'slots' }, { key: 'cmd_snakeeyes', label: 'snakeeyes' },
-          { key: 'cmd_trivia', label: 'trivia' }, { key: 'cmd_use', label: 'use' },
-          { key: 'cmd_deposit', label: 'deposit' }, { key: 'cmd_drops', label: 'drops' },
-          { key: 'cmd_alert', label: 'alert' },
+        const enabledCmds = [
+          { key: 'cmd_hunt', l: 'hunt' }, { key: 'cmd_dig', l: 'dig' },
+          { key: 'cmd_fish', l: 'fish' }, { key: 'cmd_beg', l: 'beg' },
+          { key: 'cmd_search', l: 'search' }, { key: 'cmd_hl', l: 'hl' },
+          { key: 'cmd_crime', l: 'crime' }, { key: 'cmd_pm', l: 'pm' },
+          { key: 'cmd_daily', l: 'daily' }, { key: 'cmd_weekly', l: 'weekly' },
+          { key: 'cmd_monthly', l: 'monthly' }, { key: 'cmd_work', l: 'work' },
+          { key: 'cmd_stream', l: 'stream' }, { key: 'cmd_scratch', l: 'scratch' },
+          { key: 'cmd_adventure', l: 'adv' }, { key: 'cmd_farm', l: 'farm' },
+          { key: 'cmd_tidy', l: 'tidy' }, { key: 'cmd_blackjack', l: 'bj' },
+          { key: 'cmd_cointoss', l: 'flip' }, { key: 'cmd_roulette', l: 'roul' },
+          { key: 'cmd_slots', l: 'slots' }, { key: 'cmd_snakeeyes', l: 'snake' },
+          { key: 'cmd_trivia', l: 'trivia' }, { key: 'cmd_use', l: 'use' },
+          { key: 'cmd_deposit', l: 'dep' }, { key: 'cmd_drops', l: 'drops' },
+          { key: 'cmd_alert', l: 'alert' },
         ].filter((ci) => this.account[ci.key] === true || this.account[ci.key] === 1);
 
-        const cmdStr = ALL_CMDS.map(ci => ci.label).join(', ');
-        this.log('info', `Commands: ${c.white}${cmdStr || 'none'}${c.reset}`);
-        if (this.account.bet_amount) {
-          this.log('info', `Bet amount: ${c.yellow}⏣ ${this.account.bet_amount.toLocaleString()}${c.reset}`);
-        }
+        const cmdList = enabledCmds.map(ci => ci.l).join(' ');
+        this.log('success', `${this.tag} ${c.dim}#${(this.channel.name || '?').substring(0, 12)}${c.reset} ${c.dim}[${enabledCmds.length} cmds: ${cmdList}]${c.reset}`);
 
         await this.checkBalance();
-        console.log('');
         this.grindLoop();
         resolve();
       });
@@ -1233,8 +1111,10 @@ class AccountWorker {
 
   stop() {
     this.running = false;
+    this.paused = false;
     if (this.tickTimeout) clearTimeout(this.tickTimeout);
     if (this.configInterval) clearInterval(this.configInterval);
+    this.commandQueue = null;
     try { this.client.destroy(); } catch {}
   }
 }
@@ -1245,21 +1125,37 @@ class AccountWorker {
 
 async function start(apiKey, apiUrl) {
   API_KEY = apiKey;
-  API_URL = apiUrl;
+  API_URL = apiUrl || process.env.DANKGRINDER_URL || 'http://localhost:3000';
+  REDIS_URL = process.env.REDIS_URL || '';
   initRedis();
 
-  // Clear screen & show big banner
   process.stdout.write('\x1b[2J\x1b[H');
-  console.log(BANNER);
-  console.log(`  ${c.dim}v4.0${c.reset}  ${c.dim}•${c.reset}  ${c.white}30 Commands${c.reset}  ${c.dim}•${c.reset}  ${c.cyan}Redis Cooldowns${c.reset}  ${c.dim}•${c.reset}  ${c.green}Smart AI${c.reset}`);
-  console.log('');
+  const tw = Math.min(process.stdout.columns || 80, 78);
+  const bar = c.dim + '─'.repeat(tw) + c.reset;
+
+  console.log(colorBanner());
+  console.log(
+    `  ${rgb(139, 92, 246)}v4.1${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${c.white}30 Commands${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${rgb(34, 211, 238)}Priority Queue${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}Redis Cooldowns${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${rgb(251, 191, 36)}Smart AI${c.reset}`
+  );
+  console.log(bar);
+
+  const checks = [];
+  checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}API${c.reset}`);
+  checks.push(REDIS_URL ? `${rgb(52, 211, 153)}✓${c.reset} ${c.white}Redis${c.reset}` : `${c.dim}○ Redis${c.reset}`);
+  console.log(`  ${checks.join('   ')}`);
 
-  log('info', `API: ${c.dim}${API_URL}${c.reset}`);
-  log('info', `Redis: ${c.dim}${REDIS_URL.replace(/:[^:]+@/, ':***@')}${c.reset}`);
-  log('info', 'Fetching accounts...');
+  log('info', `${c.dim}Fetching accounts...${c.reset}`);
 
   const data = await fetchConfig();
-  if (!data) { log('error', 'Failed to fetch config.'); process.exit(1); }
+  if (!data) {
+    log('error', `Cannot connect to API`);
+    log('error', `Pass ${c.white}--url${c.reset} with your Railway URL or set ${c.white}DANKGRINDER_URL${c.reset}`);
+    process.exit(1);
+  }
 
   const { accounts } = data;
   if (!accounts || accounts.length === 0) {
@@ -1267,7 +1163,10 @@ async function start(apiKey, apiUrl) {
     process.exit(1);
   }
 
-  log('success', `${c.bold}${accounts.length}${c.reset} active account(s) found`);
+  checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}${accounts.length} Account${accounts.length > 1 ? 's' : ''}${c.reset}`);
+  process.stdout.write(c.cursorUp(1));
+  process.stdout.write(c.clearLine + '\r');
+  console.log(`  ${checks.join('   ')}`);
   console.log('');
 
   for (let i = 0; i < accounts.length; i++) {
@@ -1279,26 +1178,31 @@ async function start(apiKey, apiUrl) {
   console.log('');
   startTime = Date.now();
   dashboardStarted = true;
-  process.stdout.write(c.hide); // Hide cursor for clean UI
+  process.stdout.write(c.hide);
 
-  // Start the live dashboard refresh loop
   setInterval(() => renderDashboard(), 1000);
-  renderDashboard(); // Initial render
+  renderDashboard();
 
   process.on('SIGINT', () => {
-    process.stdout.write(c.show); // Show cursor again
+    shutdownCalled = true;
+    process.stdout.write(c.show);
     dashboardStarted = false;
-    console.log('');
-    console.log('');
-    log('warn', 'Shutting down...');
-    console.log('');
-    for (const w of workers) {
-      const rate = w.stats.commands > 0 ? ((w.stats.successes / w.stats.commands) * 100).toFixed(0) : 0;
-      console.log(`  ${w.color}${c.bold}${w.username}${c.reset}  ${c.green}⏣ ${w.stats.coins.toLocaleString()}${c.reset} earned  ${c.dim}│${c.reset}  ${w.stats.commands} cmds  ${c.dim}│${c.reset}  ${rate}% success`);
-      w.stop();
+    const sepBar = rgb(139, 92, 246) + c.bold + '═'.repeat(tw) + c.reset;
+    console.log('\n');
+    console.log(`  ${rgb(251, 191, 36)}${c.bold}Session Summary${c.reset}`);
+    console.log(sepBar);
+    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}`
+      );
+      wk.stop();
     }
-    console.log('');
-    console.log(`  ${c.yellow}${c.bold}Total: ⏣ ${totalCoins.toLocaleString()}${c.reset} earned in ${formatUptime()}`);
+    console.log(sepBar);
+    console.log(`  ${rgb(251, 191, 36)}${c.bold}Total: +⏣ ${totalCoins.toLocaleString()}${c.reset} ${c.dim}in ${formatUptime()}${c.reset}`);
     console.log('');
     setTimeout(() => process.exit(0), 2000);
   });