dankgrinder 6.21.0 → 6.27.0

package/lib/grinder.js

@@ -458,7 +458,7 @@ function renderDashboard() {
     lines.push(bRow(`   ${c.bold}${titleGrad}${c.reset}  ${D}v${PKG_VERSION}${c.reset}  ${G}${spin}${c.reset}`));
   }
 
-  lines.push(bRow(`   ${D}v${PKG_VERSION}${c.reset}  ${G}${spin}${c.reset}`));
+  lines.push(bRow(`   ${D}v${PKG_VERSION}${c.reset}  ${G}${spin}${c.reset}  ${Y}◷${c.reset} ${D}UP${c.reset}  ${c.bold}${Y}${formatUptime()}${c.reset}`));
 
   // Subtitle info
   const activeCount = workers.filter(w => w.running && !w.paused && !w.dashboardPaused).length;
@@ -487,52 +487,54 @@ function renderDashboard() {
   lines.push(bEmpty);
 
   // ═══════════════════════════════════════════════════════════════
-  //  STATS PANEL (split: left = metrics, right = big trend)
+  //  STATS PANEL — left: all metrics | right: big trend + rate
   // ═══════════════════════════════════════════════════════════════
   lines.push(bSep);
   lines.push(bEmpty);
 
-  // Earnings sparkline data
   const now = Date.now();
   if (now - lastEarningsSample > 8000) { earningsHistory.push(totalCoins); lastEarningsSample = now; }
   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}` : '';
 
-  // Left column: fixed metrics (left-aligned)
+  // ── Compute metric values ─────────────────────────────────────
   const cpmVal = globalCmdRate.getRate().toFixed(1);
   const srColor = successRate >= 95 ? G : successRate >= 80 ? Y : R;
-  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]);
+  const srBar = progressBar(successRate, 100, 10, successRate >= 95 ? [52, 211, 153] : successRate >= 80 ? [251, 191, 36] : [239, 68, 68]);
   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(15, Math.floor(iw * 0.1));
-  const memBar = progressBar(memMB, 1024, memBarW, memCol, [40, 40, 55]);
+  const memBar = progressBar(memMB, 1024, 10, memCol, [40, 40, 55]);
+  const perHrColor = perHr >= 0 ? G : R;
+  const perHrSign = perHr >= 0 ? '+' : '';
+  const newHighFlag = isNewHigh ? `  ${R}${c.bold}★ NEW HIGH ★${c.reset}` : '';
 
-  // Right column: big trend sparkline
-  const sparkW = Math.floor(iw * 0.42);
+  // ── Big trend sparkline (takes ~40% of inner width) ─────────
+  const sparkW = Math.max(28, Math.floor(iw * 0.4));
   const spark = drawSparkline(earningsHistory.toArray(), sparkW);
+  const sparkLabel = `${A}~${c.reset} ${D}TREND${c.reset}`;
 
-  // 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}`));
+  // ── Left metric rows (each left-aligned, ANSI-aware padding) ─
+  // Helper: ANSI-strip-aware pad — strip ANSI then pad the visible content
+  const padRow = (content, totalVis) => {
+    const vis = content.replace(RE, '').length;
+    return content + ' '.repeat(Math.max(0, totalVis - vis));
+  };
 
-  // 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}`));
+  const leftTotal = iw - sparkW - 10; // reserve space for spark + gap
+  const lRow1 = `${Au}⟐${c.reset} ${D}BALANCE${c.reset}  ${c.bold}${Au}⏣${c.reset} ${formatCoins(totalBalance)}`;
+  const lRow2 = `${G}▲${c.reset} ${D}EARNED${c.reset}  ${c.bold}${G}${perHrSign}⏣${c.reset} ${formatCoins(totalCoins)}${newHighFlag}`;
+  const lRow3 = `${O}★${c.reset} ${D}PEAK${c.reset}     ${c.bold}${O}⏣${c.reset} ${formatCoins(sessionPeakCoins)}`;
+  const lRow4 = `${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}`;
+  const lRow5 = `${D}≡${c.reset} ${D}MEM${c.reset}      ${rgb(memCol[0], memCol[1], memCol[2])}${c.bold}${memMB}MB${c.reset}  ${memBar}`;
 
