dankgrinder 6.17.0 → 6.21.0

package/lib/grinder.js

@@ -487,7 +487,7 @@ function renderDashboard() {
   lines.push(bEmpty);
 
   // ═══════════════════════════════════════════════════════════════
-  //  STATS PANEL
+  //  STATS PANEL (split: left = metrics, right = big trend)
   // ═══════════════════════════════════════════════════════════════
   lines.push(bSep);
   lines.push(bEmpty);
@@ -495,32 +495,44 @@ function renderDashboard() {
   // Earnings sparkline data
   const now = Date.now();
   if (now - lastEarningsSample > 8000) { earningsHistory.push(totalCoins); lastEarningsSample = now; }
-  const sparkW = Math.min(30, Math.floor(iw * 0.3));
-  const spark = drawSparkline(earningsHistory.toArray(), sparkW);
-
-  // Row 1: Balance + Earned
   const elapsedHrs = (Date.now() - startTime) / 3_600_000;
   const perHr = elapsedHrs > 0.01 ? Math.round(totalCoins / elapsedHrs) : 0;
   const peakFlag = isNewHigh ? `  ${R}${c.bold}* NEW HIGH *${c.reset}` : '';
 
-  lines.push(bRow(`   ${Au}⟐${c.reset} ${D}BALANCE${c.reset}  ${c.bold}${Au}⏣ ${formatCoins(totalBalance)}${c.reset}        ${G}▲${c.reset} ${D}EARNED${c.reset}  ${c.bold}${G}+⏣ ${formatCoins(totalCoins)}${c.reset} ${D}(${c.reset}${G}${formatCoins(perHr)}/h${c.reset}${D})${c.reset}${peakFlag}`));
-
-  // Row 2: Peak + Trend sparkline
-  lines.push(bRow(`   ${O}★${c.reset} ${D}PEAK${c.reset}     ${c.bold}${O}⏣ ${formatCoins(sessionPeakCoins)}${c.reset}        ${A}~${c.reset} ${D}TREND${c.reset}   ${spark}`));
-
-  // Row 3: Commands + Success + Rate + Uptime
+  // Left column: fixed metrics (left-aligned)
   const cpmVal = globalCmdRate.getRate().toFixed(1);
   const srColor = successRate >= 95 ? G : successRate >= 80 ? Y : R;
-  const srBarW = Math.min(15, Math.floor(iw * 0.12));
+  const srBarW = Math.min(15, Math.floor(iw * 0.1));
   const srBar = progressBar(successRate, 100, srBarW, successRate >= 95 ? [52, 211, 153] : successRate >= 80 ? [251, 191, 36] : [239, 68, 68]);
-  lines.push(bRow(`   ${B}◆${c.reset} ${D}CMDS${c.reset}     ${c.bold}${B}${totalCommands}${c.reset}  ${srColor}${successRate}%${c.reset} ${srBar}  ${Cy}${cpmVal}${c.reset}${D}/min${c.reset}        ${Y}◷${c.reset} ${D}UP${c.reset} ${c.bold}${Y}${formatUptime()}${c.reset}`));
-
-  // Row 4: Memory
   const memMB = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
   const memCol = memMB > 900 ? [239, 68, 68] : memMB > 600 ? [251, 191, 36] : [52, 211, 153];
-  const memBarW = Math.min(20, Math.floor(iw * 0.15));
+  const memBarW = Math.min(15, Math.floor(iw * 0.1));
   const memBar = progressBar(memMB, 1024, memBarW, memCol, [40, 40, 55]);
-  lines.push(bRow(`   ${D}≡${c.reset} ${D}MEM${c.reset}      ${rgb(memCol[0], memCol[1], memCol[2])}${c.bold}${memMB}MB${c.reset}  ${memBar}`));
+
+  // Right column: big trend sparkline
+  const sparkW = Math.floor(iw * 0.42);
+  const spark = drawSparkline(earningsHistory.toArray(), sparkW);
+
+  // Build split rows
+  const leftHalf = Math.floor(iw * 0.52);
+
+  // Row 1: Balance + EARNED  |  TREND (big sparkline)
+  const leftRow1 = `${Au}⟐${c.reset} ${D}BALANCE${c.reset}  ${c.bold}${Au}⏣ ${formatCoins(totalBalance)}${c.reset}   ${G}▲${c.reset} ${D}EARNED${c.reset}  ${c.bold}${G}+⏣ ${formatCoins(totalCoins)}${c.reset}${peakFlag}`;
+  const rightRow1 = `${A}~${c.reset} ${D}TREND${c.reset}  ${spark}`;
+  const combined1 = `${leftRow1}${' '.repeat(Math.max(2, leftHalf - leftRow1.replace(RE, '').length))}${rightRow1}`;
+  lines.push(bRow(`   ${combined1}`));
+
+  // Row 2: Peak (left)
+  const peakRow = `${O}★${c.reset} ${D}PEAK${c.reset}     ${c.bold}${O}⏣ ${formatCoins(sessionPeakCoins)}${c.reset}`;
+  lines.push(bRow(`   ${peakRow}${' '.repeat(Math.max(2, leftHalf - peakRow.replace(RE, '').length))}${Y}◷${c.reset} ${D}UP${c.reset}  ${c.bold}${Y}${formatUptime()}${c.reset}`));
+
+  // Row 3: CMDS (left) + success bar + rate
+  const cmdsRow = `${B}◆${c.reset} ${D}CMDS${c.reset}     ${c.bold}${B}${totalCommands}${c.reset}  ${srColor}${successRate}%${c.reset} ${srBar}  ${Cy}${cpmVal}${c.reset}${D}/min${c.reset}`;
+  lines.push(bRow(`   ${cmdsRow}`));
+
+  // Row 4: MEM (left)
+  const memRow = `${D}≡${c.reset} ${D}MEM${c.reset}      ${rgb(memCol[0], memCol[1], memCol[2])}${c.bold}${memMB}MB${c.reset}  ${memBar}`;
+  lines.push(bRow(`   ${memRow}`));
 
   lines.push(bEmpty);
 
@@ -1499,7 +1511,7 @@ class AccountWorker {
     }
   }
 
-  async checkBalance() {
+  async checkBalance(silent = false) {
     const prefix = this.account.use_slash ? '/' : 'pls';
     const sentAt = Date.now();
 
@@ -1507,219 +1519,129 @@ class AccountWorker {
       if (!t) return false;
       const lower = t.toLowerCase();
       return lower.includes('balance') || lower.includes('balances') || lower.includes('global rank')
-        || lower.includes('wallet') || /<a?:coin:\d+>/.test(t) || /<a?:bank:\d+>/.test(t);
-    };
-
-    const readBalanceText = async (msg, forceCV2 = false) => {
-      if (!msg) return '';
-      const needsCv2 = forceCV2
-        || isCV2(msg)
-        || (Array.isArray(msg.components) && msg.components.length > 0
-          && (!msg.content || msg.content.length === 0)
-          && (!msg.embeds || msg.embeds.length === 0));
-      if (needsCv2) await ensureCV2(msg, forceCV2);
-      return stripAnsi(getFullText(msg)).replace(/\s+/g, ' ').trim();
-    };
-
-    const findRecentBalanceMessage = async () => {
-      if (!this.channel?.messages?.fetch) return null;
-      for (let attempt = 0; attempt < 6; attempt++) {
-        try {
-          const recent = await this.channel.messages.fetch({ limit: 12 });
-          const candidates = [...recent.values()].filter((m) =>
-            m?.author?.id === DANK_MEMER_ID && (m.createdTimestamp || 0) >= sentAt - 10000
-          );
-          for (const m of candidates) {
-            const t = await readBalanceText(m, true);
-            if (looksLikeBalance(t)) return m;
-          }
-        } catch {}
-        await new Promise((r) => setTimeout(r, 700));
-      }
-      return null;
+        || lower.includes('wallet') || /<a?:coin:\d+>/i.test(t) || /<a?:bank:\d+>/i.test(t);
     };
 
+    // Fast path: send command, wait 3s, read from rawLogger
     if (this.account.use_slash && this.channel?.sendSlash) {
       await this.channel.sendSlash(DANK_MEMER_ID, 'balance').catch(() => this.channel.send('/balance'));
     } else {
       await this.channel.send(`${prefix} bal`);
     }
-    let response = await this.waitForDankMemer(12000);
+    await new Promise(r => setTimeout(r, 3000));
 
-    // Fallback for slash setup: try legacy prefix if no slash response.
-    if (!response && this.account.use_slash) {
-      await this.channel.send('pls bal');
-      response = await this.waitForDankMemer(12000);
+    // Try rawLogger first — it captures CV2 text from gateway instantly
+    let text = '';
+    const rawData = rawLogger.getLastRaw(this.channel?.id);
+    if (rawData && rawData.cv2Text && looksLikeBalance(rawData.cv2Text)) {
+      text = rawData.cv2Text;
+    } else if (rawData && rawData.allText && looksLikeBalance(rawData.allText)) {
+      text = rawData.allText;
     }
 
-    if (response) {
-      let text = await readBalanceText(response);
-
-      // Dank Memer sometimes sends empty first payload then edits in the full card.
-      if ((!text || !looksLikeBalance(text)) && response.id) {
-        const edited = await this.waitForMessageUpdate(response.id, 8000);
-        if (edited) {
-          text = await readBalanceText(edited, true);
-          response = edited;
-        }
+    // If rawLogger didn't capture it, fall back to waitForDankMemer
+    if (!text || !looksLikeBalance(text)) {
+      let response = await this.waitForDankMemer(8000);
+      if (!response && this.account.use_slash) {
+        await this.channel.send('pls bal');
+        response = await this.waitForDankMemer(8000);
       }
-
-      // If we received a stale/irrelevant update, fetch same message fresh.
-      if ((!text || !looksLikeBalance(text)) && response.id && this.channel?.messages?.fetch) {
-        const fetched = await Promise.resolve(this.channel.messages.fetch(response.id)).catch(() => null);
-        if (fetched) {
-          const fetchedText = await readBalanceText(fetched, true);
-          if (fetchedText) {
-            text = fetchedText;
-            response = fetched;
-          }
-        }
+      if (response) {
+        if (isCV2(response)) await ensureCV2(response);
+        text = stripAnsi(getFullText(response)).replace(/\s+/g, ' ').trim();
       }
-
-      // Fallback: scan latest Dank messages right after command send.
+      // One more rawLogger check after the wait
       if (!text || !looksLikeBalance(text)) {
-        const recentBalance = await findRecentBalanceMessage();
-        if (recentBalance) {
-          text = await readBalanceText(recentBalance, true);
-          response = recentBalance;
-        }
-      }
-
-      // Last resort: wait for CV2 content propagation then re-fetch
-      if ((!text || !looksLikeBalance(text)) && response.id && this.channel?.messages?.fetch) {
-        await new Promise(r => setTimeout(r, 3000));
-        try {
-          const fresh = await this.channel.messages.fetch(response.id);
-          if (fresh) {
-            const freshText = await readBalanceText(fresh, true);
-            if (freshText && looksLikeBalance(freshText)) {
-              text = freshText;
-              response = fresh;
-            }
-          }
-        } catch {}
-      }
-
-      // Absolute last: re-scan channel messages after the extra wait
-      if (!text || !looksLikeBalance(text)) {
-        const recentBalance2 = await findRecentBalanceMessage();
-        if (recentBalance2) {
-          text = await readBalanceText(recentBalance2, true);
-          response = recentBalance2;
-        }
-      }
-
-      // Raw logger fallback — CV2 text is captured directly from gateway
-      if (!text || !looksLikeBalance(text)) {
-        const rawData = rawLogger.getLastRaw(this.channel?.id);
-        if (rawData && rawData.cv2Text) {
-          const rawText = rawData.cv2Text;
-          if (looksLikeBalance(rawText)) {
-            text = rawText;
-            this.log('debug', 'Balance: using rawLogger CV2 text fallback');
-          }
-        }
-        // Also try from Redis raw message
-        if ((!text || !looksLikeBalance(text)) && response?.id) {
-          try {
-            const rawMsg = await rawLogger.getMsg(response.id);
-            if (rawMsg?.allText && looksLikeBalance(rawMsg.allText)) {
-              text = rawMsg.allText;
-              this.log('debug', 'Balance: using rawLogger Redis fallback');
-            }
-          } catch {}
-        }
-      }
-
-      if (!text) {
-        this.log('warn', 'Balance response was empty after waiting for update');
-        return;
-      }
-
-      if (!looksLikeBalance(text)) {
-        this.log('warn', `Balance response did not look like balance card: "${text.substring(0, 140)}"`);
-        return;
+        const raw2 = rawLogger.getLastRaw(this.channel?.id);
+        if (raw2?.cv2Text && looksLikeBalance(raw2.cv2Text)) text = raw2.cv2Text;
+        else if (raw2?.allText && looksLikeBalance(raw2.allText)) text = raw2.allText;
       }
+    }
 
-      let wallet = 0;
-      let bank = 0;
-      let matched = '';
+    if (!text || !looksLikeBalance(text)) {
+      this.log('warn', 'Balance: no data after all attempts');
+      return;
+    }
 
-    // CV2 format: <:Coin:ID> 3,272,896 and <:Bank:ID> 275,000 / 275,000
+    // Parse wallet and bank
+    let wallet = 0, bank = 0, matched = '';
     const coinMatch = text.match(/<a?:Coin:\d+>\s*([\d,]+)/i);
     const bankEmojiMatch = text.match(/<a?:Bank:\d+>\s*([\d,]+)/i);
     const bankSlashMatch = text.match(/(?:<a?:Bank:\d+>\s*)?([\d,]+)\s*\/\s*[\d,]+/i);
 
-      // Legacy embed format: Wallet: ⏣ 1,234,567
-      const walletMatch = text.match(/wallet[:\s]*\*{0,2}\s*[⏣💰]?\s*\*{0,2}\s*([\d,]+)/i);
-      const bankTextMatch = text.match(/bank[:\s]*\*{0,2}\s*[⏣💰]?\s*\*{0,2}\s*([\d,]+)/i);
+    // Legacy embed format: Wallet: ⏣ 1,234,567
+    const walletMatch = text.match(/wallet[:\s]*\*{0,2}\s*[⏣💰]?\s*\*{0,2}\s*([\d,]+)/i);
+    const bankTextMatch = text.match(/bank[:\s]*\*{0,2}\s*[⏣💰]?\s*\*{0,2}\s*([\d,]+)/i);
 
-      // Fallback: any numbers near ⏣ or just plain numbers in CV2 text
-      const allNums = [...text.matchAll(/(?:⏣\s*)?(\d[\d,]*\d)/g)].map(m => parseInt(m[1].replace(/,/g, ''), 10)).filter(n => n > 0);
+    // Fallback: any numbers near ⏣ or just plain numbers in CV2 text
+    const allNums = [...text.matchAll(/(?:⏣\s*)?(\d[\d,]*\d)/g)].map(m => parseInt(m[1].replace(/,/g, ''), 10)).filter(n => n > 0);
 
-      if (coinMatch) {
-        wallet = parseInt(coinMatch[1].replace(/,/g, ''), 10);
-        matched = 'cv2-emoji';
-      } else if (walletMatch) {
-        wallet = parseInt(walletMatch[1].replace(/,/g, ''), 10);
-        matched = 'legacy-wallet';
-      } else if (allNums.length > 0) {
-        wallet = Math.max(...allNums);
-        matched = 'fallback-nums';
-      }
+    if (coinMatch) {
+      wallet = parseInt(coinMatch[1].replace(/,/g, ''), 10);
+      matched = 'cv2-emoji';
+    } else if (walletMatch) {
+      wallet = parseInt(walletMatch[1].replace(/,/g, ''), 10);
+      matched = 'legacy-wallet';
+    } else if (allNums.length > 0) {
+      wallet = Math.max(...allNums);
+      matched = 'fallback-nums';
+    }
 
-      if (bankEmojiMatch) {
-        bank = parseInt(bankEmojiMatch[1].replace(/,/g, ''), 10);
-        matched += matched ? '+bank-emoji' : 'bank-emoji';
-      } else if (bankTextMatch) {
-        bank = parseInt(bankTextMatch[1].replace(/,/g, ''), 10);
-        matched += matched ? '+bank-text' : 'bank-text';
-      } else if (bankSlashMatch) {
-        bank = parseInt(bankSlashMatch[1].replace(/,/g, ''), 10);
-        matched += matched ? '+bank-slash' : 'bank-slash';
-      }
+    if (bankEmojiMatch) {
+      bank = parseInt(bankEmojiMatch[1].replace(/,/g, ''), 10);
+      matched += matched ? '+bank-emoji' : 'bank-emoji';
+    } else if (bankTextMatch) {
+      bank = parseInt(bankTextMatch[1].replace(/,/g, ''), 10);
+      matched += matched ? '+bank-text' : 'bank-text';
+    } else if (bankSlashMatch) {
+      bank = parseInt(bankSlashMatch[1].replace(/,/g, ''), 10);
+      matched += matched ? '+bank-slash' : 'bank-slash';
+    }
 
-      if (wallet === 0 && bank === 0) {
-        this.log('warn', `Balance parse returned 0 — raw text: "${text.substring(0, 200)}"`);
-        // Don't overwrite a known-good balance with 0
-        if (this.stats.balance > 0 || this.stats.bankBalance > 0) return;
-      }
+    if (wallet === 0 && bank === 0) {
+      this.log('warn', `Balance parse returned 0 — raw text: "${text.substring(0, 200)}"`);
+      // Don't overwrite a known-good balance with 0
+      if (this.stats.balance > 0 || this.stats.bankBalance > 0) return;
+    }
 
     this.stats.balance = wallet;
     this.stats.bankBalance = bank;
-    this.log('bal', `Wallet: ${c.bold}${c.green}⏣ ${wallet.toLocaleString()}${c.reset}  Bank: ${c.bold}${c.cyan}⏣ ${bank.toLocaleString()}${c.reset}  Total: ${c.bold}⏣ ${(wallet + bank).toLocaleString()}${c.reset}  ${c.dim}(${matched || 'none'})${c.reset}`);
+    if (!silent) this.log('bal', `Wallet: ${c.bold}${c.green}⏣ ${wallet.toLocaleString()}${c.reset}  Bank: ${c.bold}${c.cyan}⏣ ${bank.toLocaleString()}${c.reset}  Total: ${c.bold}⏣ ${(wallet + bank).toLocaleString()}${c.reset}`);
 
-      // Store in Redis for persistence
-      if (redis) {
-        try {
-          await redis.set(`dkg:bal:${this.account.id}`, JSON.stringify({ wallet, bank, ts: Date.now() }));
-        } catch {}
-      }
-
-      // Always report to dashboard API
+    // Store in Redis for persistence
+    if (redis) {
       try {
-        await fetch(`${API_URL}/api/grinder/status`, {
-          method: 'POST',
-          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            account_id: this.account.id,
-            balance: wallet,
-            bank_balance: bank,
-            total_balance: wallet + bank,
-            lifesavers: this._lifesavers ?? null,
-          }),
-        });
-      } catch { /* silent */ }
+        await redis.set(`dkg:bal:${this.account.id}`, JSON.stringify({ wallet, bank, ts: Date.now() }));
+      } catch {}
     }
+
+    // Always report to dashboard API
+    try {
+      await fetch(`${API_URL}/api/grinder/status`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          account_id: this.account.id,
+          balance: wallet,
+          bank_balance: bank,
+          total_balance: wallet + bank,
+          lifesavers: this._lifesavers ?? null,
+        }),
+      });
+    } catch { /* silent */ }
   }
 
