dankgrinder 6.46.0 → 7.6.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,
+  AhoCorasick, LRUCache, StringPool, AsyncBatchQueue, JitterBackoff,
 } = require('./structures');
 const PKG_VERSION = require('../package.json').version;
 
@@ -279,9 +279,9 @@ function boxTop(w, color) { return color + BOX.dtl + BOX.dh.repeat(w - 2) + BOX.
 function boxMid(w, color) { return color + BOX.tee + BOX.h.repeat(w - 2) + BOX.teeR + c.reset; }
 function boxBot(w, color) { return color + BOX.dbl + BOX.dh.repeat(w - 2) + BOX.dbr + c.reset; }
 function boxLine(content, w, color) {
-  const stripped = stripAnsi(content);
+  const stripped = content.replace(/\x1b\[[0-9;]*m/g, '');
   const pad = Math.max(0, w - 4 - stripped.length);
-  return color + BOX.dv + c.reset + ' ' + stripAnsi(content) + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
+  return color + BOX.dv + c.reset + ' ' + content + ' '.repeat(pad) + ' ' + color + BOX.dv + c.reset;
 }
 function thinLine(w) { return '  ' + c.dim + BOX.h.repeat(w - 4) + c.reset; }
 
@@ -868,8 +868,8 @@ const CMD_NAMES_CLEAN = {
   bj: 'Blackjack', blackjack: 'Blackjack', hl: 'High Low', pm: 'Post Memes', postmemes: 'Post Memes',
   ct: 'Coin Toss', cointoss: 'Coin Toss', se: 'Snake Eyes', snakeeyes: 'Snake Eyes',
   hunt: 'Hunt', dig: 'Dig', fish: 'Fish', beg: 'Beg', search: 'Search', crime: 'Crime',
-  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', monthly: 'Monthly',
-  adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
+  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', weekly: 'Weekly', monthly: 'Monthly',
+  scratch: 'Scratch', adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
   drops: 'Drops', use: 'Use Item', dep: 'Deposit', deposit: 'Deposit', inv: 'Inventory',
   work: 'Work', stream: 'Stream', roulette: 'Roulette', slots: 'Slots',
 };
@@ -1490,9 +1490,7 @@ class AccountWorker {
                 totalValue: result.totalValue || 0,
               }),
             });
-          } catch (err) {
-            console.error(`[${this.username}] inventory API error:`, err?.message || err);
-          }
+          } catch {}
 
           return {
             ok: true,
@@ -1569,9 +1567,7 @@ class AccountWorker {
             raw_text: result.rawText || '',
           }),
         });
-      } catch (err) {
-        console.error(`[${this.username}] profile API error:`, err?.message || err);
-      }
+      } catch {}
 
       return { ok: true, ...result };
     } catch (e) {
@@ -1780,48 +1776,22 @@ class AccountWorker {
   // Each modular command handler sends the command, waits for response,
   // handles Hold Tight / cooldowns / item-buying internally.
   async runCommand(cmdName, prefix) {
-    // 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'],
-    ]);
+    let cmdString;
     const bjBet = Math.max(5000, this.account.bet_amount || 5000);
     const gambBet = Math.max(10000, this.account.bet_amount || 10000);
 
-    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}`;
-      }
+    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}`;
     }
 
     if (shutdownCalled || !this.running) return;
@@ -1919,6 +1889,7 @@ 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;
@@ -1973,9 +1944,7 @@ class AccountWorker {
             headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
             body: JSON.stringify({ account_id: this.account.id, active: false }),
           });
-        } catch (err) {
-          console.error(`[${this.username}] status deactivation API error:`, err?.message || err);
-        }
+        } catch {}
         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;
@@ -2026,6 +1995,16 @@ class AccountWorker {
         return;
       }
 
