dankgrinder 6.37.0 → 6.42.0

package/lib/grinder.js

@@ -5,7 +5,7 @@ const { setDashboardActive, isCV2, ensureCV2, stripAnsi } = require('./commands/
 const rawLogger = require('./rawLogger');
 const {
   BloomFilter, RingBuffer, TokenBucket, EMA, SlidingWindowCounter,
-  AhoCorasick, LRUCache, StringPool, AsyncBatchQueue, JitterBackoff,
+  AhoCorasick, LRUCache, StringPool, AsyncBatchQueue,
 } = require('./structures');
 const PKG_VERSION = require('../package.json').version;
 
@@ -94,6 +94,8 @@ const c = {
 };
 
 const WORKER_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
+// Unique marker written to stdout so we can query cursor position via DSR response
+const MARKER = '\x1b[6n\x1b[@@MARKER@@';
 const DANK_MEMER_ID = '270904126974590976';
 
 // ── Safe options for search/crime ──────────────────────────
@@ -277,9 +279,9 @@ function boxTop(w, color) { return color + BOX.dtl + BOX.dh.repeat(w - 2) + BOX.
 function boxMid(w, color) { return color + BOX.tee + BOX.h.repeat(w - 2) + BOX.teeR + c.reset; }
 function boxBot(w, color) { return color + BOX.dbl + BOX.dh.repeat(w - 2) + BOX.dbr + c.reset; }
 function boxLine(content, w, color) {
-  const stripped = content.replace(/\x1b\[[0-9;]*m/g, '');
+  const stripped = stripAnsi(content);
   const pad = Math.max(0, w - 4 - stripped.length);
-  return color + BOX.dv + c.reset + ' ' + content + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
+  return color + BOX.dv + c.reset + ' ' + stripAnsi(content) + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
 }
 function thinLine(w) { return '  ' + c.dim + BOX.h.repeat(w - 4) + c.reset; }
 
@@ -866,8 +868,8 @@ const CMD_NAMES_CLEAN = {
   bj: 'Blackjack', blackjack: 'Blackjack', hl: 'High Low', pm: 'Post Memes', postmemes: 'Post Memes',
   ct: 'Coin Toss', cointoss: 'Coin Toss', se: 'Snake Eyes', snakeeyes: 'Snake Eyes',
   hunt: 'Hunt', dig: 'Dig', fish: 'Fish', beg: 'Beg', search: 'Search', crime: 'Crime',
-  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', weekly: 'Weekly', monthly: 'Monthly',
-  scratch: 'Scratch', adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
+  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', monthly: 'Monthly',
+  adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
   drops: 'Drops', use: 'Use Item', dep: 'Deposit', deposit: 'Deposit', inv: 'Inventory',
   work: 'Work', stream: 'Stream', roulette: 'Roulette', slots: 'Slots',
 };
@@ -1110,6 +1112,11 @@ class AccountWorker {
     this.commandQueue = null;
     this.lastHealthCheck = Date.now();
     this.doneToday = new Map();
+
+    // Dynamic cooldown learning: tracks actual parsed cooldowns per command.
+    // Persisted in Redis hash `dkg:cd:learned:{accountId}` for cross-restart persistence.
+    // Used as adaptive floor when command parsers don't return exact cooldowns.
+    this._learnedCooldowns = new Map();
     this._fishRoundsSinceSell = 0;
     this._autoDepositThreshold = account.auto_deposit_threshold || 500000;
 
@@ -1483,7 +1490,9 @@ class AccountWorker {
                 totalValue: result.totalValue || 0,
               }),
             });
-          } catch {}
+          } catch (err) {
+            console.error(`[${this.username}] inventory API error:`, err?.message || err);
+          }
 
           return {
             ok: true,
@@ -1517,6 +1526,60 @@ class AccountWorker {
     }
   }
 
