dankgrinder 8.107.0 → 8.110.0

package/lib/commands/adventure.js

@@ -108,14 +108,31 @@ const SAFE_KEYWORDS = Object.freeze(['flee', 'run', 'hide', 'avoid', 'ignore', '
 const RISKY_KEYWORDS = Object.freeze(['reach', 'grab', 'fight', 'attack', 'steal', 'open', 'touch', 'eat', 'drink']);
 const ADVENTURE_PREFERRED_TYPES = Object.freeze(['space', 'out west']);
 
-function pickSafeChoice(choices) {
+function pickSafeChoice(choices, adventureAnswers) {
   if (choices.length === 0) return null;
   if (choices.length === 1) return choices[0];
 
-  // Check labels for safe/risky keywords
   const labels = choices.map(b => (b.label || '').toLowerCase());
 
-  // Prefer safe keywords
+  // ── 1) Config answer maps (dmg pattern — highest priority) ──
+  if (adventureAnswers) {
+    for (const [question, answers] of Object.entries(adventureAnswers)) {
+      const matched = labels.find(l => l.includes(question));
+      if (matched && Array.isArray(answers)) {
+        for (const answer of answers) {
+          const found = choices.find(c =>
+            (c.label || '').toLowerCase().includes(answer.toLowerCase())
+          );
+          if (found) {
+            LOG.info(`[adventure] Config answer: "${found.label}" matched question "${question}"`);
+            return found;
+          }
+        }
+      }
+    }
+  }
+
+  // ── 2) Hardcoded safe keywords ──
   for (let i = 0; i < labels.length; i++) {
     for (let k = 0; k < SAFE_KEYWORDS.length; k++) {
       const kw = SAFE_KEYWORDS[k];
@@ -126,7 +143,7 @@ function pickSafeChoice(choices) {
     }
   }
 
-  // Avoid risky keywords
+  // ── 3) Avoid risky keywords ──
   const nonRisky = choices.filter((b, i) => {
     return !RISKY_KEYWORDS.some(kw => labels[i].includes(kw));
   });
@@ -143,7 +160,7 @@ function pickSafeChoice(choices) {
 }
 
 // ── Play through all adventure rounds ────────────────────────────
-async function playAdventureRounds(channel, msg) {
+async function playAdventureRounds(channel, msg, adventureAnswers) {
   let current = msg;
   let interactions = 0;
   const MAX_INTERACTIONS = 30;
@@ -171,7 +188,7 @@ async function playAdventureRounds(channel, msg) {
     // ── If there are choices, pick one first ─────────────────
     if (choices.length > 0) {
       LOG.info(`[adventure] ${choices.length} choices: [${choices.map(b => `"${b.label}"`).join(', ')}]`);
-      const choice = pickSafeChoice(choices);
+      const choice = pickSafeChoice(choices, adventureAnswers);
       if (choice) {
         LOG.info(`[adventure] → Choosing: "${choice.label}"`);
         await sleep(50);
@@ -258,9 +275,10 @@ async function playAdventureRounds(channel, msg) {
  * @param {object} opts.channel - Discord channel
  * @param {function} opts.waitForDankMemer - Waits for Dank Memer response
  * @param {object} [opts.client] - Discord client (for modal handling in shop)
+ * @param {object} [opts.adventureAnswers] - Per-type answer map from AccountWorker.ADVENTURE_ANSWERS
  * @returns {Promise<{result: string, coins: number, nextCooldownSec: number|null}>}
  */
-async function runAdventure({ channel, waitForDankMemer, client }) {
+async function runAdventure({ channel, waitForDankMemer, client, adventureAnswers }) {
   LOG.cmd(`${c.white}${c.bold}pls adventure${c.reset}`);
 
   // Step 1: Send the command
@@ -334,7 +352,7 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
   if (hasNextBtn && menus.length === 0) {
     // Already mid-adventure from a previous run — jump straight to rounds
     LOG.info('[adventure] Resuming mid-adventure...');
-    const { text: finalText, coins, interactions, rewards, finalMsg } = await playAdventureRounds(channel, response);
+    const { text: finalText, coins, interactions, rewards, finalMsg } = await playAdventureRounds(channel, response, adventureAnswers);
     return buildResult(finalText, coins, interactions, rewards, finalMsg);
   }
 
@@ -434,7 +452,7 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
   }
 
   // ── Play through all adventure rounds ──────────────────────
-  const { text: finalText, coins, interactions, rewards, finalMsg } = await playAdventureRounds(channel, response);
+  const { text: finalText, coins, interactions, rewards, finalMsg } = await playAdventureRounds(channel, response, adventureAnswers);
   return buildResult(finalText, coins, interactions, rewards, finalMsg);
 }
 

package/lib/commands/index.js

@@ -16,7 +16,7 @@ const { runPostMemes } = require('./postmemes');
 const { runScratch } = require('./scratch');
 const { runBlackjack } = require('./blackjack');
 const { runTrivia, triviaDB } = require('./trivia');
-const { runWorkShift } = require('./work');
+const { runWorkShift, autoApplyForJob } = require('./work');
 const { runCointoss, runRoulette, runSlots, runSnakeeyes } = require('./gamble');
 const { runDeposit } = require('./deposit');
 const { runGeneric, runAlert } = require('./generic');
@@ -44,6 +44,7 @@ module.exports = {
   runBlackjack,
   runTrivia,
   runWorkShift,
+  autoApplyForJob,
   runCointoss,
   runRoulette,
   runSlots,

package/lib/grinder.js

@@ -598,6 +598,37 @@ class MinHeap {
 
   get size() { return this.heap.length; }
 
+  // ── Message handler registration (dmg pattern) ──────────────
+  // Allows plugins/commands to register handlers for gateway events.
+  // handlers: { messageCreate: Map<name, fn>, messageUpdate: Map<name, fn> }
+  // ── Dispatch events to registered handlers (dmg pattern) ──
+  _dispatchToHandlers(event, msg) {
+    const handlers = this._handlers[event];
+    if (!handlers || handlers.size === 0) return;
+    for (const [name, fn] of handlers) {
+      try {
+        const result = fn(msg);
+        if (result && typeof result.then === 'function') {
+          result.catch(e => this.log('error', `[handler:${name}] ${e.message}`));
+        }
+      } catch (e) {
+        this.log('error', `[handler:${name}] ${e.message}`);
+      }
+    }
+  }
+
+  _registerHandler(event, name, fn) {
+    if (this._handlers[event]) {
+      this._handlers[event].set(name, fn);
+    }
+  }
+
+  _unregisterHandler(event, name) {
+    if (this._handlers[event]) {
+      this._handlers[event].delete(name);
+    }
+  }
+
   _bubbleUp(i) {
     while (i > 0) {
       const parent = (i - 1) >> 1;
@@ -670,12 +701,21 @@ class AccountWorker {
     this._levelQuestActive = false;
     this._levelQuestQueue = [];
     this._levelQuestDone = new Set();
-  this._levelQuestProgressCache = new Map();
+    this._levelQuestProgressCache = new Map();
+    this._levelQuestRunMap = new Map(); // level -> { startedAt, updatedAt, entries: Map<cmd, state> }
     this._questBetOverride = null;
-  this._lastCommandMeta = 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;
+
+    // ── Message handler routing (dmg pattern) ─────────────────
+    // Map of event → handler functions. Plugins register here.
+    // Usage: _handlers.messageCreate.get('adventure')?.(msg)
+    this._handlers = {
+      messageCreate: new Map(),
+      messageUpdate: new Map(),
+    };
     this.lastHealthCheck = Date.now();
     this.doneToday = new Map();
 
@@ -761,6 +801,8 @@ class AccountWorker {
       }
       function handler(msg) {
         if (msg.author.id === DANK_MEMER_ID && msg.channel.id === self.channel.id) {
+          // ── Dispatch to registered handlers (dmg pattern) ────
+          self._dispatchToHandlers('messageCreate', msg);
           const hasComponentPayload = Array.isArray(msg.components)
             && msg.components.some(c => c && (c.components || c.content || c.type || c.label || c.customId));
           const hasContent = (msg.content && msg.content.length > 0)
@@ -790,6 +832,8 @@ class AccountWorker {
           // Reject edits to messages created well before our command was sent
           const msgTs = newMsg.createdTimestamp || newMsg.createdAt?.getTime?.() || 0;
           if (msgTs > 0 && msgTs < sentAt - 1500) return;
+          // ── Dispatch to registered handlers ─────────────────
+          self._dispatchToHandlers('messageUpdate', newMsg);
           cleanup();
           resolve(newMsg);
         }
@@ -843,148 +887,13 @@ class AccountWorker {
   }
 
   async buyItem(itemName, quantity = 1) {
-    const MAX_RETRIES = 1;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      this.log('buy', `Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset}... (attempt ${attempt}/${MAX_RETRIES})`);
-      if (this.account.use_slash) {
-        await this.channel.sendSlash(DANK_MEMER_ID, 'shop', 'view').catch(() => this.channel.send('pls shop view'));
-      } else {
-        await this.channel.send('pls shop view');
-      }
-      let response = await this.waitForDankMemer(10000);
-      if (!response) {
-        this.log('warn', 'No response to shop view command.');
-        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
-        return false;
-      }
-
-      const responseText = getFullText(response).toLowerCase();
-      const hasShopComponents = (response.components || []).some(row =>
-        (row.components || []).some(comp => comp.type === 3 || (comp.type === 2 && comp.label && comp.label.toLowerCase().includes('buy')))
-      );
-
-      if (!hasShopComponents && (responseText.includes('lucky') || responseText.includes('event') || responseText.includes('for the rest of the day'))) {
-        this.log('warn', 'Got event response instead of shop. Retrying...');
-        await humanDelay(3000, 5000);
-        continue;
-      }
-      if (!hasShopComponents && responseText.includes('shop')) {
-        const shopUI = await this.waitForDankMemer(8000);
-        if (shopUI) response = shopUI;
-      }
-
-      // Navigate to Coin Shop
-      let coinShopMenuId = null;
-      let coinShopOption = null;
-      for (const row of response.components || []) {
-        for (const comp of row.components || []) {
-          if (comp.type === 3) {
-            const opt = (comp.options || []).find(o => o.label && o.label.includes('Coin Shop'));
-            if (opt) { coinShopMenuId = comp.customId; coinShopOption = opt; }
-          }
-        }
-      }
-
-      if (coinShopMenuId && coinShopOption) {
-        this.log('buy', 'Navigating to Coin Shop...');
-        try {
-          await response.selectMenu(coinShopMenuId, [coinShopOption.value]);
-          const updatedMsg = await this.waitForDankMemer(8000);
-          if (updatedMsg) response = updatedMsg;
-        } catch (e) {
-          this.log('error', `Failed to open Coin Shop: ${e.message}`);
-        }
-      }
-      await humanDelay(300, 600);
-
-      // Find Buy button — match by full name or partial name
-      let buyBtn = null;
-      const searchNames = [
-        itemName.toLowerCase(),
-        itemName.toLowerCase().replace('hunting ', '').replace('fishing ', ''),
-        itemName.toLowerCase().split(' ')[0],
-      ];
-      for (const row of response.components || []) {
-        for (const comp of row.components || []) {
-          if (comp.type !== 2 || !comp.label) continue;
-          const label = comp.label.toLowerCase();
-          if (searchNames.some(s => label.includes(s) || s.includes(label))) {
-            buyBtn = comp; break;
-          }
-        }
-        if (buyBtn) break;
-      }
-
-      if (!buyBtn) {
-        this.log('warn', `Could not find Buy button for ${itemName} (attempt ${attempt})`);
-        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
-        return false;
-      }
-
-      this.log('buy', `Clicking Buy ${itemName}...`);
-      try { await safeClickButton(response, buyBtn); } catch (e) {
-        this.log('error', `Buy click failed: ${e.message}`);
-        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
-        return false;
-      }
-
-      // Handle Modal
-      const modal = await new Promise((resolve) => {
-        const timer = setTimeout(() => resolve(null), 8000);
-        const handler = (m) => {
-          clearTimeout(timer);
-          this.client.removeListener('interactionModalCreate', handler);
-          resolve(m);
-        };
-        this.client.on('interactionModalCreate', handler);
-      });
-
-      if (modal) {
-        this.log('buy', `Submitting quantity ${c.bold}${quantity}${c.reset} in modal...`);
-        try {
-          const quantityInputId = modal.components[0].components[0].customId;
-          await fetch('https://discord.com/api/v9/interactions', {
-            method: 'POST',
-            headers: { 'Authorization': this.client.token, 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-              type: 5, application_id: modal.applicationId,
-              channel_id: this.channel.id, guild_id: this.channel.guild?.id,
-              data: {
-                id: modal.id, custom_id: modal.customId,
-                components: [{ type: 1, components: [{ type: 4, custom_id: quantityInputId, value: String(quantity) }] }]
-              },
-              session_id: this.client.sessionId || "dummy_session",
-              nonce: Date.now().toString()
-            })
-          });
-        } catch (e) {
-          this.log('error', `Modal submit failed: ${e.message}`);
-          if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
-          return false;
-        }
-      } else {
-        this.log('warn', 'No modal appeared after clicking buy.');
-        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
-        return false;
-      }
-
-      const confirmMsg = await this.waitForDankMemer(8000);
-      if (confirmMsg) {
-        const text = getFullText(confirmMsg).toLowerCase();
-        if (text.includes('bought') || text.includes('purchased') || text.includes('success')) {
-          this.log('success', `Bought ${c.bold}${quantity}x ${itemName}${c.reset}!`);
-          return true;
-        }
-        if (text.includes('not enough') || text.includes("can't afford") || text.includes('insufficient')) {
-          this.log('warn', `Not enough coins to buy ${itemName}.`);
-          return false;
-        }
-      }
-      this.log('success', `Submitted purchase for ${quantity}x ${itemName}.`);
-      return true;
-    }
-    this.log('error', `Failed to buy ${itemName} after ${MAX_RETRIES} attempts.`);
-    return false;
+    return !!(await commands.buyItem({
+      channel: this.channel,
+      waitForDankMemer: (timeout) => this.waitForDankMemer(timeout),
+      client: this.client,
+      itemName,
+      quantity,
+    }));
   }
 
   // ── Check Balance ───────────────────────────────────────────
@@ -1387,7 +1296,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 };
+    this._lastCommandMeta = { cmdName, nonPlay: false, spent: 0, earned: 0, holdTightReason: null, newMinBet: null, levelLocked: null, nextRetrySec: 0 };
     let cmdString;
     const bjBet = Math.max(5000, this.account.bet_amount || 5000);
     const gambBet = Math.max(10000, this.account.bet_amount || 10000);
@@ -1490,6 +1399,7 @@ class AccountWorker {
       client: this.client,
       safeAnswers: cmdName === 'search' ? safeParseJSON(this.account.search_answers, []) :
                    cmdName === 'crime' ? safeParseJSON(this.account.crime_answers, []) : [],
+      adventureAnswers: AccountWorker.ADVENTURE_ANSWERS,
       betAmount: this._questBetOverride || (['blackjack'].includes(cmdName) ? bjBet : gambBet),
       accountId: this.account.id,
       redis,
@@ -1502,7 +1412,7 @@ class AccountWorker {
         case 'search':      cmdResult = await commands.runSearch(cmdOpts); break;
         case 'crime':       cmdResult = await commands.runCrime(cmdOpts); break;
         case 'hl':          cmdResult = await commands.runHighLow(cmdOpts); break;
-  case 'farm':        cmdResult = await commands.runFarm(cmdOpts); break;
+        case 'farm':        cmdResult = await commands.runFarm(cmdOpts); break;
         case 'pm':          cmdResult = await commands.runPostMemes(cmdOpts); break;
         case 'hunt':        cmdResult = await commands.runHunt(cmdOpts); break;
         case 'dig':         cmdResult = await commands.runDig(cmdOpts); break;
@@ -1512,6 +1422,20 @@ class AccountWorker {
         case 'blackjack':   cmdResult = await commands.runBlackjack(cmdOpts); break;
         case 'trivia':      cmdResult = await commands.runTrivia(cmdOpts); break;
         case 'work shift':  cmdResult = await commands.runWorkShift(cmdOpts); break;
+        case 'work apply': {
+          const ar = await commands.autoApplyForJob(cmdOpts);
+          cmdResult = ar?.applied
+            ? { result: 'work apply completed', coins: 0, nextCooldownSec: 8 }
+            : { result: `work apply failed${ar?.cooldownSec ? ` (${Math.ceil(ar.cooldownSec / 60)}m)` : ''}`, coins: 0, nonPlay: true, nextCooldownSec: ar?.cooldownSec || 60 };
+          break;
+        }
+        case 'shop view': {
+          const bought = await commands.buyItem({ ...cmdOpts, itemName: 'Shovel', quantity: 1 });
+          cmdResult = bought
+            ? { result: 'shop buy item completed', coins: 0, nextCooldownSec: 10 }
+            : { result: 'shop buy item failed', coins: 0, nonPlay: true, nextCooldownSec: 25 };
+          break;
+        }
         case 'cointoss':    cmdResult = await commands.runCointoss(cmdOpts); break;
         case 'roulette':    cmdResult = await commands.runRoulette(cmdOpts); break;
         case 'slots':       cmdResult = await commands.runSlots(cmdOpts); break;
@@ -1526,6 +1450,7 @@ class AccountWorker {
 
       const result = cmdResult.result || 'done';
       const resultLower = result.toLowerCase();
+  this._lastCommandMeta.result = result;
 
       // Rate limit detection — progressive backoff based on frequency
       if (resultLower.includes('slow down') || resultLower.includes('rate limit') || resultLower.includes('too fast')) {
@@ -1535,6 +1460,7 @@ class AccountWorker {
         const cooldownSec = Math.min(30 * Math.pow(2, Math.min(this._rateLimitHits - 1, 3)), 300);
         this.log('warn', `Rate limited! ${cooldownSec}s cooldown (hit #${this._rateLimitHits})`);
         this.globalCooldownUntil = Date.now() + cooldownSec * 1000;
+  this._lastCommandMeta.nextRetrySec = cooldownSec;
         await this.setCooldown(cmdName, cooldownSec);
         // Reset rate limit count after 10 minutes of no hits
         setTimeout(() => { if (this._rateLimitHits > 0) this._rateLimitHits = Math.max(0, this._rateLimitHits - 1); }, 600_000);
@@ -1545,6 +1471,8 @@ class AccountWorker {
       if (resultLower.includes('cannot post another meme') || resultLower.includes('dead meme')) {
         const minMatch = result.match(/(\d+)\s*minute/i);
         const cdSec = minMatch ? parseInt(minMatch[1]) * 60 + 30 : 150; // dead meme = N min + 30s buffer
+        this._lastCommandMeta.nonPlay = true;
+        this._lastCommandMeta.nextRetrySec = cdSec;
         this.log('warn', `${cmdName} on cooldown: ${cdSec}s`);
         await this.setCooldown(cmdName, cdSec);
         return;
@@ -1565,6 +1493,28 @@ class AccountWorker {
             this._mergeLevelQuestProgress(targetLv, progress);
           }
           this.log('warn', `Command /${cmdName} requires Level ${targetLv} quests`);
+        } else {
+          // Fallback: some responses are truncated/ephemeral and omit "Level X" in result text.
+          // Run one profile check and infer lock level from raw profile text.
+          try {
+            const profile = await this.checkProfile(true);
+            const profileText = String(profile?.rawText || '');
+            if (profileText.toLowerCase().includes('not unlocked') || profileText.toLowerCase().includes('have not unlocked')) {
+              const pm = profileText.match(/level\s*(\d+)/i);
+              if (pm) {
+                const targetLv = parseInt(pm[1], 10);
+                if (Number.isFinite(targetLv) && targetLv > 0) {
+                  cmdResult.levelLocked = targetLv;
+                  const progress = this._parseLevelQuestProgress(targetLv, profileText);
+                  if (progress) {
+                    cmdResult.levelQuestProgress = progress;
+                    this._mergeLevelQuestProgress(targetLv, progress);
+                  }
+                  this.log('warn', `Command /${cmdName} requires Level ${targetLv} quests (profile fallback)`);
+                }
+              }
+            }
+          } catch {}
         }
       }
 
@@ -1660,6 +1610,7 @@ class AccountWorker {
       if (resultLower.includes('already got your daily') || resultLower.includes('already got your weekly') ||
           resultLower.includes('already got your monthly') || resultLower.includes('already claimed') ||
           resultLower.includes('try again <t:')) {
+        this._lastCommandMeta.nonPlay = true;
         this.log('info', `${cmdName} already claimed — waiting`);
         const timeMatch = result.match(/<t:(\d+):R>/);
         let waitSec;
@@ -1670,6 +1621,7 @@ class AccountWorker {
           const defaultWaits = { daily: 86400, weekly: 604800, monthly: 2592000 };
           waitSec = defaultWaits[cmdName] || 86400;
         }
+  this._lastCommandMeta.nextRetrySec = waitSec;
         await this.setCooldown(cmdName, waitSec);
         this.doneToday.set(cmdName, Date.now() + waitSec * 1000);
         if (redis) try { await redis.set(`dkg:done:${this.account.id}:${cmdName}`, '1', 'EX', waitSec); } catch {}
@@ -1695,6 +1647,7 @@ class AccountWorker {
       // Track net earnings (add wins, subtract losses)
       this.stats.coins += (earned - spent);
       if (cmdResult.nextCooldownSec) {
+        this._lastCommandMeta.nextRetrySec = Math.max(this._lastCommandMeta.nextRetrySec || 0, cmdResult.nextCooldownSec);
         await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
         this._lastCooldownOverride = cmdResult.nextCooldownSec;
         // Learn: record this cooldown as the known value for future fallback use
@@ -1738,6 +1691,7 @@ class AccountWorker {
         this._lastCommandMeta.nonPlay = true;
         this._lastCommandMeta.holdTightReason = reason;
         const holdSec = 35;
+  this._lastCommandMeta.nextRetrySec = Math.max(this._lastCommandMeta.nextRetrySec || 0, holdSec);
         this.log('warn', `Hold Tight: /${reason} — ${holdSec}s global cooldown`);
         const reasonMap = { postmemes: 'pm', highlow: 'hl', blackjack: 'bj', 'work shift': 'work shift' };
         const mappedCmd = reasonMap[reason] || reason;
@@ -1911,16 +1865,63 @@ class AccountWorker {
   ].map(Object.freeze);
 
   // ── Level Quest System — blocks grinding until quests complete ──
+  // ── Adventure answer maps (per type) ──────────────────────────
+  // Pattern: question text → answer choice to click
+  // Supports: space, out west, brazil, vacation, halloween, museum
+  static ADVENTURE_ANSWERS = {
+    space: {
+      'what do you want to do': ['search for debris', 'scavenge wreckage'],
+      'how do you respond': ['stay calm', 'analyze situation'],
+      'what do you choose': ['try to communicate', 'observe first'],
+    },
+    west: {
+      'what do you do': ['draw first', 'hide behind cover'],
+      'how do you respond': ['draw', 'shoot'],
+      'sheriff wants': ['accept bounty', 'decline'],
+    },
+    brazil: {
+      'what do you want to do': ['search for treasure', 'ask locals'],
+      'how do you respond': ['negotiate', 'accept offer'],
+      'locals offer': ['take the deal', 'refuse'],
+    },
+    vacation: {
+      'stranger offers': ['accept', 'decline'],
+      'what do you do': ['explore', 'rest'],
+      'something suspicious': ['investigate', 'ignore'],
+    },
+    halloween: {
+      'knock at door': ['open it', 'hide'],
+      'what do you do': ['investigate', 'run away'],
+      'ghost appears': ['speak to it', 'hide'],
+    },
+    museum: {
+      'what do you do': ['touch exhibit', 'keep distance'],
+      'alarm sounds': ['hide', 'run'],
+      'guard asks': ['tell truth', 'lie'],
+    },
+  };
+
   static LEVEL_QUESTS = {
     1: [
       { cmd: 'beg',    times: 2 },
       { cmd: 'search', times: 2 },
       { cmd: 'tidy',   times: 2 },
     ],
+    2: [
+      { cmd: 'inventory', times: 1, progressMatch: 'inventory', progressSlash: 'inventory' },
+      { cmd: 'balance',   times: 1, progressMatch: 'balance',   progressSlash: 'balance' },
+      { cmd: 'hunt',      times: 2, progressMatch: 'hunt',      progressSlash: 'hunt' },
+      { cmd: 'dig',       times: 2, progressMatch: 'dig',       progressSlash: 'dig' },
+    ],
     3: [
-      { cmd: 'work apply',         times: 1 },
-      { cmd: 'work shift',         times: 1 },
-      { cmd: 'shop sell common coin 1', times: 2 },
+      { cmd: 'work apply',             times: 1, progressMatch: 'get a job',       progressSlash: 'work apply' },
+      { cmd: 'work shift',             times: 1, progressMatch: 'work a shift',    progressSlash: 'work shift' },
+      { cmd: 'shop sell item shovel 1',times: 2, progressMatch: 'sell items',      progressSlash: 'shop sell' },
+      { cmd: 'shop view',              times: 1, progressMatch: 'buy an item',     progressSlash: 'shop view' },
+    ],
+    4: [
+      // Keep this command-driven so the quest runner can continue progression.
+      { cmd: 'bal',                    times: 1, progressMatch: 'balance',         progressSlash: 'balance' },
     ],
     5: [
       // "Lose 50,000 coins in /slots" etc — loseTarget means keep playing until cumulative losses hit 50k
@@ -1928,24 +1929,89 @@ class AccountWorker {
       { cmd: 'cointoss',  loseTarget: 50000, bet: 10000, times: 50 },
       { cmd: 'snakeeyes', loseTarget: 50000, bet: 10000, times: 50 },
     ],
+    6: [
+      // Slash text in lock-card maps to regular pls command strings below.
+      { cmd: 'item new player pack', times: 1, progressMatch: 'new player pack', progressSlash: 'item' },
+      { cmd: 'use player 1',         times: 1, progressMatch: 'new player pack', progressSlash: 'use' },
+      { cmd: 'use normie 1',         times: 1, progressMatch: 'normie box',      progressSlash: 'use' },
+    ],
+    7: [
+      { cmd: 'title set newbie', times: 1, progressMatch: 'newbie title', progressSlash: 'title' },
+      { cmd: 'profile',          times: 1, progressMatch: 'profile',       progressSlash: 'profile' },
+      { cmd: 'daily',            times: 1, progressMatch: 'daily',         progressSlash: 'daily' },
+      { cmd: 'hl',               times: 3, progressMatch: 'highlow',       progressSlash: 'highlow' },
+    ],
   };
 
   _parseLevelQuestProgress(targetLevel, rawText) {
-    if (targetLevel !== 5) return null;
     const text = String(rawText || '');
     const out = {};
-    const re = /(\d[\d,]*)\s*\/\s*50,000[\s\S]{0,180}?<\/(slots|cointoss|snakeeyes):/gi;
-    let m;
-    while ((m = re.exec(text)) !== null) {
-      const cur = parseInt(String(m[1] || '').replace(/,/g, ''), 10);
-      const cmd = String(m[2] || '').toLowerCase();
-      if (Number.isFinite(cur) && cmd) out[cmd] = Math.max(0, cur);
+
+    if (targetLevel === 5) {
+      const re = /(\d[\d,]*)\s*\/\s*50,000[\s\S]{0,180}?<\/(slots|cointoss|snakeeyes):/gi;
+      let m;
+      while ((m = re.exec(text)) !== null) {
+        const cur = parseInt(String(m[1] || '').replace(/,/g, ''), 10);
+        const cmd = String(m[2] || '').toLowerCase();
+        if (Number.isFinite(cur) && cmd) out[cmd] = Math.max(0, cur);
+      }
     }
+
+    if (targetLevel === 6) {
+      // handled below by generic times-based parser
+    }
+
+    if (targetLevel !== 5) {
+      const quests = AccountWorker.LEVEL_QUESTS[targetLevel] || [];
+      const lines = text.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+      for (const q of quests) {
+        if (q.loseTarget) continue;
+        const cmd = String(q.cmd || '').toLowerCase();
+        const cmdParts = cmd.split(/\s+/).filter(Boolean);
+        if (cmdParts.length === 0) continue;
+
+        const slashHints = new Set();
+        slashHints.add(cmdParts[0]);
+        if (q.progressSlash) {
+          for (const p of String(q.progressSlash).toLowerCase().split(/[\s,/|]+/).filter(Boolean)) {
+            slashHints.add(p);
+          }
+        }
+        if (cmd === 'hl') slashHints.add('highlow');
+        if (cmd === 'highlow') slashHints.add('hl');
+
+        const matchPhrase = String(q.progressMatch || q.cmd || '').toLowerCase();
+        const tail = matchPhrase
+          .split(/\s+/)
+          .filter(Boolean)
+          .filter(t => !/^\d+$/.test(t))
+          .filter(t => t !== cmdParts[0]);
+
+        for (const line of lines) {
+          const lower = line.toLowerCase();
+          const hasSlash = Array.from(slashHints).some(h => lower.includes(`/${h}`));
+          if (!hasSlash) continue;
+
+          let ok = true;
+          for (const token of tail) {
+            if (!lower.includes(token)) { ok = false; break; }
+          }
+          if (!ok) continue;
+
+          const m = lower.match(/(\d[\d,]*)\s*\/\s*(\d[\d,]*)/);
+          if (!m) continue;
+          const cur = parseInt(String(m[1] || '').replace(/,/g, ''), 10);
+          if (!Number.isFinite(cur)) continue;
+          out[cmd] = Math.max(out[cmd] || 0, cur);
+        }
+      }
+    }
+
     return Object.keys(out).length > 0 ? out : null;
   }
 
   _mergeLevelQuestProgress(targetLevel, progressHint) {
-    if (!progressHint || targetLevel !== 5) return;
+    if (!progressHint) return;
     const prev = this._levelQuestProgressCache.get(targetLevel) || {};
     const merged = { ...prev };
     for (const [cmd, val] of Object.entries(progressHint)) {
@@ -1963,13 +2029,31 @@ class AccountWorker {
 
     this._mergeLevelQuestProgress(targetLevel, progressHint);
     const cached = this._levelQuestProgressCache.get(targetLevel) || {};
-    const seededQueue = quests
+    const seededAll = quests
       .map(q => {
         const target = Number(q.loseTarget || 0);
-        const seeded = target > 0 ? Math.min(target, Math.max(0, Number(cached[q.cmd] || 0))) : 0;
-        return { ...q, level: targetLevel, _lostSoFar: seeded };
-      })
-      .filter(q => !(q.loseTarget && q._lostSoFar >= q.loseTarget));
+        const seededLoss = target > 0 ? Math.min(target, Math.max(0, Number(cached[q.cmd] || 0))) : 0;
+        const seededDone = target === 0 ? Math.max(0, Math.min(Number(q.times || 0), Number(cached[q.cmd] || 0))) : 0;
+        const timesRemaining = target === 0 ? Math.max(0, Number(q.times || 0) - seededDone) : Number(q.times || 0);
+        const defaultCdSec = this._getCommandDefaultCooldownSec(q.cmd);
+        return {
+          ...q,
+          level: targetLevel,
+          _lostSoFar: seededLoss,
+          _doneSoFar: seededDone,
+          times: timesRemaining,
+          _defaultCdSec: defaultCdSec,
+          _nextRunAt: 0,
+        };
+      });
+
+    const seededQueue = seededAll
+      .filter(q => {
+        if (q.loseTarget) return q._lostSoFar < q.loseTarget;
+        return q.times > 0;
+      });
+
+    this._initLevelQuestRunState(targetLevel, seededAll);
 
     if (seededQueue.length === 0) {
       this.log('info', `[QUEST] Level ${targetLevel} tasks already complete from progress cache — verifying unlock`);
@@ -1997,6 +2081,71 @@ class AccountWorker {
     return true;
   }
 
+  _getCommandDefaultCooldownSec(cmdName) {
+    const cmd = String(cmdName || '').toLowerCase().trim();
+    if (!cmd) return 8;
+    const map = AccountWorker.COMMAND_MAP || [];
+    const exact = map.find(r => String(r.cmd || '').toLowerCase() === cmd);
+    if (exact && Number.isFinite(exact.defaultCd) && exact.defaultCd > 0) return exact.defaultCd;
+    if (cmd === 'highlow') {
+      const hl = map.find(r => String(r.cmd || '').toLowerCase() === 'hl');
+      if (hl?.defaultCd) return hl.defaultCd;
+    }
+    const head = cmd.split(/\s+/)[0];
+    const byHead = map.find(r => String(r.cmd || '').toLowerCase() === head);
+    if (byHead && Number.isFinite(byHead.defaultCd) && byHead.defaultCd > 0) return byHead.defaultCd;
+    return 10;
+  }
+
+  _initLevelQuestRunState(targetLevel, questRows) {
+    const startedAt = Date.now();
+    const state = {
+      level: targetLevel,
+      startedAt,
+      updatedAt: startedAt,
+      completedAt: 0,
+      entries: new Map(),
+    };
+
+    for (const q of (questRows || [])) {
+      const cmd = String(q.cmd || '').toLowerCase();
+      if (!cmd) continue;
+      const required = q.loseTarget
+        ? Number(q.loseTarget || 0)
+        : Math.max(0, Number(q._doneSoFar || 0) + Number(q.times || 0));
+      const completed = q.loseTarget
+        ? Math.max(0, Number(q._lostSoFar || 0))
+        : Math.max(0, Number(q._doneSoFar || 0));
+      const remaining = q.loseTarget
+        ? Math.max(0, required - completed)
+        : Math.max(0, Number(q.times || 0));
+
+      state.entries.set(cmd, {
+        cmd,
+        required,
+        completed,
+        remaining,
+        attemptsLeft: Number(q.times || 0),
+        runs: 0,
+        success: 0,
+        failed: 0,
+        nonPlay: 0,
+        lastResult: '',
+        lastRunAt: 0,
+        nextRunAt: Number(q._nextRunAt || 0),
+        status: remaining <= 0 ? 'done' : 'pending',
+      });
+    }
+
+    this._levelQuestRunMap.set(targetLevel, state);
+  }
+
+  _getLevelQuestRunEntry(level, cmdName) {
+    const st = this._levelQuestRunMap.get(level);
+    if (!st?.entries) return null;
+    return st.entries.get(String(cmdName || '').toLowerCase()) || null;
+  }
+
   async buildCommandQueue() {
     const heap = new MinHeap();
     const now = Date.now();
@@ -2259,6 +2408,11 @@ class AccountWorker {
           this.log('success', `[QUEST] Level ${targetLv} verified ✓ — level unlocked!`);
           this._level = currentLv;
           this._levelQuestProgressCache.delete(targetLv);
+          const st = this._levelQuestRunMap.get(targetLv);
+          if (st) {
+            st.updatedAt = Date.now();
+            st.verifiedAt = Date.now();
+          }
         } else {
           this.log('warn', `[QUEST] Level ${targetLv} NOT verified — still at ${currentLv}. Re-triggering quests.`);
           // Re-trigger quests for this level
@@ -2279,7 +2433,22 @@ class AccountWorker {
 
     // BLOCK: quest mode active — run quests only, no normal grinding
     if (this._levelQuestActive && this._levelQuestQueue.length > 0) {
+      const now = Date.now();
+      let dueIdx = this._levelQuestQueue.findIndex(q => !q._nextRunAt || q._nextRunAt <= now);
+      if (dueIdx < 0) {
+        const soonest = Math.min(...this._levelQuestQueue.map(q => Number(q._nextRunAt || now + 5000)));
+        const waitMs = Math.max(1200, Math.min(60000, soonest - now));
+        this.setStatus(`[QUEST] cooldown wait ${Math.ceil(waitMs / 1000)}s`);
+        this.tickTimeout = setTimeout(() => this.tick(), waitMs);
+        return;
+      }
+      if (dueIdx > 0) {
+        const [dueQuest] = this._levelQuestQueue.splice(dueIdx, 1);
+        this._levelQuestQueue.unshift(dueQuest);
+      }
+
       const quest = this._levelQuestQueue[0];
+      let nextQuestDelayMs = 1200;
       if (quest.loseTarget) {
         const remaining = Math.max(0, quest.loseTarget - (quest._lostSoFar || 0));
         const floorBet = quest._minBet || quest.bet || 1;
@@ -2306,6 +2475,12 @@ class AccountWorker {
       this.busy = true;
       await this.runCommand(quest.cmd, prefix);
       const questMeta = this._lastCommandMeta || {};
+      const qEntry = this._getLevelQuestRunEntry(quest.level, quest.cmd);
+      if (qEntry) {
+        qEntry.runs++;
+        qEntry.lastRunAt = Date.now();
+        qEntry.lastResult = String(questMeta.result || '');
+      }
       this._commandRunning = false;
       this.busy = false;
       this._questBetOverride = null;
@@ -2328,6 +2503,10 @@ class AccountWorker {
         if (!nonPlay) {
           quest._lostSoFar = (quest._lostSoFar || 0) + lostThisRound;
           this._mergeLevelQuestProgress(quest.level, { [quest.cmd]: quest._lostSoFar });
+          if (qEntry) qEntry.success++;
+        } else if (qEntry) {
+          qEntry.nonPlay++;
+          qEntry.failed++;
         }
 
         this.log('info', `[QUEST] ${quest.cmd} — lost ⏣${quest._lostSoFar.toLocaleString()} / ⏣${quest.loseTarget.toLocaleString()}`);
@@ -2346,10 +2525,57 @@ class AccountWorker {
           questStepDone = true;
           this.log('info', `[QUEST] ${quest.cmd} max attempts reached — moving on`);
         }
+
+        if (qEntry) {
+          qEntry.completed = Math.max(0, Number(quest._lostSoFar || 0));
+          qEntry.remaining = Math.max(0, Number(quest.loseTarget || 0) - qEntry.completed);
+          qEntry.attemptsLeft = Number(quest.times || 0);
+          qEntry.status = questStepDone ? 'done' : (nonPlay ? 'cooldown' : 'progress');
+        }
       } else {
         // Normal times-based quest
-        quest.times--;
+        const nonPlay = !!questMeta.nonPlay;
+        if (!nonPlay) {
+          quest.times--;
+          quest._doneSoFar = (quest._doneSoFar || 0) + 1;
+          this._mergeLevelQuestProgress(quest.level, { [quest.cmd]: quest._doneSoFar });
+          if (qEntry) qEntry.success++;
+        } else {
+          if (qEntry) {
+            qEntry.nonPlay++;
+            qEntry.failed++;
+          }
+          this.log('warn', `[QUEST] ${quest.cmd} non-play response — progress unchanged`);
+          // Rotate to next quest so we don't spam one command during cooldown.
+          if (this._levelQuestQueue.length > 1) {
+            const rotated = this._levelQuestQueue.shift();
+            this._levelQuestQueue.push(rotated);
+          }
+        }
         if (quest.times <= 0) questStepDone = true;
+
+        if (qEntry) {
+          qEntry.completed = Math.max(0, Number(quest._doneSoFar || 0));
+          qEntry.remaining = Math.max(0, Number(quest.times || 0));
+          qEntry.attemptsLeft = Number(quest.times || 0);
+          qEntry.status = questStepDone ? 'done' : (nonPlay ? 'cooldown' : 'progress');
+        }
+      }
+
+      const retrySec = Math.max(
+        1,
+        Number(questMeta.nextRetrySec || 0),
+        Number(quest._defaultCdSec || 0)
+      );
+      quest._nextRunAt = Date.now() + retrySec * 1000;
+      nextQuestDelayMs = Math.max(nextQuestDelayMs, Math.min(60000, Math.floor(retrySec * 1000)));
+  if (qEntry) qEntry.nextRunAt = Number(quest._nextRunAt || 0);
+
+  const runState = this._levelQuestRunMap.get(quest.level);
+  if (runState) runState.updatedAt = Date.now();
+
+      if (questMeta.nextRetrySec && Number.isFinite(questMeta.nextRetrySec) && questMeta.nextRetrySec > 0) {
+        nextQuestDelayMs = Math.max(nextQuestDelayMs, Math.min(60000, Math.floor(questMeta.nextRetrySec * 1000)));
       }
 
       if (questStepDone) this._levelQuestQueue.shift();
@@ -2358,6 +2584,11 @@ class AccountWorker {
         this._levelQuestActive = false;
         this._levelQuestDone.add(quest.level);
         const justCompletedLevel = quest.level;
+        const st = this._levelQuestRunMap.get(justCompletedLevel);
+        if (st) {
+          st.completedAt = Date.now();
+          st.updatedAt = st.completedAt;
+        }
         this.log('success', `[QUEST] Level ${justCompletedLevel} quests DONE — verifying unlock...`);
         // Null out commandQueue so buildCommandQueue picks only unlocked commands
         this.commandQueue = null;
@@ -2367,7 +2598,7 @@ class AccountWorker {
         this.tickTimeout = setTimeout(() => this.tick(), 3000);
         return;
       }
-      this.tickTimeout = setTimeout(() => this.tick(), 2500);
+      this.tickTimeout = setTimeout(() => this.tick(), nextQuestDelayMs);
       return;
     }
 

package/lib/rawLogger.js

@@ -457,6 +457,20 @@ async function store(d, event) {
         pipe.ltrim(accKey, 0, 4999);
         pipe.expire(accKey, LOG_TTL);
       }
+      // Track ephemeral in memory for quick access before they vanish
+      if (parsed.isEphemeral || (d.flags & 32832)) {
+        let chMap = ephemeralByChannel.get(d.channel_id);
+        if (!chMap) {
+          chMap = new Map();
+          ephemeralByChannel.set(d.channel_id, chMap);
+        }
+        chMap.set(d.id, parsed);
+        // Cap per-channel ephemeral buffer at 50
+        if (chMap.size > 50) {
+          const firstKey = chMap.keys().next().value;
+          chMap.delete(firstKey);
+        }
+      }
       // Ephemeral log
       if (parsed.isEphemeral || (d.flags & 32832)) {
         pipe.lpush('raw:ephemeral:log', `${d.id}:${parsed._capturedAt}:${parsed.command}:${d.channel_id}`);
@@ -494,8 +508,17 @@ function onDmEvent(fn) { dmListeners.push(fn); }
 
 // ── Ephemeral message callbacks ──
 const ephemeralListeners = [];
+const ephemeralByChannel = new Map(); // channelId → Map<msgId, parsed msg>
+
 function onNextEphemeral(fn) { ephemeralListeners.push(fn); }
 
+// Track ephemeral messages per channel — useful for reading state before vanish
+function getEphemeralMsgs(channelId, count = 20) {
+  const map = ephemeralByChannel.get(channelId);
+  if (!map) return [];
+  return [...map.values()].slice(-count);
+}
+
 function _notifyEphemeral(parsed) {
   if (!ephemeralListeners.length) return;
   const listeners = [...ephemeralListeners];

package/package.json

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