dankgrinder 3.0.0 → 4.0.0

package/lib/grinder.js

@@ -1,12 +1,21 @@
 const { Client } = require('discord.js-selfbot-v13');
+const Redis = require('ioredis');
 
-// ── Terminal Colors ──────────────────────────────────────────
+// ── Terminal Colors & ANSI ───────────────────────────────────
 const c = {
   reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', italic: '\x1b[3m',
   green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m', cyan: '\x1b[36m',
   magenta: '\x1b[35m', white: '\x1b[37m', blue: '\x1b[34m',
   bgGreen: '\x1b[42m', bgRed: '\x1b[41m', bgYellow: '\x1b[43m', bgCyan: '\x1b[46m',
-  bgMagenta: '\x1b[45m', bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m', bgBlue: '\x1b[44m', bgWhite: '\x1b[47m',
+  // Cursor control
+  clearLine: '\x1b[2K',
+  cursorUp: (n) => `\x1b[${n}A`,
+  cursorTo: (col) => `\x1b[${col}G`,
+  hide: '\x1b[?25l',
+  show: '\x1b[?25h',
+  saveCursor: '\x1b7',
+  restoreCursor: '\x1b8',
 };
 
 const WORKER_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
@@ -27,22 +36,140 @@ 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 = null;
 const workers = [];
 
+function initRedis() {
+  if (!redis) {
+    try {
+      redis = new Redis(REDIS_URL, { maxRetriesPerRequest: null, lazyConnect: true });
+      redis.connect().catch(() => {});
+    } catch (e) {
+      console.error('Redis connection failed', e);
+    }
+  }
+}
+
+// ── Live Dashboard State ─────────────────────────────────────
+let dashboardLines = 0;
+let dashboardStarted = 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}
+`;
+
+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`;
+}
+
+function formatCoins(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toLocaleString();
+}
+
+function renderDashboard() {
+  if (!dashboardStarted || workers.length === 0) return;
+
+  // Compute totals
+  totalBalance = 0; totalCoins = 0; totalCommands = 0;
+  for (const w of workers) {
+    totalBalance += w.stats.balance || 0;
+    totalCoins += w.stats.coins || 0;
+    totalCommands += w.stats.commands || 0;
+  }
+
+  const lines = [];
+  const width = Math.min(process.stdout.columns || 80, 90);
+  const sep = c.dim + '─'.repeat(width) + c.reset;
+
+  // Header bar
+  lines.push(sep);
+  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}`
+  );
+  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(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(sep);
+
+  // Move cursor up to overwrite previous dashboard
+  if (dashboardLines > 0) {
+    process.stdout.write(c.cursorUp(dashboardLines));
+  }
+  for (const line of lines) {
+    process.stdout.write(c.clearLine + '\r' + line + '\n');
+  }
+  dashboardLines = lines.length;
+}
+
 function log(type, msg, label) {
   const time = new Date().toLocaleTimeString('en-US', { hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit' });
   const icons = {
-    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}`,
+    info: `│`, success: `✓`, error: `✗`, warn: `!`,
+    cmd: `▸`, coin: `$`, buy: `♦`, bal: `◈`, debug: `⊙`,
   };
   const tag = label ? `${label} ` : '';
-  console.log(`  ${c.dim}${time}${c.reset}  ${icons[type] || icons.info}  ${tag}${msg}`);
+  const stripped = msg.replace(/\x1b\[[0-9;]*m/g, ''); // Strip ANSI for log buffer
+  if (dashboardStarted) {
+    // Add to scrolling log buffer
+    recentLogs.push(`${time}  ${icons[type] || '│'}  ${tag}${stripped}`.substring(0, 80));
+    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}`,
+    };
+    console.log(`  ${c.dim}${time}${c.reset}  ${colorIcons[type] || colorIcons.info}  ${tag}${msg}`);
+  }
 }
 
 async function fetchConfig() {
@@ -56,12 +183,12 @@ async function fetchConfig() {
   } catch (err) { log('error', `Cannot reach API: ${err.message}`); return null; }
 }
 
-async function sendLog(command, response, status) {
+async function sendLog(accountName, command, response, status) {
   try {
     await fetch(`${API_URL}/api/grinder/log`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ command, response, status }),
+      body: JSON.stringify({ account_name: accountName, command, response, status }),
     });
   } catch { /* silent */ }
 }
@@ -79,7 +206,6 @@ function safeParseJSON(str, fallback = []) {
 // ── Coin Parser ──────────────────────────────────────────────
 function parseCoins(text) {
   if (!text) return 0;
-  // Match patterns like "⏣ 1,250" or "+1,250 coins" or "**1,250**"
   const patterns = [
     /[⏣💰]\s*[\d,]+/g,
     /\+\s*[\d,]+\s*coins?/gi,
@@ -88,6 +214,8 @@ function parseCoins(text) {
     /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) {
@@ -119,42 +247,66 @@ function getFullText(msg) {
   return text;
 }
 
-// ── Smart Button Picker ──────────────────────────────────────
+function getAllButtons(msg) {
+  const buttons = [];
+  if (msg.components) {
+    for (const row of msg.components) {
+      if (row.components) {
+        for (const comp of row.components) {
+          if (comp.type === 2) buttons.push(comp);
+        }
+      }
+    }
+  }
+  return buttons;
+}
+
+function getAllSelectMenus(msg) {
+  const menus = [];
+  if (msg.components) {
+    for (const row of msg.components) {
+      if (row.components) {
+        for (const comp of row.components) {
+          if (comp.type === 3) menus.push(comp);
+        }
+      }
+    }
+  }
+  return menus;
+}
+
 function pickSafeButton(buttons, safeList) {
   if (!buttons || buttons.length === 0) return null;
-
-  // First check user-configured safe answers
   if (safeList && safeList.length > 0) {
     for (const btn of buttons) {
       const label = (btn.label || '').toLowerCase();
       if (safeList.some((s) => label.includes(s.toLowerCase()))) return btn;
     }
   }
-
-  // Then check built-in safe list
   for (const btn of buttons) {
     const label = (btn.label || '').toLowerCase();
     if (SAFE_SEARCH_LOCATIONS.some((s) => label.includes(s))) return btn;
     if (SAFE_CRIME_OPTIONS.some((s) => label.includes(s))) return btn;
   }
-
-  // Fallback: pick random
   const clickable = buttons.filter((b) => !b.disabled);
   return clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
 }
 
-function getAllButtons(msg) {
-  const buttons = [];
-  if (msg.components) {
-    for (const row of msg.components) {
-      if (row.components) {
-        for (const comp of row.components) {
-          if (comp.type === 2) buttons.push(comp);
-        }
-      }
+// Debug: log all embed/component data for a message
+function debugMessage(msg, label) {
+  if (!msg) return;
+  const text = getFullText(msg);
+  log('debug', `${label || 'MSG'}: ${c.dim}${text.substring(0, 120)}${c.reset}`);
+  const buttons = getAllButtons(msg);
+  if (buttons.length > 0) {
+    log('debug', `  Buttons: ${buttons.map(b => `[${b.label || b.emoji?.name || '?'}${b.disabled ? ' (disabled)' : ''}]`).join(' ')}`);
+  }
+  const menus = getAllSelectMenus(msg);
+  if (menus.length > 0) {
+    for (const m of menus) {
+      log('debug', `  SelectMenu: ${(m.options || []).map(o => o.label).join(', ')}`);
     }
   }
-  return buttons;
 }
 
 // ══════════════════════════════════════════════════════════════
@@ -169,22 +321,29 @@ class AccountWorker {
     this.client = new Client();
     this.channel = null;
     this.running = false;
+    this.busy = false;
     this.username = account.label || `Account ${idx + 1}`;
-
-    // Session stats
+    this.tickTimeout = null;
     this.stats = { coins: 0, commands: 0, successes: 0, errors: 0, balance: 0 };
+    this.lastRunTime = {};
+    this.cycleCount = 0;
+    this.lastCommandRun = 0;
   }
 
-  get tag() {
-    return `${this.color}${c.bold}${this.username}${c.reset}`;
-  }
-
+  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
+  setStatus(text) {
+    this.lastStatus = text;
+    renderDashboard();
+  }
+
   waitForDankMemer(timeout = 15000) {
     return new Promise((resolve) => {
       const timer = setTimeout(() => {
         this.client.removeListener('messageCreate', handler);
+        this.client.removeListener('messageUpdate', updateHandler);
         resolve(null);
       }, timeout);
       const self = this;
@@ -192,75 +351,224 @@ class AccountWorker {
         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);
           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);
+          resolve(newMsg);
+        }
+      }
       this.client.on('messageCreate', handler);
+      this.client.on('messageUpdate', updateHandler);
+    });
+  }
+
+  // Wait specifically for message edits (Dank Memer often edits messages)
+  waitForMessageUpdate(msgId, timeout = 10000) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.client.removeListener('messageUpdate', handler);
+        resolve(null);
+      }, timeout);
+      const self = this;
+      function handler(oldMsg, newMsg) {
+        if (newMsg.id === msgId && newMsg.channel?.id === self.channel.id) {
+          clearTimeout(timer);
+          self.client.removeListener('messageUpdate', handler);
+          resolve(newMsg);
+        }
+      }
+      this.client.on('messageUpdate', handler);
     });
   }
 
   // ── Needs Item Detection ────────────────────────────────────
   needsItem(text) {
     const lower = text.toLowerCase();
-    if (lower.includes("don't have a shovel") || lower.includes('need to go buy') && lower.includes('shovel'))
+    if (lower.includes("don't have a shovel") || (lower.includes('need') && lower.includes('shovel')) || lower.includes('you need a shovel'))
       return 'shovel';
-    if (lower.includes("don't have a fishing") || lower.includes('need a fishing'))
+    if (lower.includes("don't have a fishing") || lower.includes('need a fishing') || lower.includes('you need a fishing pole'))
       return 'fishing pole';
-    if (lower.includes("don't have a hunting rifle") || lower.includes('need a hunting rifle'))
+    if (lower.includes("don't have a hunting rifle") || lower.includes('need a hunting rifle') || lower.includes('you need a rifle'))
       return 'hunting rifle';
     return null;
   }
 
-  async buyItem(itemName) {
-    this.log('buy', `Buying ${c.bold}${itemName}${c.reset}...`);
-    await this.channel.send(`pls buy ${itemName}`);
-    const response = await this.waitForDankMemer(10000);
-    if (response) {
-      const text = getFullText(response);
-      // Sometimes Dank Memer asks for confirmation
-      const buttons = getAllButtons(response);
-      if (buttons.length > 0) {
-        const confirm = buttons.find((b) => {
-          const label = (b.label || '').toLowerCase();
-          return label.includes('yes') || label.includes('confirm') || label.includes('buy');
-        });
-        if (confirm) {
-          await humanDelay();
-          try { await confirm.click(); } catch {}
-          await this.waitForDankMemer(5000);
+  async buyItem(itemName, quantity = 10) {
+    const MAX_RETRIES = 3;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      this.log('buy', `Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset}... (attempt ${attempt}/${MAX_RETRIES})`);
+      if (this.account.use_slash) {
+        await this.channel.sendSlash(DANK_MEMER_ID, 'shop', 'view').catch(() => this.channel.send('pls shop view'));
+      } else {
+        await this.channel.send('pls shop view');
+      }
+      let response = await this.waitForDankMemer(10000);
+      if (!response) {
+        this.log('warn', 'No response to shop view command.');
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+
+      const responseText = getFullText(response).toLowerCase();
+      const hasShopComponents = (response.components || []).some(row =>
+        (row.components || []).some(comp => comp.type === 3 || (comp.type === 2 && comp.label && comp.label.toLowerCase().includes('buy')))
+      );
+
+      if (!hasShopComponents && (responseText.includes('lucky') || responseText.includes('event') || responseText.includes('for the rest of the day'))) {
+        this.log('warn', 'Got event response instead of shop. Retrying...');
+        await humanDelay(3000, 5000);
+        continue;
+      }
+      if (!hasShopComponents && responseText.includes('shop')) {
+        const shopUI = await this.waitForDankMemer(8000);
+        if (shopUI) response = shopUI;
+      }
+
+      // Navigate to Coin Shop
+      let coinShopMenuId = null;
+      let coinShopOption = null;
+      for (const row of response.components || []) {
+        for (const comp of row.components || []) {
+          if (comp.type === 3) {
+            const opt = (comp.options || []).find(o => o.label && o.label.includes('Coin Shop'));
+            if (opt) { coinShopMenuId = comp.customId; coinShopOption = opt; }
+          }
         }
       }
-      if (text.toLowerCase().includes('bought') || text.toLowerCase().includes('purchased')) {
-        this.log('success', `Bought ${c.bold}${itemName}${c.reset}!`);
-        return true;
+
+      if (coinShopMenuId && coinShopOption) {
+        this.log('buy', 'Navigating to Coin Shop...');
+        try {
+          await response.selectMenu(coinShopMenuId, [coinShopOption.value]);
+          const updatedMsg = await this.waitForDankMemer(8000);
+          if (updatedMsg) response = updatedMsg;
+        } catch (e) {
+          this.log('error', `Failed to open Coin Shop: ${e.message}`);
+        }
+      }
+      await humanDelay(1000, 2000);
+
+      // Find Buy button
+      let buyBtn = null;
+      const searchName = itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '');
+      for (const row of response.components || []) {
+        for (const comp of row.components || []) {
+          if (comp.type === 2 && comp.label && comp.label.toLowerCase().includes(searchName)) {
+            buyBtn = comp; break;
+          }
+        }
+        if (buyBtn) break;
+      }
+
+      if (!buyBtn) {
+        this.log('warn', `Could not find Buy button for ${itemName} (attempt ${attempt})`);
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
       }
+
+      this.log('buy', `Clicking Buy ${itemName}...`);
+      try { await buyBtn.click(); } catch (e) {
+        this.log('error', `Buy click failed: ${e.message}`);
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+
+      // Handle Modal
+      const modal = await new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(null), 8000);
+        const handler = (m) => {
+          clearTimeout(timer);
+          this.client.removeListener('interactionModalCreate', handler);
+          resolve(m);
+        };
+        this.client.on('interactionModalCreate', handler);
+      });
+
+      if (modal) {
+        this.log('buy', `Submitting quantity ${c.bold}${quantity}${c.reset} in modal...`);
+        try {
+          const quantityInputId = modal.components[0].components[0].customId;
+          await fetch('https://discord.com/api/v9/interactions', {
+            method: 'POST',
+            headers: { 'Authorization': this.client.token, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              type: 5, application_id: modal.applicationId,
+              channel_id: this.channel.id, guild_id: this.channel.guild?.id,
+              data: {
+                id: modal.id, custom_id: modal.customId,
+                components: [{ type: 1, components: [{ type: 4, custom_id: quantityInputId, value: String(quantity) }] }]
+              },
+              session_id: this.client.sessionId || "dummy_session",
+              nonce: Date.now().toString()
+            })
+          });
+        } catch (e) {
+          this.log('error', `Modal submit failed: ${e.message}`);
+          if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+          return false;
+        }
+      } else {
+        this.log('warn', 'No modal appeared after clicking buy.');
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+
+      const confirmMsg = await this.waitForDankMemer(8000);
+      if (confirmMsg) {
+        const text = getFullText(confirmMsg).toLowerCase();
+        if (text.includes('bought') || text.includes('purchased') || text.includes('success')) {
+          this.log('success', `Bought ${c.bold}${quantity}x ${itemName}${c.reset}!`);
+          return true;
+        }
+        if (text.includes('not enough') || text.includes("can't afford") || text.includes('insufficient')) {
+          this.log('warn', `Not enough coins to buy ${itemName}.`);
+          return false;
+        }
+      }
+      this.log('success', `Submitted purchase for ${quantity}x ${itemName}.`);
+      return true;
     }
-    this.log('warn', `Could not buy ${itemName}`);
+    this.log('error', `Failed to buy ${itemName} after ${MAX_RETRIES} attempts.`);
     return false;
   }
 
   // ── Check Balance ───────────────────────────────────────────
   async checkBalance() {
-    await this.channel.send('pls bal');
+    const prefix = this.account.use_slash ? '/' : 'pls';
+    await this.channel.send(`${prefix} bal`);
     const response = await this.waitForDankMemer(10000);
     if (response) {
       const text = getFullText(response);
-      // Try to parse wallet balance
       const walletMatch = text.match(/wallet[:\s]*[⏣💰]?\s*([\d,]+)/i);
       if (walletMatch) {
         this.stats.balance = parseInt(walletMatch[1].replace(/,/g, ''));
         this.log('bal', `Wallet: ${c.bold}${c.green}⏣ ${this.stats.balance.toLocaleString()}${c.reset}`);
+        try {
+          await fetch(`${API_URL}/api/grinder/status`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, balance: this.stats.balance }),
+          });
+        } catch { /* silent */ }
       }
     }
   }
 
-  // ── Command Handlers ────────────────────────────────────────
+  // ══════════════════════════════════════════════════════════════
+  // ═  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) {
@@ -271,10 +579,7 @@ class AccountWorker {
         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 (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`;
         }
