dankgrinder 8.100.0 → 8.101.0

package/lib/commands/adventure.js

@@ -36,7 +36,7 @@
 const {
   LOG, c, sleep, humanDelay, getFullText, parseCoins,
   getAllButtons, getAllSelectMenus, findButton,
-  safeClickButton, isHoldTight, logMsg,
+  safeClickButton, isHoldTight, logMsg, checkLevelLock,
 } = require('./utils');
 
 const RE_DISCORD_TIMESTAMP = /<t:(\d+)(?::[tTdDfFR])?>/g;
@@ -279,6 +279,10 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
     return { result: 'hold tight', coins: 0, nextCooldownSec: 35 };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'adventure');
+  if (lvLock) return lvLock;
+
   logMsg(response, 'adventure-initial');
 
   const text = getFullText(response);

package/lib/commands/beg.js

@@ -3,7 +3,7 @@
  * Simple command: send "pls beg", parse coins from response.
  */
 
-const { LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep } = require('./utils');
+const { LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep, checkLevelLock } = require('./utils');
 
 const RE_NEWLINE = /\n/g;
 
@@ -31,6 +31,10 @@ async function runBeg({ channel, waitForDankMemer }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'beg');
+  if (lvLock) return lvLock;
+
   logMsg(response, 'beg');
   const text = getFullText(response);
   const coins = parseCoins(text);

package/lib/commands/blackjack.js

@@ -6,7 +6,7 @@
 
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2, checkLevelLock,
 } = require('./utils');
 
 const RE_BACKTICK_SCORE = /`\s*(\d+)\s*`/;
@@ -154,6 +154,10 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(current, 'bj');
+  if (lvLock) return lvLock;
+
   logMsg(current, 'bj');
 
   const MAX_ROUNDS = 10;

package/lib/commands/crime.js

@@ -11,7 +11,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
-  isCV2, ensureCV2,
+  isCV2, ensureCV2, checkLevelLock,
 } = require('./utils');
 const { Trie, VoseAlias, LRUCache } = require('../structures');
 
@@ -101,6 +101,10 @@ async function runCrime({ channel, waitForDankMemer, safeAnswers }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'crime');
+  if (lvLock) return lvLock;
+
   if (isCV2(response)) await ensureCV2(response);
   logMsg(response, 'crime');
   let buttons = getAllButtons(response);

package/lib/commands/dig.js

@@ -6,7 +6,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton, humanDelay,
   logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
-  isCV2, ensureCV2, stripAnsi,
+  isCV2, ensureCV2, stripAnsi, checkLevelLock,
 } = require('./utils');
 const { buyItem } = require('./shop');
 
@@ -111,6 +111,10 @@ async function runDig({ channel, waitForDankMemer, client }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'dig');
+  if (lvLock) return lvLock;
+
   if (isCV2(response)) await ensureCV2(response);
   logMsg(response, 'dig');
   const text = getFullText(response);

package/lib/commands/farm.js

@@ -1,7 +1,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
   safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
-  isCV2, ensureCV2, stripAnsi, needsItem, clickCV2SelectMenu,
+  isCV2, ensureCV2, stripAnsi, needsItem, clickCV2SelectMenu, checkLevelLock,
 } = require('./utils');
 const { buyItem, buyItemsBatch } = require('./shop');
 const rawLogger = require('../../lib/rawLogger');
@@ -1317,7 +1317,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
 
   let text = getFullText(response);
   let clean = brief(text, 600);
-  const lower = clean.toLowerCase();
+  let lower = clean.toLowerCase();
 
   // Subcommand required — retry once.
   if (lower.includes('must specify a subcommand')) {
@@ -1331,8 +1331,13 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
     logFarmState('retry-view', response);
     text = getFullText(response);
     clean = brief(text, 600);
+    lower = clean.toLowerCase();
   }
 
+  // Level-locked detection parity with other handlers (pm/hl/etc).
+  const lvLock = await checkLevelLock(response, 'farm');
+  if (lvLock) return lvLock;
+
   const cd = parseFarmCooldownSec(text);
   if (cd || lower.includes('already farmed') || lower.includes('farm again') || lower.includes('on cooldown')) {
     return { result: `farm cooldown (${Math.ceil((cd || 10) / 60)}m)`, coins: 0, nextCooldownSec: cd || 10 };

package/lib/commands/fish.js

@@ -17,7 +17,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
-  isCV2, ensureCV2,
+  isCV2, ensureCV2, checkLevelLock,
 } = require('./utils');
 const { downloadImage, extractImageUrl, findSafeCells } = require('./fishVision');
 