-  // 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}`));
+  // Build right column label
+  const rRate = `${perHrColor}${perHrSign}⏣${c.reset} ${formatCoins(Math.abs(perHr))}/h`;
 
-  // 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(bRow(`   ${padRow(lRow1, leftTotal)}  ${sparkLabel}  ${spark}`));
+  lines.push(bRow(`   ${padRow(lRow2, leftTotal)}  ${D}────────${c.reset}  ${c.dim}earned${c.reset}`));
+  lines.push(bRow(`   ${padRow(lRow3, leftTotal)}  ${D}        ${c.reset}  ${rRate}`));
+  lines.push(bRow(`   ${padRow(lRow4, leftTotal)}  ${D}        ${c.reset}`));
+  lines.push(bRow(`   ${padRow(lRow5, leftTotal)}  ${D}        ${c.reset}`));
 
   lines.push(bEmpty);
 
@@ -642,9 +644,9 @@ function renderDashboard() {
     else if (ls != null) lsStr = `${G}♥${ls}${c.reset}`;
     else lsStr = `${D}♥?${c.reset}`;
 
-    // ── Level indicator ──
+    // ── Level indicator (fixed width so value changes don't jitter) ──
     const lvl = wk._level || 0;
-    const lvlStr = lvl > 0 ? `${Cy}L${lvl}${c.reset}` : `${D}L?${c.reset}`;
+    const lvlStr = lvl > 0 ? `${Cy}L${String(lvl).padStart(3)}${c.reset}` : `${D}L???${c.reset}`;
 
     // ── Earned (fixed visible width) ──
     const earnNum = wk.stats.coins || 0;
@@ -1413,6 +1415,7 @@ class AccountWorker {
       startupProgress = null,
       requireComplete = false,
       maxAttempts = 1,
+      silent = false,
     } = options;
     if (this._invRunning) return { ok: false, skipped: 'busy' };
     if (!force && this._lastInvCheck && Date.now() - this._lastInvCheck < 300_000) return { ok: false, skipped: 'recent' };
@@ -1426,7 +1429,7 @@ class AccountWorker {
         const baseLabel = startupProgress ? `[inv] ${startupProgress.current}/${startupProgress.total}` : '[inv]';
         const attemptLabel = tries > 1 ? ` [try ${attempt}/${tries}]` : '';
         const progressLine = `${baseLabel}${c.bold} ${this.username}${c.reset}${attemptLabel}`;
-        process.stdout.write(`\x1b[2K\r${progressLine}`);
+        if (!silent) process.stdout.write(`\x1b[2K\r${progressLine}`);
 
         try {
           const result = await commands.runInventory({
@@ -1436,9 +1439,10 @@ class AccountWorker {
             accountId: this.account.id,
             redis,
             onPageProgress: ({ page, total }) => {
-              // Update progress on same line
-              const erase = '\x1b[2K\r';
-              process.stdout.write(`${erase}${baseLabel} ${c.bold}${this.username}${c.reset} · page ${page}/${total}${attemptLabel}`);
+              if (!silent) {
+                const erase = '\x1b[2K\r';
+                process.stdout.write(`${erase}${baseLabel} ${c.bold}${this.username}${c.reset} · page ${page}/${total}${attemptLabel}`);
+              }
             },
           });
 
@@ -1447,8 +1451,10 @@ class AccountWorker {
           }
 
           // Final result on same line
-          const resultLine = `${baseLabel} ${c.bold}${this.username}${c.reset}: ${c.green}${result.items?.length || 0} items${c.reset}, ⏣ ${c.green}${(result.totalValue || 0).toLocaleString()}${c.reset} net${attemptLabel}`;
-          process.stdout.write(`\x1b[2K\r${resultLine}\n`);
+          if (!silent) {
+            const resultLine = `${baseLabel} ${c.bold}${this.username}${c.reset}: ${c.green}${result.items?.length || 0} items${c.reset}, ⏣ ${c.green}${(result.totalValue || 0).toLocaleString()}${c.reset} net${attemptLabel}`;
+            process.stdout.write(`\x1b[2K\r${resultLine}\n`);
+          }
 
           // Extract lifesaver count from inventory and cache in Redis
           if (result.items && redis) {
@@ -1492,7 +1498,7 @@ class AccountWorker {
           if (attempt < tries) {
             const baseLabel = startupProgress ? `[inv] ${startupProgress.current}/${startupProgress.total}` : '[inv]';
             const retryLine = `${baseLabel} ${c.bold}${this.username}${c.reset}: ${c.yellow}attempt ${attempt}/${tries} failed${c.reset} — retrying...`;
-            process.stdout.write(`\x1b[2K\r${retryLine}\n`);
+            if (!silent) process.stdout.write(`\x1b[2K\r${retryLine}\n`);
             await new Promise((r) => setTimeout(r, 1500 + Math.floor(Math.random() * 1500)));
             continue;
           }
@@ -1503,7 +1509,7 @@ class AccountWorker {
     } catch (e) {
       const baseLabel = startupProgress ? `[inv] ${startupProgress.current}/${startupProgress.total}` : '[inv]';
       const failLine = `${baseLabel} ${c.bold}${this.username}${c.reset}: ${c.red}failed${c.reset} — ${e.message}`;
-      process.stdout.write(`\x1b[2K\r${failLine}\n`);
+      if (!silent) process.stdout.write(`\x1b[2K\r${failLine}\n`);
       return { ok: false, error: e.message };
     } finally {
       this._invRunning = false;
@@ -3014,102 +3020,90 @@ async function start(apiKey, apiUrl) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
-  // ── Per-account inline login UI ──────────────────────────────
-  // Track login state per account for inline rendering
+  // ── Phase 1: Login with per-account inline rendering ─────────────────────────
+  const startupTw = process.stdout.columns || 90;
+  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;
+
   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)}`);
+  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 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}`);
+    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}`);
   }
-  console.log(`  ${'─'.repeat(totalVis)}`);
+  loginLines.push(`  ${'─'.repeat(loginVis)}`);
+  for (const l of loginLines) console.log(l);
+  loginLines = null;
 
-  // Draw pending spinners
+  let loginPending = new Array(accounts.length).fill(true);
   const drawLoginSpinners = () => {
-    for (let i = 0; i < loginStates.length; i++) {
-      const s = loginStates[i];
-      if (s.done || s.failed) continue;
+    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 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}`);
+      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;
+      process.stdout.write(`\r\x1b[2K  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${guild}  ${cmds}\x1b[K`);
     }
-    process.stdout.write(`\x1b[${loginStates.length + 3};0H`);
   };
   const loginSpinnerInterval = setInterval(drawLoginSpinners, 80);
 