+  // ── Profile Check ────────────────────────────────────────────
+  async checkProfile(silent = false) {
+    try {
+      const result = await commands.runProfile({
+        channel: this.channel,
+        waitForDankMemer: (t) => this.waitForDankMemer(t),
+        accountId: this.account.id,
+        redis,
+      });
+
+      if (result.error) {
+        if (!silent) this.log('warn', `[profile] Check failed: ${result.error}`);
+        return result;
+      }
+
+      if (!silent) {
+        this.log('info', `[profile] Level ${result.level} · ⏣ ${(result.wallet || 0).toLocaleString()} wallet · ⏣ ${(result.net || 0).toLocaleString()} net`);
+      }
+
+      // Push to web dashboard via grinder status endpoint
+      try {
+        await fetch(`${API_URL}/api/grinder/profile`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            account_id: this.account.id,
+            level: result.level,
+            xp_current: result.xpCurrent,
+            xp_max: result.xpMax,
+            wallet: result.wallet,
+            bank: result.bank,
+            net: result.net,
+            items_unique: result.itemsUnique,
+            items_total: result.itemsTotal,
+            items_worth: result.itemsWorth,
+            cmds_total: result.cmdsTotal,
+            favorite: result.favorite,
+            badges: result.badges || [],
+            pets: result.pets || [],
+            showcase: result.showcase || [],
+            raw_text: result.rawText || '',
+          }),
+        });
+      } catch (err) {
+        console.error(`[${this.username}] profile API error:`, err?.message || err);
+      }
+
+      return { ok: true, ...result };
+    } catch (e) {
+      if (!silent) this.log('warn', `[profile] Check error: ${e.message}`);
+      return { ok: false, error: e.message };
+    }
+  }
+
   async checkBalance(silent = false) {
     const prefix = this.account.use_slash ? '/' : 'pls';
     const sentAt = Date.now();
@@ -1717,22 +1780,48 @@ class AccountWorker {
   // Each modular command handler sends the command, waits for response,
   // handles Hold Tight / cooldowns / item-buying internally.
   async runCommand(cmdName, prefix) {
-    let cmdString;
+    // Slash commands use '/cmd' without a space between slash and subcommand
+    // (e.g. '/dep max', '/work shift'). Legacy prefix uses 'pls cmd'.
+    const SLASH_CMD = new Map([
+      ['dep max',     '/dep max'],
+      ['with max',    '/with max'],
+      ['work shift',  '/work shift'],
+      ['monthly',     '/monthly'],
+    ]);
     const bjBet = Math.max(5000, this.account.bet_amount || 5000);
     const gambBet = Math.max(10000, this.account.bet_amount || 10000);
 
-    switch (cmdName) {
-      case 'dep max':     cmdString = `${prefix} dep max`; break;
-      case 'with max':    cmdString = `${prefix} with max`; break;
-      case 'blackjack':   cmdString = `${prefix} bj ${bjBet}`; break;
-      case 'cointoss':    cmdString = `${prefix} cointoss ${gambBet}`; break;
-      case 'roulette':    cmdString = `${prefix} roulette ${gambBet}`; break;
-      case 'slots':       cmdString = `${prefix} slots ${gambBet}`; break;
-      case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${gambBet}`; break;
-      case 'work shift':  cmdString = `${prefix} work shift`; break;
-      case 'weekly':      cmdString = `${prefix} weekly`; break;
-      case 'monthly':     cmdString = `${prefix} monthly`; break;
-      default:            cmdString = `${prefix} ${cmdName}`;
+    let cmdString;
+    if (prefix === '/') {
+      const slashVariant = SLASH_CMD.get(cmdName);
+      if (slashVariant) {
+        cmdString = slashVariant;
+      } else if (cmdName === 'blackjack') {
+        cmdString = `/bj ${bjBet}`;
+      } else if (cmdName === 'cointoss') {
+        cmdString = `/cointoss ${gambBet}`;
+      } else if (cmdName === 'roulette') {
+        cmdString = `/roulette ${gambBet}`;
+      } else if (cmdName === 'slots') {
+        cmdString = `/slots ${gambBet}`;
+      } else if (cmdName === 'snakeeyes') {
+        cmdString = `/snakeeyes ${gambBet}`;
+      } else {
+        cmdString = `/${cmdName}`;
+      }
+    } else {
+      switch (cmdName) {
+        case 'dep max':     cmdString = `${prefix} dep max`; break;
+        case 'with max':    cmdString = `${prefix} with max`; break;
+        case 'blackjack':   cmdString = `${prefix} bj ${bjBet}`; break;
+        case 'cointoss':    cmdString = `${prefix} cointoss ${gambBet}`; break;
+        case 'roulette':    cmdString = `${prefix} roulette ${gambBet}`; break;
+        case 'slots':       cmdString = `${prefix} slots ${gambBet}`; break;
+        case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${gambBet}`; break;
+        case 'work shift':  cmdString = `${prefix} work shift`; break;
+        case 'monthly':     cmdString = `${prefix} monthly`; break;
+        default:            cmdString = `${prefix} ${cmdName}`;
+      }
     }
 
     if (shutdownCalled || !this.running) return;
@@ -1830,7 +1919,6 @@ class AccountWorker {
         case 'hunt':        cmdResult = await commands.runHunt(cmdOpts); break;
         case 'dig':         cmdResult = await commands.runDig(cmdOpts); break;
         case 'fish':        cmdResult = await commands.runFish(cmdOpts); break;
-        case 'scratch':     cmdResult = await commands.runScratch(cmdOpts); break;
         case 'adventure':   cmdResult = await commands.runAdventure(cmdOpts); break;
         case 'blackjack':   cmdResult = await commands.runBlackjack(cmdOpts); break;
         case 'trivia':      cmdResult = await commands.runTrivia(cmdOpts); break;
@@ -1885,7 +1973,9 @@ class AccountWorker {
             headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
             body: JSON.stringify({ account_id: this.account.id, active: false }),
           });
-        } catch {}
+        } catch (err) {
+          console.error(`[${this.username}] status deactivation API error:`, err?.message || err);
+        }
         await sendLog(this.username, cmdString, 'VERIFICATION — account deactivated', 'error');
         sendWebhook('CAPTCHA ALERT', `**${this.username}** needs verification!\nCommand: \`${cmdName}\`\nSolve in Discord and re-enable from dashboard.`, 0xef4444);
         return;