@@ -319,6 +319,10 @@ async function runFish({ channel, waitForDankMemer }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'fish');
+  if (lvLock) return lvLock;
+
   logMsg(response, 'fish');
   const text = getFullText(response);
 

package/lib/commands/gamble.js

@@ -11,7 +11,7 @@
 
 const {
   LOG, c, getFullText, parseCoins, parseNetCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2, checkLevelLock,
 } = require('./utils');
 const { EMA, AhoCorasick, SlidingWindowCounter } = require('../structures');
 
@@ -108,6 +108,11 @@ async function commonChecks(response, cmdName) {
     return { skip: true, ret: { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason } };
   }
   const text = getFullText(response);
+
+  // Level-locked detection — uses shared helper
+  const lvLock = await checkLevelLock(response, cmdName);
+  if (lvLock) return { skip: true, ret: lvLock };
+
   const minBet = checkMinBet(text);
   if (minBet !== 0) {
     const val = minBet > 0 ? minBet : 0;

package/lib/commands/highlow.js

@@ -6,7 +6,7 @@
 
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep,
+  logMsg, isHoldTight, getHoldTightReason, sleep, checkLevelLock,
 } = require('./utils');
 
 const RE_HINT_BOLD = /hint.*?\*\*(\d+)\*\*/i;
@@ -144,6 +144,10 @@ async function runHighLow({ channel, waitForDankMemer }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'hl');
+  if (lvLock) return lvLock;
+
   logMsg(response, 'hl');
   const { result, coins, lost } = await playHighLow(response);
 

package/lib/commands/hunt.js

@@ -7,7 +7,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
-  isCV2, ensureCV2, stripAnsi,
+  isCV2, ensureCV2, stripAnsi, checkLevelLock,
 } = require('./utils');
 const { buyItem } = require('./shop');
 
@@ -95,6 +95,10 @@ async function runHunt({ channel, waitForDankMemer, client }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, needsRifle: false, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'hunt');
+  if (lvLock) return lvLock;
+
   if (isCV2(response)) await ensureCV2(response);
   logMsg(response, 'hunt');
   const text = getFullText(response);

package/lib/commands/postmemes.js

@@ -15,7 +15,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
   findButton, safeClickButton, logMsg, isHoldTight, getHoldTightReason,
-  sleep, humanDelay,
+  sleep, humanDelay, checkLevelLock,
 } = require('./utils');
 
 const RE_COOLDOWN_MIN = /(\d+)\s*minute/i;
@@ -52,6 +52,10 @@ async function runPostMemes({ channel, waitForDankMemer }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'pm');
+  if (lvLock) return lvLock;
+
   logMsg(response, 'pm');
 
   // Check for cooldown or direct text response (no select menus)

package/lib/commands/scratch.js

@@ -6,7 +6,7 @@
 
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, checkLevelLock,
 } = require('./utils');
 const { meetsLevelRequirement } = require('./profile');
 
@@ -42,6 +42,10 @@ async function runScratch({ channel, waitForDankMemer, accountId, redis }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'scratch');
+  if (lvLock) return lvLock;
+
   logMsg(response, 'scratch');
   const buttons = getAllButtons(response);
 

package/lib/commands/search.js

@@ -11,7 +11,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
-  isCV2, ensureCV2,
+  isCV2, ensureCV2, checkLevelLock,
 } = require('./utils');
 const { VoseAlias, Trie, EMA, LRUCache } = require('../structures');
 
@@ -99,6 +99,10 @@ async function runSearch({ channel, waitForDankMemer, safeAnswers }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'search');
+  if (lvLock) return lvLock;
+
   if (isCV2(response)) await ensureCV2(response);
   logMsg(response, 'search');
   let buttons = getAllButtons(response);

package/lib/commands/stream.js

@@ -1,7 +1,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
   safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, needsItem,
-  isCV2, ensureCV2, stripAnsi, clickCV2Button,
+  isCV2, ensureCV2, stripAnsi, clickCV2Button, checkLevelLock,
 } = require('./utils');
 const { buyItem } = require('./shop');
 