-  // Update a line when an account finishes
   const finalizeLoginLine = (idx, worker) => {
+    if (!loginPending[idx]) return;
+    loginPending[idx] = false;
     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 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 = '···';
+      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);
       guild = gn.padEnd(colGuild);
-      cmds = `${worker.stats?.commands || 0}cmds`;
+      cmds = `${worker.stats?.commands || 0}`.padEnd(colCmds);
     } else {
       sts = `${rgb(251, 146, 60)}⏳${c.reset}`;
       guild = 'timeout'.padEnd(colGuild);
-      cmds = '···';
+      cmds = '···'.padEnd(colCmds);
     }
-
-    const line = `  ${num}${sts}  ${name}  ${guild}  ${cmds}`;
-    process.stdout.write(`\x1b[${idx + 2};0H\x1b[2K${line}`);
+    process.stdout.write(`\r\x1b[2K  ${num}  ${sts}  ${name}  ${c.dim}${guild}${c.reset}  ${c.dim}${cmds}${c.reset}\x1b[K`);
   };
 
-  // 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;
-  const LOGIN_GAP_MAX_MS = Number.isFinite(parsedGapMax) && parsedGapMax >= LOGIN_GAP_MIN_MS ? parsedGapMax : Math.max(LOGIN_GAP_MIN_MS, 150);
-
-  const randomLoginGap = () => {
-    if (LOGIN_GAP_MAX_MS <= LOGIN_GAP_MIN_MS) return LOGIN_GAP_MIN_MS;
-    return LOGIN_GAP_MIN_MS + Math.floor(Math.random() * (LOGIN_GAP_MAX_MS - LOGIN_GAP_MIN_MS + 1));
-  };
+  const LOGIN_GAP_MAX_MS = Number.isFinite(parsedGapMax) && parsedGapMax >= LOGIN_GAP_MIN_MS ? parsedGapMax : Math.max(parsedGapMin, 150);
+  const randomLoginGap = () => LOGIN_GAP_MAX_MS <= LOGIN_GAP_MIN_MS ? LOGIN_GAP_MIN_MS : LOGIN_GAP_MIN_MS + Math.floor(Math.random() * (LOGIN_GAP_MAX_MS - LOGIN_GAP_MIN_MS + 1));
 
   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));