@@ -286,9 +591,9 @@ class AccountWorker {
 
   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) {
@@ -299,10 +604,7 @@ class AccountWorker {
         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 (coins > 0) { this.stats.coins += coins; return `${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
           return `${btn.label} → done`;
         }
         return `Clicked: ${btn.label}`;
@@ -313,46 +615,34 @@ class AccountWorker {
 
   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 {
-        // Jackpot hint
+      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}`;
-          }
-          // Multi-round: keep playing
+          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);
-          }
+          if (moreButtons.length >= 2) return await this.handleHighLow(followUp);
           return `${num} → ${targetBtn.label}`;
         }
         return `${num} → ${targetBtn.label}`;
       } catch { return null; }
     }
-
-    // Fallback: click random
     if (buttons.length > 0) {
       const btn = buttons[Math.floor(Math.random() * buttons.length)];
       await humanDelay();
@@ -362,12 +652,166 @@ class AccountWorker {
     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);
-
-    // Check if we need to buy something
     const neededItem = this.needsItem(text);
     if (neededItem) {
       this.log('warn', `Missing ${c.bold}${neededItem}${c.reset} — auto-buying...`);
@@ -375,8 +819,7 @@ class AccountWorker {
       if (bought) return `auto-bought ${neededItem}`;
       return `need ${neededItem} (couldn't buy)`;
     }
-
-    // Handle buttons if present
+    // 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];
@@ -389,22 +832,122 @@ class AccountWorker {
             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 {}
       }
     }
-
-    if (coins > 0) {
-      this.stats.coins += coins;
-      return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`;
+    // 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 ──────────────────────────────────────
   async runCommand(cmdName, prefix) {
-    const cmdString = `${prefix} ${cmdName}`;
+    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;
+      case 'coinflip':    cmdString = `${prefix} coinflip ${betAmount} heads`; break;
+      case 'roulette':    cmdString = `${prefix} roulette ${betAmount} red`; break;
+      case 'slots':       cmdString = `${prefix} slots ${betAmount}`; break;
+      case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${betAmount}`; break;
+      case 'work shift':  cmdString = `${prefix} work shift`; break;
+      default:            cmdString = `${prefix} ${cmdName}`;
+    }
+
     this.log('cmd', `${c.white}${c.bold}${cmdString}${c.reset}`);
     this.stats.commands++;
 
@@ -415,113 +958,206 @@ class AccountWorker {
       if (!response) {
         this.log('warn', `No response for ${cmdString}`);
         this.stats.errors++;
-        await sendLog(cmdString, 'timeout', 'timeout');
+        await sendLog(this.username, cmdString, 'timeout', 'timeout');
+        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');
         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;
-        default:       result = await this.handleGenericCommand(response); break;
+        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;
       }
 
       this.stats.successes++;
       this.log('success', `${c.dim}${cmdString}${c.reset} → ${result || 'done'}`);
-      await sendLog(cmdString, result || 'done', 'success');
+      await sendLog(this.username, cmdString, result || 'done', 'success');
     } catch (err) {
       this.stats.errors++;
       this.log('error', `${cmdString} failed: ${err.message}`);
-      await sendLog(cmdString, err.message, 'error');
+      await sendLog(this.username, cmdString, err.message, 'error');
     }
   }
 
