dankgrinder 4.3.0 → 4.5.0

package/lib/commands/adventure.js

@@ -365,9 +365,12 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
 
   // ── Select adventure type from dropdown ─────────────────────
   if (menus.length > 0) {
-    // Re-fetch message to get hydrated components (minValues/maxValues)
-    const freshMsg = await channel.messages.fetch(response.id).catch(() => null);
-    if (freshMsg) response = freshMsg;
+    try {
+      if (channel.messages && typeof channel.messages.fetch === 'function') {
+        const freshMsg = await channel.messages.fetch(response.id);
+        if (freshMsg) response = freshMsg;
+      }
+    } catch { /* proceed with original */ }
 
     // Find the select menu row index
     let menuRowIdx = -1;

package/lib/commands/drops.js

@@ -0,0 +1,116 @@
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons,
+  safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+
+async function runDrops({ channel, waitForDankMemer, redis, accountId }) {
+  LOG.cmd(`${c.white}${c.bold}pls drops${c.reset}`);
+
+  await channel.send('pls drops');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) return { result: 'no response', coins: 0 };
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'drops');
+  const text = getFullText(response);
+  const lower = text.toLowerCase();
+
+  const drops = [];
+
+  for (const embed of response.embeds || []) {
+    const desc = embed.description || '';
+    const items = desc.split(/\n\n+/);
+    for (const block of items) {
+      const nameMatch = block.match(/\*\*(.+?)\*\*/);
+      const costMatch = block.match(/Cost:\s*[⏣💰]?\s*([\d,]+)/i);
+      const stockMatch = block.match(/Stock:\s*(\d+|Infinite)/i);
+      const dateMatch = block.match(/<t:(\d+):[tTdDfFR]>/);
+      if (nameMatch) {
+        drops.push({
+          name: nameMatch[1],
+          cost: costMatch ? parseInt(costMatch[1].replace(/,/g, '')) : 0,
+          stock: stockMatch ? (stockMatch[1] === 'Infinite' ? Infinity : parseInt(stockMatch[1])) : 0,
+          dropTimestamp: dateMatch ? parseInt(dateMatch[1]) : 0,
+        });
+      }
+    }
+  }
+
+  // Also parse from text lines
+  const textBlocks = text.split(/\n/).filter(l => l.trim());
+  for (let i = 0; i < textBlocks.length; i++) {
+    const line = textBlocks[i];
+    if (line.includes('Cost:') && i > 0) {
+      const prevLine = textBlocks[i - 1];
+      const nameMatch = prevLine.match(/\*\*(.+?)\*\*/) || prevLine.match(/(\w[\w\s']+)/);
+      const costMatch = line.match(/Cost:\s*[⏣💰o]?\s*([\d,]+)/i);
+      if (nameMatch && costMatch) {
+        const cost = parseInt(costMatch[1].replace(/,/g, ''));
+        const existing = drops.find(d => d.name === nameMatch[1]);
+        if (!existing && cost > 0) {
+          drops.push({ name: nameMatch[1], cost, stock: 0, dropTimestamp: 0 });
+        }
+      }
+    }
+  }
+
+  // Store drop schedule in Redis: track dates so we can auto-buy
+  if (redis && drops.length > 0) {
+    try {
+      await redis.set('dkg:drops:latest', JSON.stringify(drops), 'EX', 172800);
+      // Schedule individual drops with their timestamps
+      for (const drop of drops) {
+        if (drop.dropTimestamp > 0) {
+          const key = `dkg:drops:schedule:${drop.name.replace(/\s+/g, '_').toLowerCase()}`;
+          await redis.set(key, JSON.stringify(drop), 'EX', 172800);
+        }
+      }
+    } catch {}
+  }
+
+  // Try to buy any drops that are currently available (stock > 0, no future date)
+  const now = Math.floor(Date.now() / 1000);
+  const buttons = getAllButtons(response);
+  let boughtCount = 0;
+  for (const drop of drops) {
+    if (drop.stock > 0 && (drop.dropTimestamp === 0 || drop.dropTimestamp <= now)) {
+      const buyBtn = buttons.find(b =>
+        !b.disabled && b.label && (
+          b.label.toLowerCase().includes('buy') ||
+          b.label.toLowerCase().includes(drop.name.toLowerCase().split(' ')[0])
+        )
+      );
+      if (buyBtn) {
+        try {
+          await humanDelay(100, 300);
+          await safeClickButton(response, buyBtn);
+          boughtCount++;
+          LOG.coin(`[drops] ${c.green}Bought ${drop.name}!${c.reset}`);
+        } catch {}
+      }
+    }
+  }
+
+  if (drops.length > 0) {
+    const summary = drops.slice(0, 3).map(d => {
+      const ts = d.dropTimestamp > 0 ? ` @${new Date(d.dropTimestamp * 1000).toLocaleDateString()}` : '';
+      return `${d.name}(⏣${d.cost > 0 ? d.cost.toLocaleString() : '?'}${ts})`;
+    }).join(', ');
+    const boughtMsg = boughtCount > 0 ? ` — bought ${boughtCount}` : '';
+    LOG.info(`[drops] ${drops.length} drops: ${summary}${boughtMsg}`);
+    return { result: `${drops.length} drops: ${summary}${boughtMsg}`, coins: 0 };
+  }
+
+  if (lower.includes('no drops') || lower.includes('nothing')) {
+    return { result: 'no drops available', coins: 0 };
+  }
+
+  return { result: text.substring(0, 50) || 'drops checked', coins: 0 };
+}
+
+module.exports = { runDrops };

package/lib/commands/gamble.js

@@ -70,26 +70,29 @@ async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
   }
 
   const lower = text.toLowerCase();
-  if (lower.includes('won')) return { result: `${cmdName} → ${c.green}won${c.reset}`, coins: 0 };
-  if (lower.includes('lost')) return { result: `${cmdName} → ${c.red}lost${c.reset}`, coins: 0 };
+  if (lower.includes('won')) return { result: `${cmdName} → won`, coins };
+  if (lower.includes('lost')) {
+    const lostCoins = parseCoins(text);
+    return { result: `${cmdName} → lost`, coins: 0, lost: lostCoins };
+  }
 
   return { result: `${cmdName} done`, coins: 0 };
 }
 
 // Convenience wrappers