-  // ── Check DM History for deaths/level-ups ──────────────────
+  // ── Check DM History for deaths/level-ups (with retry) ─────
   async checkDmHistory() {
-    try {
-      const dankUser = await this.client.users.fetch(DANK_MEMER_ID);
-      const dm = await dankUser.createDM();
-      this._dmChannelId = dm.id;
-      const recent = await dm.messages.fetch({ limit: 20 });
+    const maxRetries = 3;
+    const delays = [1000, 2000, 4000];
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const dankUser = await this.client.users.fetch(DANK_MEMER_ID);
+        const dm = await dankUser.createDM();
+        this._dmChannelId = dm.id;
+        const recent = await dm.messages.fetch({ limit: 20 });
 
       let deaths = 0, levelUps = 0, currentLevel = 0, lastLifesaverCount = -1;
       for (const [, msg] of recent) {
@@ -1773,11 +1695,16 @@ class AccountWorker {
         }
       }
 
-      return { deaths, levelUps, currentLevel, lifesavers: lastLifesaverCount, dmChannelId: dm.id };
-    } catch (e) {
-      this.log('debug', `DM check failed: ${e.message}`);
-      return { deaths: 0, levelUps: 0, currentLevel: 0, lifesavers: -1 };
+        return { deaths, levelUps, currentLevel, lifesavers: lastLifesaverCount, dmChannelId: dm.id };
+      } catch (e) {
+        lastError = e;
+        if (attempt < maxRetries - 1) {
+          await new Promise(r => setTimeout(r, delays[attempt]));
+        }
+      }
     }
