dankgrinder 6.39.0 → 6.45.0

package/lib/commands/beg.js

@@ -1,17 +1,20 @@
 /**
  * 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}>}
+ * @returns {Promise<{result: string, coins: number, lifeSaver?: boolean}>}
  */
 async function runBeg({ channel, waitForDankMemer }) {
   LOG.cmd(`${c.white}${c.bold}pls beg${c.reset}`);
@@ -33,11 +36,30 @@ async function runBeg({ channel, waitForDankMemer }) {
 
   logMsg(response, 'beg');
   const text = getFullText(response);
-  const coins = parseCoins(text);
+
+  // 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);
 
   if (coins > 0) {
-    LOG.coin(`[beg] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-    return { result: `beg → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`, coins };
+    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.info(`[beg] ${text.substring(0, 80).replace(RE_NEWLINE, ' ')}`);

package/lib/commands/fishVision.js

@@ -11,10 +11,27 @@ 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 => {
@@ -22,7 +39,16 @@ function downloadImage(url) {
         return downloadImage(res.headers.location).then(resolve, reject);
       }
       const chunks = [];
-      res.on('data', c => chunks.push(c));
+      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('end', () => resolve(Buffer.concat(chunks)));
       res.on('error', reject);
     });

package/lib/commands/index.js

@@ -13,7 +13,6 @@ 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');
@@ -23,7 +22,7 @@ const { runGeneric, runAlert } = require('./generic');
 const { runStream } = require('./stream');
 const { runDrops } = require('./drops');
 const { buyItem, ITEM_COSTS } = require('./shop');
-const { getPlayerLevel, meetsLevelRequirement } = require('./profile');
+const { getPlayerLevel, meetsLevelRequirement, runProfile } = require('./profile');
 const { runInventory, fetchItemValues, enrichItems, getCachedInventory, getAllInventories, updateInventoryItem, deleteInventoryItem } = require('./inventory');
 
 module.exports = {
@@ -39,7 +38,6 @@ module.exports = {
   runFish,
   sellAllFish,
   runPostMemes,
-  runScratch,
   runBlackjack,
   runTrivia,
   runWorkShift,
@@ -66,6 +64,7 @@ module.exports = {
   // Profile / Level
   getPlayerLevel,
   meetsLevelRequirement,
+  runProfile,
 
   // Constants
   SAFE_SEARCH_LOCATIONS,

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(10000);
+  let response = await waitForDankMemer(15000);
 
   if (!response) {
     LOG.warn('[inv] No response');

package/lib/commands/profile.js

@@ -1,49 +1,170 @@
+"use strict";
+
 /**
- * Profile level checker.
- * Send "pls profile", parse level, cache in Redis.
- * Used to gate commands like scratch (requires level 25).
+ * Profile command — parses Dank Memer `pls profile` responses.
+ * Extracts: level, XP, badges (emoji IDs), wallet/bank/net, items, commands, pets, showcase.
  */
 
 const {
-  LOG, c, getFullText, logMsg, isHoldTight, sleep,
+  LOG, c, getFullText, logMsg, isHoldTight, sleep, stripAnsi,
 } = require('./utils');
 
-// In-memory cache: { accountId: { level: number, checkedAt: timestamp } }
-const levelCache = {};
 const CACHE_TTL = 10 * 60 * 1000; // 10 minutes
 
-const RE_PROFILE_LEVEL = /(?:level|lvl)\s*:?\s*`?(\d+)`?/i;
-const RE_PROFILE_PRESTIGE_LEVEL = /prestige\s+\d+\s+level\s+`?(\d+)`?/i;
+// ── Regex patterns for each profile field ────────────────────────────────────
 
-/**
- * Parse level from profile response text.
- * Looks for patterns like "Level 25", "Lvl 25", "level: 25"
- */
-function parseLevelFromText(text) {
-  const match = text.match(RE_PROFILE_LEVEL);
-  if (match) return parseInt(match[1]);
-  const presMatch = text.match(RE_PROFILE_PRESTIGE_LEVEL);
-  if (presMatch) return parseInt(presMatch[1]);
-  return null;
+// "Level: `73`" or "Level: Level: `73`"
+const RE_LEVEL = /(?:global\s+)?level[:\s]+[`'"]?(\d+)[`'"]?/i;
+
+// "Experience: `69/100`"
+const RE_XP = /experience[:\s]+`?(\d+)\s*\/\s*(\d+)`?/i;
+
+// Badges: "<:PB1C:123456789>..." (custom Discord emojis)
+const RE_BADGE = /<a?:(\w+):(\d+)>/g;
+
+// "Wallet: `⏣ 3.2M`"
+const RE_WALLET = /wallet[:\s]+[`⏣]?\s*([\d,.KMB]+(?:[KMB])?(?:\.\d+[KMB])?)/i;
+const RE_BANK   = /bank[:\s]+[`⏣]?\s*([\d,.KMB]+(?:[KMB])?(?:\.\d+[KMB])?)/i;
+const RE_NET    = /net[:\s]+[`⏣]?\s*([\d,.KMB]+(?:[KMB])?(?:\.\d+[KMB])?)/i;
+
+// "Items: Unique: `70`\nTotal: `766`\nWorth: `⏣ 31M`"
+const RE_ITEMS_UNIQUE  = /unique[:\s]+[`']?(\d+)[`']?/i;
+const RE_ITEMS_TOTAL   = /total[:\s]+[`']?(\d+)[`']?/i;
+const RE_ITEMS_WORTH   = /worth[:\s]+[`⏣]?\s*([\d,.KMB]+(?:[KMB])?(?:\.\d+[KMB])?)/i;
+
+// "Commands: Total: `5.1K`\nFavorite: `hunt`"
+const RE_CMDS_TOTAL    = /(?:total\s+)?commands?[:\s]+[`']?([\d,.KMB]+(?:[KMB])?(?:\.\d+[KMB])?)[`']?/i;
+const RE_FAVORITE      = /favorite[:\s]+[`']?(\w+)[`']?/i;
+
+// Pets: "Pets: <:Rock:861584585250308106> **Rock**\n`Level 1 Rock`"
+const RE_PET_BLOCK = /pets[:\s]*((?:<a?:\w+:\d+>\s*\*+\*?\*?\*?\s*(?:[\w ]+)\*+\s*`[^`]+`\s*)+)/gi;
+const RE_PET_ENTRY = /<a?:(\w+):(\d+)>[\s\*]*([\w ]+?)[\s\*]*`([^`]+)`/gi;
+
+// Showcase: "Showcase: ..." or "Showcase: No showcase"
+const RE_SHOWCASE = /showcase[:\s]*(.+?)(?:\n|$)/i;
+
+// ── Coin number parser ───────────────────────────────────────────────────────
+
+function parseCoinNum(str) {
+  if (!str) return 0;
+  str = str.replace(/[⏣,\s]/g, '').toUpperCase();
+  const m = parseFloat(str);
+  if (isNaN(m)) return 0;
+  if (str.includes('B')) return Math.round(m * 1_000_000_000);
+  if (str.includes('M')) return Math.round(m * 1_000_000);
+  if (str.includes('K')) return Math.round(m * 1_000);
+  return Math.round(m);
 }
 
+// ── Badge extraction ──────────────────────────────────────────────────────────
+
+function parseBadges(text) {
+  const badges = [];
+  let m;
+  const re = /<a?:([^>]+):(\d+)>/g;
+  while ((m = re.exec(text)) !== null) {
+    badges.push({ name: m[1], emojiId: m[2] });
+  }
+  return badges;
+}
+
+// ── Pet extraction ────────────────────────────────────────────────────────────
+
+function parsePets(text) {
+  const pets = [];
+  let m;
+  // Match: emoji + bold name + level line
+  // e.g. "<:Rock:861584585250308106> **Rock**\n`Level 1 Rock`"
+  const re = /<a?:(\w+):(\d+)>\s*\*\*([^\*]+)\*\*\s*`([^`]+)`/gi;
+  while ((m = re.exec(text)) !== null) {
+    pets.push({
+      emojiName: m[1],
+      emojiId: m[2],
+      name: m[3].trim(),
+      level: m[4].trim(),
+    });
+  }
+  return pets;
+}
+
+// ── Main parse function ──────────────────────────────────────────────────────
+
 /**
- * Check player level. Returns cached value if fresh, otherwise sends "pls profile".
- * @param {object} opts
- * @param {object} opts.channel
- * @param {function} opts.waitForDankMemer
- * @param {string} [opts.accountId] - for cache key
- * @param {object} [opts.redis] - Redis client for persistent cache
- * @returns {Promise<number|null>} Level number or null if can't determine
+ * Parse all profile fields from Dank Memer `pls profile` response.
+ * @param {object} msg - Discord message (or partial with embeds)
+ * @returns {object} Parsed profile data
  */
+function parseProfile(msg) {
+  const text = getFullText(msg);
+
+  // Level
+  let level = null;
+  const levelMatch = text.match(RE_LEVEL);
+  if (levelMatch) level = parseInt(levelMatch[1], 10);
+
+  // XP
+  let xpCurrent = null, xpMax = null;
+  const xpMatch = text.match(RE_XP);
+  if (xpMatch) {
+    xpCurrent = parseInt(xpMatch[1], 10);
+    xpMax = parseInt(xpMatch[2], 10);
+  }
+
+  // Coins
+  const wallet = parseCoinNum((text.match(RE_WALLET) || [])[1]);
+  const bank   = parseCoinNum((text.match(RE_BANK)   || [])[1]);
+  const net    = parseCoinNum((text.match(RE_NET)    || [])[1]);
+
+  // Items
+  const itemsUnique = parseInt((text.match(RE_ITEMS_UNIQUE) || [])[1], 10) || 0;
+  const itemsTotal  = parseInt((text.match(RE_ITEMS_TOTAL)  || [])[1], 10) || 0;
+  const itemsWorth = parseCoinNum((text.match(RE_ITEMS_WORTH) || [])[1]);
+
+  // Commands
+  const cmdsTotal  = (text.match(RE_CMDS_TOTAL) || [])[1] || '0';
+  const favorite   = ((text.match(RE_FAVORITE) || [])[1] || '').trim().toLowerCase();
+
+  // Badges
+  const badges = parseBadges(text);
+
+  // Pets
+  const pets = parsePets(text);
+
+  // Showcase
+  const showcaseRaw = (text.match(RE_SHOWCASE) || [])[1] || '';
+  const showcase = showcaseRaw.toLowerCase().includes('no showcase')
+    ? []
+    : showcaseRaw.split('\n').filter(l => l.trim()).map(l => l.trim().replace(/^\*\*|\*\*$/g, ''));
+
+  return {
+    level,
+    xpCurrent,
+    xpMax,
+    wallet,
+    bank,
+    net,
+    itemsUnique,
+    itemsTotal,
+    itemsWorth,
+    cmdsTotal,
+    favorite,
+    badges,
+    pets,
+    showcase,
+    rawText: text.substring(0, 2000),
+    parsedAt: Date.now(),
+  };
+}
+
+// ── In-memory cache ─────────────────────────────────────────────────────────
+
+const levelCache = {};
+
 async function getPlayerLevel({ channel, waitForDankMemer, accountId = 'default', redis }) {
-  // Check in-memory cache first
   const cached = levelCache[accountId];
   if (cached && (Date.now() - cached.checkedAt) < CACHE_TTL) {
     return cached.level;
   }
-
-  // Check Redis cache
   if (redis) {
     try {
       const redisLevel = await redis.get(`dkg:level:${accountId}`);
@@ -54,48 +175,75 @@ async function getPlayerLevel({ channel, waitForDankMemer, accountId = 'default'
       }
     } catch {}
   }
-
-  // Fetch from Discord
-  LOG.debug('[profile] Checking level...');
   await channel.send('pls profile');
   const response = await waitForDankMemer(8000);
+  if (!response) { LOG.warn('[profile] No response'); return null; }
+  if (isHoldTight(response)) { await sleep(5000); return null; }
+  logMsg(response, 'profile');
+  const parsed = parseProfile(response);
+  if (parsed.level !== null) {
+    levelCache[accountId] = { level: parsed.level, checkedAt: Date.now() };
+    if (redis) {
+      const ttl = parsed.level >= 25 ? 2592000 : 600;
+      try { await redis.set(`dkg:level:${accountId}`, String(parsed.level), 'EX', ttl); } catch {}
+    }
+  }
+  return parsed.level;
+}
 
+/**
+ * Run full profile check, parse all fields, and return structured data.
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} [opts.accountId]
+ * @param {object} [opts.redis]
+ * @returns {Promise<object>} Parsed profile data
+ */
+async function runProfile({ channel, waitForDankMemer, accountId = 'default', redis }) {
+  LOG.cmd(`${c.white}${c.bold}pls profile${c.reset}`);
+  await channel.send('pls profile');
+  const response = await waitForDankMemer(8000);
   if (!response) {
     LOG.warn('[profile] No response');
-    return null;
+    return { error: 'no_response' };
   }
-
   if (isHoldTight(response)) {
-    await sleep(5000);
-    return null;
+    LOG.warn('[profile] Hold Tight');
+    await sleep(30000);
+    return { error: 'hold_tight' };
   }
-
   logMsg(response, 'profile');
-  const text = getFullText(response);
-  const level = parseLevelFromText(text);
+  const parsed = parseProfile(response);
 
-  if (level !== null) {
-    LOG.info(`[profile] Level: ${c.bold}${level}${c.reset}`);
-    levelCache[accountId] = { level, checkedAt: Date.now() };
-    // Persist to Redis — longer TTL for higher levels since they only go up
+  if (parsed.level !== null) {
+    levelCache[accountId] = { level: parsed.level, checkedAt: Date.now() };
     if (redis) {
-      const ttl = level >= 25 ? 2592000 : 600; // 30 days if ≥25, 10 min otherwise
-      try { await redis.set(`dkg:level:${accountId}`, String(level), 'EX', ttl); } catch {}
+      const ttl = parsed.level >= 25 ? 2592000 : 600;
+      try { await redis.set(`dkg:level:${accountId}`, String(parsed.level), 'EX', ttl); } catch {}
+      try {
+        await redis.set(`dkg:profile:${accountId}`, JSON.stringify(parsed), 'EX', CACHE_TTL / 1000);
+      } catch {}
     }
-  } else {
-    LOG.warn(`[profile] Could not parse level from: ${text.substring(0, 100)}`);
   }
 
-  return level;
+  LOG.info(`[profile] Level ${parsed.level} · ⏣ ${parsed.wallet?.toLocaleString() || 0} wallet · ⏣ ${parsed.net?.toLocaleString() || 0} net`);
+  return parsed;
 }
 
-/**
- * Check if player meets minimum level requirement.
- */
 async function meetsLevelRequirement(opts, minLevel) {
   const level = await getPlayerLevel(opts);
-  if (level === null) return false; // can't determine, skip
+  if (level === null) return false;
   return level >= minLevel;
 }
 
-module.exports = { getPlayerLevel, meetsLevelRequirement, parseLevelFromText };
+module.exports = {
+  getPlayerLevel,
+  meetsLevelRequirement,
+  parseLevelFromText: (text) => parseProfile({ content: text, embeds: [] }).level,
+  runProfile,
+  parseProfile,
+  parseCoinNum,
+  parseBadges,
+  parsePets,
+};

package/lib/commands/utils.js

@@ -558,7 +558,8 @@ 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 nonce = `${BigInt(Date.now() - 1420070400000) << 22n}`;
+  const { randomUUID } = require('crypto');
+  const nonce = randomUUID();
   const payloadObj = {
     type: 3,
     application_id: String(msg.applicationId || DANK_MEMER_ID),
@@ -603,7 +604,8 @@ 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 nonce = `${BigInt(Date.now() - 1420070400000) << 22n}`;
+  const { randomUUID } = require('crypto');
+  const nonce = randomUUID();
   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, JitterBackoff,
+  AhoCorasick, LRUCache, StringPool, AsyncBatchQueue,
 } = 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 = content.replace(/\x1b\[[0-9;]*m/g, '');
+  const stripped = stripAnsi(content);
   const pad = Math.max(0, w - 4 - stripped.length);
-  return color + BOX.dv + c.reset + ' ' + content + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
+  return color + BOX.dv + c.reset + ' ' + stripAnsi(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', weekly: 'Weekly', monthly: 'Monthly',
-  scratch: 'Scratch', adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
+  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', monthly: 'Monthly',
+  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,7 +1490,9 @@ class AccountWorker {
                 totalValue: result.totalValue || 0,
               }),
             });
-          } catch {}
+          } catch (err) {
+            console.error(`[${this.username}] inventory API error:`, err?.message || err);
+          }
 
           return {
             ok: true,
@@ -1524,6 +1526,60 @@ class AccountWorker {
     }
   }
 
+  // ── Profile Check ────────────────────────────────────────────
+  async checkProfile(silent = false) {
+    try {
+      const result = await commands.runProfile({
+        channel: this.channel,
+        waitForDankMemer: (t) => this.waitForDankMemer(t),
+        accountId: this.account.id,
+        redis,
+      });
+
+      if (result.error) {
+        if (!silent) this.log('warn', `[profile] Check failed: ${result.error}`);
+        return result;
+      }
+
+      if (!silent) {
+        this.log('info', `[profile] Level ${result.level} · ⏣ ${(result.wallet || 0).toLocaleString()} wallet · ⏣ ${(result.net || 0).toLocaleString()} net`);
+      }
+
+      // Push to web dashboard via grinder status endpoint
+      try {
+        await fetch(`${API_URL}/api/grinder/profile`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            account_id: this.account.id,
+            level: result.level,
+            xp_current: result.xpCurrent,
+            xp_max: result.xpMax,
+            wallet: result.wallet,
+            bank: result.bank,
+            net: result.net,
+            items_unique: result.itemsUnique,
+            items_total: result.itemsTotal,
+            items_worth: result.itemsWorth,
+            cmds_total: result.cmdsTotal,
+            favorite: result.favorite,
+            badges: result.badges || [],
+            pets: result.pets || [],
+            showcase: result.showcase || [],
+            raw_text: result.rawText || '',
+          }),
+        });
+      } catch (err) {
+        console.error(`[${this.username}] profile API error:`, err?.message || err);
+      }
+
+      return { ok: true, ...result };
+    } catch (e) {
+      if (!silent) this.log('warn', `[profile] Check error: ${e.message}`);
+      return { ok: false, error: e.message };
+    }
+  }
+
   async checkBalance(silent = false) {
     const prefix = this.account.use_slash ? '/' : 'pls';
     const sentAt = Date.now();
@@ -1724,22 +1780,48 @@ class AccountWorker {
   // Each modular command handler sends the command, waits for response,
   // handles Hold Tight / cooldowns / item-buying internally.
   async runCommand(cmdName, prefix) {
-    let cmdString;
+    // 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'],
+    ]);
     const bjBet = Math.max(5000, this.account.bet_amount || 5000);
     const gambBet = Math.max(10000, this.account.bet_amount || 10000);
 
-    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}`;
+    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}`;
+      }
     }
 
     if (shutdownCalled || !this.running) return;
@@ -1837,7 +1919,6 @@ 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;
@@ -1892,7 +1973,9 @@ class AccountWorker {
             headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
             body: JSON.stringify({ account_id: this.account.id, active: false }),
           });
-        } catch {}
+        } catch (err) {
+          console.error(`[${this.username}] status deactivation API error:`, err?.message || err);
+        }
         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;
@@ -1943,16 +2026,6 @@ 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') ||
@@ -1971,8 +2044,9 @@ class AccountWorker {
         const timeMatch = result.match(/<t:(\d+):R>/);
         let waitSec;
         if (timeMatch) {
-          const nextAvail = parseInt(timeMatch[1]) * 1000;
-          waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
+          // 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]));
         } else {
           const defaultWaits = { daily: 86400, weekly: 604800, monthly: 2592000 };
           waitSec = defaultWaits[cmdName] || 86400;
@@ -2152,13 +2226,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/weekly/monthly — never miss),
+  //   10 = time-gated (daily/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/scratch),
+  //    3 = interactive/long CD (adventure/stream/work),
   //    2 = utility (drops/use/tidy)
   static COMMAND_MAP = [
     // Gambling — 2-3s CD, highest frequency
@@ -2169,7 +2243,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
@@ -2180,20 +2254,19 @@ 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 },
-    // scratch removed — requires voting which can't be automated
-  { 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 },
+    { 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 },
-    // weekly removed — premium only, not available for free users
-    { key: 'cmd_monthly',   cmd: 'monthly',     cdKey: 'cd_monthly',   defaultCd: 2592000,priority: 10 },
+    { 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 },
     // 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);
 
@@ -2470,91 +2543,58 @@ class AccountWorker {
       return;
     }
 
-    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;
-    }
-
-    const item = this.commandQueue.pop();
-    if (!item) {
-      this.tickTimeout = setTimeout(() => this.tick(), 1000);
-      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 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;
+    // Re-insert waiting items back into the queue (they still have time to wait)
+    for (const item of waitingItems) {
+      this.commandQueue.push(item);
     }
 
-    // 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 {}
+    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;
       }
-    }
-
-    // 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);
+      this.setStatus('cooldown...');
+      this.tickTimeout = setTimeout(() => this.tick(), Math.max(100, Math.min(minWaitMs, 5000)));
       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');
-    }
 
-    // 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;
+    // 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];
+
+    // 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]);
     }
 
-    this._cmdRate.increment();
-    this.busy = true;
+    // Anti-detection: per-account jitter + micro-pauses for this command
     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;
 
@@ -2566,6 +2606,32 @@ 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));
 
@@ -2579,15 +2645,40 @@ class AccountWorker {
       next_run_at: nextItemRun?.nextRunAt || null,
     });
 
-    const beforeCoins = this.stats.coins;
-    await this.runCommand(item.cmd, prefix);
-    const earned = this.stats.coins - beforeCoins;
+    // 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();
 
-    // 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)) {
+    // Grace period for interactive commands — Dank Memer needs time to process
+    // the interaction before accepting the next command.
+    if (isInteractive) {
       await new Promise(r => setTimeout(r, 2500 + Math.random() * 1500));
     }
 
@@ -2605,8 +2696,6 @@ 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
@@ -2678,6 +2767,11 @@ 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();
@@ -2781,11 +2875,28 @@ class AccountWorker {
                 headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
                 body: JSON.stringify({ action_id: action.id }),
               });
-            } catch {}
+            } catch (err) {
+              console.error(`[${this.username}] delete pending action error:`, err?.message || err);
+            }
+          }
+          if (action.action === 'check_profile' && !this.busy) {
+            this.log('info', 'Dashboard requested profile check');
+            await this.checkProfile().catch(() => {});
+            try {
+              await fetch(`${API_URL}/api/grinder/actions`, {
+                method: 'DELETE',
+                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 { /* silent */ }
+    } catch (err) {
+      console.error(`[${this.username}] refreshConfig error:`, err?.message || err);
+    }
   }
 
   async start() {
@@ -2835,9 +2946,8 @@ 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_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_daily', l: 'daily' }, { key: 'cmd_monthly', l: 'monthly' },
+          { key: 'cmd_work', l: 'work' }, { key: 'cmd_stream', l: 'stream' },
           { 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' },
@@ -3062,19 +3172,38 @@ async function start(apiKey, apiUrl) {
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
     rawLogger.init(REDIS_URL).catch(() => {});
-    // Listen for DM death events across all accounts
+    // Live DM listener: detect deaths and level-ups in real-time across all accounts
     rawLogger.onDmEvent((event, raw) => {
-      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);
+      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);
           }
         }
-        sendWebhook?.('DEATH ALERT (DM)', `Account died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
+      } 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}.`);
+        }
       }
     });
     checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}RawLog${c.reset}`);
@@ -3282,7 +3411,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: 3, silent: true }); }
+    try { invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 5, silent: true }); }
     catch { invRes = { ok: false }; }
     invPending--;
     const items = invRes?.ok ? (invRes.result?.items?.length || 0) : 0;