-
     await Promise.all(batch.map(async (acc, idx) => {
-      if (idx > 0) {
-        const jitter = 100 + Math.floor(Math.random() * 500);
-        await new Promise(r => setTimeout(r, jitter));
-      }
+      if (idx > 0) await new Promise(r => setTimeout(r, 100 + Math.floor(Math.random() * 500)));
       const worker = new AccountWorker(acc, i + idx);
       workers.push(worker);
       workerMap.set(acc.id, worker);
@@ -3117,216 +3111,143 @@ async function start(apiKey, apiUrl) {
       await worker.start();
       finalizeLoginLine(i + idx, worker);
     }));
-
-    if (i + BATCH_SIZE < accounts.length) {
-      await new Promise(r => setTimeout(r, randomLoginGap()));
-    }
-
+    if (i + BATCH_SIZE < accounts.length) await new Promise(r => setTimeout(r, randomLoginGap()));
     hintGC();
   }
 
   clearInterval(loginSpinnerInterval);
-  process.stdout.write(`\x1b[${loginStates.length + 3};0H`);
-
-  // 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(`\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) {
     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`);
-    }
+    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)`);
-  }
+  if (timedOutWorkers.length > 0) log('warn', `${timedOutWorkers.length} account(s) timed out during login (will retry in background)`);
 
-  // Filter out workers with invalid tokens from grinding
   const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
-  // ── 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;
+  // ── Phase 2: Inventory check — spinner for pending count, results inline ─────────
   const iColNum = 4;
-  const iColName = Math.min(22, Math.max(10, Math.floor(tw2 * 0.22)));
+  const iColName = Math.min(22, Math.max(12, Math.floor(startupTw * 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 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}`);
+  const iColVal = 16;
+  const invVis = 7 + iColNum + iColName + iColItems + iColVal + 12;
+
+  console.log(`  ${'─'.repeat(invVis)}`);
+  for (let i = 0; i < activeWorkers.length; i++) {
+    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);
+    console.log(`  ${num}  ${c.dim}··${c.reset}  ${name}  ${c.dim}${'checking...'.padEnd(iColItems)}${c.reset}  ${c.dim}${'···'.padEnd(iColVal)}${c.reset}`);
+  }
+  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)}%`;
+    process.stdout.write(`\r\x1b[2K  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Inventory...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - invPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  ${c.dim}${pctStr}${c.reset}  `);
   };
+  const invSpinnerInterval = setInterval(drawInvProgress, 80);
 
   await Promise.all(activeWorkers.map(async (w, i) => {
-    try {
-      const invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3 });
-      finalizeInvLine(i, invRes);
-    } catch {
-      finalizeInvLine(i, { ok: false });
-    }
+    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}`;
+    process.stdout.write(`\r\x1b[2K  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
+    if (invRes?.ok) invDone++; else invFailed++;
   }));
 
   clearInterval(invSpinnerInterval);