-async function runCoinflip({ channel, waitForDankMemer, betAmount = 1000 }) {
+async function runCoinflip({ channel, waitForDankMemer, betAmount = 5000 }) {
   return runGamble({ channel, waitForDankMemer, cmdName: 'coinflip', cmdString: `pls coinflip ${betAmount} heads` });
 }
 
-async function runRoulette({ channel, waitForDankMemer, betAmount = 1000 }) {
+async function runRoulette({ channel, waitForDankMemer, betAmount = 5000 }) {
   return runGamble({ channel, waitForDankMemer, cmdName: 'roulette', cmdString: `pls roulette ${betAmount} red` });
 }
 
-async function runSlots({ channel, waitForDankMemer, betAmount = 1000 }) {
+async function runSlots({ channel, waitForDankMemer, betAmount = 5000 }) {
   return runGamble({ channel, waitForDankMemer, cmdName: 'slots', cmdString: `pls slots ${betAmount}` });
 }
 
-async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 1000 }) {
+async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 5000 }) {
   return runGamble({ channel, waitForDankMemer, cmdName: 'snakeeyes', cmdString: `pls snakeeyes ${betAmount}` });
 }
 

package/lib/commands/generic.js

@@ -99,9 +99,12 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
   // Handle select menus
   const menus = getAllSelectMenus(response);
   if (menus.length > 0) {
-    // Re-fetch for hydrated components (minValues/maxValues)
-    const freshMsg = await channel.messages.fetch(response.id).catch(() => null);
-    if (freshMsg) response = freshMsg;
+    try {
+      if (channel.messages && typeof channel.messages.fetch === 'function') {
+        const freshMsg = await channel.messages.fetch(response.id);
+        if (freshMsg) response = freshMsg;
+      }
+    } catch { /* proceed with original */ }
     // Find row index of first select menu
     let menuRowIdx = -1;
     for (let i = 0; i < (response.components || []).length; i++) {

package/lib/commands/index.js

@@ -20,6 +20,7 @@ const { runCoinflip, runRoulette, runSlots, runSnakeeyes, runGamble } = require(
 const { runDeposit } = require('./deposit');
 const { runGeneric, runAlert } = require('./generic');
 const { runStream } = require('./stream');
+const { runDrops } = require('./drops');
 const { buyItem, ITEM_COSTS } = require('./shop');
 const { getPlayerLevel, meetsLevelRequirement } = require('./profile');
 
@@ -47,6 +48,7 @@ module.exports = {
   runGeneric,
   runAlert,
   runStream,
+  runDrops,
   buyItem,
 
   // Profile / Level

package/lib/commands/shop.js

@@ -79,9 +79,13 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
     }
 
     // Step 2: Navigate to Coin Shop tab
-    // Re-fetch message to get hydrated components (minValues/maxValues for selectMenu)
-    const freshShopMsg = await channel.messages.fetch(response.id).catch(() => null);
-    if (freshShopMsg) response = freshShopMsg;
+    // Try re-fetch for hydrated components; skip if unavailable
+    try {
+      if (channel.messages && typeof channel.messages.fetch === 'function') {
+        const freshShopMsg = await channel.messages.fetch(response.id);
+        if (freshShopMsg) response = freshShopMsg;
+      }
+    } catch { /* proceed with original response */ }
 
     const csInfo = findSelectMenuOption(response, 'Coin Shop');
     if (csInfo) {

package/lib/commands/stream.js

@@ -1,5 +1,5 @@
 const {
-  LOG, c, getFullText, parseCoins, getAllButtons,
+  LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
   safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, needsItem,
 } = require('./utils');
 const { buyItem } = require('./shop');
@@ -10,7 +10,7 @@ async function runStream({ channel, waitForDankMemer, client }) {
   LOG.cmd(`${c.white}${c.bold}pls stream${c.reset}`);
 
   await channel.send('pls stream');
-  let response = await waitForDankMemer(10000);
+  let response = await waitForDankMemer(12000);
 
   if (!response) {
     LOG.warn('[stream] No response');
@@ -19,78 +19,133 @@ async function runStream({ channel, waitForDankMemer, client }) {
 
   if (isHoldTight(response)) {
     const reason = getHoldTightReason(response);
-    LOG.warn(`[stream] Hold Tight${reason ? ` (reason: /${reason})` : ''}`);
-    await sleep(30000);
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
   logMsg(response, 'stream');
   let text = getFullText(response);
+  let lower = text.toLowerCase();
 
-  const lower = text.toLowerCase();
-  if (lower.includes('missing items') || lower.includes('need following items') || lower.includes('need a keyboard') || lower.includes('need a mouse')) {
+  // Missing items — buy keyboard + mouse
+  if (lower.includes('missing items') || lower.includes('need following items') ||
+      lower.includes('need a keyboard') || lower.includes('need a mouse')) {
     const itemsToBuy = [];
     if (lower.includes('keyboard')) itemsToBuy.push('keyboard');
     if (lower.includes('mouse')) itemsToBuy.push('mouse');
-
     if (itemsToBuy.length === 0) itemsToBuy.push(...STREAM_ITEMS);
 
-    LOG.warn(`[stream] Missing items: ${c.bold}${itemsToBuy.join(', ')}${c.reset} — auto-buying...`);
-
     for (const item of itemsToBuy) {
       const bought = await buyItem({ channel, waitForDankMemer, client, itemName: item, quantity: 1 });
-      if (bought) {
-        LOG.success(`[stream] Bought ${c.bold}${item}${c.reset}`);
-      } else {
-        LOG.error(`[stream] Failed to buy ${item}`);
-        return { result: `need ${item} (buy failed)`, coins: 0 };
-      }
-      await humanDelay(1500, 2500);
+      if (!bought) return { result: `need ${item} (buy failed)`, coins: 0 };
+      await humanDelay(500, 1000);
     }
 
-    LOG.info('[stream] Retrying stream after buying items...');
-    await sleep(3000);
+    await sleep(2000);
     await channel.send('pls stream');
-    response = await waitForDankMemer(10000);
+    response = await waitForDankMemer(12000);
     if (!response) return { result: 'no response after buy', coins: 0 };
     logMsg(response, 'stream-retry');
     text = getFullText(response);
+    lower = text.toLowerCase();
   }
 
-  const coins = parseCoins(text);
+  // Stream Manager — select a game from dropdown, then click "Go Live"
+  if (lower.includes('stream manager') || lower.includes('what game do you want to stream')) {
+    const menus = getAllSelectMenus(response);
+    if (menus.length > 0) {
+      const menu = menus[0];
+      const options = menu.options || [];
+      if (options.length > 0) {
+        // Pick a random game (variety is better for Dank Memer)
+        const pick = options[Math.floor(Math.random() * options.length)];
+        LOG.info(`[stream] Selecting game: "${pick.label}"`);
+
+        let menuRowIdx = -1;
+        for (let i = 0; i < (response.components || []).length; i++) {
+          for (const comp of (response.components[i].components || [])) {
+            if (comp.type === 'STRING_SELECT' || comp.type === 3) { menuRowIdx = i; break; }
+          }
+          if (menuRowIdx >= 0) break;
+        }
 
-  const buttons = getAllButtons(response);
-  if (buttons.length > 0) {
-    const actionBtn = buttons.find(b => !b.disabled && b.label &&
-      !b.label.toLowerCase().includes('end') && !b.label.toLowerCase().includes('stop'));
-    const btn = actionBtn || buttons.find(b => !b.disabled);
-    if (btn) {
-      LOG.info(`[stream] Clicking "${btn.label || '?'}"`);
-      await humanDelay();
-      try {
-        await safeClickButton(response, btn);
-        const followUp = await waitForDankMemer(8000);
-        if (followUp) {
-          logMsg(followUp, 'stream-action');
-          const fText = getFullText(followUp);
-          const fCoins = parseCoins(fText);
-          if (fCoins > 0) {
-            LOG.coin(`[stream] ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
-            return { result: `+⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
+        if (menuRowIdx >= 0) {
+          try {
+            const selectResult = await response.selectMenu(menuRowIdx, [pick.value]);
+            if (selectResult) {
+              response = selectResult;
+              logMsg(response, 'stream-game-selected');
+            }
+          } catch (e) {
+            LOG.error(`[stream] Select game failed: ${e.message}`);
           }
+          await humanDelay(200, 500);
+        }
+      }
+    }
+
+    // Click "Go Live" button
+    const buttons = getAllButtons(response);
+    const goLiveBtn = buttons.find(b => !b.disabled && b.label && b.label.toLowerCase().includes('go live'));
+    if (goLiveBtn) {
+      LOG.info('[stream] Clicking "Go Live"');
+      await humanDelay(100, 300);
+      try {
+        const liveResult = await safeClickButton(response, goLiveBtn);
+        if (liveResult) {
+          response = liveResult;
+          logMsg(response, 'stream-live');
+          text = getFullText(response);
+          lower = text.toLowerCase();
         }
       } catch (e) {
-        LOG.error(`[stream] Click error: ${e.message}`);
+        LOG.error(`[stream] Go Live click failed: ${e.message}`);
+      }
+    } else {
+      const anyBtn = buttons.find(b => !b.disabled && b.label && !b.label.toLowerCase().includes('back'));
+      if (anyBtn) {
+        try { await safeClickButton(response, anyBtn); } catch {}
       }
     }
   }
 
-  if (coins > 0) {
-    LOG.coin(`[stream] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-    return { result: `+⏣ ${coins.toLocaleString()}`, coins };
+  // After going live, there might be interactive stream events
+  // Keep clicking non-end buttons for up to 5 rounds
+  for (let round = 0; round < 5; round++) {
+    const followUp = await waitForDankMemer(15000);
+    if (!followUp) break;
+
+    logMsg(followUp, `stream-round-${round}`);
+    const fText = getFullText(followUp);
+    const fLower = fText.toLowerCase();
+    const fCoins = parseCoins(fText);
+
+    if (fLower.includes('stream ended') || fLower.includes('stream is over') || fLower.includes('you earned')) {
+      if (fCoins > 0) {
+        LOG.coin(`[stream] ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
+        return { result: `stream → +⏣ ${fCoins.toLocaleString()}`, coins: fCoins, nextCooldownSec: 600 };
+      }
+      return { result: 'stream ended', coins: 0, nextCooldownSec: 600 };
+    }
+
+    const btns = getAllButtons(followUp);
+    const actionBtn = btns.find(b => !b.disabled && b.label &&
+      !b.label.toLowerCase().includes('end') && !b.label.toLowerCase().includes('stop') && !b.label.toLowerCase().includes('back'));
+    if (actionBtn) {
+      LOG.info(`[stream] Clicking "${actionBtn.label}"`);
+      await humanDelay(100, 300);
+      try { await safeClickButton(followUp, actionBtn); } catch {}
+    } else if (btns.length > 0) {
+      const first = btns.find(b => !b.disabled);
+      if (first) { try { await safeClickButton(followUp, first); } catch {} }
+    } else {
+      break;
+    }
   }
 
-  return { result: text.substring(0, 60) || 'streamed', coins: 0, nextCooldownSec: 600 };
+  const coins = parseCoins(text);
+  if (coins > 0) return { result: `stream → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: 600 };
+
+  return { result: text.substring(0, 50) || 'streamed', coins: 0, nextCooldownSec: 600 };
 }
 
 module.exports = { runStream };

package/lib/commands/utils.js

@@ -13,7 +13,13 @@ const c = {
 };
 
 // ── Logging ──────────────────────────────────────────────────
+// When dashboard is active, suppress direct console output from command handlers.
+// grinder.js sets this to true once the live dashboard starts rendering.
+let _dashboardActive = false;
+function setDashboardActive(val) { _dashboardActive = val; }
+
 function log(label, msg) {
+  if (_dashboardActive) return;
   const time = new Date().toLocaleTimeString('en-US', { hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit' });
   console.log(`  ${c.dim}${time}${c.reset}  ${label}  ${msg}`);
 }
@@ -32,7 +38,7 @@ const LOG = {
 // ── Sleep ────────────────────────────────────────────────────
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
-function humanDelay(min = 100, max = 350) {
+function humanDelay(min = 50, max = 200) {
   return new Promise(r => setTimeout(r, min + Math.random() * (max - min)));
 }
 
@@ -277,6 +283,7 @@ module.exports = {
   DANK_MEMER_ID,
   c,
   LOG,
+  setDashboardActive,
   sleep,
   humanDelay,
   getFullText,

package/lib/grinder.js

@@ -1,6 +1,7 @@
 const { Client } = require('discord.js-selfbot-v13');
 const Redis = require('ioredis');
 const commands = require('./commands');
+const { setDashboardActive, getFullText } = require('./commands/utils');
 
 // ── Terminal Colors & ANSI ───────────────────────────────────
 const c = {
@@ -283,7 +284,7 @@ async function reportEarnings(accountId, accountName, earned, spent, command) {
 function randomDelay(min, max) {
   return new Promise((r) => setTimeout(r, (Math.random() * (max - min) + min) * 1000));
 }
-function humanDelay(min = 300, max = 800) {
+function humanDelay(min = 80, max = 250) {
   return new Promise((r) => setTimeout(r, min + Math.random() * (max - min)));
 }
 function safeParseJSON(str, fallback = []) {
@@ -758,10 +759,11 @@ class AccountWorker {
   // handles Hold Tight / cooldowns / item-buying internally.
   async runCommand(cmdName, prefix) {
     let cmdString;
-    const betAmount = this.account.bet_amount || 1000;
+    const betAmount = Math.max(5000, this.account.bet_amount || 5000);
 
     switch (cmdName) {
       case 'dep max':     cmdString = `${prefix} dep max`; break;
+      case 'with max':    cmdString = `${prefix} with 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;
@@ -808,6 +810,7 @@ class AccountWorker {
         case 'dep max':     cmdResult = await commands.runDeposit(cmdOpts); break;
         case 'alert':       cmdResult = await commands.runAlert(cmdOpts); break;
         case 'stream':      cmdResult = await commands.runStream(cmdOpts); break;
+        case 'drops':       cmdResult = await commands.runDrops(cmdOpts); break;
         default:            cmdResult = await commands.runGeneric({ ...cmdOpts, cmdString, cmdName }); break;
       }
 
@@ -822,12 +825,37 @@ class AccountWorker {
         return;
       }
 
-      // 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', `CAPTCHA DETECTED! Worker PAUSED.`);
+      // Captcha/verification detection — deactivate account and stop
+      if (resultLower.includes('captcha') || resultLower.includes('verification required') ||
+          resultLower.includes('verify your account') || resultLower.includes('pass verification') ||
+          resultLower.includes('are you human') || resultLower.includes("prove you're not a bot") ||
+          resultLower.includes('complete the captcha') || resultLower.includes('continue playing')) {
+        this.log('error', `VERIFICATION REQUIRED! Deactivating account.`);
+        this.log('error', `Solve it in Discord, then re-enable from dashboard.`);
         this.paused = true;
-        await sendLog(this.username, cmdString, 'CAPTCHA DETECTED — worker paused', 'error');
+        this.account.active = false;
+        // Deactivate in DB so dashboard shows it as paused
+        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, active: false }),
+          });
+        } catch {}
+        await sendLog(this.username, cmdString, 'VERIFICATION — account deactivated', 'error');
+        return;
+      }
+
+      // Min bet detection — raise bet amount
+      if (resultLower.includes('cannot bet less than') || resultLower.includes('minimum bet')) {
+        const betMatch = result.match(/⏣\s*([\d,]+)/);
+        if (betMatch) {
+          const minBet = parseInt(betMatch[1].replace(/,/g, ''));
+          if (minBet > 0) {
+            this.account.bet_amount = minBet;
+            this.log('info', `${cmdName} min bet: ⏣ ${minBet.toLocaleString()}`);
+          }
+        }
         return;
       }
 
@@ -853,6 +881,13 @@ class AccountWorker {
         return;
       }
 
+      // Scratch level-gate: if level too low, disable for 24h
+      if (cmdResult.skipReason === 'level') {
+        this.log('warn', `${cmdName} level too low — retry in 24h`);
+        await this.setCooldown(cmdName, 86400);
+        return;
+      }
+
       const earned = Math.max(0, cmdResult.coins || 0);
       const spent = Math.max(0, cmdResult.lost || 0);
       if (earned > 0) this.stats.coins += earned;
@@ -899,6 +934,7 @@ class AccountWorker {
 
   // ── Command Map (shared across ticks, used to build the heap) ──
   static COMMAND_MAP = [
+    // Core grinding commands (short cooldowns, run frequently)
     { 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 },
@@ -909,23 +945,25 @@ class AccountWorker {
     { 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_trivia', cmd: 'trivia', cdKey: 'cd_trivia', defaultCd: 10, priority: 2 },
+    // Gambling (fast cycle)
     { 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 },
+    // Utility
     { 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 },
+    // Interactive commands
+    { key: 'cmd_stream', cmd: 'stream', cdKey: 'cd_stream', defaultCd: 600, priority: 6 },
+    { key: 'cmd_scratch', cmd: 'scratch', cdKey: 'cd_scratch', defaultCd: 21600, priority: 4 },
+    { key: 'cmd_adventure', cmd: 'adventure', cdKey: 'cd_adventure', defaultCd: 300, priority: 4 },
+    { key: 'cmd_work', cmd: 'work shift', cdKey: 'cd_work', defaultCd: 3600, priority: 6 },
+    // Time-gated
     { 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 },
+    { key: 'cmd_deposit', cmd: 'dep max', cdKey: 'cd_deposit', defaultCd: 300, priority: 7 },
+    { key: 'cmd_drops', cmd: 'drops', cdKey: 'cd_drops', defaultCd: 86400, priority: 2 },
+    // Alert is NOT scheduled — it's reactive (listener-based, see grindLoop)
   ];
 
   buildCommandQueue() {
@@ -948,6 +986,38 @@ class AccountWorker {
     return heap;
   }
 
+  // Merge config changes into existing queue without resetting cooldown timings.
+  // Uses a HashMap to drain old items, then rebuilds preserving nextRunAt.
+  mergeCommandQueue() {
+    const enabled = new Set(
+      AccountWorker.COMMAND_MAP.filter(ci => Boolean(this.account[ci.key])).map(ci => ci.cmd)
+    );
+    if (enabled.size === 0) return;
+
+    const existing = new Map();
+    if (this.commandQueue) {
+      while (this.commandQueue.size > 0) {
+        const item = this.commandQueue.pop();
+        existing.set(item.cmd, item);
+      }
+    }
+
+    const heap = new MinHeap();
+    const now = Date.now();
+    for (const info of AccountWorker.COMMAND_MAP) {
+      if (!enabled.has(info.cmd)) continue;
+      const old = existing.get(info.cmd);
+      if (old) {
+        old.info = info;
+        old.priority = info.priority;
+        heap.push(old);
+      } else {
+        heap.push({ cmd: info.cmd, nextRunAt: now, priority: info.priority, info });
+      }
+    }
+    this.commandQueue = heap;
+  }
+
   // ── Health Check: verify Discord client is still connected ──
   async healthCheck() {
     if (!this.running || shutdownCalled) return;
@@ -1042,7 +1112,7 @@ class AccountWorker {
     await this.setCooldown(item.cmd, totalWait);
 
     const timeSinceLastCmd = now - (this.lastCommandRun || 0);
-    const globalJitter = 1500 + Math.random() * 1500;
+    const globalJitter = 500 + Math.random() * 1000;
     if (timeSinceLastCmd < globalJitter) {
       await new Promise(r => setTimeout(r, globalJitter - timeSinceLastCmd));
     }
@@ -1098,14 +1168,33 @@ class AccountWorker {
     this.commandQueue = this.buildCommandQueue();
     this.lastHealthCheck = Date.now();
 
+    // Reactive alert listener: run `pls alert` only when Dank Memer
+    // sends an unsolicited message containing alert-like keywords
+    this._alertHandler = (msg) => {
+      if (!this.running || this.paused || this.dashboardPaused || shutdownCalled) return;
+      if (msg.author?.id !== DANK_MEMER_ID || msg.channel?.id !== this.channel?.id) return;
+      const text = getFullText(msg).toLowerCase();
+      if (text.includes('alert') || text.includes('notification') ||
+          text.includes('you have a pending') || text.includes('check your alerts')) {
+        if (!this.busy) {
+          this.log('info', 'Alert detected → running pls alert');
+          this.busy = true;
+          const prefix = this.account.use_slash ? '/' : 'pls';
+          this.runCommand('alert', prefix).finally(() => { this.busy = false; });
+        }
+      }
+    };
+    this.client.on('messageCreate', this._alertHandler);
+
     this.configInterval = setInterval(async () => {
       if (!this.running) return;
       await this.refreshConfig();
 
       if (this.account.active && this.paused) {
-        this.log('success', 'Captcha cleared! Resuming...');
+        this.log('success', 'Account re-enabled! Resuming...');
         this.paused = false;
         this.dashboardPaused = false;
+        if (this.commandQueue) this.mergeCommandQueue();
       }
 
       if (!this.account.active && !this.dashboardPaused) {
@@ -1117,7 +1206,7 @@ class AccountWorker {
       }
 
       if (this.commandQueue && !shutdownCalled) {
-        this.commandQueue = this.buildCommandQueue();
+        this.mergeCommandQueue();
       }
     }, 15000);
 
@@ -1184,8 +1273,7 @@ class AccountWorker {
           { 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' },
+          { key: 'cmd_deposit', l: 'dep' },           { key: 'cmd_drops', l: 'drops' },
         ].filter((ci) => Boolean(this.account[ci.key]));
 
         const chName = (this.channel.name || '?').substring(0, 12);
@@ -1208,6 +1296,10 @@ class AccountWorker {
     this.busy = false;
     if (this.tickTimeout) { clearTimeout(this.tickTimeout); this.tickTimeout = null; }
     if (this.configInterval) { clearInterval(this.configInterval); this.configInterval = null; }
+    if (this._alertHandler) {
+      try { this.client.removeListener('messageCreate', this._alertHandler); } catch {}
+      this._alertHandler = null;
+    }
     this.commandQueue = null;
     try { this.client.destroy(); } catch {}
   }
@@ -1229,7 +1321,7 @@ async function start(apiKey, apiUrl) {
 
   console.log(colorBanner());
   console.log(
-    `  ${rgb(139, 92, 246)}v4.3${c.reset}` +
+    `  ${rgb(139, 92, 246)}v4.5${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}` +
@@ -1272,6 +1364,7 @@ async function start(apiKey, apiUrl) {
   console.log('');
   startTime = Date.now();
   dashboardStarted = true;
+  setDashboardActive(true);
   process.stdout.write(c.hide);
 
   setInterval(() => scheduleRender(), 1000);
@@ -1283,6 +1376,7 @@ async function start(apiKey, apiUrl) {
     sigintHandled = true;
     shutdownCalled = true;
     dashboardStarted = false;
+    setDashboardActive(false);
     process.stdout.write(c.show);
 
     // Clear the dashboard area before printing summary

package/package.json

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