dankgrinder 6.45.0 → 7.1.0

package/lib/commands/beg.js

@@ -1,20 +1,17 @@
 /**
  * Beg command handler.
  * Simple command: send "pls beg", parse coins from response.
- * Detects: positive coins, Life Saver drops, negative (no coins).
  */
 
 const { LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep } = require('./utils');
 
 const RE_NEWLINE = /\n/g;
-const RE_LIFE_SAVER = /life\s*saver/i;
-const RE_BEG_COINS = /you\s+received\s*:\s*[\s\S]{0,200}?([\d,]+)/i;
 
 /**
  * @param {object} opts
  * @param {object} opts.channel
  * @param {function} opts.waitForDankMemer
- * @returns {Promise<{result: string, coins: number, lifeSaver?: boolean}>}
+ * @returns {Promise<{result: string, coins: number}>}
  */
 async function runBeg({ channel, waitForDankMemer }) {
   LOG.cmd(`${c.white}${c.bold}pls beg${c.reset}`);
@@ -36,30 +33,11 @@ async function runBeg({ channel, waitForDankMemer }) {
 
   logMsg(response, 'beg');
   const text = getFullText(response);
-
-  // Extract coins: prefer "You received" pattern for beg responses
-  let coins = 0;
-  const begMatch = text.match(RE_BEG_COINS);
-  if (begMatch) {
-    coins = parseInt(begMatch[1].replace(/,/g, ''), 10) || 0;
-  }
-  // Fallback to general parseCoins
-  if (coins === 0) {
-    coins = parseCoins(text);
-  }
-
-  // Detect Life Saver drops
-  const lifeSaver = RE_LIFE_SAVER.test(text);
+  const coins = parseCoins(text);
 
   if (coins > 0) {
-    const lsNote = lifeSaver ? ` + ${c.cyan}Life Saver${c.reset}` : '';
-    LOG.coin(`[beg] ${c.green}+⏣ ${coins.toLocaleString()}${lsNote}${c.reset}`);
-    return { result: `beg → ${c.green}+⏣ ${coins.toLocaleString()}${lifeSaver ? ' + Life Saver' : ''}${c.reset}`, coins, lifeSaver };
-  }
-
-  if (lifeSaver) {
-    LOG.coin(`[beg] ${c.cyan}Life Saver${c.reset} (no coins)`);
-    return { result: 'beg → Life Saver', coins: 0, lifeSaver };
+    LOG.coin(`[beg] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `beg → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`, coins };
   }
 
   LOG.info(`[beg] ${text.substring(0, 80).replace(RE_NEWLINE, ' ')}`);

package/lib/commands/fishVision.js

@@ -11,27 +11,10 @@ const sharp = require('sharp');
 const https = require('https');
 const http = require('http');
 
-// Allowed CDN hostnames for image downloads (prevents SSRF).
-const ALLOWED_IMAGE_HOSTS = new Set([
-  'cdn.discordapp.com',
-  'media.discordapp.net',
-  'images.discordapp.net',
-]);
-
-const MAX_IMAGE_BYTES = 5 * 1024 * 1024; // 5 MB cap — prevents memory exhaustion
-
 /**
  * Download an image from a URL and return as Buffer.
- * Only allows Discord CDN URLs and enforces a max size limit.
  */
 function downloadImage(url) {
-  // ── SSRF check ──────────────────────────────────────────────
-  let hostname;
-  try { hostname = new URL(url).hostname; } catch { return Promise.reject(new Error('invalid URL')); }
-  if (!ALLOWED_IMAGE_HOSTS.has(hostname)) {
-    return Promise.reject(new Error(`disallowed host: ${hostname}`));
-  }
-
   return new Promise((resolve, reject) => {
     const proto = url.startsWith('https') ? https : http;
     const req = proto.get(url, res => {
@@ -39,16 +22,7 @@ function downloadImage(url) {
         return downloadImage(res.headers.location).then(resolve, reject);
       }
       const chunks = [];
-      let bytesReceived = 0;
-      res.on('data', c => {
-        bytesReceived += c.length;
-        if (bytesReceived > MAX_IMAGE_BYTES) {
-          req.destroy();
-          reject(new Error(`image too large: ${bytesReceived} bytes (max ${MAX_IMAGE_BYTES})`));
-          return;
-        }
-        chunks.push(c);
-      });
+      res.on('data', c => chunks.push(c));
       res.on('end', () => resolve(Buffer.concat(chunks)));
       res.on('error', reject);
     });

package/lib/commands/index.js

@@ -13,6 +13,7 @@ const { runHunt } = require('./hunt');
 const { runDig } = require('./dig');
 const { runFish, sellAllFish } = require('./fish');
 const { runPostMemes } = require('./postmemes');
+const { runScratch } = require('./scratch');
 const { runBlackjack } = require('./blackjack');
 const { runTrivia, triviaDB } = require('./trivia');
 const { runWorkShift } = require('./work');
@@ -38,6 +39,7 @@ module.exports = {
   runFish,
   sellAllFish,
   runPostMemes,
+  runScratch,
   runBlackjack,
   runTrivia,
   runWorkShift,

package/lib/commands/inventory.js

@@ -198,7 +198,7 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   LOG.cmd(`${c.white}${c.bold}pls inv${c.reset}`);
 
   await channel.send('pls inv');
-  let response = await waitForDankMemer(15000);
+  let response = await waitForDankMemer(10000);
 
   if (!response) {
     LOG.warn('[inv] No response');

package/lib/commands/scratch.js

@@ -0,0 +1,83 @@
+/**
+ * Scratch command handler.
+ * Send "pls scratch", click through scratch card buttons.
+ * Requires level 25 — checks profile level before running.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+const { meetsLevelRequirement } = require('./profile');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} [opts.accountId]
+ * @param {object} [opts.redis]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runScratch({ channel, waitForDankMemer, accountId, redis }) {
+  // Check level 25 requirement before wasting a command
+  const canRun = await meetsLevelRequirement({ channel, waitForDankMemer, accountId, redis }, 25);
+  if (!canRun) {
+    LOG.warn(`[scratch] Skipped — need level 25`);
+    return { result: 'skipped (need level 25)', coins: 0, skipReason: 'level' };
+  }
+  LOG.cmd(`${c.white}${c.bold}pls scratch${c.reset}`);
+
+  await channel.send('pls scratch');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[scratch] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[scratch] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'scratch');
+  const buttons = getAllButtons(response);
+
+  if (buttons.length === 0) {
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+    if (coins > 0) {
+      LOG.coin(`[scratch] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+      return { result: `scratch → +⏣ ${coins.toLocaleString()}`, coins };
+    }
+    return { result: text.substring(0, 60) || 'done', coins: 0 };
+  }
+
+  // Click through all scratch card cells
+  let lastResponse = response;
+  let clickCount = 0;
+  for (let i = 0; i < Math.min(buttons.length, 9); i++) {
+    const btn = buttons[i];
+    if (btn && !btn.disabled) {
+      await humanDelay(300, 700);
+      try {
+        const followUp = await safeClickButton(lastResponse, btn);
+        if (followUp) { lastResponse = followUp; clickCount++; }
+      } catch { break; }
+    }
+  }
+
+  const finalText = getFullText(lastResponse);
+  const coins = parseCoins(finalText);
+
+  if (coins > 0) {
+    LOG.coin(`[scratch] ${clickCount} clicks → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `scratch (${clickCount} clicks) → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  return { result: `scratch done (${clickCount} clicks)`, coins: 0 };
+}
+
+module.exports = { runScratch };

package/lib/commands/utils.js

@@ -558,8 +558,7 @@ async function clickCV2Button(msg, customId) {
   const gId = msg.guildId || msg.guild?.id;
   if (!token) throw new Error('No token for CV2 click');
   const sessionId = msg.client?.ws?.shards?.first?.()?.sessionId;
-  const { randomUUID } = require('crypto');
-  const nonce = randomUUID();
+  const nonce = `${BigInt(Date.now() - 1420070400000) << 22n}`;
   const payloadObj = {
     type: 3,
     application_id: String(msg.applicationId || DANK_MEMER_ID),
@@ -604,8 +603,7 @@ async function clickCV2SelectMenu(msg, customId, values = []) {
   const gId = msg.guildId || msg.guild?.id;
   if (!token) throw new Error('No token for CV2 select');
   const sessionId = msg.client?.ws?.shards?.first?.()?.sessionId;
-  const { randomUUID } = require('crypto');
-  const nonce = randomUUID();
+  const nonce = `${BigInt(Date.now() - 1420070400000) << 22n}`;
   const payloadObj = {
     type: 3,
     application_id: String(msg.applicationId || DANK_MEMER_ID),

package/lib/grinder.js

@@ -5,7 +5,7 @@ const { setDashboardActive, isCV2, ensureCV2, stripAnsi } = require('./commands/
 const rawLogger = require('./rawLogger');
 const {
   BloomFilter, RingBuffer, TokenBucket, EMA, SlidingWindowCounter,
-  AhoCorasick, LRUCache, StringPool, AsyncBatchQueue,
+  AhoCorasick, LRUCache, StringPool, AsyncBatchQueue, JitterBackoff,
 } = require('./structures');
 const PKG_VERSION = require('../package.json').version;
 
@@ -279,9 +279,9 @@ function boxTop(w, color) { return color + BOX.dtl + BOX.dh.repeat(w - 2) + BOX.
 function boxMid(w, color) { return color + BOX.tee + BOX.h.repeat(w - 2) + BOX.teeR + c.reset; }
 function boxBot(w, color) { return color + BOX.dbl + BOX.dh.repeat(w - 2) + BOX.dbr + c.reset; }
 function boxLine(content, w, color) {
-  const stripped = stripAnsi(content);
+  const stripped = content.replace(/\x1b\[[0-9;]*m/g, '');
   const pad = Math.max(0, w - 4 - stripped.length);
-  return color + BOX.dv + c.reset + ' ' + stripAnsi(content) + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
+  return color + BOX.dv + c.reset + ' ' + content + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
 }
 function thinLine(w) { return '  ' + c.dim + BOX.h.repeat(w - 4) + c.reset; }
 
@@ -868,8 +868,8 @@ const CMD_NAMES_CLEAN = {
   bj: 'Blackjack', blackjack: 'Blackjack', hl: 'High Low', pm: 'Post Memes', postmemes: 'Post Memes',
   ct: 'Coin Toss', cointoss: 'Coin Toss', se: 'Snake Eyes', snakeeyes: 'Snake Eyes',
   hunt: 'Hunt', dig: 'Dig', fish: 'Fish', beg: 'Beg', search: 'Search', crime: 'Crime',
-  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', monthly: 'Monthly',
-  adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
+  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', weekly: 'Weekly', monthly: 'Monthly',
+  scratch: 'Scratch', adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
   drops: 'Drops', use: 'Use Item', dep: 'Deposit', deposit: 'Deposit', inv: 'Inventory',
   work: 'Work', stream: 'Stream', roulette: 'Roulette', slots: 'Slots',
 };
@@ -1490,9 +1490,7 @@ class AccountWorker {
                 totalValue: result.totalValue || 0,
               }),
             });
-          } catch (err) {
-            console.error(`[${this.username}] inventory API error:`, err?.message || err);
-          }
+          } catch {}
 
           return {
             ok: true,
@@ -1569,9 +1567,7 @@ class AccountWorker {
             raw_text: result.rawText || '',
           }),
         });
-      } catch (err) {
-        console.error(`[${this.username}] profile API error:`, err?.message || err);
-      }
+      } catch {}
 
       return { ok: true, ...result };
     } catch (e) {
@@ -1780,48 +1776,22 @@ class AccountWorker {
   // Each modular command handler sends the command, waits for response,
   // handles Hold Tight / cooldowns / item-buying internally.
   async runCommand(cmdName, prefix) {
-    // Slash commands use '/cmd' without a space between slash and subcommand
-    // (e.g. '/dep max', '/work shift'). Legacy prefix uses 'pls cmd'.
-    const SLASH_CMD = new Map([
-      ['dep max',     '/dep max'],
-      ['with max',    '/with max'],
-      ['work shift',  '/work shift'],
-      ['monthly',     '/monthly'],
-    ]);
+    let cmdString;
     const bjBet = Math.max(5000, this.account.bet_amount || 5000);
     const gambBet = Math.max(10000, this.account.bet_amount || 10000);
 
-    let cmdString;
-    if (prefix === '/') {
-      const slashVariant = SLASH_CMD.get(cmdName);
-      if (slashVariant) {
-        cmdString = slashVariant;
-      } else if (cmdName === 'blackjack') {
-        cmdString = `/bj ${bjBet}`;
-      } else if (cmdName === 'cointoss') {
-        cmdString = `/cointoss ${gambBet}`;
-      } else if (cmdName === 'roulette') {
-        cmdString = `/roulette ${gambBet}`;
-      } else if (cmdName === 'slots') {
-        cmdString = `/slots ${gambBet}`;
-      } else if (cmdName === 'snakeeyes') {
-        cmdString = `/snakeeyes ${gambBet}`;
-      } else {
-        cmdString = `/${cmdName}`;
-      }
-    } else {
-      switch (cmdName) {
-        case 'dep max':     cmdString = `${prefix} dep max`; break;
-        case 'with max':    cmdString = `${prefix} with max`; break;
-        case 'blackjack':   cmdString = `${prefix} bj ${bjBet}`; break;
-        case 'cointoss':    cmdString = `${prefix} cointoss ${gambBet}`; break;
-        case 'roulette':    cmdString = `${prefix} roulette ${gambBet}`; break;
-        case 'slots':       cmdString = `${prefix} slots ${gambBet}`; break;
-        case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${gambBet}`; break;
-        case 'work shift':  cmdString = `${prefix} work shift`; break;
-        case 'monthly':     cmdString = `${prefix} monthly`; break;
-        default:            cmdString = `${prefix} ${cmdName}`;
-      }
+    switch (cmdName) {
+      case 'dep max':     cmdString = `${prefix} dep max`; break;
+      case 'with max':    cmdString = `${prefix} with max`; break;
+      case 'blackjack':   cmdString = `${prefix} bj ${bjBet}`; break;
+      case 'cointoss':    cmdString = `${prefix} cointoss ${gambBet}`; break;
+      case 'roulette':    cmdString = `${prefix} roulette ${gambBet}`; break;
+      case 'slots':       cmdString = `${prefix} slots ${gambBet}`; break;
+      case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${gambBet}`; break;
+      case 'work shift':  cmdString = `${prefix} work shift`; break;
+      case 'weekly':      cmdString = `${prefix} weekly`; break;
+      case 'monthly':     cmdString = `${prefix} monthly`; break;
+      default:            cmdString = `${prefix} ${cmdName}`;
     }
 
     if (shutdownCalled || !this.running) return;
@@ -1919,6 +1889,7 @@ class AccountWorker {
         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;
@@ -1973,9 +1944,7 @@ class AccountWorker {
             headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
             body: JSON.stringify({ account_id: this.account.id, active: false }),
           });
-        } catch (err) {
-          console.error(`[${this.username}] status deactivation API error:`, err?.message || err);
-        }
+        } catch {}
         await sendLog(this.username, cmdString, 'VERIFICATION — account deactivated', 'error');
         sendWebhook('CAPTCHA ALERT', `**${this.username}** needs verification!\nCommand: \`${cmdName}\`\nSolve in Discord and re-enable from dashboard.`, 0xef4444);
         return;
@@ -2026,6 +1995,16 @@ class AccountWorker {
         return;
       }
 
+      // Died flag from crime/search handler (death detected in the command response)
+      if (cmdResult.died) {
+        this.log('error', `${cmdName} → DIED! Checking lifesaver count...`);
+        // The DM will come separately with the actual death details
+        // For now, be cautious — set a short cooldown and let DM listener handle the rest
+        await this.setCooldown('crime', 300); // 5 min cooldown to check DMs
+        await this.setCooldown('search', 300);
+        return;
+      }
+
       // Premium-only command detection — disable permanently
       if (resultLower.includes('only available on premium') || resultLower.includes('premium') ||
           resultLower.includes('buy the ability to use this command') ||
@@ -2044,9 +2023,8 @@ class AccountWorker {
         const timeMatch = result.match(/<t:(\d+):R>/);
         let waitSec;
         if (timeMatch) {
-          // Discord <t:TS:R> format: :R = relative seconds from NOW (not Unix ms).
-          // The captured number IS already the number of seconds to wait.
-          waitSec = Math.max(60, parseInt(timeMatch[1]));
+          const nextAvail = parseInt(timeMatch[1]) * 1000;
+          waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
         } else {
           const defaultWaits = { daily: 86400, weekly: 604800, monthly: 2592000 };
           waitSec = defaultWaits[cmdName] || 86400;
@@ -2226,13 +2204,13 @@ class AccountWorker {
 
   // ── Command Map (shared across ticks, used to build the heap) ──
   // Priority: higher = runs first when multiple commands are ready simultaneously.
-  //   10 = time-gated (daily/monthly — never miss),
+  //   10 = time-gated (daily/weekly/monthly — never miss),
   //    8 = financial safety (deposit),
   //    7 = gambling fast-cycle (2-3s CD — run MOST often),
   //    6 = fast grinders (10s CD),
   //    5 = medium grinders (20-40s CD),
   //    4 = resource grinders (hunt/dig — need items),
-  //    3 = interactive/long CD (adventure/stream/work),
+  //    3 = interactive/long CD (adventure/stream/work/scratch),
   //    2 = utility (drops/use/tidy)
   static COMMAND_MAP = [
     // Gambling — 2-3s CD, highest frequency
@@ -2243,7 +2221,7 @@ class AccountWorker {
     { key: 'cmd_snakeeyes', cmd: 'snakeeyes',   cdKey: 'cd_snakeeyes', defaultCd: 3,      priority: 7 },
     // Fast grinders — 10s CD
     { key: 'cmd_hl',        cmd: 'hl',          cdKey: 'cd_hl',        defaultCd: 10,     priority: 6 },
-    { key: 'cmd_farm',      cmd: 'farm',         cdKey: 'cd_farm',      defaultCd: 30,     priority: 4 },
+  { key: 'cmd_farm',      cmd: 'farm',        cdKey: 'cd_farm',      defaultCd: 30,     priority: 4 },
     { key: 'cmd_trivia',    cmd: 'trivia',      cdKey: 'cd_trivia',    defaultCd: 10,     priority: 6 },
     { key: 'cmd_use',       cmd: 'use',         cdKey: 'cd_use',       defaultCd: 10,     priority: 2 },
     // Medium grinders — 20-25s CD
@@ -2254,19 +2232,20 @@ class AccountWorker {
     { key: 'cmd_search',    cmd: 'search',      cdKey: 'cd_search',    defaultCd: 25,     priority: 5 },
     // Slow grinders — 40s CD
     { key: 'cmd_beg',       cmd: 'beg',         cdKey: 'cd_beg',       defaultCd: 40,     priority: 5 },
-    { key: 'cmd_crime',     cmd: 'crime',        cdKey: 'cd_crime',     defaultCd: 40,     priority: 5 },
-    { key: 'cmd_tidy',      cmd: 'tidy',         cdKey: 'cd_tidy',      defaultCd: 40,     priority: 2 },
+    { key: 'cmd_crime',     cmd: 'crime',       cdKey: 'cd_crime',     defaultCd: 40,     priority: 5 },
+    { key: 'cmd_tidy',      cmd: 'tidy',        cdKey: 'cd_tidy',      defaultCd: 40,     priority: 2 },
     // Interactive — response-driven CD (handler sets nextCooldownSec)
-    { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 300,    priority: 3 },
-    { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',   defaultCd: 600,    priority: 3 },
-    { key: 'cmd_work',      cmd: 'work shift',   cdKey: 'cd_work',     defaultCd: 1800,   priority: 3 },
+  { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 300,    priority: 3 },
+  { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',    defaultCd: 600,    priority: 3 },
+    // scratch removed — requires voting which can't be automated
+  { key: 'cmd_work',      cmd: 'work shift',  cdKey: 'cd_work',      defaultCd: 1800,   priority: 3 },
     // Time-gated (run ASAP when available)
-    { key: 'cmd_daily',     cmd: 'daily',       cdKey: 'cd_daily',    defaultCd: 86400,  priority: 10 },
-    // monthly — premium only
-    { key: 'cmd_monthly',   cmd: 'monthly',     cdKey: 'cd_monthly',  defaultCd: 2592000, priority: 10 },
+    { key: 'cmd_daily',     cmd: 'daily',       cdKey: 'cd_daily',     defaultCd: 86400,  priority: 10 },
+    // weekly removed — premium only, not available for free users
+    { key: 'cmd_monthly',   cmd: 'monthly',     cdKey: 'cd_monthly',   defaultCd: 2592000,priority: 10 },
     // Financial safety
-    { key: 'cmd_deposit',   cmd: 'dep max',     cdKey: 'cd_deposit',  defaultCd: 3600,   priority: 8 },
-    { key: 'cmd_drops',     cmd: 'drops',       cdKey: 'cd_drops',    defaultCd: 86400, priority: 2 },
+    { key: 'cmd_deposit',   cmd: 'dep max',     cdKey: 'cd_deposit',   defaultCd: 3600,   priority: 8 },
+    { key: 'cmd_drops',     cmd: 'drops',       cdKey: 'cd_drops',     defaultCd: 86400,  priority: 2 },
     // Alert is NOT scheduled — it's reactive (listener-based, see grindLoop)
   ].map(Object.freeze);
 
@@ -2543,58 +2522,91 @@ class AccountWorker {
       return;
     }
 
-    // ── Scan entire queue for ready commands ─────────────────────
-    // Previously we only peeked the top item, missing other commands that
-    // were already ready while a slower command was at the top of the heap.
-    // Now we drain the queue and separate ready vs. waiting commands.
-    // All ready commands fire immediately — no priority, FIFO order.
-    const readyItems = [];
-    const waitingItems = [];
-    while (this.commandQueue.size > 0) {
-      const item = this.commandQueue.pop();
-      if (!item) break;
-      if (item.nextRunAt <= now) {
-        readyItems.push(item);
-      } else {
-        waitingItems.push(item);
-      }
+    const top = this.commandQueue.peek();
+    if (top.nextRunAt > now) {
+      const waitMs = Math.min(top.nextRunAt - now, 2000);
+      this.setStatus('cooldown...');
+      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
+      return;
     }
 
-    // Re-insert waiting items back into the queue (they still have time to wait)
-    for (const item of waitingItems) {
-      this.commandQueue.push(item);
+    const item = this.commandQueue.pop();
+    if (!item) {
+      this.tickTimeout = setTimeout(() => this.tick(), 1000);
+      return;
     }
 
-    if (readyItems.length === 0) {
-      // Nothing ready — wait until the soonest command becomes available.
-      let minWaitMs = 5000; // cap at 5s to stay responsive
-      for (const item of waitingItems) {
-        const diff = item.nextRunAt - now;
-        if (diff < minWaitMs) minWaitMs = diff;
-      }
-      this.setStatus('cooldown...');
-      this.tickTimeout = setTimeout(() => this.tick(), Math.max(100, Math.min(minWaitMs, 5000)));
+    const ready = await this.isCooldownReady(item.cmd);
+    if (!ready) {
+      const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
+      item.nextRunAt = now + cd * 1000;
+      if (this.commandQueue) this.commandQueue.push(item);
+      this.tickTimeout = setTimeout(() => this.tick(), 100);
       return;
     }
 
-    // FIFO — execute commands in the order they became ready.
-    // Commands that aren't picked this tick go back into the queue for next tick.
-    const item = readyItems[0];
+    // Skip time-gated commands if already claimed (in-memory + Redis)
+    if (item.cmd === 'daily' || item.cmd === 'weekly' || item.cmd === 'monthly' || item.cmd === 'drops') {
+      const memExpiry = this.doneToday.get(item.cmd);
+      if (memExpiry && Date.now() < memExpiry) {
+        item.nextRunAt = memExpiry;
+        if (this.commandQueue) this.commandQueue.push(item);
+        this.tickTimeout = setTimeout(() => this.tick(), 100);
+        return;
+      }
+      if (redis) {
+        try {
+          const done = await redis.get(`dkg:done:${this.account.id}:${item.cmd}`);
+          if (done) {
+            const ttlMap = { daily: 86400, weekly: 604800, monthly: 2592000, drops: 86400 };
+            const ttl = ttlMap[item.cmd] || 86400;
+            const expiry = now + ttl * 1000;
+            this.doneToday.set(item.cmd, expiry);
+            item.nextRunAt = expiry;
+            if (this.commandQueue) this.commandQueue.push(item);
+            this.tickTimeout = setTimeout(() => this.tick(), 100);
+            return;
+          }
+        } catch {}
+      }
+    }
 
-    // Any remaining ready items that we didn't execute go back immediately
-    // so they run in the next tick without waiting for the slow top item.
-    for (let i = 1; i < readyItems.length; i++) {
-      this.commandQueue.push(readyItems[i]);
+    // Smart gambling: skip gamble commands while loss-paused
+    const GAMBLE_SET = new Set(['blackjack', 'cointoss', 'roulette', 'slots', 'snakeeyes']);
+    if (GAMBLE_SET.has(item.cmd) && this._gamblePausedUntil > now) {
+      item.nextRunAt = this._gamblePausedUntil;
+      if (this.commandQueue) this.commandQueue.push(item);
+      this.setStatus(`gamble paused (${Math.ceil((this._gamblePausedUntil - now) / 1000)}s)`);
+      this.tickTimeout = setTimeout(() => this.tick(), 100);
+      return;
+    }
+    if (GAMBLE_SET.has(item.cmd) && this._gamblePausedUntil > 0 && this._gamblePausedUntil <= now) {
+      this._gamblePausedUntil = 0;
+      this._gambleLossStreak = 0;
+      this._gambleSessionLoss = 0;
+      this.log('info', 'Gambling pause expired — resuming bets');
     }
 
-    // Anti-detection: per-account jitter + micro-pauses for this command
+    // TokenBucket rate limiter: prevent Discord 429s by throttling commands
+    if (!this._rateLimiter.consume(1)) {
+      const waitMs = this._rateLimiter.waitTime(1);
+      this.setStatus(`rate throttle (${Math.ceil(waitMs / 1000)}s)`);
+      if (this.commandQueue) this.commandQueue.push(item);
+      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
+      return;
+    }
+
+    this._cmdRate.increment();
+    this.busy = true;
     const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
+    // Anti-detection: per-account jitter with varying patterns
     const patternMod = this._activePattern;
     const jitterBase = cd <= 5
       ? 0.3 + Math.random() * 0.7
       : cd <= 20
         ? 0.5 + Math.random() * 1.5
         : 1 + Math.random() * 2;
+    // Add human-like micro-pauses (occasionally take longer, simulating distraction)
     const microPause = Math.random() < 0.08 ? 1.5 + Math.random() * 3 : 0;
     const totalWait = cd + jitterBase + microPause;
 
@@ -2606,32 +2618,6 @@ class AccountWorker {
       await new Promise(r => setTimeout(r, minGap - timeSinceLastCmd));
     }
 
-    // TokenBucket rate limiter — prevent Discord 429s
-    if (!this._rateLimiter.consume(1)) {
-      const waitMs = this._rateLimiter.waitTime(1);
-      this.setStatus(`rate throttle (${Math.ceil(waitMs / 1000)}s)`);
-      if (this.commandQueue) this.commandQueue.push(item);
-      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
-      return;
-    }
-
-    // Startup delay: don't send commands for the first 30s after grindLoop() starts.
-    // This prevents flooding Dank Memer during the Phase 2 inventory check which
-    // sends pls inv for all accounts simultaneously after login.
-    if (this._startupDelayUntil && now < this._startupDelayUntil) {
-      const waitMs = this._startupDelayUntil - now;
-      this.setStatus('warming up...');
-      item.nextRunAt = now + waitMs + 1000;
-      if (this.commandQueue) this.commandQueue.push(item);
-      this.tickTimeout = setTimeout(() => this.tick(), waitMs + 1000);
-      return;
-    }
-
-    this.busy = true;
-
-    // ── Run command (with interactive retry) ───────────────────
-    // Commands run ONE BY ONE — sequential execution, no concurrency within this account.
-    // Each runCommand() call waits for Dank Memer's Discord response before returning.
     const prefix = this.account.use_slash ? '/' : 'pls';
     this.setStatus(formatCommandName(item.cmd));
 
@@ -2645,40 +2631,15 @@ class AccountWorker {
       next_run_at: nextItemRun?.nextRunAt || null,
     });
 
-    // Interactive commands (button-click): retry up to 3 times on failure.
-    // Non-interactive commands run once.
-    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'adventure', 'stream', 'fish', 'farm', 'work shift']);
-    const isInteractive = INTERACTIVE_CMDS.has(item.cmd);
-    const maxAttempts = isInteractive ? 3 : 1;
-    let attempt = 0;
-    let lastError = null;
-    let earned = 0;
-    while (attempt < maxAttempts) {
-      attempt++;
-      try {
-        const beforeCoins = this.stats.coins;
-        await this.runCommand(item.cmd, prefix);
-        earned = this.stats.coins - beforeCoins;
-        lastError = null;
-        this.lastCommandRun = Date.now();
-        break; // success
-      } catch (err) {
-        lastError = err;
-        this.log('warn', `${item.cmd} attempt ${attempt}/${maxAttempts} failed: ${err.message}`);
-        if (attempt < maxAttempts) {
-          await new Promise(r => setTimeout(r, 1000 + Math.random() * 1000));
-        }
-      }
-    }
-    if (lastError) {
-      this.log('error', `${item.cmd} failed after ${maxAttempts} attempts — skipping`);
-    }
-
-    this._cmdRate.increment();
+    const beforeCoins = this.stats.coins;
+    await this.runCommand(item.cmd, prefix);
+    const earned = this.stats.coins - beforeCoins;
 
-    // Grace period for interactive commands — Dank Memer needs time to process
-    // the interaction before accepting the next command.
-    if (isInteractive) {
+    // Grace period for interactive (button-click) commands — Dank Memer
+    // needs time to process the interaction before accepting the next command.
+    // Without this, the next command gets "Hold Tight" errors.
+    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'scratch', 'adventure', 'stream', 'fish', 'farm', 'work shift']);
+    if (INTERACTIVE_CMDS.has(item.cmd)) {
       await new Promise(r => setTimeout(r, 2500 + Math.random() * 1500));
     }
 
@@ -2696,6 +2657,8 @@ class AccountWorker {
       this.failStreak = 0;
     }
 
+  this.lastCommandRun = Date.now();
+
     // Exponential backoff: if too many consecutive failures, slow down
     const backoffMultiplier = this.failStreak > 5 ? Math.min(this.failStreak - 4, 5) : 1;
     // Minimum 5s cooldown for failed commands to prevent rapid-fire retries
@@ -2767,11 +2730,6 @@ class AccountWorker {
     this.failStreak = 0;
     this.cycleCount = 0;
     this.lastCommandRun = 0;
-    // Delay first command by 30s to avoid competing with Phase 2 inventory check
-    // which sends pls inv for all accounts simultaneously after login.
-    // Without this, the grind loop floods Dank Memer with commands during the
-    // login surge, triggering rate-limits that cause Phase 2 inventory to fail.
-    this._startupDelayUntil = Date.now() + 30000;
     await this._loadLearnedCooldowns();
     this.commandQueue = await this.buildCommandQueue();
     this.lastHealthCheck = Date.now();
@@ -2875,9 +2833,7 @@ class AccountWorker {
                 headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
                 body: JSON.stringify({ action_id: action.id }),
               });
-            } catch (err) {
-              console.error(`[${this.username}] delete pending action error:`, err?.message || err);
-            }
+            } catch {}
           }
           if (action.action === 'check_profile' && !this.busy) {
             this.log('info', 'Dashboard requested profile check');
@@ -2888,15 +2844,11 @@ class AccountWorker {
                 headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
                 body: JSON.stringify({ action_id: action.id }),
               });
-            } catch (err) {
-              console.error(`[${this.username}] delete pending action error:`, err?.message || err);
-            }
+            } catch {}
           }
         }
       }
-    } catch (err) {
-      console.error(`[${this.username}] refreshConfig error:`, err?.message || err);
-    }
+    } catch { /* silent */ }
   }
 
   async start() {
@@ -2946,8 +2898,9 @@ class AccountWorker {
           { 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_monthly', l: 'monthly' },
-          { key: 'cmd_work', l: 'work' }, { key: 'cmd_stream', l: 'stream' },
+          { 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: 'toss' }, { key: 'cmd_roulette', l: 'roul' },
@@ -3172,38 +3125,19 @@ async function start(apiKey, apiUrl) {
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
     rawLogger.init(REDIS_URL).catch(() => {});
-    // Live DM listener: detect deaths and level-ups in real-time across all accounts
+    // Listen for DM death events across all accounts
     rawLogger.onDmEvent((event, raw) => {
-      const dmChannelId = raw.channel_id;
-
-      // Find which worker owns this DM channel
-      const worker = workers.find(w => w._dmChannelId === dmChannelId);
-      if (!worker) return;
-
-      if (event.type === 'death') {
-        const lsLeft = event.lifesaversLeft;
-
-        if (lsLeft === 0) {
-          // 0 lifesavers — disable crime/search immediately
-          worker.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
-          worker.setCooldown?.('crime', 86400);
-          worker.setCooldown?.('search', 86400);
-          worker._lifesavers = 0;
-          sendWebhook?.('DEATH ALERT (DM)', `**${worker.username}** died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
-        } else if (lsLeft > 0) {
-          // Lifesaver(s) used — update count in real-time
-          worker._lifesavers = lsLeft;
-          worker.log?.('warn', `Lifesaver used! ${lsLeft} remaining.`);
-          if (lsLeft <= 2) {
-            sendWebhook?.('LOW LIFESAVERS', `**${worker.username}** died! Only **${lsLeft}** lifesaver(s) left!`, 0xfbbf24);
+      if (event.type === 'death' && event.lifesaversLeft === 0) {
+        const channelId = raw.channel_id;
+        // Find which worker uses this DM channel and disable their crime/search
+        for (const w of workers) {
+          if (w.client?.user?.dmChannel?.id === channelId || w.channel?.id) {
+            w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
+            w.setCooldown?.('crime', 86400);
+            w.setCooldown?.('search', 86400);
           }
         }
-      } else if (event.type === 'levelup') {
-        // Level up — update in-memory level
-        if (event.to > 0) {
-          worker._level = event.to;
-          worker.log?.('info', `Level up! Now level ${event.to}.`);
-        }
+        sendWebhook?.('DEATH ALERT (DM)', `Account died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
       }
     });
     checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}RawLog${c.reset}`);
@@ -3411,7 +3345,7 @@ async function start(apiKey, apiUrl) {
     const num = `${c.dim}${(i + 1).toString().padStart(iColNum - 1)}${c.reset}`;
     const name = (w.username || w.account.label || '?').substring(0, iColName).padEnd(iColName);
     let invRes;
-    try { invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 5, silent: true }); }
+    try { invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
     catch { invRes = { ok: false }; }
     invPending--;
     const items = invRes?.ok ? (invRes.result?.items?.length || 0) : 0;

package/lib/rawLogger.js

@@ -151,26 +151,24 @@ function detectCommand(d) {
   // Non-gambling CV2
   if (cv2Text.includes('fishing') || cv2Text.includes('fisherfolk')) return 'fish';
   if (cv2Text.includes('deposit') || cv2Text.includes('bank account')) return 'deposit';
-  if (cv2Text.includes('begging') || cv2Text.includes('imagine begging') || cv2Text.includes('wumpus gives you') || (cv2Text.includes('you received') && !cv2Text.includes('search') && !cv2Text.includes('hunt') && !cv2Text.includes('dig'))) return 'beg';
-  if (cv2Text.includes('hunting') || cv2Text.includes('went hunting') || cv2Text.includes('hunting rifle') || cv2Text.includes('your aim was so bad') || cv2Text.includes('animals laughed') || cv2Text.includes('animals attacked') || cv2Text.includes('barely escaped') || cv2Text.includes('fell asleep in a tree') || cv2Text.includes('caught nothing') || cv2Text.includes('brought back literally nothing') || cv2Text.includes('rifle broke') || (cv2Text.includes('brought back') && (cv2Text.includes('deer') || cv2Text.includes('wolf') || cv2Text.includes('bear') || cv2Text.includes('boar') || cv2Text.includes('lion') || cv2Text.includes('rabbit') || cv2Text.includes('squirrel') || cv2Text.includes('moose') || cv2Text.includes('bird') || cv2Text.includes('elk') || cv2Text.includes('hunting') || cv2Text.includes('capybara')))) return 'hunt';
-  if (cv2Text.includes('digging') || cv2Text.includes('found nothing while') || cv2Text.includes('you dig') || cv2Text.includes('dug in the dirt') || (cv2Text.includes('brought back') && (cv2Text.includes('ant') || cv2Text.includes('worm') || cv2Text.includes('stickbug') || cv2Text.includes('ladybug')))) return 'dig';
+  if (cv2Text.includes('begging') || cv2Text.includes('imagine begging')) return 'beg';
+  if (cv2Text.includes('hunting') || cv2Text.includes('went hunting') || cv2Text.includes('hunting rifle') || cv2Text.includes('your aim was so bad') || cv2Text.includes('animals laughed') || cv2Text.includes('animals attacked') || cv2Text.includes('barely escaped') || cv2Text.includes('fell asleep in a tree') || cv2Text.includes('caught nothing') || cv2Text.includes('brought back literally nothing') || cv2Text.includes('rifle broke')) return 'hunt';
+  if (cv2Text.includes('digging') || cv2Text.includes('found nothing while') || cv2Text.includes('you dig') || cv2Text.includes('dug in the dirt') || cv2Text.includes('brought back') && (cv2Text.includes('ant') || cv2Text.includes('worm') || cv2Text.includes('stickbug') || cv2Text.includes('ladybug'))) return 'dig';
   if (cv2Text.includes('great work') || cv2Text.includes('for your shift') || cv2Text.includes('working as') || cv2Text.includes('work shift') || cv2Text.includes('what color was') || cv2Text.includes('remember words order') || cv2Text.includes('remember the colors') || cv2Text.includes('remember the emojis') || cv2Text.includes('what word was repeated') || cv2Text.includes('unscramble') || cv2Text.includes('remember the number') || cv2Text.includes('click the buttons in correct order') || cv2Text.includes('babysitter') || cv2Text.includes('click the matching')) return 'work';
-  // Quest completions (before generic daily/weekly)
-  if (cv2Text.includes('locations') && (cv2Text.includes('inventory locations') || cv2Text.includes('found locations') || cv2Text.includes('completed your') || cv2Text.includes('locations remaining'))) return 'search';
   if (cv2Text.includes('weekly')) return 'weekly';
   if (cv2Text.includes('daily')) return 'daily';
-  // Only match inventory if it looks like an actual inventory display (header format or sellable indicator)
-  if (cv2Text.includes('inventory') && (cv2Text.includes('###') || cv2Text.includes('sellable') || cv2Text.includes('<:reply:'))) return 'inventory';
+  if (cv2Text.includes('inventory')) return 'inventory';
   if (cv2Text.includes('profile') || cv2Text.includes('level:')) return 'profile';
   if (cv2Text.includes('balances') && cv2Text.includes('global rank')) return 'balance';
 
   // Check content text (plain message content)
   const contentText = (d.content || '').toLowerCase();
   if (contentText.includes('balances') && contentText.includes('global rank')) return 'balance';
-  if (contentText.includes('your aim was so bad') || contentText.includes('animals laughed') || contentText.includes('imagine going into the woods')) return 'hunt';
+  if (contentText.includes('your aim was so bad') || contentText.includes('animals laughed')) return 'hunt';
+  if (contentText.includes('imagine going into the woods')) return 'hunt';
   if (contentText.includes('you ran an ad for') && contentText.includes('received')) return 'stream';
   if (contentText.includes('you can\'t interact with your stream')) return 'stream';
-  if (contentText.includes('you dug in the dirt') || (contentText.includes('found nothing while digging') && (contentText.includes('dug') || contentText.includes('dirt')))) return 'dig';
+  if (contentText.includes('you dug in the dirt') || contentText.includes('found nothing while digging')) return 'dig';
 
   // Check embed text
   const embedText = extractEmbedText(d.embeds).toLowerCase();
@@ -199,8 +197,8 @@ function detectCommand(d) {
     return 'search';
   }
   // Hunt / dig
-  if (embedText.includes('hunting') || embedText.includes('came back with') || embedText.includes('hunting rifle') || embedText.includes('dragon\'s fireball') || embedText.includes('dodge the') || embedText.includes('went hunting') || embedText.includes('your aim was so bad') || embedText.includes('animals laughed') || embedText.includes('animals attacked') || embedText.includes('barely escaped') || embedText.includes('fell asleep in a tree') || embedText.includes('caught nothing') || embedText.includes('brought back literally nothing') || embedText.includes('rifle broke') || embedText.includes('imagine going into the woods') || (embedText.includes('brought back') && (embedText.includes('deer') || embedText.includes('wolf') || embedText.includes('bear') || embedText.includes('boar') || embedText.includes('lion') || embedText.includes('rabbit') || embedText.includes('squirrel') || embedText.includes('moose') || embedText.includes('bird') || embedText.includes('elk') || embedText.includes('capybara')))) return 'hunt';
-  if (embedText.includes('digging') || embedText.includes('you dig') || embedText.includes('dug in the dirt') || embedText.includes('found nothing while') || embedText.includes('what are the odds lol') || (embedText.includes('brought back') && (embedText.includes('ant') || embedText.includes('worm') || embedText.includes('stickbug') || embedText.includes('ladybug')))) return 'dig';
+  if (embedText.includes('hunting') || embedText.includes('came back with') || embedText.includes('hunting rifle') || embedText.includes('dragon\'s fireball') || embedText.includes('dodge the') || embedText.includes('went hunting') || embedText.includes('your aim was so bad') || embedText.includes('animals laughed') || embedText.includes('animals attacked') || embedText.includes('barely escaped') || embedText.includes('fell asleep in a tree') || embedText.includes('caught nothing') || embedText.includes('brought back literally nothing') || embedText.includes('rifle broke') || embedText.includes('imagine going into the woods')) return 'hunt';
+  if (embedText.includes('digging') || embedText.includes('you dig') || embedText.includes('dug in the dirt') || embedText.includes('found nothing while') || embedText.includes('what are the odds lol') || embedText.includes('brought back') && (embedText.includes('ant') || embedText.includes('worm') || embedText.includes('stickbug') || embedText.includes('ladybug'))) return 'dig';
   // Work — match both minigame prompt AND completion
   if (embedText.includes('work') && (embedText.includes('shift') || embedText.includes('mini-game') || embedText.includes('color') || embedText.includes('what color') || embedText.includes('babysitter') || embedText.includes('great work') || embedText.includes('for your shift'))) return 'work';
   if (embedText.includes('you were given') && embedText.includes('shift')) return 'work';
@@ -209,7 +207,7 @@ function detectCommand(d) {
   // Postmemes
   if (embedText.includes('pick a meme') || embedText.includes('meme posting')) return 'postmemes';
   // Stream
-  if (embedText.includes('stream manager') || embedText.includes('go live') || embedText.includes('what game do you want to stream') || embedText.includes('you ran an ad for') || (embedText.includes('you received') && embedText.includes('from your sponsors')) || (embedText.includes('### chat') && embedText.includes('hasanbabi'))) return 'stream';
+  if (embedText.includes('stream manager') || embedText.includes('go live') || embedText.includes('what game do you want to stream') || embedText.includes('you ran an ad for') || embedText.includes('you received') && embedText.includes('from your sponsors') || embedText.includes('### chat') && embedText.includes('hasanbabi')) return 'stream';
   if (embedText.includes('you can\'t interact with your stream') || embedText.includes('stream can last')) return 'stream';
   // Deposit
   if (embedText.includes('deposited') && embedText.includes('bank balance')) return 'deposit';
@@ -230,7 +228,7 @@ function detectCommand(d) {
   // Farm
   if (embedText.includes('farm') && (embedText.includes('harvest') || embedText.includes('plant') || embedText.includes('hoe') || embedText.includes('water'))) return 'farm';
   // Beg
-  if (embedText.includes('begging') || embedText.includes('wumpus gives you') || embedText.includes('life saver') || embedText.includes('lifesaver')) return 'beg';
+  if (embedText.includes('begging')) return 'beg';
   // Daily/weekly quest
   if (embedText.includes('daily quest')) return 'daily';
   // Fish

package/lib/structures.js

@@ -443,25 +443,6 @@ class MinHeap {
 
   peek() { return this.heap[0]; }
 
-  /**
-   * Remove a specific node from the heap by reference.
-   * Used by CommandScheduler.unschedule() to cancel a pending scheduled command.
-   * O(n) — linear scan since we store node references in a Map.
-   */
-  remove(node) {
-    const idx = this.heap.indexOf(node);
-    if (idx === -1) return false;
-    const last = this.heap.pop();
-    if (idx < this.heap.length) {
-      this.heap[idx] = last;
-      // Bubble up or sink down depending on where the removed item was
-      if (this._bubbleUp(idx) === idx) {
-        this._sinkDown(idx);
-      }
-    }
-    return true;
-  }
-
   _bubbleUp(i) {
     while (i > 0) {
       const parent = (i - 1) >>> 1;
@@ -699,6 +680,31 @@ class AsyncBatchQueue {
   destroy() { if (this._timer) clearTimeout(this._timer); this.queue.length = 0; }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// JitterBackoff – Decorrelated jitter (AWS-style), O(1)
+// Standard exponential backoff causes "thundering herd" when 10K
+// accounts retry simultaneously. Decorrelated jitter spreads them:
+//   sleep = min(cap, random_between(base, sleep_prev * 3))
+// This is the recommended strategy from AWS Architecture Blog.
+// ═══════════════════════════════════════════════════════════════
+class JitterBackoff {
+  constructor(baseMs = 1000, capMs = 30000) {
+    this.baseMs = baseMs;
+    this.capMs = capMs;
+    this._sleep = baseMs;
+    this.attempt = 0;
+  }
+
+  next() {
+    this._sleep = Math.min(this.capMs, this.baseMs + Math.random() * (this._sleep * 3 - this.baseMs));
+    this.attempt++;
+    return this._sleep;
+  }
+
+  reset() { this._sleep = this.baseMs; this.attempt = 0; }
+  get current() { return this._sleep; }
+}
+
 module.exports = {
   BloomFilter,
   LRUCache,
@@ -715,4 +721,5 @@ module.exports = {
   ObjectPool,
   TimerWheel,
   AsyncBatchQueue,
+  JitterBackoff,
 };

package/package.json

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