dankgrinder 6.42.0 → 6.46.0

package/lib/commands/inventory.js

@@ -198,7 +198,7 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   LOG.cmd(`${c.white}${c.bold}pls inv${c.reset}`);
 
   await channel.send('pls inv');
-  let response = await waitForDankMemer(10000);
+  let response = await waitForDankMemer(15000);
 
   if (!response) {
     LOG.warn('[inv] No response');

package/lib/grinder.js

@@ -2026,16 +2026,6 @@ 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') ||
@@ -2625,6 +2615,18 @@ class AccountWorker {
       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) ───────────────────
@@ -2765,6 +2767,11 @@ 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();
@@ -3165,19 +3172,38 @@ async function start(apiKey, apiUrl) {
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
     rawLogger.init(REDIS_URL).catch(() => {});
-    // Listen for DM death events across all accounts
+    // Live DM listener: detect deaths and level-ups in real-time across all accounts
     rawLogger.onDmEvent((event, raw) => {
-      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);
+      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);
           }
         }
-        sendWebhook?.('DEATH ALERT (DM)', `Account died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
+      } 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}.`);
+        }
       }
     });
     checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}RawLog${c.reset}`);
@@ -3191,39 +3217,21 @@ async function start(apiKey, apiUrl) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
-  // ── Phase 1: Login with per-account inline rendering ─────────────────────────
+  // ── Phase 1: Login — inline table with per-row updates ─────────
   const startupTw = process.stdout.columns || 90;
-  const colNum = 4;    // "  #"
-  const colSts = 3;    // "ST"
+  const colNum = 4;
+  const colSts = 3;
   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;
 
-  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);
+  // 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 chunks = [];
     const handler = (chunk) => {
       chunks.push(chunk);
@@ -3231,51 +3239,52 @@ async function start(apiKey, apiUrl) {
       const m = raw.match(/\x1b\[(\d+);\d+R/);
       if (m) {
         process.stdin.removeListener('data', handler);
-        loginBaseRow = parseInt(m[1], 10) + 1;
+        tableTopRow = parseInt(m[1], 10);
         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`);
+  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`);
 
+  // Spinner: updates rows inline using absolute row numbers
   const drawLoginSpinners = () => {
-    for (let i = 0; i < loginPending.length; i++) {
-      if (!loginPending[i]) continue;
+    for (const i of pendingSet) {
       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}`;
-      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);
+      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 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 loginSpinner = setInterval(drawLoginSpinners, 80);
 
+  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 || s.name || '?').substring(0, colName).padEnd(colName);
+    const name = (worker.username || accounts[idx].label || accounts[idx].id || '?').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);
@@ -3286,9 +3295,7 @@ async function start(apiKey, apiUrl) {
       guild = 'timeout'.padEnd(colGuild);
       cmds = '···'.padEnd(colCmds);
     }
-    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`);
+    process.stdout.write(`\x1b[${dataStartRow + idx};1H  ${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);
@@ -3306,58 +3313,34 @@ 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();
-      finalizeLoginLine(i + idx, worker);
+      finalizeLoginRow(i + idx, worker);
     }));
     if (i + BATCH_SIZE < accounts.length) await new Promise(r => setTimeout(r, randomLoginGap()));
     hintGC();
   }
 
-  clearInterval(loginSpinnerInterval);
-  const loginDone = workers.filter(w => !w._tokenInvalid && w.channel).length;
+  clearInterval(loginSpinner);
   const invalidWorkers = workers.filter(w => w._tokenInvalid);
   const timedOutWorkers = workers.filter(w => !w.channel && !w._tokenInvalid);
-  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('');
+  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`);
   if (invalidWorkers.length > 0) {
-    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('');
+    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(', ')}`);
   }
   if (timedOutWorkers.length > 0) log('warn', `${timedOutWorkers.length} account(s) timed out during login (will retry in background)`);
+  console.log('');
 
-  const activeWorkers = workers.filter(w => !w._tokenInvalid);
+  // ── Phase 2: Inventory check — clean sequential table ─────────
 
-  // ── 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];
@@ -3367,40 +3350,31 @@ async function start(apiKey, apiUrl) {
   }
   console.log(`  ${'─'.repeat(invVis)}`);
 
-  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);
+  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 };
+    }
+  }));
 
-  await Promise.all(activeWorkers.map(async (w, i) => {
+  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];
     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}`;
-    const row = invBaseRow + 1 + i;
-    invMoveToRow(row);
-    process.stdout.write(`  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
+    console.log(`  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}`);
     if (invRes?.ok) invDone++; else invFailed++;
-  }));
-
-  clearInterval(invSpinnerInterval);
-  process.stdout.write(`\r\x1b[2K`);
+  }
+  console.log(`  ${'─'.repeat(invVis)}`);
 
   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}`);
@@ -3410,7 +3384,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 — inline table, single spinner for progress ─────────
+  // ── Phase 2.5: Balance check — clean sequential table ─────────
   const bColNum = 4;
   const bColName = Math.min(22, Math.max(12, Math.floor(startupTw * 0.22)));
   const bColWallet = 12;
@@ -3419,27 +3393,6 @@ 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];
@@ -3449,22 +3402,14 @@ async function start(apiKey, apiUrl) {
   }
   console.log(`  ${'─'.repeat(balVis)}`);
 
-  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);
-
-  await Promise.all(activeWorkers.map(async (w, i) => {
+  await Promise.all(activeWorkers.map(async (w) => {
     try { await w.checkBalance(true); } catch {}
-    balPending--;
+  }));
+
+  // Re-print table with results
+  console.log(`  ${'─'.repeat(balVis)}`);
+  for (let i = 0; i < activeWorkers.length; i++) {
+    const w = activeWorkers[i];
     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;
@@ -3474,14 +3419,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}`;
-    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`);
+    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)}`);
 
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
   for (const w of activeWorkers) {
@@ -3495,7 +3435,6 @@ 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 = [];

package/package.json

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