+      // Died flag from crime/search handler (death detected in the command response)
+      if (cmdResult.died) {
+        this.log('error', `${cmdName} → DIED! Checking lifesaver count...`);
+        // The DM will come separately with the actual death details
+        // For now, be cautious — set a short cooldown and let DM listener handle the rest
+        await this.setCooldown('crime', 300); // 5 min cooldown to check DMs
+        await this.setCooldown('search', 300);
+        return;
+      }
+
       // Premium-only command detection — disable permanently
       if (resultLower.includes('only available on premium') || resultLower.includes('premium') ||
           resultLower.includes('buy the ability to use this command') ||
@@ -2044,9 +2023,8 @@ class AccountWorker {
         const timeMatch = result.match(/<t:(\d+):R>/);
         let waitSec;
         if (timeMatch) {
-          // 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]));
+          const nextAvail = parseInt(timeMatch[1]) * 1000;
+          waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
         } else {
           const defaultWaits = { daily: 86400, weekly: 604800, monthly: 2592000 };
           waitSec = defaultWaits[cmdName] || 86400;
@@ -2226,13 +2204,13 @@ class AccountWorker {
 
   // ── Command Map (shared across ticks, used to build the heap) ──
   // Priority: higher = runs first when multiple commands are ready simultaneously.
-  //   10 = time-gated (daily/monthly — never miss),
+  //   10 = time-gated (daily/weekly/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),
+  //    3 = interactive/long CD (adventure/stream/work/scratch),
   //    2 = utility (drops/use/tidy)
   static COMMAND_MAP = [
     // Gambling — 2-3s CD, highest frequency
@@ -2243,7 +2221,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
@@ -2254,19 +2232,20 @@ 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 },
-    { 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 },
+    // scratch removed — requires voting which can't be automated
+  { 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 },
-    // monthly — premium only
-    { key: 'cmd_monthly',   cmd: 'monthly',     cdKey: 'cd_monthly',  defaultCd: 2592000, priority: 10 },
+    { 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 },
     // 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);
 
@@ -2543,58 +2522,91 @@ class AccountWorker {
       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 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;
     }
 
-    // Re-insert waiting items back into the queue (they still have time to wait)
-    for (const item of waitingItems) {
-      this.commandQueue.push(item);
+    const item = this.commandQueue.pop();
+    if (!item) {
+      this.tickTimeout = setTimeout(() => this.tick(), 1000);
+      return;
     }
 
-    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;
-      }
-      this.setStatus('cooldown...');
-      this.tickTimeout = setTimeout(() => this.tick(), Math.max(100, Math.min(minWaitMs, 5000)));
+    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;
     }
 
-    // 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];
+    // 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 {}
+      }
+    }
 
-    // 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]);
+    // 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);
+      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;
     }
 
-    // Anti-detection: per-account jitter + micro-pauses for this command
+    this._cmdRate.increment();
+    this.busy = true;
     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;
 
@@ -2606,32 +2618,6 @@ class AccountWorker {
       await new Promise(r => setTimeout(r, minGap - timeSinceLastCmd));
     }
 
-    // TokenBucket rate limiter — prevent Discord 429s
-    if (!this._rateLimiter.consume(1)) {
-      const waitMs = this._rateLimiter.waitTime(1);
-      this.setStatus(`rate throttle (${Math.ceil(waitMs / 1000)}s)`);
-      if (this.commandQueue) this.commandQueue.push(item);
-      this.tickTimeout = setTimeout(() => this.tick(), waitMs);
-      return;
-    }
-
-    // Startup delay: don't send commands for the first 30s after grindLoop() starts.
-    // This prevents flooding Dank Memer during the Phase 2 inventory check which
-    // sends pls inv for all accounts simultaneously after login.
-    if (this._startupDelayUntil && now < this._startupDelayUntil) {
-      const waitMs = this._startupDelayUntil - now;
-      this.setStatus('warming up...');
-      item.nextRunAt = now + waitMs + 1000;
-      if (this.commandQueue) this.commandQueue.push(item);
-      this.tickTimeout = setTimeout(() => this.tick(), waitMs + 1000);
-      return;
-    }
-
-    this.busy = true;
-
-    // ── Run command (with interactive retry) ───────────────────
-    // Commands run ONE BY ONE — sequential execution, no concurrency within this account.
-    // Each runCommand() call waits for Dank Memer's Discord response before returning.
     const prefix = this.account.use_slash ? '/' : 'pls';
     this.setStatus(formatCommandName(item.cmd));
 
