dankgrinder 8.105.0 → 8.109.0

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

@@ -670,8 +670,10 @@ class AccountWorker {
     this._levelQuestActive = false;
     this._levelQuestQueue = [];
     this._levelQuestDone = new Set();
+    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;
@@ -842,148 +844,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 ───────────────────────────────────────────
@@ -1386,7 +1253,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);
@@ -1501,7 +1368,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;
@@ -1511,6 +1378,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;
@@ -1525,6 +1406,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')) {
@@ -1534,6 +1416,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);
@@ -1544,6 +1427,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;
@@ -1558,7 +1443,34 @@ class AccountWorker {
         if (lvMatch) {
           const targetLv = parseInt(lvMatch[1]);
           cmdResult.levelLocked = targetLv;
+          const progress = this._parseLevelQuestProgress(targetLv, allDetectionText);
+          if (progress) {
+            cmdResult.levelQuestProgress = progress;
+            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 {}
         }
       }
 
@@ -1654,6 +1566,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;
@@ -1664,6 +1577,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 {}
@@ -1689,6 +1603,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
@@ -1732,6 +1647,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;
@@ -1746,10 +1662,10 @@ class AccountWorker {
         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)) {
+        if (this._startLevelQuests(targetLv, cmdResult.levelQuestProgress || null)) {
           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)`);
+          this.log('warn', `[QUEST] Level ${targetLv} quests already done or not defined — waiting for verification`);
         }
         // Don't count as success — skip normal post-command processing
         return;
@@ -1911,10 +1827,21 @@ class AccountWorker {
       { 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
@@ -1922,13 +1849,141 @@ 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' },
+    ],
   };
 
-  _startLevelQuests(targetLevel) {
+  _parseLevelQuestProgress(targetLevel, rawText) {
+    const text = String(rawText || '');
+    const out = {};
+
+    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) return;
+    const prev = this._levelQuestProgressCache.get(targetLevel) || {};
+    const merged = { ...prev };
+    for (const [cmd, val] of Object.entries(progressHint)) {
+      const n = Number(val);
+      if (!Number.isFinite(n) || n < 0) continue;
+      merged[cmd] = Math.max(merged[cmd] || 0, n);
+    }
+    this._levelQuestProgressCache.set(targetLevel, merged);
+  }
+
+  _startLevelQuests(targetLevel, progressHint = null) {
     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, _lostSoFar: 0 }));
+
+    this._mergeLevelQuestProgress(targetLevel, progressHint);
+    const cached = this._levelQuestProgressCache.get(targetLevel) || {};
+    const seededAll = quests
+      .map(q => {
+        const target = Number(q.loseTarget || 0);
+        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`);
+      this._verifyLevelUnlock = targetLevel;
+      this.setStatus('verifying level...');
+      this.commandQueue = null;
+      return false;
+    }
+
+    this._levelQuestQueue = seededQueue;
     this._levelQuestActive = true;
     this._questBetOverride = null;
     // Clear commandQueue so no stale grinding commands fire after quests finish
@@ -1936,13 +1991,81 @@ class AccountWorker {
     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 => {
-      if (q.loseTarget) return `"${q.cmd}" lose ⏣${q.loseTarget.toLocaleString()}`;
+      if (q.loseTarget) {
+        const rem = Math.max(0, q.loseTarget - (q._lostSoFar || 0));
+        return `"${q.cmd}" lose ⏣${rem.toLocaleString()} more`;
+      }
       return `"${q.cmd}" x${q.times}`;
     }).join(', ');
     this.log('info', `[QUEST] Quests: ${questList}`);
     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();
@@ -2204,11 +2327,18 @@ class AccountWorker {
         if (currentLv >= targetLv) {
           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
           this._levelQuestDone.delete(targetLv);
-          this._startLevelQuests(targetLv);
+          const cached = this._levelQuestProgressCache.get(targetLv) || null;
+          this._startLevelQuests(targetLv, cached);
           this.tickTimeout = setTimeout(() => this.tick(), 2000);
           return;
         }
@@ -2223,7 +2353,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;
@@ -2231,7 +2376,6 @@ class AccountWorker {
       } else {
         this._questBetOverride = quest.bet || null;
       }
-      const questBetUsed = this._questBetOverride;
       const prefix = this.account.use_slash ? '/' : 'pls';
 
       if (quest.loseTarget) {
@@ -2250,7 +2394,13 @@ class AccountWorker {
       this._commandRunning = true;
       this.busy = true;
       await this.runCommand(quest.cmd, prefix);
-    const questMeta = this._lastCommandMeta || {};
+      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;
@@ -2270,13 +2420,13 @@ class AccountWorker {
           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._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()}`);
@@ -2295,10 +2445,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();
@@ -2307,6 +2504,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;
@@ -2316,7 +2518,7 @@ class AccountWorker {
         this.tickTimeout = setTimeout(() => this.tick(), 3000);
         return;
       }
-      this.tickTimeout = setTimeout(() => this.tick(), 2500);
+      this.tickTimeout = setTimeout(() => this.tick(), nextQuestDelayMs);
       return;
     }
 

package/package.json

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