-  // ── Print Session Stats ─────────────────────────────────────
-  printStats() {
-    const rate = this.stats.commands > 0 ? ((this.stats.successes / this.stats.commands) * 100).toFixed(0) : 0;
-    this.log('info', `${c.dim}──────────────────────────────────────${c.reset}`);
-    this.log('coin', `Session: ${c.bold}${c.green}⏣ ${this.stats.coins.toLocaleString()}${c.reset} earned  ${c.dim}│${c.reset}  ${c.white}${this.stats.commands}${c.reset} cmds  ${c.dim}│${c.reset}  ${c.green}${rate}%${c.reset} success`);
-    if (this.stats.balance > 0) {
-      this.log('bal', `Wallet: ${c.bold}⏣ ${this.stats.balance.toLocaleString()}${c.reset}`);
-    }
-    this.log('info', `${c.dim}──────────────────────────────────────${c.reset}`);
+  // ── Redis Cooldown Management ───────────────────────────────
+  async setCooldown(cmdName, durationSeconds) {
+    if (!redis) return;
+    const key = `dkg:cd:${this.account.id}:${cmdName}`;
+    await redis.set(key, '1', 'EX', Math.ceil(durationSeconds));
   }
 
-  // ── Main Grind Loop ─────────────────────────────────────────
-  async grindLoop() {
-    if (this.running) return;
-    this.running = true;
+  async isCooldownReady(cmdName) {
+    if (!redis) return true;
+    const key = `dkg:cd:${this.account.id}:${cmdName}`;
+    const val = await redis.get(key);
+    return !val;
+  }
 
-    const commandMap = {
-      cmd_hunt: { cmd: 'hunt', cdKey: 'cd_hunt', defaultCd: 20 },
-      cmd_dig: { cmd: 'dig', cdKey: 'cd_dig', defaultCd: 20 },
-      cmd_beg: { cmd: 'beg', cdKey: 'cd_beg', defaultCd: 20 },
-      cmd_search: { cmd: 'search', cdKey: 'cd_search', defaultCd: 20 },
-      cmd_hl: { cmd: 'hl', cdKey: 'cd_hl', defaultCd: 20 },
-      cmd_crime: { cmd: 'crime', cdKey: 'cd_crime', defaultCd: 40 },
-      cmd_pm: { cmd: 'pm', cdKey: 'cd_pm', defaultCd: 20 },
-    };
+  printStats() {
+    // Stats are shown in the live dashboard, no-op here
+  }
 
-    let cycleCount = 0;
-
-    while (this.running) {
-      // Re-fetch config from API every cycle for live dashboard control
-      if (cycleCount > 0 && cycleCount % 3 === 0) {
-        await this.refreshConfig();
-        if (!this.account.active) {
-          this.log('warn', 'Account deactivated from dashboard. Pausing...');
-          while (!this.account.active && this.running) {
-            await new Promise((r) => setTimeout(r, 10000));
-            await this.refreshConfig();
-          }
-          if (!this.running) break;
-          this.log('success', 'Account re-activated! Resuming...');
-        }
-      }
+  // ── Main Non-Blocking Grind Scheduler ───────────────────────
+  async tick() {
+    if (!this.running) return;
+    if (this.busy) {
+      this.tickTimeout = setTimeout(() => this.tick(), 1000);
+      return;
+    }
 
-      const acc = this.account;
-      const prefix = acc.use_slash ? '/' : 'pls';
+    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) {
+      this.tickTimeout = setTimeout(() => this.tick(), 15000);
+      return;
+    }
 
-      const enabledCommands = Object.entries(commandMap)
-        .filter(([key]) => acc[key] === true || acc[key] === 1)
-        .map(([, val]) => val);
+    let nextCmdToRun = null;
+    let highestPriority = -1;
 
-      if (enabledCommands.length === 0) {
-        this.log('warn', 'No commands enabled. Waiting 30s...');
-        await new Promise((r) => setTimeout(r, 30000));
-        continue;
+    for (const info of enabledCommands) {
+      const ready = await this.isCooldownReady(info.cmd);
+      if (ready && info.priority > highestPriority) {
+        nextCmdToRun = info;
+        highestPriority = info.priority;
       }
+    }
 
-      for (const { cmd, cdKey, defaultCd } of enabledCommands) {
-        if (!this.running) break;
-        await this.runCommand(cmd, prefix);
-
-        // Per-command cooldown with jitter
-        const cd = (acc[cdKey] || defaultCd);
-        const jitter = 1 + Math.random() * 3; // 1-4s random jitter for safety
-        const totalWait = cd + jitter;
-        this.log('info', `${c.dim}⏳ cd ${cd}s + ${jitter.toFixed(1)}s jitter = ${totalWait.toFixed(1)}s${c.reset}`);
-        await new Promise((r) => setTimeout(r, totalWait * 1000));
+    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));
       }
 
-      cycleCount++;
-
-      // Every 5 cycles: print stats + check balance
-      if (cycleCount % 5 === 0) {
-        this.printStats();
-        await humanDelay(500, 1500);
+      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++;
+
+      if (this.cycleCount > 0 && this.cycleCount % 10 === 0) this.printStats();
+      if (this.cycleCount > 0 && this.cycleCount % 20 === 0) {
+        this.busy = true;
         await this.checkBalance();
-        await humanDelay(2000, 4000);
+        this.busy = false;
       }
 
-      const cycleDelay = 2 + Math.random() * 3;
-      this.log('info', `${c.dim}Cycle ${cycleCount} done. Next in ${cycleDelay.toFixed(1)}s${c.reset}`);
-      await new Promise((r) => setTimeout(r, cycleDelay * 1000));
+      this.tickTimeout = setTimeout(() => this.tick(), 100);
+    } else {
+      this.setStatus(`${c.dim}waiting for cooldowns...${c.reset}`);
+      this.tickTimeout = setTimeout(() => this.tick(), 1000);
     }
   }
 
-  // ── Re-fetch Config from API ─────────────────────────────────
+  async grindLoop() {
+    if (this.running) return;
+    this.running = true;
+    this.busy = false;
+    this.cycleCount = 0;
+    this.lastCommandRun = 0;
+
+    this.configInterval = setInterval(async () => {
+      if (!this.running) return;
+      await this.refreshConfig();
+      if (!this.account.active && !this.busy) {
+        this.log('warn', 'Account deactivated from dashboard. Pausing...');
+        this.busy = true;
+      } else if (this.account.active && this.busy) {
+        this.log('success', 'Account re-activated! Resuming...');
+        this.busy = false;
+      }
+    }, 15000);
+
+    this.tick();
+  }
+
   async refreshConfig() {
     try {
       const res = await fetch(`${API_URL}/api/grinder/status`, {
@@ -535,19 +1171,15 @@ class AccountWorker {
     } catch { /* silent */ }
   }
 
-  // ── Start Worker ────────────────────────────────────────────
   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...`);
+    this.log('info', 'Connecting...');
 
     return new Promise((resolve) => {
       this.client.on('ready', async () => {
-        // Use the actual Discord username
         this.username = this.client.user.tag || this.username;
-
-        // Report username back to API
         try {
           await fetch(`${API_URL}/api/grinder/status`, {
             method: 'POST',
@@ -566,24 +1198,31 @@ class AccountWorker {
 
         this.log('info', `Channel: ${c.white}#${this.channel.name || this.account.channel_id}${c.reset}`);
 
-        // Show per-command cooldowns
-        const cmdInfo = [
-          { key: 'cmd_hunt', cd: 'cd_hunt', label: 'hunt' },
-          { key: 'cmd_dig', cd: 'cd_dig', label: 'dig' },
-          { key: 'cmd_beg', cd: 'cd_beg', label: 'beg' },
-          { key: 'cmd_search', cd: 'cd_search', label: 'search' },
-          { key: 'cmd_hl', cd: 'cd_hl', label: 'hl' },
-          { key: 'cmd_crime', cd: 'cd_crime', label: 'crime' },
-          { key: 'cmd_pm', cd: 'cd_pm', label: 'pm' },
+        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' },
         ].filter((ci) => this.account[ci.key] === true || this.account[ci.key] === 1);
 
-        const cmdStr = cmdInfo.map((ci) => `${ci.label}(${this.account[ci.cd] || 20}s)`).join(', ');
+        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}`);
+        }
 
-        // Initial balance check
         await this.checkBalance();
         console.log('');
-
         this.grindLoop();
         resolve();
       });
@@ -594,6 +1233,8 @@ class AccountWorker {
 
   stop() {
     this.running = false;
+    if (this.tickTimeout) clearTimeout(this.tickTimeout);
+    if (this.configInterval) clearInterval(this.configInterval);
     try { this.client.destroy(); } catch {}
   }
 }
@@ -605,17 +1246,16 @@ class AccountWorker {
 async function start(apiKey, apiUrl) {
   API_KEY = apiKey;
   API_URL = apiUrl;
+  initRedis();
 
-  console.log('');
-  console.log(`  ${c.magenta}${c.bold}┌─────────────────────────────────────────┐${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}│${c.reset}                                         ${c.magenta}${c.bold}│${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}│${c.reset}   ${c.white}${c.bold}⚡ DankGrinder${c.reset} ${c.dim}v3.0${c.reset}                    ${c.magenta}${c.bold}│${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}│${c.reset}   ${c.dim}Per-Cmd CD • Live Control • Smart${c.reset}     ${c.magenta}${c.bold}│${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}│${c.reset}                                         ${c.magenta}${c.bold}│${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}└─────────────────────────────────────────┘${c.reset}`);
+  // 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('');
 
   log('info', `API: ${c.dim}${API_URL}${c.reset}`);
+  log('info', `Redis: ${c.dim}${REDIS_URL.replace(/:[^:]+@/, ':***@')}${c.reset}`);
   log('info', 'Fetching accounts...');
 
   const data = await fetchConfig();
@@ -636,16 +1276,30 @@ async function start(apiKey, apiUrl) {
     await worker.start();
   }
 
-  log('info', `${c.bold}All workers running.${c.reset} ${c.dim}Ctrl+C to stop.${c.reset}`);
   console.log('');
+  startTime = Date.now();
+  dashboardStarted = true;
+  process.stdout.write(c.hide); // Hide cursor for clean UI
+
+  // Start the live dashboard refresh loop
+  setInterval(() => renderDashboard(), 1000);
+  renderDashboard(); // Initial render
 
   process.on('SIGINT', () => {
+    process.stdout.write(c.show); // Show cursor again
+    dashboardStarted = false;
+    console.log('');
     console.log('');
     log('warn', 'Shutting down...');
+    console.log('');
     for (const w of workers) {
-      w.printStats();
+      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();
     }
+    console.log('');
+    console.log(`  ${c.yellow}${c.bold}Total: ⏣ ${totalCoins.toLocaleString()}${c.reset} earned in ${formatUptime()}`);
+    console.log('');
     setTimeout(() => process.exit(0), 2000);
   });
 }