package/lib/rawLogger.js

@@ -151,24 +151,26 @@ 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')) 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('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('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';
-  if (cv2Text.includes('inventory')) return 'inventory';
+  // 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('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')) return 'hunt';
-  if (contentText.includes('imagine going into the woods')) return 'hunt';
+  if (contentText.includes('your aim was so bad') || contentText.includes('animals laughed') || 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')) return 'dig';
+  if (contentText.includes('you dug in the dirt') || (contentText.includes('found nothing while digging') && (contentText.includes('dug') || contentText.includes('dirt')))) return 'dig';
 
   // Check embed text
   const embedText = extractEmbedText(d.embeds).toLowerCase();
@@ -197,8 +199,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')) 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') || (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';
   // 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';
@@ -207,7 +209,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';
@@ -228,7 +230,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')) return 'beg';
+  if (embedText.includes('begging') || embedText.includes('wumpus gives you') || embedText.includes('life saver') || embedText.includes('lifesaver')) return 'beg';
   // Daily/weekly quest
   if (embedText.includes('daily quest')) return 'daily';
   // Fish

package/lib/structures.js

@@ -443,6 +443,25 @@ 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;
@@ -680,31 +699,6 @@ 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,
@@ -721,5 +715,4 @@ module.exports = {
   ObjectPool,
   TimerWheel,
   AsyncBatchQueue,
-  JitterBackoff,
 };

package/package.json

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

package/lib/commands/scratch.js

@@ -1,83 +0,0 @@
-/**
- * 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 };