@@ -209,6 +209,10 @@ async function runStream({ channel, waitForDankMemer, client }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason, nextCooldownSec: 30 };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'stream');
+  if (lvLock) return lvLock;
+
   await hydrate(response);
   logMsg(response, 'stream');
   let text = getFullText(response);

package/lib/commands/trivia.js

@@ -9,7 +9,7 @@
 
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, checkLevelLock,
 } = require('./utils');
 
 const RE_TRIVIA_MD_BOLD = /\*\*/g;
@@ -94,6 +94,10 @@ async function runTrivia({ channel, waitForDankMemer, redis }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(response, 'trivia');
+  if (lvLock) return lvLock;
+
   logMsg(response, 'trivia');
   const buttons = getAllButtons(response);
 

package/lib/commands/utils.js

@@ -703,6 +703,58 @@ function needsItem(text) {
   return match;
 }
 
+// ── Level-Lock Detection (shared across ALL command handlers) ─
+// Dank Memer replies "You have not unlocked this feature yet!"
+// with the required level (e.g. "Level 5"). This helper checks
+// the response text and returns early if the command is gated.
+//
+// CRITICAL: The "not unlocked" message is almost always a CV2 message
+// (Components V2, flags & 32768). getFullText() returns empty for CV2
+// unless ensureCV2() has been called first to hydrate _cv2text.
+// We also check rawLogger as a secondary source since it captures
+// the raw gateway data including CV2 component text.
+const RE_LEVEL_NUM = /level\s*(\d+)/i;
+
+async function checkLevelLock(response, cmdName) {
+  if (!response) return null;
+
+  // 1. Hydrate CV2 if needed so getFullText() has content
+  if (isCV2(response)) {
+    try { await ensureCV2(response); } catch (e) { /* best effort */ }
+  }
+
+  // 2. Primary: getFullText (works for both embed and CV2 messages)
+  let text = getFullText(response);
+
+  // 3. Secondary: rawLogger captures gateway data for CV2 messages
+  //    that ensureCV2 might have missed (timing, cache)
+  try {
+    const chId = response.channelId || response.channel?.id;
+    if (chId) {
+      const raw = rawLogger.getLastRaw(chId);
+      if (raw) {
+        const rawText = (raw.content || '') + ' ' + (raw.cv2Text || '') + ' ' + (raw.embedText || '');
+        text = text + ' ' + rawText;
+      }
+    }
+    // Also try by message ID
+    const rawById = rawLogger.getRawMessage(response.id);
+    if (rawById) {
+      const rawText2 = (rawById.content || '') + ' ' + (rawById.cv2Text || '') + ' ' + (rawById.embedText || '');
+      text = text + ' ' + rawText2;
+    }
+  } catch (e) { /* rawLogger not available in tests */ }
+
+  const lower = text.toLowerCase();
+  if (lower.includes('not unlocked') || lower.includes('have not unlocked')) {
+    const lvMatch = text.match(RE_LEVEL_NUM);
+    const targetLv = lvMatch ? parseInt(lvMatch[1]) : 5;
+    LOG.warn(`[${cmdName}] LEVEL LOCKED — requires Level ${targetLv} quests`);
+    return { result: `level locked (L${targetLv})`, coins: 0, levelLocked: targetLv };
+  }
+  return null;
+}
+
 module.exports = {
   DANK_MEMER_ID,
   c,
@@ -729,6 +781,7 @@ module.exports = {
   ensureCV2,
   clickCV2Button,
   clickCV2SelectMenu,
+  checkLevelLock,
   // Shared structures and optimized constants
   strings,
   cv2Cache,

package/lib/commands/work.js

@@ -18,7 +18,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
-  isCV2, ensureCV2, stripAnsi,
+  isCV2, ensureCV2, stripAnsi, checkLevelLock,
 } = require('./utils');
 
 const RE_MEMORY_BACKTICK_CHUNK = /`([^`]+)`/g;
@@ -421,6 +421,10 @@ async function runWorkShift({ channel, waitForDankMemer }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason, nextCooldownSec: 30 };
   }
 
+  // Level-lock detection — returns early if feature is gated
+  const lvLock = await checkLevelLock(current, 'work');
+  if (lvLock) return lvLock;
+
   if (isCV2(current)) await ensureCV2(current);
 
   logMsg(current, 'work');

package/lib/grinder.js

@@ -671,6 +671,7 @@ class AccountWorker {
     this._levelQuestQueue = [];
     this._levelQuestDone = new Set();
     this._questBetOverride = null;
+  this._lastCommandMeta = null;
     this._commandRunning = false;  // prevents grinding commands from overlapping with quest commands
     this._verifyLevelUnlock = null; // holds level to verify after quest completion
     this.commandQueue = null;
@@ -1385,6 +1386,7 @@ class AccountWorker {
   // Each modular command handler sends the command, waits for response,
   // handles Hold Tight / cooldowns / item-buying internally.
   async runCommand(cmdName, prefix) {
+    this._lastCommandMeta = { cmdName, nonPlay: false, spent: 0, earned: 0, holdTightReason: null, newMinBet: null, levelLocked: null };
     let cmdString;
     const bjBet = Math.max(5000, this.account.bet_amount || 5000);
     const gambBet = Math.max(10000, this.account.bet_amount || 10000);
@@ -1526,6 +1528,7 @@ class AccountWorker {
 
       // Rate limit detection — progressive backoff based on frequency
       if (resultLower.includes('slow down') || resultLower.includes('rate limit') || resultLower.includes('too fast')) {
+        this._lastCommandMeta.nonPlay = true;
         this._rateLimitHits++;
         // Progressive: 30s for first hit, then 60s, 120s, cap at 300s
         const cooldownSec = Math.min(30 * Math.pow(2, Math.min(this._rateLimitHits - 1, 3)), 300);
@@ -1546,11 +1549,12 @@ class AccountWorker {
         return;
       }
 
-      // Level-locked detection — check rawLogger (CV2/embed text) NOT just content
+      // Level-locked detection — check rawLogger (CV2/embed text) AND result text
       const raw = rawLogger.getLastRaw(this.channel?.id);
       const rawAllText = (raw?.content || '') + '\n' + (raw?.cv2Text || '') + '\n' + (raw?.embedText || '');
-      if (rawAllText.toLowerCase().includes('not unlocked')) {
-        const lvMatch = rawAllText.match(/level\s*(\d+)/i);
+      const allDetectionText = rawAllText + '\n' + result;
+      if (allDetectionText.toLowerCase().includes('not unlocked') || allDetectionText.toLowerCase().includes('have not unlocked')) {
+        const lvMatch = allDetectionText.match(/level\s*(\d+)/i);
         if (lvMatch) {
           const targetLv = parseInt(lvMatch[1]);
           cmdResult.levelLocked = targetLv;
@@ -1579,11 +1583,13 @@ class AccountWorker {
 
       // Min bet detection — "You can't bet less than 10,000" or "cannot bet less than ⏣ 5,000"
       if (resultLower.includes("can't bet less than") || resultLower.includes('cannot bet less than') || resultLower.includes('minimum bet')) {
+        this._lastCommandMeta.nonPlay = true;
         const betMatch = result.match(/less than\s*\*?\*?\s*[⏣o]?\s*([\d,]+)/i) || result.match(/(\d[\d,]+)/);
         if (betMatch) {
           const minBet = parseInt(betMatch[1].replace(/,/g, ''));
           if (minBet > 0) {
             this.account.bet_amount = minBet;
+            this._lastCommandMeta.newMinBet = minBet;
             this.log('info', `${cmdName} min bet raised → ⏣ ${minBet.toLocaleString()}`);
           }
         }
@@ -1591,6 +1597,8 @@ class AccountWorker {
       }
       // Also handle newMinBet from gamble handler
       if (cmdResult.newMinBet && cmdResult.newMinBet > (this.account.bet_amount || 0)) {
+        this._lastCommandMeta.nonPlay = true;
+        this._lastCommandMeta.newMinBet = cmdResult.newMinBet;
         this.account.bet_amount = cmdResult.newMinBet;
         this.log('info', `${cmdName} min bet raised → ⏣ ${cmdResult.newMinBet.toLocaleString()}`);
         return;
@@ -1676,6 +1684,8 @@ class AccountWorker {
 
       const earned = Math.max(0, cmdResult.coins || 0);
       const spent = Math.max(0, cmdResult.lost || 0);
+  this._lastCommandMeta.earned = earned;
+  this._lastCommandMeta.spent = spent;
       // Track net earnings (add wins, subtract losses)
       this.stats.coins += (earned - spent);
       if (cmdResult.nextCooldownSec) {
@@ -1719,6 +1729,8 @@ class AccountWorker {
 
       if (cmdResult.holdTightReason) {
         const reason = cmdResult.holdTightReason;
+        this._lastCommandMeta.nonPlay = true;
+        this._lastCommandMeta.holdTightReason = reason;
         const holdSec = 35;
         this.log('warn', `Hold Tight: /${reason} — ${holdSec}s global cooldown`);
         const reasonMap = { postmemes: 'pm', highlow: 'hl', blackjack: 'bj', 'work shift': 'work shift' };
@@ -1731,12 +1743,16 @@ class AccountWorker {
       // Detect level-locked command → start quest mode
       if (cmdResult.levelLocked) {
         const targetLv = cmdResult.levelLocked;
+        this._lastCommandMeta.nonPlay = true;
+        this._lastCommandMeta.levelLocked = targetLv;
         this.log('warn', `Command /${cmdName} is LOCKED at Level ${targetLv} — starting quest unlock flow`);
         if (this._startLevelQuests(targetLv)) {
           this.log('info', `[QUEST] Quest mode activated for Level ${targetLv} — grinding will resume after quests complete`);
         } else {
           this.log('warn', `[QUEST] Level ${targetLv} quests already done or not defined — grinding continues (may re-trigger)`);
         }
+        // Don't count as success — skip normal post-command processing
+        return;
       }
 
       this.stats.successes++;
@@ -1773,6 +1789,7 @@ class AccountWorker {
         } catch {}
       }
     } catch (err) {
+      this._lastCommandMeta.nonPlay = true;
       this.stats.errors++;
       this.log('error', `${cmdString} failed: ${err.message}`);
       await sendLog(this.username, cmdName, err.message, 'error');
@@ -1900,9 +1917,10 @@ class AccountWorker {
       { cmd: 'shop sell common coin 1', times: 2 },
     ],
     5: [
-      { cmd: 'slots',     times: 1, bet: 50000 },
-      { cmd: 'cointoss', times: 1, bet: 50000 },
-      { cmd: 'snakeeyes', times: 1, bet: 50000 },
+      // "Lose 50,000 coins in /slots" etc — loseTarget means keep playing until cumulative losses hit 50k
+      { cmd: 'slots',     loseTarget: 50000, bet: 10000, times: 50 },
+      { cmd: 'cointoss',  loseTarget: 50000, bet: 10000, times: 50 },
+      { cmd: 'snakeeyes', loseTarget: 50000, bet: 10000, times: 50 },
     ],
   };
 
@@ -1910,14 +1928,17 @@ class AccountWorker {
     if (this._levelQuestDone.has(targetLevel)) return false;
     const quests = AccountWorker.LEVEL_QUESTS[targetLevel];
     if (!quests || quests.length === 0) return false;
-    this._levelQuestQueue = quests.map(q => ({ ...q, level: targetLevel }));
+    this._levelQuestQueue = quests.map(q => ({ ...q, level: targetLevel, _lostSoFar: 0 }));
     this._levelQuestActive = true;
     this._questBetOverride = null;
     // Clear commandQueue so no stale grinding commands fire after quests finish
     this.commandQueue = null;
     this._commandRunning = false;  // cancel any in-flight grinding command
     this.log('info', `[QUEST] Level ${targetLevel} quests started — grinding PAUSED`);
-    const questList = this._levelQuestQueue.map(q => `"${q.cmd}" x${q.times}`).join(', ');
+    const questList = this._levelQuestQueue.map(q => {
+      if (q.loseTarget) return `"${q.cmd}" lose ⏣${q.loseTarget.toLocaleString()}`;
+      return `"${q.cmd}" x${q.times}`;
+    }).join(', ');
     this.log('info', `[QUEST] Quests: ${questList}`);
     return true;
   }
@@ -1959,7 +1980,8 @@ class AccountWorker {
       const ttlVal = ttlMap.get(key);
       if (Number.isFinite(ttlVal) && ttlVal > 0) {
         nextRunAt = now + ttlVal * 1000;
-        this._cooldownBloom.add(key);
+        // Bloom uses accountId:cmd keys (not Redis key format)
+        this._cooldownBloom.add(`${this.account.id}:${info.cmd}`);
         this.log('info', `Restored cooldown for ${info.cmd}: ${ttlVal}s remaining`);
       }
       heap.push({ cmd: info.cmd, nextRunAt, priority: info.priority, info });
@@ -2202,18 +2224,85 @@ class AccountWorker {
     // BLOCK: quest mode active — run quests only, no normal grinding
     if (this._levelQuestActive && this._levelQuestQueue.length > 0) {
       const quest = this._levelQuestQueue[0];
-      this._questBetOverride = quest.bet || null;
+      if (quest.loseTarget) {
+        const remaining = Math.max(0, quest.loseTarget - (quest._lostSoFar || 0));
+        const floorBet = quest._minBet || quest.bet || 1;
+        this._questBetOverride = Math.max(floorBet, remaining);
+      } else {
+        this._questBetOverride = quest.bet || null;
+      }
+      const questBetUsed = this._questBetOverride;
       const prefix = this.account.use_slash ? '/' : 'pls';
-      this.setStatus(`[L${quest.level}] QUEST ${quest.cmd} (${quest.times}x left)`);
-      this.lastStatus = `[L${quest.level}] ${quest.cmd}`;
+
+      if (quest.loseTarget) {
+        // Loss-target quest: keep playing until cumulative losses >= loseTarget
+        const remaining = quest.loseTarget - (quest._lostSoFar || 0);
+        this.setStatus(`[L${quest.level}] QUEST ${quest.cmd} — lose ⏣${remaining.toLocaleString()} more`);
+        this.lastStatus = `[L${quest.level}] ${quest.cmd} lose ${remaining}`;
+      } else {
+        this.setStatus(`[L${quest.level}] QUEST ${quest.cmd} (${quest.times}x left)`);
+        this.lastStatus = `[L${quest.level}] ${quest.cmd}`;
+      }
+
+      // Capture balance before the command
+      const balBefore = this.stats.balance || 0;
+
       this._commandRunning = true;
-      this.busy = true;  // also set busy so grinding tick path blocks while quest runs
+      this.busy = true;
       await this.runCommand(quest.cmd, prefix);
+    const questMeta = this._lastCommandMeta || {};
       this._commandRunning = false;
       this.busy = false;
       this._questBetOverride = null;
-      quest.times--;
-      if (quest.times <= 0) this._levelQuestQueue.shift();
+
+      // Determine if quest step is complete
+      let questStepDone = false;
+
+      if (quest.loseTarget) {
+        // Track cumulative loss from balance diff
+        const balAfter = this.stats.balance || 0;
+        const balLoss = Math.max(0, balBefore - balAfter);
+        const reportedLoss = Math.max(0, Number(questMeta.spent || 0));
+        let lostThisRound = Math.max(balLoss, reportedLoss);
+
+        const nonPlay = !!questMeta.nonPlay;
+        if (questMeta.newMinBet && Number.isFinite(questMeta.newMinBet) && questMeta.newMinBet > 0) {
+          quest._minBet = Math.max(quest._minBet || 1, questMeta.newMinBet);
+        }
+
+        // Fallback only for actual played rounds where parsed/observed loss was zero.
+        if (!nonPlay && lostThisRound === 0 && (questBetUsed || quest.bet)) {
+          lostThisRound = questBetUsed || quest.bet;
+        }
+
+        if (!nonPlay) {
+          quest._lostSoFar = (quest._lostSoFar || 0) + lostThisRound;
+        }
+
+        this.log('info', `[QUEST] ${quest.cmd} — lost ⏣${quest._lostSoFar.toLocaleString()} / ⏣${quest.loseTarget.toLocaleString()}`);
+        if (nonPlay) {
+          this.log('warn', `[QUEST] ${quest.cmd} non-play response — progress unchanged`);
+        }
+
+        if (quest._lostSoFar >= quest.loseTarget) {
+          questStepDone = true;
+          this.log('success', `[QUEST] ${quest.cmd} loss target reached! ⏣${quest._lostSoFar.toLocaleString()} lost`);
+        }
+
+        // Safety attempts decrement only when a playable round happened.
+        if (!nonPlay) quest.times--;
+        if (quest.times <= 0) {
+          questStepDone = true;
+          this.log('info', `[QUEST] ${quest.cmd} max attempts reached — moving on`);
+        }
+      } else {
+        // Normal times-based quest
+        quest.times--;
+        if (quest.times <= 0) questStepDone = true;
+      }
+
+      if (questStepDone) this._levelQuestQueue.shift();
+
       if (this._levelQuestQueue.length === 0) {
         this._levelQuestActive = false;
         this._levelQuestDone.add(quest.level);

package/package.json

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