+    this.log('debug', `DM check failed after ${maxRetries} attempts: ${lastError.message}`);
+    return { deaths: 0, levelUps: 0, currentLevel: 0, lifesavers: -1 };
   }
 
   // ── Run Single Command ──────────────────────────────────────
@@ -1805,20 +1732,68 @@ class AccountWorker {
     if (shutdownCalled || !this.running) return;
     this.stats.commands++;
 
+    // ── Monthly: only run if balance ≥ 18M (advancements requirement) ──
+    if (cmdName === 'monthly') {
+      const totalBal = (this.stats.balance || 0) + (this.stats.bankBalance || 0);
+      if (totalBal < 18_000_000) {
+        this.log('warn', `[monthly] SKIPPED — balance ${(totalBal / 1e6).toFixed(1)}M < 18M`);
+        await this.setCooldown(cmdName, 86400);
+        return;
+      }
+      // Check if disabled (not premium / no advancement)
+      if (redis) {
+        try {
+          const disabled = await redis.get(`dkg:disabled:${this.account.id}:monthly`);
+          if (disabled) {
+            this.log('warn', `[monthly] SKIPPED — disabled (needs advancement purchase)`);
+            return;
+          }
+        } catch {}
+      }
+    }
+
+    // ── Daily/Monthly: check if already claimed today (avoid wasting a command) ──
+    if (cmdName === 'daily' || cmdName === 'monthly') {
+      if (redis) {
+        try {
+          const done = await redis.get(`dkg:done:${this.account.id}:${cmdName}`);
+          if (done) {
+            const ttl = await redis.ttl(`dkg:done:${this.account.id}:${cmdName}`);
+            this.log('info', `[${cmdName}] already claimed — ${Math.ceil(ttl / 60)}min left`);
+            await this.setCooldown(cmdName, Math.max(60, ttl));
+            return;
+          }
+        } catch {}
+      }
+    }
+
+    // ── Deposit: max once per hour, only when enabled ──
+    if (cmdName === 'dep max') {
+      if (this._lastDepositAt && Date.now() - this._lastDepositAt < 3600_000) {
+        return; // silently skip — too soon
+      }
+    }
+
     // ── Lifesaver protection: skip crime/search if 0 lifesavers ──
     if (cmdName === 'crime' || cmdName === 'search') {
+      // Fast path: check in-memory lifesaver count (set from inv + DM check)
+      if (this._lifesavers === 0) {
+        this.log('warn', `[${cmdName}] SKIPPED — 0 lifesavers (in-memory)`);
+        await this.setCooldown(cmdName, 3600);
+        return;
+      }
       const noLifesaver = await rawLogger.hasNoLifesaverAlert(this.channel?.id);
       if (noLifesaver) {
         this.log('warn', `[${cmdName}] SKIPPED — no lifesavers! (death detected in DMs)`);
-        await this.setCooldown(cmdName, 3600); // block for 1 hour
+        await this.setCooldown(cmdName, 3600);
         return;
       }
-      // Also check Redis key for lifesaver count
       if (redis) {
         try {
           const lsCount = await redis.get(`dkg:lifesavers:${this.account.id}`);
           if (lsCount === '0') {
-            this.log('warn', `[${cmdName}] SKIPPED — 0 lifesavers cached`);
+            this._lifesavers = 0;
+            this.log('warn', `[${cmdName}] SKIPPED — 0 lifesavers (Redis)`);
             await this.setCooldown(cmdName, 3600);
             return;
           }
@@ -1885,7 +1860,7 @@ class AccountWorker {
       // PostMemes / command-specific cooldown from response
       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 : 120;
+        const cdSec = minMatch ? parseInt(minMatch[1]) * 60 + 30 : 150; // dead meme = N min + 30s buffer
         this.log('warn', `${cmdName} on cooldown: ${cdSec}s`);
         await this.setCooldown(cmdName, cdSec);
         return;
@@ -1965,11 +1940,13 @@ class AccountWorker {
         return;
       }
 
-      // Premium-only command detection — disable for 24h
+      // 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')) {
-        this.log('warn', `${cmdName} requires premium — skipping for 24h`);
-        await this.setCooldown(cmdName, 86400);
+          resultLower.includes('buy the ability to use this command') ||
+          resultLower.includes('advancements upgrades')) {
+        this.log('warn', `${cmdName} requires premium/advancement — DISABLED`);
+        await this.setCooldown(cmdName, 2592000); // 30 days
+        if (redis) try { await redis.set(`dkg:disabled:${this.account.id}:${cmdName}`, '1', 'EX', 2592000); } catch {}
         return;
       }
 
@@ -2076,9 +2053,12 @@ class AccountWorker {
         }
       }
 
-      // Smart auto-deposit: when wallet exceeds threshold, deposit to protect from robbery
-      if (earned > 0 && this.stats.balance > this._autoDepositThreshold) {
+      // Smart auto-deposit: max once per hour, only if deposit is enabled
+      const depositEnabled = this.account.cmd_deposit !== false;
+      const depositCooldownOk = !this._lastDepositAt || Date.now() - this._lastDepositAt >= 3600_000;
+      if (depositEnabled && depositCooldownOk && earned > 0 && this.stats.balance > this._autoDepositThreshold) {
         this.log('info', `Wallet ⏣ ${this.stats.balance.toLocaleString()} exceeds threshold — auto-depositing`);
+        this._lastDepositAt = Date.now();
         try {
           await this.channel.send('pls dep max');
           await this.waitForDankMemer(6000);
@@ -2172,10 +2152,10 @@ class AccountWorker {
   { 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 },
-    { key: 'cmd_weekly',    cmd: 'weekly',       cdKey: 'cd_weekly',    defaultCd: 604800, 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: 120,    priority: 8 },
+    { 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);
@@ -3034,25 +3014,82 @@ async function start(apiKey, apiUrl) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
-  // ── Animated loading bar helper ──────────────────────────────
-  const barW = Math.min(40, (process.stdout.columns || 80) - 30);
-  let loginDone = 0;
-  const drawLoginProgress = () => {
-    const pct = accounts.length > 0 ? loginDone / accounts.length : 0;
-    const filled = Math.round(pct * barW);
-    const empty = barW - filled;
-    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
-    const bar = rgb(139, 92, 246) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(empty) + c.reset;
-    const pctStr = `${Math.round(pct * 100)}%`;
-    process.stdout.write(`\r  ${rgb(139, 92, 246)}${spin}${c.reset}  ${c.dim}Logging in...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${loginDone}${c.reset}${c.dim}/${c.reset}${c.white}${accounts.length}${c.reset}  ${c.dim}${pctStr}${c.reset}  `);
+  // ── Per-account inline login UI ──────────────────────────────
+  // Track login state per account for inline rendering
+  const loginStates = accounts.map((acc, i) => ({
+    name: acc.label || acc.id || '?',
+    done: false,
+    failed: false,
+    worker: null,
+    workerIdx: i,
+  }));
+
+  // Column widths (visible chars)
+  const terminalW = process.stdout.columns || 90;
+  const colNum = 4;    // "  # "
+  const colSts = 3;     // "ST "
+  const colName = Math.min(24, Math.max(12, Math.floor(terminalW * 0.25)));
+  const colGuild = Math.min(20, Math.max(8, Math.floor(terminalW * 0.2)));
+  const colCmds = 10;   // "  20 cmds"
+  const totalVis = colNum + colSts + colName + colGuild + colCmds + 8;
+
+  // Print header + all account lines (initial pending state)
+  console.log(`  ${'─'.repeat(totalVis)}`);
+  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);
+    console.log(`${num}${c.dim}PN${c.reset}  ${name}  ${c.dim}${'···'.padEnd(colGuild)}${c.reset}  ${c.dim}···${c.reset}`);
+  }
+  console.log(`  ${'─'.repeat(totalVis)}`);
+
+  // Draw pending spinners
+  const drawLoginSpinners = () => {
+    for (let i = 0; i < loginStates.length; i++) {
+      const s = loginStates[i];
+      if (s.done || s.failed) continue;
+      const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+      const num = `${c.dim}${(i + 1).toString().padStart(colNum - 1)}${c.reset}  `;
+      const name = s.name.substring(0, colName).padEnd(colName);
+      const guild = 'logging in...'.substring(0, colGuild).padEnd(colGuild);
+      process.stdout.write(`\x1b[${i + 2};0H\x1b[2K  ${num}${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${c.dim}${guild}${c.reset}  ${c.dim}···${c.reset}`);
+    }
+    process.stdout.write(`\x1b[${loginStates.length + 3};0H`);
   };
+  const loginSpinnerInterval = setInterval(drawLoginSpinners, 80);
+
+  // Update a line when an account finishes
+  const finalizeLoginLine = (idx, worker) => {
+    const s = loginStates[idx];
+    if (s.done || s.failed) return;
+    s.done = true;
+    s.worker = worker;
+
+    const num = `${c.dim}${(idx + 1).toString().padStart(colNum - 1)}${c.reset}  `;
+    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 = '···';
+      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);
+      guild = gn.padEnd(colGuild);
+      cmds = `${worker.stats?.commands || 0}cmds`;
+    } else {
+      sts = `${rgb(251, 146, 60)}⏳${c.reset}`;
+      guild = 'timeout'.padEnd(colGuild);
+      cmds = '···';
+    }
 
-  // Progress animation timer
-  const progressInterval = setInterval(drawLoginProgress, 80);
+    const line = `  ${num}${sts}  ${name}  ${guild}  ${cmds}`;
+    process.stdout.write(`\x1b[${idx + 2};0H\x1b[2K${line}`);
+  };
 
-  // Phase 1: Login all accounts (optimized for speed)
-  const LOGIN_PROGRESS_EVERY = 10;
-  // Reduced delays: 50-150ms between logins (faster startup for 1k+ accounts)
+  // Phase 1: Login in batches of 10
   const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '50'), 10);
   const parsedGapMax = Number.parseInt(String(process.env.LOGIN_GAP_MAX_MS || '150'), 10);
   const LOGIN_GAP_MIN_MS = Number.isFinite(parsedGapMin) && parsedGapMin >= 0 ? parsedGapMin : 50;
@@ -3063,16 +3100,12 @@ async function start(apiKey, apiUrl) {
     return LOGIN_GAP_MIN_MS + Math.floor(Math.random() * (LOGIN_GAP_MAX_MS - LOGIN_GAP_MIN_MS + 1));
   };
 
-  // Parallel login in batches of 10 to avoid rate limits while being fast
-  // Within each batch, stagger logins by 100-600ms to avoid gateway flood
   const BATCH_SIZE = 10;
   for (let i = 0; i < accounts.length; i += BATCH_SIZE) {
     if (shutdownCalled) break;
     const batch = accounts.slice(i, Math.min(i + BATCH_SIZE, accounts.length));
 
-    // Staggered parallel login: fire each login with a small jitter delay
     await Promise.all(batch.map(async (acc, idx) => {
-      // Stagger within batch: 0ms for first, 100-600ms for subsequent
       if (idx > 0) {
         const jitter = 100 + Math.floor(Math.random() * 500);
         await new Promise(r => setTimeout(r, jitter));
@@ -3080,30 +3113,29 @@ 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();
-      loginDone++;
+      finalizeLoginLine(i + idx, worker);
     }));
 
-    // Small gap between batches
     if (i + BATCH_SIZE < accounts.length) {
-      const gapMs = randomLoginGap();
-      await new Promise(r => setTimeout(r, gapMs));
+      await new Promise(r => setTimeout(r, randomLoginGap()));
     }
 
     hintGC();
   }
 
-  clearInterval(progressInterval);
-  // Clear the progress line and show done
-  process.stdout.write(`\r${c.clearLine}`);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Login complete${c.reset}  ${rgb(52, 211, 153)}${loginDone}/${accounts.length}${c.reset} ${c.dim}accounts connected${c.reset}`);
-  console.log('');
+  clearInterval(loginSpinnerInterval);
+  process.stdout.write(`\x1b[${loginStates.length + 3};0H`);
 
-  // Login summary: show invalid tokens clearly
+  // Final summary
+  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);
+  console.log(`  ${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('');
     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`);
@@ -3117,85 +3149,176 @@ async function start(apiKey, apiUrl) {
   // Filter out workers with invalid tokens from grinding
   const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
-  // Phase 2: Run inventory on ALL valid accounts in parallel (must complete before grinding)
-  console.log(`  ${rgb(139, 92, 246)}${BRAILLE_SPIN[0]}${c.reset}  ${c.dim}Checking inventory for ${c.reset}${c.bold}${activeWorkers.length}${c.reset}${c.dim} accounts...${c.reset}`);
-
-  // Animated inventory progress
-  let invDone = 0;
-  let invFailed = 0;
-  const total = activeWorkers.length;
-  const invBarW = Math.min(40, (process.stdout.columns || 80) - 30);
-
-  const drawInvProgress = () => {
-    const pct = total > 0 ? invDone / total : 0;
-    const filled = Math.round(pct * invBarW);
-    const empty = invBarW - filled;
-    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
-    const bar = rgb(34, 211, 238) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(empty) + c.reset;
-    process.stdout.write(`\r  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Inventory...${c.reset}    ${bar}  ${c.bold}${rgb(52, 211, 153)}${invDone}${c.reset}${c.dim}/${c.reset}${c.white}${total}${c.reset}  ${c.dim}${Math.round(pct * 100)}%${c.reset}  `);
+  // ── Phase 2: Inventory check with per-account inline rendering ─────────────────
+  const invStates = activeWorkers.map((w, i) => ({
+    name: w.username || w.account.label || '?',
+    idx: i,
+    done: false,
+    failed: false,
+    items: 0,
+    value: 0,
+    attempt: 0,
+    worker: w,
+  }));
+
+  const tw2 = process.stdout.columns || 90;
+  const iColNum = 4;
+  const iColName = Math.min(22, Math.max(10, Math.floor(tw2 * 0.22)));
+  const iColItems = 8;
+  const iColVal = 14;
+  const iColTries = 10;
+  const iTotalVis = iColNum + iColName + iColItems + iColVal + iColTries + 10;
+
+  console.log(`  ${'─'.repeat(iTotalVis)}`);
+  for (let i = 0; i < invStates.length; i++) {
+    const s = invStates[i];
+    const num = `${c.dim}${(i + 1).toString().padStart(iColNum - 1)}${c.reset}  `;
+    const name = s.name.substring(0, iColName).padEnd(iColName);
+    console.log(`${num}${c.dim}··${c.reset}  ${name}  ${c.dim}${'checking...'.padEnd(iColItems)}${c.reset}  ${c.dim}${'··'.padEnd(iColVal)}${c.reset}  ${c.dim}${''.padEnd(iColTries)}${c.reset}`);
+  }
+  console.log(`  ${'─'.repeat(iTotalVis)}`);
+
+  let invDone = 0, invFailed = 0;
+
+  const drawInvSpinners = () => {
+    for (let i = 0; i < invStates.length; i++) {
+      const s = invStates[i];
+      if (s.done || s.failed) continue;
+      const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+      const num = `${c.dim}${(i + 1).toString().padStart(iColNum - 1)}${c.reset}  `;
+      const name = s.name.substring(0, iColName).padEnd(iColName);
+      const items = 'checking'.substring(0, iColItems).padEnd(iColItems);
+      const val = ''.padEnd(iColVal);
+      const tries = s.attempt > 0 ? `try ${s.attempt}/3` : '';
+      process.stdout.write(`\x1b[${i + 2};0H\x1b[2K  ${num}${rgb(34, 211, 238)}${spin}${c.reset}  ${name}  ${c.dim}${items}${c.reset}  ${c.dim}${val}${c.reset}  ${c.dim}${tries}${c.reset}`);
+    }
+    process.stdout.write(`\x1b[${invStates.length + 3};0H`);
   };
+  const invSpinnerInterval = setInterval(drawInvSpinners, 80);
+
+  const finalizeInvLine = (idx, invRes) => {
+    const s = invStates[idx];
+    if (s.done || s.failed) return;
+    if (invRes?.ok) {
+      s.done = true;
+      invDone++;
+    } else {
+      s.failed = true;
+      invFailed++;
+    }
 
-  const invProgressInterval = setInterval(drawInvProgress, 80);
+    const num = `${c.dim}${(idx + 1).toString().padStart(iColNum - 1)}${c.reset}  `;
+    const name = s.name.substring(0, iColName).padEnd(iColName);
+    const items = `${invRes?.items?.length || 0}`.padEnd(iColItems);
+    const val = invRes?.ok
+      ? `${c.green}⏣${(invRes.totalValue || 0).toLocaleString()}${c.reset}`.padEnd(iColVal + 3)
+      : `${c.dim}··${c.reset}`.padEnd(iColVal);
+    const sts = invRes?.ok ? `${rgb(52, 211, 153)}✓${c.reset}` : `${rgb(239, 68, 68)}✗${c.reset}`;
+
+    const line = `  ${num}${sts}  ${name}  ${items}  ${val}`;
+    process.stdout.write(`\x1b[${idx + 2};0H\x1b[2K${line}`);
+  };
 
   await Promise.all(activeWorkers.map(async (w, i) => {
     try {
-      const invRes = await w.checkInventory({
-        force: true,
-        startupProgress: { current: i + 1, total },
-        requireComplete: true,
-        maxAttempts: 3,
-      });
-      if (invRes?.ok) invDone++;
-      else invFailed++;
+      const invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3 });
+      finalizeInvLine(i, invRes);
     } catch {
-      invFailed++;
+      finalizeInvLine(i, { ok: false });
     }
   }));
 
-  clearInterval(invProgressInterval);
-  process.stdout.write(`\r${c.clearLine}`);
+  clearInterval(invSpinnerInterval);
+  process.stdout.write(`\x1b[${invStates.length + 3};0H`);
 
-  // Final summary
   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}${total}${c.reset} done, ${rgb(239, 68, 68)}${invFailed} failed${c.reset}`);
+    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}`);
     log('error', `${c.red}Not starting grind loops — ${invFailed} accounts failed inventory.${c.reset}`);
     return;
   }
 
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Inventory complete${c.reset}  ${rgb(52, 211, 153)}${invDone}/${total}${c.reset} ${c.dim}all clear${c.reset}`);
+  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: Check balance for ALL accounts sequentially (CV2 needs raw logger timing)
-  console.log(`  ${rgb(139, 92, 246)}${BRAILLE_SPIN[0]}${c.reset}  ${c.dim}Checking balance for ${c.reset}${c.bold}${activeWorkers.length}${c.reset}${c.dim} accounts...${c.reset}`);
+  // ── Phase 2.5: Balance check with inline per-account rendering ─────────────────
+  const balStates = activeWorkers.map((w, i) => ({
+    name: w.username || w.account.label || '?',
+    idx: i,
+    done: false,
+    wallet: 0,
+    bank: 0,
+    worker: w,
+  }));
+
+  const bColNum = 4;
+  const bColName = Math.min(22, Math.max(10, Math.floor(tw2 * 0.22)));
+  const bColWallet = 14;
+  const bColBank = 14;
+  const bColTotal = 14;
+  const bColLs = 4;
+  const bTotalVis = bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 12;
+
+  console.log(`  ${'─'.repeat(bTotalVis)}`);
+  for (let i = 0; i < balStates.length; i++) {
+    const s = balStates[i];
+    const num = `${c.dim}${(i + 1).toString().padStart(bColNum - 1)}${c.reset}  `;
+    const name = s.name.substring(0, bColName).padEnd(bColName);
+    console.log(`${num}${c.dim}··${c.reset}  ${name}  ${c.dim}${'checking'.padEnd(bColWallet)}${c.reset}  ${c.dim}${'··'.padEnd(bColBank)}${c.reset}  ${c.dim}${'··'.padEnd(bColTotal)}${c.reset}  ${c.dim}♥?${c.reset}`);
+  }
+  console.log(`  ${'─'.repeat(bTotalVis)}`);
 
   let balDone = 0;
-  const balProgressInterval = setInterval(() => {
-    const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
-    process.stdout.write(`\r  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Balance...${c.reset}  ${c.bold}${rgb(52, 211, 153)}${balDone}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  `);
-  }, 80);
 
-  // Run in parallel
+  const drawBalSpinners = () => {
+    for (let i = 0; i < balStates.length; i++) {
+      const s = balStates[i];
+      if (s.done) continue;
+      const spin = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+      const num = `${c.dim}${(i + 1).toString().padStart(bColNum - 1)}${c.reset}  `;
+      const name = s.name.substring(0, bColName).padEnd(bColName);
+      process.stdout.write(`\x1b[${i + 2};0H\x1b[2K  ${num}${rgb(251, 191, 36)}${spin}${c.reset}  ${name}  ${c.dim}${'checking'.padEnd(bColWallet)}${c.reset}  ${c.dim}${'··'.padEnd(bColBank)}${c.reset}  ${c.dim}${'··'.padEnd(bColTotal)}${c.reset}  ${c.dim}♥?${c.reset}`);
+    }
+    process.stdout.write(`\x1b[${balStates.length + 3};0H`);
+  };
+  const balSpinnerInterval = setInterval(drawBalSpinners, 80);
+
+  const finalizeBalLine = (idx, w) => {
+    const s = balStates[idx];
+    if (s.done) return;
+    s.done = true;
+    s.wallet = w.stats?.balance || 0;
+    s.bank = w.stats?.bankBalance || 0;
+    balDone++;
+
+    const num = `${c.dim}${(idx + 1).toString().padStart(bColNum - 1)}${c.reset}  `;
+    const name = (w.username || s.name || '?').substring(0, bColName).padEnd(bColName);
+    const ls = w._lifesavers ?? '?';
+    const lsColor = ls === 0 ? rgb(239, 68, 68) : ls <= 2 ? rgb(251, 191, 36) : rgb(52, 211, 153);
+    const wallet = `${c.green}⏣${(s.wallet).toLocaleString()}${c.reset}`.padEnd(bColWallet + 3);
+    const bank = `${c.cyan}⏣${(s.bank).toLocaleString()}${c.reset}`.padEnd(bColBank + 3);
+    const total = `${c.bold}⏣${(s.wallet + s.bank).toLocaleString()}${c.reset}`.padEnd(bColTotal + 3);
+
+    const line = `  ${num}${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${wallet}  ${bank}  ${total}  ${lsColor}♥${ls}${c.reset}`;
+    process.stdout.write(`\x1b[${idx + 2};0H\x1b[2K${line}`);
+  };
+
   await Promise.all(activeWorkers.map(async w => {
     try {
-      await w.checkBalance();
-      balDone++;
+      await w.checkBalance(true); // silent: don't spam console during inline rendering
     } catch {}
+    const idx = balStates.findIndex(s => s.worker === w);
+    if (idx >= 0) finalizeBalLine(idx, w);
   }));
 
-  clearInterval(balProgressInterval);
-  process.stdout.write(`\r${c.clearLine}`);
+  clearInterval(balSpinnerInterval);
+  process.stdout.write(`\x1b[${balStates.length + 3};0H`);
 
-  // Show balance + lifesaver summary for each account
+  // Balance summary
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
-  for (const w of activeWorkers) {
-    const wallet = w.stats?.balance || 0;
-    const bank = w.stats?.bankBalance || 0;
-    const ls = w._lifesavers ?? '?';
-    totalWallet += wallet;
-    totalBank += bank;
-    const lsColor = ls === 0 ? rgb(239, 68, 68) : ls <= 2 ? rgb(251, 191, 36) : rgb(52, 211, 153);
-    console.log(`  ${c.dim}├${c.reset} ${c.bold}${w.username}${c.reset}  Wallet: ${c.green}⏣ ${wallet.toLocaleString()}${c.reset}  Bank: ${c.cyan}⏣ ${bank.toLocaleString()}${c.reset}  Total: ${c.bold}⏣ ${(wallet + bank).toLocaleString()}${c.reset}  LS: ${lsColor}${ls}${c.reset}`);
-    if (ls === 0) noLifesaverAccounts.push(w.username);
+  for (const s of balStates) {
+    totalWallet += s.wallet;
+    totalBank += s.bank;
+    if (s.worker._lifesavers === 0) noLifesaverAccounts.push(s.name);
   }
   console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}Balance${c.reset}  Total: ${c.bold}${c.green}⏣ ${(totalWallet + totalBank).toLocaleString()}${c.reset} ${c.dim}(wallet: ⏣ ${totalWallet.toLocaleString()} + bank: ⏣ ${totalBank.toLocaleString()})${c.reset}`);