-  process.stdout.write(`\x1b[${invStates.length + 3};0H`);
+  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}`);
     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}/${activeWorkers.length}${c.reset} ${c.dim}all clear${c.reset}`);
   console.log('');
 
-  // ── 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,
-  }));
-
+  // ── Phase 2.5: Balance check — inline table, single spinner for progress ─────────
   const bColNum = 4;
-  const bColName = Math.min(22, Math.max(10, Math.floor(tw2 * 0.22)));
-  const bColWallet = 14;
-  const bColBank = 14;
+  const bColName = Math.min(22, Math.max(12, Math.floor(startupTw * 0.22)));
+  const bColWallet = 12;
+  const bColBank = 12;
   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 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 balVis = 7 + bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 14;
+
+  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);
+    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(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;
+    process.stdout.write(`\r\x1b[2K  ${rgb(251, 191, 36)}${spin}${c.reset}  ${c.dim}Balance...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - balPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  `);
   };
-  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 balSpinnerInterval = setInterval(drawBalProgress, 80);
 
-    const num = `${c.dim}${(idx + 1).toString().padStart(bColNum - 1)}${c.reset}  `;
-    const name = (w.username || s.name || '?').substring(0, bColName).padEnd(bColName);
+  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;
+    const bank = w.stats?.bankBalance || 0;
     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(true); // silent: don't spam console during inline rendering
-    } catch {}
-    const idx = balStates.findIndex(s => s.worker === w);
-    if (idx >= 0) finalizeBalLine(idx, w);
+    const walletStr = `${c.green}⏣${wallet.toLocaleString()}${c.reset}`;
+    const bankStr = `${c.cyan}⏣${bank.toLocaleString()}${c.reset}`;
+    const totalStr = `${c.bold}⏣${(wallet + bank).toLocaleString()}${c.reset}`;
+    process.stdout.write(`\r\x1b[2K  ${num}  ${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${walletStr.padEnd(bColWallet + 4)}  ${bankStr.padEnd(bColBank + 4)}  ${totalStr.padEnd(bColTotal + 3)}  ${lsColor}♥${ls}${c.reset}\x1b[K`);
+    balDone++;
   }));
 
   clearInterval(balSpinnerInterval);
-  process.stdout.write(`\x1b[${balStates.length + 3};0H`);
+  process.stdout.write(`\r\x1b[2K`);
 
-  // Balance summary
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
-  for (const s of balStates) {
-    totalWallet += s.wallet;
-    totalBank += s.bank;
-    if (s.worker._lifesavers === 0) noLifesaverAccounts.push(s.name);
+  for (const w of activeWorkers) {
+    totalWallet += w.stats?.balance || 0;
+    totalBank += w.stats?.bankBalance || 0;
+    if (w._lifesavers === 0) noLifesaverAccounts.push(w.username || w.account.label);
   }
   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}`);
-
   if (noLifesaverAccounts.length > 0) {
     console.log(`  ${rgb(239, 68, 68)}⚠${c.reset}  ${c.bold}${c.red}WARNING: ${noLifesaverAccounts.length} account(s) have 0 LIFESAVERS!${c.reset} Crime/Search disabled for: ${noLifesaverAccounts.join(', ')}`);
   }
   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.21.0",
+  "version": "6.27.0",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"