@@ -1964,8 +2054,9 @@ class AccountWorker {
         const timeMatch = result.match(/<t:(\d+):R>/);
         let waitSec;
         if (timeMatch) {
-          const nextAvail = parseInt(timeMatch[1]) * 1000;
-          waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
+          // Discord <t:TS:R> format: :R = relative seconds from NOW (not Unix ms).
+          // The captured number IS already the number of seconds to wait.
+          waitSec = Math.max(60, parseInt(timeMatch[1]));
         } else {
           const defaultWaits = { daily: 86400, weekly: 604800, monthly: 2592000 };
           waitSec = defaultWaits[cmdName] || 86400;
@@ -1995,6 +2086,11 @@ class AccountWorker {
       if (cmdResult.nextCooldownSec) {
         await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
         this._lastCooldownOverride = cmdResult.nextCooldownSec;
+        // Learn: record this cooldown as the known value for future fallback use
+        this._learnedCooldowns.set(cmdName, cmdResult.nextCooldownSec);
+        if (redis) {
+          await redis.hset(`dkg:cd:learned:${this.account.id}`, cmdName, String(cmdResult.nextCooldownSec));
+        }
       }
 
       // Smart gambling loss tracker
@@ -2115,19 +2211,38 @@ class AccountWorker {
     }
   }
 
+  // Load previously learned cooldowns from Redis so floors adapt across restarts.
+  async _loadLearnedCooldowns() {
+    if (!redis) return;
+    try {
+      const learned = await redis.hgetall(`dkg:cd:learned:${this.account.id}`);
+      for (const [cmd, val] of Object.entries(learned)) {
+        const n = parseFloat(val);
+        if (Number.isFinite(n) && n > 0) {
+          this._learnedCooldowns.set(cmd, n);
+        }
+      }
+      if (this._learnedCooldowns.size > 0) {
+        this.log('info', `Loaded ${this._learnedCooldowns.size} learned cooldowns from Redis`);
+      }
+    } catch (e) {
+      this.log('warn', `Failed to load learned cooldowns: ${e.message}`);
+    }
+  }
+
   printStats() {
     // Stats are shown in the live dashboard, no-op here
   }
 
   // ── Command Map (shared across ticks, used to build the heap) ──
   // Priority: higher = runs first when multiple commands are ready simultaneously.
-  //   10 = time-gated (daily/weekly/monthly — never miss),
+  //   10 = time-gated (daily/monthly — never miss),
   //    8 = financial safety (deposit),
   //    7 = gambling fast-cycle (2-3s CD — run MOST often),
   //    6 = fast grinders (10s CD),
   //    5 = medium grinders (20-40s CD),
   //    4 = resource grinders (hunt/dig — need items),
-  //    3 = interactive/long CD (adventure/stream/work/scratch),
+  //    3 = interactive/long CD (adventure/stream/work),
   //    2 = utility (drops/use/tidy)
   static COMMAND_MAP = [
     // Gambling — 2-3s CD, highest frequency
@@ -2138,7 +2253,7 @@ class AccountWorker {
     { key: 'cmd_snakeeyes', cmd: 'snakeeyes',   cdKey: 'cd_snakeeyes', defaultCd: 3,      priority: 7 },
     // Fast grinders — 10s CD
     { key: 'cmd_hl',        cmd: 'hl',          cdKey: 'cd_hl',        defaultCd: 10,     priority: 6 },
-  { key: 'cmd_farm',      cmd: 'farm',        cdKey: 'cd_farm',      defaultCd: 30,     priority: 4 },
+    { key: 'cmd_farm',      cmd: 'farm',         cdKey: 'cd_farm',      defaultCd: 30,     priority: 4 },
     { key: 'cmd_trivia',    cmd: 'trivia',      cdKey: 'cd_trivia',    defaultCd: 10,     priority: 6 },
     { key: 'cmd_use',       cmd: 'use',         cdKey: 'cd_use',       defaultCd: 10,     priority: 2 },
     // Medium grinders — 20-25s CD
@@ -2149,24 +2264,23 @@ class AccountWorker {
     { key: 'cmd_search',    cmd: 'search',      cdKey: 'cd_search',    defaultCd: 25,     priority: 5 },
     // Slow grinders — 40s CD
     { key: 'cmd_beg',       cmd: 'beg',         cdKey: 'cd_beg',       defaultCd: 40,     priority: 5 },
-    { key: 'cmd_crime',     cmd: 'crime',       cdKey: 'cd_crime',     defaultCd: 40,     priority: 5 },
-    { key: 'cmd_tidy',      cmd: 'tidy',        cdKey: 'cd_tidy',      defaultCd: 40,     priority: 2 },
+    { key: 'cmd_crime',     cmd: 'crime',        cdKey: 'cd_crime',     defaultCd: 40,     priority: 5 },
+    { key: 'cmd_tidy',      cmd: 'tidy',         cdKey: 'cd_tidy',      defaultCd: 40,     priority: 2 },
     // Interactive — response-driven CD (handler sets nextCooldownSec)
-  { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 300,    priority: 3 },
-  { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',    defaultCd: 600,    priority: 3 },
-    // scratch removed — requires voting which can't be automated
-  { key: 'cmd_work',      cmd: 'work shift',  cdKey: 'cd_work',      defaultCd: 1800,   priority: 3 },
+    { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 300,    priority: 3 },
+    { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',   defaultCd: 600,    priority: 3 },
+    { key: 'cmd_work',      cmd: 'work shift',   cdKey: 'cd_work',     defaultCd: 1800,   priority: 3 },
     // Time-gated (run ASAP when available)
-    { key: 'cmd_daily',     cmd: 'daily',       cdKey: 'cd_daily',     defaultCd: 86400,  priority: 10 },
-    // weekly removed — premium only, not available for free users
-    { key: 'cmd_monthly',   cmd: 'monthly',     cdKey: 'cd_monthly',   defaultCd: 2592000,priority: 10 },
+    { key: 'cmd_daily',     cmd: 'daily',       cdKey: 'cd_daily',    defaultCd: 86400,  priority: 10 },
+    // monthly — premium only
+    { key: 'cmd_monthly',   cmd: 'monthly',     cdKey: 'cd_monthly',  defaultCd: 2592000, priority: 10 },
     // Financial safety
-    { key: 'cmd_deposit',   cmd: 'dep max',     cdKey: 'cd_deposit',   defaultCd: 3600,   priority: 8 },
-    { key: 'cmd_drops',     cmd: 'drops',       cdKey: 'cd_drops',     defaultCd: 86400,  priority: 2 },
+    { key: 'cmd_deposit',   cmd: 'dep max',     cdKey: 'cd_deposit',  defaultCd: 3600,   priority: 8 },
+    { key: 'cmd_drops',     cmd: 'drops',       cdKey: 'cd_drops',    defaultCd: 86400, priority: 2 },
     // Alert is NOT scheduled — it's reactive (listener-based, see grindLoop)
   ].map(Object.freeze);
 
-  buildCommandQueue() {
+  async buildCommandQueue() {
     const heap = new MinHeap();
     const now = Date.now();
     let enabled = AccountWorker.COMMAND_MAP.filter(
@@ -2180,8 +2294,33 @@ class AccountWorker {
       enabled = AccountWorker.COMMAND_MAP.filter(ci => Boolean(this.account[ci.key]));
     }
 
+    // Restore cooldown state from Redis so commands don't re-run immediately
+    // after restart. We use TTL to calculate remaining cooldown time.
+    const accountId = this.account.id;
+    const cmdKeys = enabled.map(info => `dkg:cd:${accountId}:${info.cmd}`);
+    let ttlMap = new Map();
+    if (redis) {
+      const pipeline = redis.pipeline();
+      for (const k of cmdKeys) pipeline.ttl(k);
+      const results = await pipeline.exec();
+      for (let i = 0; i < cmdKeys.length; i++) {
+        const [err, val] = results[i];
+        if (!err && Number.isFinite(val) && val > 0) {
+          ttlMap.set(cmdKeys[i], val);
+        }
+      }
+    }
+
     for (const info of enabled) {
-      heap.push({ cmd: info.cmd, nextRunAt: now, priority: info.priority, info });
+      let nextRunAt = now;
+      const key = `dkg:cd:${accountId}:${info.cmd}`;
+      const ttlVal = ttlMap.get(key);
+      if (Number.isFinite(ttlVal) && ttlVal > 0) {
+        nextRunAt = now + ttlVal * 1000;
+        this._cooldownBloom.add(key);
+        this.log('info', `Restored cooldown for ${info.cmd}: ${ttlVal}s remaining`);
+      }
+      heap.push({ cmd: info.cmd, nextRunAt, priority: info.priority, info });
     }
     return heap;
   }
@@ -2309,7 +2448,7 @@ class AccountWorker {
 
         // Resume grind loop if it was running
         if (!this.commandQueue || this.commandQueue.size === 0) {
-          this.commandQueue = this.buildCommandQueue();
+          this.commandQueue = await this.buildCommandQueue();
         }
       } else {
         this.log('error', 'Recovered connection but channel not found — retrying');
@@ -2407,98 +2546,65 @@ class AccountWorker {
     }
 
     if (!this.commandQueue || this.commandQueue.size === 0) {
-      this.commandQueue = this.buildCommandQueue();
+      this.commandQueue = await this.buildCommandQueue();
     }
     if (!this.commandQueue || this.commandQueue.size === 0) {
       this.tickTimeout = setTimeout(() => this.tick(), 15000);
       return;
     }
 
-    const top = this.commandQueue.peek();
-    if (top.nextRunAt > now) {
-      const waitMs = Math.min(top.nextRunAt - now, 2000);
-      this.setStatus('cooldown...');
-      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
-      return;
-    }
-
-    const item = this.commandQueue.pop();
-    if (!item) {
-      this.tickTimeout = setTimeout(() => this.tick(), 1000);
-      return;
+    // ── Scan entire queue for ready commands ─────────────────────
+    // Previously we only peeked the top item, missing other commands that
+    // were already ready while a slower command was at the top of the heap.
+    // Now we drain the queue and separate ready vs. waiting commands.
+    // All ready commands fire immediately — no priority, FIFO order.
+    const readyItems = [];
+    const waitingItems = [];
+    while (this.commandQueue.size > 0) {
+      const item = this.commandQueue.pop();
+      if (!item) break;
+      if (item.nextRunAt <= now) {
+        readyItems.push(item);
+      } else {
+        waitingItems.push(item);
+      }
     }
 
-    const ready = await this.isCooldownReady(item.cmd);
-    if (!ready) {
-      const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
-      item.nextRunAt = now + cd * 1000;
-      if (this.commandQueue) this.commandQueue.push(item);
-      this.tickTimeout = setTimeout(() => this.tick(), 100);
-      return;
+    // Re-insert waiting items back into the queue (they still have time to wait)
+    for (const item of waitingItems) {
+      this.commandQueue.push(item);
     }
 
-    // Skip time-gated commands if already claimed (in-memory + Redis)
-    if (item.cmd === 'daily' || item.cmd === 'weekly' || item.cmd === 'monthly' || item.cmd === 'drops') {
-      const memExpiry = this.doneToday.get(item.cmd);
-      if (memExpiry && Date.now() < memExpiry) {
-        item.nextRunAt = memExpiry;
-        if (this.commandQueue) this.commandQueue.push(item);
-        this.tickTimeout = setTimeout(() => this.tick(), 100);
-        return;
-      }
-      if (redis) {
-        try {
-          const done = await redis.get(`dkg:done:${this.account.id}:${item.cmd}`);
-          if (done) {
-            const ttlMap = { daily: 86400, weekly: 604800, monthly: 2592000, drops: 86400 };
-            const ttl = ttlMap[item.cmd] || 86400;
-            const expiry = now + ttl * 1000;
-            this.doneToday.set(item.cmd, expiry);
-            item.nextRunAt = expiry;
-            if (this.commandQueue) this.commandQueue.push(item);
-            this.tickTimeout = setTimeout(() => this.tick(), 100);
-            return;
-          }
-        } catch {}
+    if (readyItems.length === 0) {
+      // Nothing ready — wait until the soonest command becomes available.
+      let minWaitMs = 5000; // cap at 5s to stay responsive
+      for (const item of waitingItems) {
+        const diff = item.nextRunAt - now;
+        if (diff < minWaitMs) minWaitMs = diff;
       }
-    }
-
-    // Smart gambling: skip gamble commands while loss-paused
-    const GAMBLE_SET = new Set(['blackjack', 'cointoss', 'roulette', 'slots', 'snakeeyes']);
-    if (GAMBLE_SET.has(item.cmd) && this._gamblePausedUntil > now) {
-      item.nextRunAt = this._gamblePausedUntil;
-      if (this.commandQueue) this.commandQueue.push(item);
-      this.setStatus(`gamble paused (${Math.ceil((this._gamblePausedUntil - now) / 1000)}s)`);
-      this.tickTimeout = setTimeout(() => this.tick(), 100);
+      this.setStatus('cooldown...');
+      this.tickTimeout = setTimeout(() => this.tick(), Math.max(100, Math.min(minWaitMs, 5000)));
       return;
     }
-    if (GAMBLE_SET.has(item.cmd) && this._gamblePausedUntil > 0 && this._gamblePausedUntil <= now) {
-      this._gamblePausedUntil = 0;
-      this._gambleLossStreak = 0;
-      this._gambleSessionLoss = 0;
-      this.log('info', 'Gambling pause expired — resuming bets');
-    }
 
-    // TokenBucket rate limiter: prevent Discord 429s by throttling commands
-    if (!this._rateLimiter.consume(1)) {
-      const waitMs = this._rateLimiter.waitTime(1);
-      this.setStatus(`rate throttle (${Math.ceil(waitMs / 1000)}s)`);
-      if (this.commandQueue) this.commandQueue.push(item);
-      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
-      return;
+    // FIFO — execute commands in the order they became ready.
+    // Commands that aren't picked this tick go back into the queue for next tick.
+    const item = readyItems[0];
+
+    // Any remaining ready items that we didn't execute go back immediately
+    // so they run in the next tick without waiting for the slow top item.
+    for (let i = 1; i < readyItems.length; i++) {
+      this.commandQueue.push(readyItems[i]);
     }
 
-    this._cmdRate.increment();
-    this.busy = true;
+    // Anti-detection: per-account jitter + micro-pauses for this command
     const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
-    // Anti-detection: per-account jitter with varying patterns
     const patternMod = this._activePattern;
     const jitterBase = cd <= 5
       ? 0.3 + Math.random() * 0.7
       : cd <= 20
         ? 0.5 + Math.random() * 1.5
         : 1 + Math.random() * 2;
-    // Add human-like micro-pauses (occasionally take longer, simulating distraction)
     const microPause = Math.random() < 0.08 ? 1.5 + Math.random() * 3 : 0;
     const totalWait = cd + jitterBase + microPause;
 
@@ -2510,6 +2616,20 @@ class AccountWorker {
       await new Promise(r => setTimeout(r, minGap - timeSinceLastCmd));
     }
 
+    // TokenBucket rate limiter — prevent Discord 429s
+    if (!this._rateLimiter.consume(1)) {
+      const waitMs = this._rateLimiter.waitTime(1);
+      this.setStatus(`rate throttle (${Math.ceil(waitMs / 1000)}s)`);
+      if (this.commandQueue) this.commandQueue.push(item);
+      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
+      return;
+    }
+
+    this.busy = true;
+
+    // ── Run command (with interactive retry) ───────────────────
+    // Commands run ONE BY ONE — sequential execution, no concurrency within this account.
+    // Each runCommand() call waits for Dank Memer's Discord response before returning.
     const prefix = this.account.use_slash ? '/' : 'pls';
     this.setStatus(formatCommandName(item.cmd));
 
@@ -2523,15 +2643,40 @@ class AccountWorker {
       next_run_at: nextItemRun?.nextRunAt || null,
     });
 
-    const beforeCoins = this.stats.coins;
-    await this.runCommand(item.cmd, prefix);
-    const earned = this.stats.coins - beforeCoins;
+    // Interactive commands (button-click): retry up to 3 times on failure.
+    // Non-interactive commands run once.
+    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'adventure', 'stream', 'fish', 'farm', 'work shift']);
+    const isInteractive = INTERACTIVE_CMDS.has(item.cmd);
+    const maxAttempts = isInteractive ? 3 : 1;
+    let attempt = 0;
+    let lastError = null;
+    let earned = 0;
+    while (attempt < maxAttempts) {
+      attempt++;
+      try {
+        const beforeCoins = this.stats.coins;
+        await this.runCommand(item.cmd, prefix);
+        earned = this.stats.coins - beforeCoins;
+        lastError = null;
+        this.lastCommandRun = Date.now();
+        break; // success
+      } catch (err) {
+        lastError = err;
+        this.log('warn', `${item.cmd} attempt ${attempt}/${maxAttempts} failed: ${err.message}`);
+        if (attempt < maxAttempts) {
+          await new Promise(r => setTimeout(r, 1000 + Math.random() * 1000));
+        }
+      }
+    }
+    if (lastError) {
+      this.log('error', `${item.cmd} failed after ${maxAttempts} attempts — skipping`);
+    }
 
-    // Grace period for interactive (button-click) commands — Dank Memer
-    // needs time to process the interaction before accepting the next command.
-    // Without this, the next command gets "Hold Tight" errors.
-    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'scratch', 'adventure', 'stream', 'fish', 'farm', 'work shift']);
-    if (INTERACTIVE_CMDS.has(item.cmd)) {
+    this._cmdRate.increment();
+
+    // Grace period for interactive commands — Dank Memer needs time to process
+    // the interaction before accepting the next command.
+    if (isInteractive) {
       await new Promise(r => setTimeout(r, 2500 + Math.random() * 1500));
     }
 
@@ -2549,8 +2694,6 @@ class AccountWorker {
       this.failStreak = 0;
     }
 
-  this.lastCommandRun = Date.now();
-
     // Exponential backoff: if too many consecutive failures, slow down
     const backoffMultiplier = this.failStreak > 5 ? Math.min(this.failStreak - 4, 5) : 1;
     // Minimum 5s cooldown for failed commands to prevent rapid-fire retries
@@ -2558,22 +2701,33 @@ class AccountWorker {
 
     if (this.commandQueue && this.running && !shutdownCalled) {
       const hasOverride = Number.isFinite(this._lastCooldownOverride) && this._lastCooldownOverride > 0;
-      let effectiveWait = hasOverride ? this._lastCooldownOverride : totalWait;
       this._lastCooldownOverride = null;
 
-      // Smart fallback floors for long/interactive commands when parser misses exact cooldown.
-      if (!hasOverride) {
-        const floor = AccountWorker.SMART_CD_FLOORS[item.cmd];
-        if (Number.isFinite(floor) && floor > 0) {
-          effectiveWait = Math.max(effectiveWait, floor);
+      let scheduledWaitSec;
+      if (hasOverride) {
+        // Exact cooldown returned by command parser — use it without jitter or backoff.
+        // This ensures work (1h), adventure (5h), stream (10m), farm (varies) are honored exactly.
+        scheduledWaitSec = Math.max(1, this._lastCooldownOverride);
+      } else {
+        // Jitter-based cooldown for commands without a parsed override.
+        let effectiveWait = totalWait;
+
+        // Smart fallback floors: static floor OR dynamically learned cooldown (whichever is higher).
+        // Learned cooldowns come from actual parsed responses and persist across restarts via Redis.
+        const staticFloor = AccountWorker.SMART_CD_FLOORS[item.cmd] || 0;
+        const learnedCd = this._learnedCooldowns.get(item.cmd) || 0;
+        const adaptiveFloor = Math.max(staticFloor, learnedCd);
+        if (adaptiveFloor > 0) {
+          effectiveWait = Math.max(effectiveWait, adaptiveFloor);
         }
-      }
 
-      if (earned <= 0 && !noFailCmds.includes(item.cmd) && effectiveWait < MIN_FAIL_COOLDOWN) {
-        effectiveWait = MIN_FAIL_COOLDOWN;
+        if (earned <= 0 && !noFailCmds.includes(item.cmd) && effectiveWait < MIN_FAIL_COOLDOWN) {
+          effectiveWait = MIN_FAIL_COOLDOWN;
+        }
+
+        scheduledWaitSec = Math.max(1, effectiveWait * backoffMultiplier);
       }
 
-      const scheduledWaitSec = Math.max(1, effectiveWait * backoffMultiplier);
       await this.setCooldown(item.cmd, scheduledWaitSec);
       item.nextRunAt = Date.now() + scheduledWaitSec * 1000;
       this.commandQueue.push(item);
@@ -2611,7 +2765,8 @@ class AccountWorker {
     this.failStreak = 0;
     this.cycleCount = 0;
     this.lastCommandRun = 0;
-    this.commandQueue = this.buildCommandQueue();
+    await this._loadLearnedCooldowns();
+    this.commandQueue = await this.buildCommandQueue();
     this.lastHealthCheck = Date.now();
 
     // Reactive alert listener: run `pls alert` only when Dank Memer
@@ -2713,11 +2868,28 @@ class AccountWorker {
                 headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
                 body: JSON.stringify({ action_id: action.id }),
               });
-            } catch {}
+            } catch (err) {
+              console.error(`[${this.username}] delete pending action error:`, err?.message || err);
+            }
+          }
+          if (action.action === 'check_profile' && !this.busy) {
+            this.log('info', 'Dashboard requested profile check');
+            await this.checkProfile().catch(() => {});
+            try {
+              await fetch(`${API_URL}/api/grinder/actions`, {
+                method: 'DELETE',
+                headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action_id: action.id }),
+              });
+            } catch (err) {
+              console.error(`[${this.username}] delete pending action error:`, err?.message || err);
+            }
           }
         }
       }
-    } catch { /* silent */ }
+    } catch (err) {
+      console.error(`[${this.username}] refreshConfig error:`, err?.message || err);
+    }
   }
 
   async start() {
@@ -2767,9 +2939,8 @@ class AccountWorker {
           { key: 'cmd_fish', l: 'fish' }, { key: 'cmd_beg', l: 'beg' },
           { key: 'cmd_search', l: 'search' }, { key: 'cmd_hl', l: 'hl' },
           { key: 'cmd_crime', l: 'crime' }, { key: 'cmd_pm', l: 'pm' },
-          { key: 'cmd_daily', l: 'daily' }, { key: 'cmd_weekly', l: 'weekly' },
-          { key: 'cmd_monthly', l: 'monthly' }, { key: 'cmd_work', l: 'work' },
-          { key: 'cmd_stream', l: 'stream' }, { key: 'cmd_scratch', l: 'scratch' },
+          { key: 'cmd_daily', l: 'daily' }, { key: 'cmd_monthly', l: 'monthly' },
+          { key: 'cmd_work', l: 'work' }, { key: 'cmd_stream', l: 'stream' },
           { key: 'cmd_adventure', l: 'adv' }, { key: 'cmd_farm', l: 'farm' },
           { key: 'cmd_tidy', l: 'tidy' }, { key: 'cmd_blackjack', l: 'bj' },
           { key: 'cmd_cointoss', l: 'toss' }, { key: 'cmd_roulette', l: 'roul' },
@@ -3048,9 +3219,30 @@ async function start(apiKey, apiUrl) {
   }
   loginLines.push(`  ${'─'.repeat(loginVis)}`);
   for (const l of loginLines) console.log(l);
-  loginLines = null;
+
+  // Dynamically capture the starting row of the login table via DSR
+  let loginBaseRow = 1;
+  const captureLoginRow = () => new Promise(resolve => {
+    process.stdout.write(MARKER);
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        loginBaseRow = parseInt(m[1], 10) + 1;
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    setTimeout(resolve, 50);
+  });
+  await captureLoginRow();
 
   let loginPending = new Array(accounts.length).fill(true);
+  const moveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
+
   const drawLoginSpinners = () => {
     for (let i = 0; i < loginPending.length; i++) {
       if (!loginPending[i]) continue;
@@ -3059,8 +3251,13 @@ async function start(apiKey, apiUrl) {
       const name = loginStates[i].name.substring(0, colName).padEnd(colName);
       const guild = c.dim + 'logging in...'.substring(0, colGuild) + c.reset;
       const cmds = c.dim + '···'.padEnd(colCmds) + c.reset;
-      process.stdout.write(`\r\x1b[2K  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${guild}  ${cmds}\x1b[K`);
+      const row = loginBaseRow + 1 + i; // +1 skips the top border line
+      moveToRow(row);
+      process.stdout.write(`  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${guild}  ${cmds}\x1b[K`);
     }
+    // Move cursor back to bottom to avoid overwriting the bottom border
+    const lastRow = loginBaseRow + 1 + accounts.length + 1;
+    moveToRow(lastRow);
   };
   const loginSpinnerInterval = setInterval(drawLoginSpinners, 80);
 
@@ -3089,7 +3286,9 @@ async function start(apiKey, apiUrl) {
       guild = 'timeout'.padEnd(colGuild);
       cmds = '···'.padEnd(colCmds);
     }
-    process.stdout.write(`\r\x1b[2K  ${num}  ${sts}  ${name}  ${c.dim}${guild}${c.reset}  ${c.dim}${cmds}${c.reset}\x1b[K`);
+    const row = loginBaseRow + 1 + idx; // +1 skips the top border line
+    moveToRow(row);
+    process.stdout.write(`  ${num}  ${sts}  ${name}  ${c.dim}${guild}${c.reset}  ${c.dim}${cmds}${c.reset}\x1b[K`);
   };
 
   const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '50'), 10);
@@ -3137,6 +3336,28 @@ async function start(apiKey, apiUrl) {
   const iColVal = 16;
   const invVis = 7 + iColNum + iColName + iColItems + iColVal + 12;
 
+  // Print a unique marker, query its position, then overwrite it with the table
+  process.stdout.write(MARKER);
+  let invBaseRow = 1;
+  const captureRow = () => new Promise(resolve => {
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        invBaseRow = parseInt(m[1], 10) + 1; // +1: first account row is after marker
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    setTimeout(resolve, 50);
+  });
+  await captureRow();
+
+  // Now print the inventory table starting at invBaseRow
+  const invMoveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
   console.log(`  ${'─'.repeat(invVis)}`);
   for (let i = 0; i < activeWorkers.length; i++) {
     const w = activeWorkers[i];
@@ -3155,7 +3376,8 @@ async function start(apiKey, apiUrl) {
     const filled = Math.round(pct * barW);
     const bar = rgb(34, 211, 238) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(barW - filled) + c.reset;
     const pctStr = `${Math.round(pct * 100)}%`;
-    process.stdout.write(`\r\x1b[2K  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Inventory...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - invPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  ${c.dim}${pctStr}${c.reset}  `);
+    invMoveToRow(invBaseRow);
+    process.stdout.write(`  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Inventory...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - invPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  ${c.dim}${pctStr}${c.reset}  \x1b[K`);
   };
   const invSpinnerInterval = setInterval(drawInvProgress, 80);
 
@@ -3171,7 +3393,9 @@ async function start(apiKey, apiUrl) {
     const sts = invRes?.ok ? `${rgb(52, 211, 153)}✓${c.reset}` : `${rgb(239, 68, 68)}✗${c.reset}`;
     const itemStr = `${items}`.padEnd(iColItems);
     const valStr = invRes?.ok ? `${c.green}⏣${val.toLocaleString()}${c.reset}` : `${c.dim}···${c.reset}`;
-    process.stdout.write(`\r\x1b[2K  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
+    const row = invBaseRow + 1 + i;
+    invMoveToRow(row);
+    process.stdout.write(`  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
     if (invRes?.ok) invDone++; else invFailed++;
   }));
 
@@ -3195,6 +3419,27 @@ async function start(apiKey, apiUrl) {
   const bColLs = 4;
   const balVis = 7 + bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 14;
 
+  // Capture starting row for balance phase
+  process.stdout.write(MARKER);
+  let balBaseRow = 1;
+  const balCaptureRow = () => new Promise(resolve => {
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        balBaseRow = parseInt(m[1], 10) + 1;
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    setTimeout(resolve, 50);
+  });
+  await balCaptureRow();
+
+  const balMoveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
   console.log(`  ${'─'.repeat(balVis)}`);
   for (let i = 0; i < activeWorkers.length; i++) {
     const w = activeWorkers[i];
@@ -3212,7 +3457,8 @@ async function start(apiKey, apiUrl) {
     const barW = Math.min(20, startupTw - 40);
     const filled = Math.round(pct * barW);
     const bar = rgb(251, 191, 36) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(barW - filled) + c.reset;
-    process.stdout.write(`\r\x1b[2K  ${rgb(251, 191, 36)}${spin}${c.reset}  ${c.dim}Balance...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - balPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  `);
+    balMoveToRow(balBaseRow);
+    process.stdout.write(`  ${rgb(251, 191, 36)}${spin}${c.reset}  ${c.dim}Balance...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - balPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  \x1b[K`);
   };
   const balSpinnerInterval = setInterval(drawBalProgress, 80);
 
@@ -3228,7 +3474,9 @@ async function start(apiKey, apiUrl) {
     const walletStr = `${c.green}⏣${wallet.toLocaleString()}${c.reset}`;
     const bankStr = `${c.cyan}⏣${bank.toLocaleString()}${c.reset}`;
     const totalStr = `${c.bold}⏣${(wallet + bank).toLocaleString()}${c.reset}`;
-    process.stdout.write(`\r\x1b[2K  ${num}  ${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${walletStr.padEnd(bColWallet + 4)}  ${bankStr.padEnd(bColBank + 4)}  ${totalStr.padEnd(bColTotal + 3)}  ${lsColor}♥${ls}${c.reset}\x1b[K`);
+    const row = balBaseRow + 1 + i;
+    balMoveToRow(row);
+    process.stdout.write(`  ${num}  ${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${walletStr.padEnd(bColWallet + 4)}  ${bankStr.padEnd(bColBank + 4)}  ${totalStr.padEnd(bColTotal + 3)}  ${lsColor}♥${ls}${c.reset}\x1b[K`);
     balDone++;
   }));