@@ -2645,40 +2631,15 @@ class AccountWorker {
       next_run_at: nextItemRun?.nextRunAt || null,
     });
 
-    // Interactive commands (button-click): retry up to 3 times on failure.
-    // Non-interactive commands run once.
-    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'adventure', 'stream', 'fish', 'farm', 'work shift']);
-    const isInteractive = INTERACTIVE_CMDS.has(item.cmd);
-    const maxAttempts = isInteractive ? 3 : 1;
-    let attempt = 0;
-    let lastError = null;
-    let earned = 0;
-    while (attempt < maxAttempts) {
-      attempt++;
-      try {
-        const beforeCoins = this.stats.coins;
-        await this.runCommand(item.cmd, prefix);
-        earned = this.stats.coins - beforeCoins;
-        lastError = null;
-        this.lastCommandRun = Date.now();
-        break; // success
-      } catch (err) {
-        lastError = err;
-        this.log('warn', `${item.cmd} attempt ${attempt}/${maxAttempts} failed: ${err.message}`);
-        if (attempt < maxAttempts) {
-          await new Promise(r => setTimeout(r, 1000 + Math.random() * 1000));
-        }
-      }
-    }
-    if (lastError) {
-      this.log('error', `${item.cmd} failed after ${maxAttempts} attempts — skipping`);
-    }
-
-    this._cmdRate.increment();
+    const beforeCoins = this.stats.coins;
+    await this.runCommand(item.cmd, prefix);
+    const earned = this.stats.coins - beforeCoins;
 
-    // Grace period for interactive commands — Dank Memer needs time to process
-    // the interaction before accepting the next command.
-    if (isInteractive) {
+    // 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)) {
       await new Promise(r => setTimeout(r, 2500 + Math.random() * 1500));
     }
 
@@ -2696,6 +2657,8 @@ 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
@@ -2767,11 +2730,6 @@ class AccountWorker {
     this.failStreak = 0;
     this.cycleCount = 0;
     this.lastCommandRun = 0;
-    // Delay first command by 30s to avoid competing with Phase 2 inventory check
-    // which sends pls inv for all accounts simultaneously after login.
-    // Without this, the grind loop floods Dank Memer with commands during the
-    // login surge, triggering rate-limits that cause Phase 2 inventory to fail.
-    this._startupDelayUntil = Date.now() + 30000;
     await this._loadLearnedCooldowns();
     this.commandQueue = await this.buildCommandQueue();
     this.lastHealthCheck = Date.now();
@@ -2875,9 +2833,7 @@ class AccountWorker {
                 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 {}
           }
           if (action.action === 'check_profile' && !this.busy) {
             this.log('info', 'Dashboard requested profile check');
@@ -2888,15 +2844,11 @@ class AccountWorker {
                 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 {}
           }
         }
       }
-    } catch (err) {
-      console.error(`[${this.username}] refreshConfig error:`, err?.message || err);
-    }
+    } catch { /* silent */ }
   }
 
   async start() {
@@ -2946,8 +2898,9 @@ 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_monthly', l: 'monthly' },
-          { key: 'cmd_work', l: 'work' }, { key: 'cmd_stream', l: 'stream' },
+          { 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_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' },
@@ -3172,38 +3125,19 @@ async function start(apiKey, apiUrl) {
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
     rawLogger.init(REDIS_URL).catch(() => {});
-    // Live DM listener: detect deaths and level-ups in real-time across all accounts
+    // Listen for DM death events across all accounts
     rawLogger.onDmEvent((event, raw) => {
-      const dmChannelId = raw.channel_id;
-
-      // Find which worker owns this DM channel
-      const worker = workers.find(w => w._dmChannelId === dmChannelId);
-      if (!worker) return;
-
-      if (event.type === 'death') {
-        const lsLeft = event.lifesaversLeft;
-
-        if (lsLeft === 0) {
-          // 0 lifesavers — disable crime/search immediately
-          worker.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
-          worker.setCooldown?.('crime', 86400);
-          worker.setCooldown?.('search', 86400);
-          worker._lifesavers = 0;
-          sendWebhook?.('DEATH ALERT (DM)', `**${worker.username}** died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
-        } else if (lsLeft > 0) {
-          // Lifesaver(s) used — update count in real-time
-          worker._lifesavers = lsLeft;
-          worker.log?.('warn', `Lifesaver used! ${lsLeft} remaining.`);
-          if (lsLeft <= 2) {
-            sendWebhook?.('LOW LIFESAVERS', `**${worker.username}** died! Only **${lsLeft}** lifesaver(s) left!`, 0xfbbf24);
+      if (event.type === 'death' && event.lifesaversLeft === 0) {
+        const channelId = raw.channel_id;
+        // Find which worker uses this DM channel and disable their crime/search
+        for (const w of workers) {
+          if (w.client?.user?.dmChannel?.id === channelId || w.channel?.id) {
+            w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
+            w.setCooldown?.('crime', 86400);
+            w.setCooldown?.('search', 86400);
           }
         }
-      } else if (event.type === 'levelup') {
-        // Level up — update in-memory level
-        if (event.to > 0) {
-          worker._level = event.to;
-          worker.log?.('info', `Level up! Now level ${event.to}.`);
-        }
+        sendWebhook?.('DEATH ALERT (DM)', `Account died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
       }
     });
     checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}RawLog${c.reset}`);
@@ -3217,21 +3151,39 @@ async function start(apiKey, apiUrl) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
-  // ── Phase 1: Login — inline table with per-row updates ─────────
+  // ── Phase 1: Login with per-account inline rendering ─────────────────────────
   const startupTw = process.stdout.columns || 90;
-  const colNum = 4;
-  const colSts = 3;
+  const colNum = 4;    // "  #"
+  const colSts = 3;    // "ST"
   const colName = Math.min(24, Math.max(12, Math.floor(startupTw * 0.25)));
   const colGuild = Math.min(18, Math.max(8, Math.floor(startupTw * 0.2)));
   const colCmds = 8;
   const loginVis = colNum + colSts + colName + colGuild + colCmds + 10;
 
-  // Use DSR to find starting row, then use explicit row numbers for all table writes.
-  // This avoids relying on cursor tracking via \n which varies by terminal.
-  let tableTopRow = 1;
-  let pendingSet = new Set(Array.from({ length: accounts.length }, (_, i) => i));
-  const captureTopRow = () => new Promise(resolve => {
-    process.stdout.write('\x1b[6n');
+  const loginStates = accounts.map((acc, i) => ({
+    name: acc.label || acc.id || '?',
+    done: false,
+    failed: false,
+    worker: null,
+  }));
+
+  let loginLines = [];
+  loginLines.push(`  ${'─'.repeat(loginVis)}`);
+  for (let i = 0; i < loginStates.length; i++) {
+    const s = loginStates[i];
+    const num = `${c.dim}${(i + 1).toString().padStart(colNum - 1)}${c.reset}`;
+    const name = s.name.substring(0, colName).padEnd(colName);
+    const guild = c.dim + '···'.padEnd(colGuild) + c.reset;
+    const cmds = c.dim + '···'.padEnd(colCmds) + c.reset;
+    loginLines.push(`  ${num}  ${c.dim}··${c.reset}  ${name}  ${guild}  ${cmds}`);
+  }
+  loginLines.push(`  ${'─'.repeat(loginVis)}`);
+  for (const l of loginLines) console.log(l);
+
+  // 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);
@@ -3239,52 +3191,51 @@ async function start(apiKey, apiUrl) {
       const m = raw.match(/\x1b\[(\d+);\d+R/);
       if (m) {
         process.stdin.removeListener('data', handler);
-        tableTopRow = parseInt(m[1], 10);
+        loginBaseRow = parseInt(m[1], 10) + 1;
         resolve();
       }
     };
     process.stdin.on('data', handler);
     setTimeout(resolve, 50);
   });
-  await captureTopRow();
-
-  // Absolute row numbers for all table elements (calculated from captured top row)
-  const borderTopRow = tableTopRow;           // border
-  const dataStartRow = tableTopRow + 1;       // first account row
-  const borderBotRow = tableTopRow + accounts.length + 1; // bottom border
-  const bottomRow = borderBotRow + 1;          // cursor final position after table
-
-  // Print initial table using explicit row positioning
-  process.stdout.write(`\x1b[${borderTopRow};1H  ${'─'.repeat(loginVis)}`);
-  for (let i = 0; i < accounts.length; i++) {
-    const row = dataStartRow + i;
-    const name = (accounts[i].label || accounts[i].id || '?').substring(0, colName).padEnd(colName);
-    const num = `${c.dim}${(i + 1).toString().padStart(colNum - 1)}${c.reset}`;
-    process.stdout.write(`\x1b[${row};1H  ${num}  ${c.dim}··${c.reset}  ${name}  ${c.dim}${'···'.padEnd(colGuild)}${c.reset}  ${c.dim}${'···'.padEnd(colCmds)}${c.reset}\x1b[K`);
-  }
-  process.stdout.write(`\x1b[${borderBotRow};1H  ${'─'.repeat(loginVis)}\x1b[K`);
+  await captureLoginRow();
+
+  let loginPending = new Array(accounts.length).fill(true);
+  const moveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
 
-  // Spinner: updates rows inline using absolute row numbers
   const drawLoginSpinners = () => {
-    for (const i of pendingSet) {
+    for (let i = 0; i < loginPending.length; i++) {
+      if (!loginPending[i]) continue;
       const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
-      const name = (accounts[i].label || accounts[i].id || '?').substring(0, colName).padEnd(colName);
       const num = `${c.dim}${(i + 1).toString().padStart(colNum - 1)}${c.reset}`;
-      process.stdout.write(`\x1b[${dataStartRow + i};1H  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${c.dim}${'logging in...'.substring(0, colGuild)}${c.reset}  ${c.dim}${'···'.padEnd(colCmds)}${c.reset}\x1b[K`);
-    }
+      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;
+      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 loginSpinner = setInterval(drawLoginSpinners, 80);
+  const loginSpinnerInterval = setInterval(drawLoginSpinners, 80);
+
+  const finalizeLoginLine = (idx, worker) => {
+    if (!loginPending[idx]) return;
+    loginPending[idx] = false;
+    const s = loginStates[idx];
+    s.done = true;
+    s.worker = worker;
 
-  const finalizeLoginRow = (idx, worker) => {
-    if (!pendingSet.has(idx)) return;
-    pendingSet.delete(idx);
     const num = `${c.dim}${(idx + 1).toString().padStart(colNum - 1)}${c.reset}`;
-    const name = (worker.username || accounts[idx].label || accounts[idx].id || '?').substring(0, colName).padEnd(colName);
+    const name = (worker.username || s.name || '?').substring(0, colName).padEnd(colName);
     let sts, guild, cmds;
     if (worker._tokenInvalid) {
       sts = `${rgb(239, 68, 68)}✗${c.reset}`;
       guild = 'INVALID'.padEnd(colGuild);
       cmds = '···'.padEnd(colCmds);
+      s.failed = true;
     } else if (worker.channel) {
       sts = `${rgb(52, 211, 153)}✓${c.reset}`;
       const gn = (worker.channel.guild?.name || worker.channel.guild?.id || 'DM').substring(0, colGuild);
@@ -3295,7 +3246,9 @@ async function start(apiKey, apiUrl) {
       guild = 'timeout'.padEnd(colGuild);
       cmds = '···'.padEnd(colCmds);
     }
-    process.stdout.write(`\x1b[${dataStartRow + idx};1H  ${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);
@@ -3313,34 +3266,58 @@ async function start(apiKey, apiUrl) {
       const worker = new AccountWorker(acc, i + idx);
       workers.push(worker);
       workerMap.set(acc.id, worker);
+      loginStates[i + idx].worker = worker;
       await worker.start();
-      finalizeLoginRow(i + idx, worker);
+      finalizeLoginLine(i + idx, worker);
     }));
     if (i + BATCH_SIZE < accounts.length) await new Promise(r => setTimeout(r, randomLoginGap()));
     hintGC();
   }
 
-  clearInterval(loginSpinner);
+  clearInterval(loginSpinnerInterval);
+  const loginDone = workers.filter(w => !w._tokenInvalid && w.channel).length;
   const invalidWorkers = workers.filter(w => w._tokenInvalid);
   const timedOutWorkers = workers.filter(w => !w.channel && !w._tokenInvalid);
-  const activeWorkers = workers.filter(w => !w._tokenInvalid);
-  const loginDone = activeWorkers.filter(w => w.channel).length;
-  // Clear bottom border row, move to new line, print login complete
-  process.stdout.write(`\x1b[${borderBotRow};1H\x1b[2K\n  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Login complete${c.reset}  ${rgb(52, 211, 153)}${loginDone}${c.reset}${c.dim}/${c.reset}${c.white}${accounts.length}${c.reset} ${c.dim}accounts connected${c.reset}\n`);
+  console.log(`\r\x1b[2K  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Login complete${c.reset}  ${rgb(52, 211, 153)}${loginDone}${c.reset}${c.dim}/${c.reset}${c.white}${accounts.length}${c.reset} ${c.dim}accounts connected${c.reset}`);
+  console.log('');
   if (invalidWorkers.length > 0) {
-    console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  ${c.bold}${c.red}${invalidWorkers.length} INVALID token(s):${c.reset} ${invalidWorkers.map(w => w.account.label || w.account.id).join(', ')}`);
+    log('warn', `${rgb(239, 68, 68)}${invalidWorkers.length} account(s) have INVALID tokens:${c.reset}`);
+    for (const w of invalidWorkers) log('error', `  ✗ ${w.account.label || w.account.id} — token is invalid or expired`);
+    console.log('');
   }
   if (timedOutWorkers.length > 0) log('warn', `${timedOutWorkers.length} account(s) timed out during login (will retry in background)`);
-  console.log('');
 
-  // ── Phase 2: Inventory check — clean sequential table ─────────
+  const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
+  // ── Phase 2: Inventory check — spinner for pending count, results inline ─────────
   const iColNum = 4;
   const iColName = Math.min(22, Math.max(12, Math.floor(startupTw * 0.22)));
   const iColItems = 8;
   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];
@@ -3350,31 +3327,40 @@ async function start(apiKey, apiUrl) {
   }
   console.log(`  ${'─'.repeat(invVis)}`);
 
-  const invResults = await Promise.all(activeWorkers.map(async (w, i) => {
-    try {
-      return await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 5, silent: true });
-    } catch {
-      return { ok: false };
-    }
-  }));
+  let invDone = 0, invFailed = 0, invPending = activeWorkers.length;
+  const drawInvProgress = () => {
+    if (invPending === 0) return;
+    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+    const pct = activeWorkers.length > 0 ? ((activeWorkers.length - invPending) / activeWorkers.length) : 0;
+    const barW = Math.min(20, startupTw - 40);
+    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)}%`;
+    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);
 
-  let invDone = 0, invFailed = 0;
-  // Re-print table with results
-  console.log(`  ${'─'.repeat(invVis)}`);
-  for (let i = 0; i < activeWorkers.length; i++) {
-    const invRes = invResults[i] || { ok: false };
-    const w = activeWorkers[i];
+  await Promise.all(activeWorkers.map(async (w, i) => {
     const num = `${c.dim}${(i + 1).toString().padStart(iColNum - 1)}${c.reset}`;
     const name = (w.username || w.account.label || '?').substring(0, iColName).padEnd(iColName);
+    let invRes;
+    try { invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
+    catch { invRes = { ok: false }; }
+    invPending--;
     const items = invRes?.ok ? (invRes.result?.items?.length || 0) : 0;
     const val = invRes?.ok ? (invRes.result?.totalValue || 0) : 0;
     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}`;
-    console.log(`  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}`);
+    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++;
-  }
-  console.log(`  ${'─'.repeat(invVis)}`);
+  }));
+
+  clearInterval(invSpinnerInterval);
+  process.stdout.write(`\r\x1b[2K`);
 
   if (invFailed > 0) {
     console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  ${c.bold}Inventory incomplete${c.reset}  ${rgb(52, 211, 153)}${invDone}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset} ${c.dim}done, ${rgb(239, 68, 68)}${invFailed} failed${c.reset}`);
@@ -3384,7 +3370,7 @@ async function start(apiKey, apiUrl) {
   console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Inventory complete${c.reset}  ${rgb(52, 211, 153)}${invDone}/${activeWorkers.length}${c.reset} ${c.dim}all clear${c.reset}`);
   console.log('');
 
-  // ── Phase 2.5: Balance check — clean sequential table ─────────
+  // ── Phase 2.5: Balance check — inline table, single spinner for progress ─────────
   const bColNum = 4;
   const bColName = Math.min(22, Math.max(12, Math.floor(startupTw * 0.22)));
   const bColWallet = 12;
@@ -3393,6 +3379,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];
@@ -3402,14 +3409,22 @@ async function start(apiKey, apiUrl) {
   }
   console.log(`  ${'─'.repeat(balVis)}`);
 
-  await Promise.all(activeWorkers.map(async (w) => {
-    try { await w.checkBalance(true); } catch {}
-  }));
+  let balDone = 0, balPending = activeWorkers.length;
+  const drawBalProgress = () => {
+    if (balPending === 0) return;
+    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+    const pct = activeWorkers.length > 0 ? ((activeWorkers.length - balPending) / activeWorkers.length) : 0;
+    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;
+    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);
 
-  // Re-print table with results
-  console.log(`  ${'─'.repeat(balVis)}`);
-  for (let i = 0; i < activeWorkers.length; i++) {
-    const w = activeWorkers[i];
+  await Promise.all(activeWorkers.map(async (w, i) => {
+    try { await w.checkBalance(true); } catch {}
+    balPending--;
     const num = `${c.dim}${(i + 1).toString().padStart(bColNum - 1)}${c.reset}`;
     const name = (w.username || w.account.label || '?').substring(0, bColName).padEnd(bColName);
     const wallet = w.stats?.balance || 0;
@@ -3419,9 +3434,14 @@ 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}`;
-    console.log(`  ${num}  ${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${walletStr.padEnd(bColWallet + 4)}  ${bankStr.padEnd(bColBank + 4)}  ${totalStr.padEnd(bColTotal + 3)}  ${lsColor}♥${ls}${c.reset}`);
-  }
-  console.log(`  ${'─'.repeat(balVis)}`);
+    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++;
+  }));
+
+  clearInterval(balSpinnerInterval);
+  process.stdout.write(`\r\x1b[2K`);
 
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
   for (const w of activeWorkers) {
@@ -3435,6 +3455,7 @@ async function start(apiKey, apiUrl) {
   }
   console.log('');
 
+
   // Phase 2.75: Check DM history for deaths/level-ups (sequential, fast)
   console.log(`  ${rgb(139, 92, 246)}${BRAILLE_SPIN[0]}${c.reset}  ${c.dim}Checking DM history...${c.reset}`);
   let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [];