dankgrinder 8.2.0 → 8.10.0

package/lib/grinder.js

@@ -94,20 +94,10 @@ const c = {
 };
 
 const WORKER_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
+// Unique marker written to stdout so we can query cursor position via DSR response
+const MARKER = '\x1b[6n\x1b[@@MARKER@@';
 const DANK_MEMER_ID = '270904126974590976';
 
-
-// Simple uptime formatter
-function formatUptime() {
-  const s = Math.floor((Date.now() - startTime) / 1000);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m ${s % 60}s`;
-  const h = Math.floor(m / 60);
-  if (h < 24) return `${h}h ${m % 60}m`;
-  const d = Math.floor(h / 24);
-  return `${d}d ${h % 24}h`;
-}
 // ── Safe options for search/crime ──────────────────────────
 // Object.freeze → V8 marks these as immutable, enabling inline caching
 // and preventing accidental mutation across 10K worker instances.
@@ -282,6 +272,17 @@ function progressBar(value, max, width, filledColor, emptyColor) {
   return rgb(fc[0], fc[1], fc[2]) + '█'.repeat(filled) + rgb(ec[0], ec[1], ec[2]) + '░'.repeat(empty) + c.reset;
 }
 
+// ── Animated braille spinner frames ──────────────────────────
+const BRAILLE_SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const BLOCK_SPIN = ['▉', '▊', '▋', '▌', '▍', '▎', '▏', '▎', '▍', '▌', '▋', '▊'];
+const PULSE_CHARS = ['○', '◎', '●', '◉', '●', '◎'];
+function getSpinner(type = 'braille') {
+  const now = Math.floor(Date.now() / 80);
+  if (type === 'block') return BLOCK_SPIN[now % BLOCK_SPIN.length];
+  if (type === 'pulse') return PULSE_CHARS[now % PULSE_CHARS.length];
+  return BRAILLE_SPIN[now % BRAILLE_SPIN.length];
+}
+
 // ── Box drawing helpers ──────────────────────────────────────
 const BOX = {
   tl: '╭', tr: '╮', bl: '╰', br: '╯',
@@ -1388,7 +1389,9 @@ class AccountWorker {
 
       // Update Redis with findings
       if (redis) {
-        try {
+        if (currentLevel > 0) {
+          await redis.set(`dkg:level:${this.account.id}`, String(currentLevel), 'EX', 2592000);
+          this._level = currentLevel;
           if (currentLevel > 0) {
             await redis.set(`dkg:level:${this.account.id}`, String(currentLevel), 'EX', 2592000);
             this._level = currentLevel;
@@ -1401,19 +1404,17 @@ class AccountWorker {
               await redis.set(`raw:alert:no-lifesaver:${this.channel?.id}`, '1', 'EX', 86400);
             }
           }
-        } catch { /* Redis errors non-fatal */ }
-      }
-
-      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]));
+        }
+        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]));
+        }
       }
     }
+    return { deaths: 0, levelUps: 0, currentLevel: 0, lifesavers: -1 };
   }
-  return { deaths: 0, levelUps: 0, currentLevel: 0, lifesavers: -1 };
-}
 
   // ── Run Single Command ──────────────────────────────────────
   // Each modular command handler sends the command, waits for response,
@@ -2748,6 +2749,10 @@ async function start(apiKey, apiUrl, opts = {}) {
   REDIS_URL = process.env.REDIS_URL || '';
   WEBHOOK_URL = process.env.WEBHOOK_URL || '';
 
+  process.stdout.write('\x1b[2J\x1b[H');
+  const tw = Math.min(process.stdout.columns || 80, 78);
+  const bar = c.dim + '─'.repeat(tw) + c.reset;
+
   // Detect zlib-sync availability
   let hasZlib = false;
   try { require('zlib-sync'); hasZlib = true; } catch {}
@@ -2760,6 +2765,8 @@ async function start(apiKey, apiUrl, opts = {}) {
     `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}Auto-Recovery${c.reset}` +
     `  ${c.dim}·${c.reset}  ${rgb(251, 191, 36)}Loss Limiter${c.reset}`
   );
+  console.log(bar);
+
   log('info', `${c.dim}Fetching accounts...${c.reset}`);
 
   const fetchOpts = CLOUD_MODE ? { cloud: true } : {};
@@ -2824,7 +2831,7 @@ async function start(apiKey, apiUrl, opts = {}) {
 
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
-    rawLogger.init(redis);
+    rawLogger.init(REDIS_URL).catch(() => {});
     // Listen for DM events across all accounts — update worker state + dashboard LIVE
     rawLogger.onDmEvent((event, raw) => {
       const channelId = raw.channel_id;
@@ -2873,8 +2880,110 @@ async function start(apiKey, apiUrl, opts = {}) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
-  // ── Phase 1: Login accounts ─────────────────────────────────────────
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  Logging in ${accounts.length} account(s)...`);
+  // ── 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,
+  }));
+
+  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.
+  // Write MARKER to stderr (not stdout) to avoid PTY cooked-mode echoing
+  // of the visible "@MARKER@@" text portion, which was causing the DSR
+  // response to be swallowed or delayed.
+  let loginBaseRow = 1;
+  const captureLoginRow = () => 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);
+        loginBaseRow = parseInt(m[1], 10) + 1;
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
+    setTimeout(resolve, 50);
+  });
+  await captureLoginRow();
+
+  let loginPending = new Array(accounts.length).fill(true);
+  const moveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
+
+  const drawLoginSpinners = () => {
+    for (let i = 0; i < loginPending.length; i++) {
+      if (!loginPending[i]) continue;
+      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 = loginStates[i].name.substring(0, colName).padEnd(colName);
+      const guild = c.dim + 'logging in...'.substring(0, colGuild) + c.reset;
+      const cmds = c.dim + '···'.padEnd(colCmds) + c.reset;
+      const row = loginBaseRow + 1 + i; // +1 skips the top border line
+      moveToRow(row);
+      process.stdout.write(`  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${guild}  ${cmds}\x1b[K`);
+    }
+    // Move cursor back to bottom to avoid overwriting the bottom border
+    const lastRow = loginBaseRow + 1 + accounts.length + 1;
+    moveToRow(lastRow);
+  };
+  const 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 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 = '···'.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}`.padEnd(colCmds);
+    } else {
+      sts = `${rgb(251, 146, 60)}⏳${c.reset}`;
+      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`);
+  };
+
   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;
@@ -2890,58 +2999,203 @@ async function start(apiKey, apiUrl, opts = {}) {
       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);
     }));
     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;
   const invalidWorkers = workers.filter(w => w._tokenInvalid);
   const timedOutWorkers = workers.filter(w => !w.channel && !w._tokenInvalid);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${loginDone}/${accounts.length} accounts connected`);
+  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`);
-    for (const w of invalidWorkers) log('error', `  ${w.account.label || w.account.id} — token invalid or expired`);
+    log('warn', `${rgb(239, 68, 68)}${invalidWorkers.length} account(s) have INVALID tokens:${c.reset}`);
+    for (const w of invalidWorkers) log('error', `  ✗ ${w.account.label || w.account.id} — token is invalid or expired`);
+    console.log('');
   }
-  if (timedOutWorkers.length > 0) log('warn', `${timedOutWorkers.length} account(s) timed out during login`);
+  if (timedOutWorkers.length > 0) log('warn', `${timedOutWorkers.length} account(s) timed out during login (will retry in background)`);
 
   const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
-  // ── Phase 2: Inventory check ─────────────────────────────────────
-  console.log(`  ${rgb(34, 211, 238)}·${c.reset}  Checking inventory (${activeWorkers.length} accounts)...`);
-  let invDone = 0, invFailed = 0;
-  await Promise.all(activeWorkers.map(async (w) => {
-    try { await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
-    catch { invFailed++; return; }
-    invDone++;
+  // ── 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
+  // Set up stdin handler BEFORE writing MARKER (same fix as Phase 1 — avoids race)
+  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);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
+    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];
+    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)}%`;
+    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);
+
+  await Promise.all(activeWorkers.map(async (w, i) => {
+    const num = `${c.dim}${(i + 1).toString().padStart(iColNum - 1)}${c.reset}`;
+    const name = (w.username || w.account.label || '?').substring(0, iColName).padEnd(iColName);
+    let invRes;
+    try { invRes = await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
+    catch { invRes = { ok: false }; }
+    invPending--;
+    const items = invRes?.ok ? (invRes.result?.items?.length || 0) : 0;
+    const val = invRes?.ok ? (invRes.result?.totalValue || 0) : 0;
+    const sts = invRes?.ok ? `${rgb(52, 211, 153)}✓${c.reset}` : `${rgb(239, 68, 68)}✗${c.reset}`;
+    const itemStr = `${items}`.padEnd(iColItems);
+    const valStr = invRes?.ok ? `${c.green}⏣${val.toLocaleString()}${c.reset}` : `${c.dim}···${c.reset}`;
+    const row = invBaseRow + 1 + i;
+    invMoveToRow(row);
+    process.stdout.write(`  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
+    if (invRes?.ok) invDone++; else invFailed++;
   }));
 
+  clearInterval(invSpinnerInterval);
+  process.stdout.write(`\r\x1b[2K`);
+
   if (invFailed > 0) {
-    console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  Inventory: ${invFailed} failed — not starting grind loops`);
+    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}  Inventory: ${invDone}/${activeWorkers.length} clear`);
+  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 ────────────────────────────────────
-  console.log(`  ${rgb(251, 191, 36)}·${c.reset}  Checking balance (${activeWorkers.length} accounts)...`);
-  await Promise.all(activeWorkers.map(async (w) => {
+  // ── Phase 2.5: Balance check — inline table, single spinner for progress ─────────
+  const bColNum = 4;
+  const bColName = Math.min(22, Math.max(12, Math.floor(startupTw * 0.22)));
+  const bColWallet = 12;
+  const bColBank = 12;
+  const bColTotal = 14;
+  const bColLs = 4;
+  const balVis = 7 + bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 14;
+
+  // Capture starting row for balance phase
+  // Set up stdin handler BEFORE writing MARKER (same fix — avoids race + PTY echo)
+  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);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
+    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];
+    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;
+    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) => {
     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 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`);
+
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
   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}  Balance: ${c.green}⏣ ${(totalWallet + totalBank).toLocaleString()}${c.reset} ${c.dim}(wallet: ⏣ ${totalWallet.toLocaleString()} + bank: ⏣ ${totalBank.toLocaleString()})${c.reset}`);
+  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}  ${noLifesaverAccounts.length} account(s) have 0 LIFESAVERS — crime/search disabled`);
+    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: DM history check ────────────────────────────────
-  console.log(`  ${rgb(139, 92, 246)}·${c.reset}  Checking DM history...`);
+
+  // Phase 2.75: Check DM history for deaths/level-ups (sequential, fast)
+  const dmCheckPulse = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+  console.log(`  ${rgb(139, 92, 246)}${dmCheckPulse}${c.reset}  ${c.dim}Checking DM history...${c.reset}`);
   let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [], dmUnknown = [];
   for (const w of activeWorkers) {
     try {
@@ -2950,12 +3204,25 @@ async function start(apiKey, apiUrl, opts = {}) {
       if (dm.levelUps > 0) dmLevelUps += dm.levelUps;
       if (dm.lifesavers === 0) dmNoLs.push(w.username);
       if (dm.lifesavers === -1) dmUnknown.push(w.username);
+      // Store level and lifesaver for dashboard
       if (dm.currentLevel > 0) w._level = dm.currentLevel;
       if (dm.lifesavers >= 0) w._lifesavers = dm.lifesavers;
+      const parts = [];
+      if (dm.currentLevel > 0) parts.push(`Lv${dm.currentLevel}`);
+      if (dm.deaths > 0) parts.push(`${rgb(239, 68, 68)}${dm.deaths} deaths${c.reset}`);
+      if (dm.lifesavers >= 0) {
+        const lc = dm.lifesavers === 0 ? rgb(239, 68, 68) : dm.lifesavers <= 2 ? rgb(251, 191, 36) : rgb(52, 211, 153);
+        parts.push(`${lc}♥${dm.lifesavers}${c.reset}`);
+      } else {
+        // Unknown lifesavers — pulse to show pending
+        const pulse = PULSE_CHARS[Math.floor(Date.now() / 400) % PULSE_CHARS.length];
+        parts.push(`${D}${pulse}♥?${c.reset}`);
+      }
     } catch {}
   }
   if (dmNoLs.length > 0) {
     log('warn', `⚠ No lifesavers: ${dmNoLs.join(', ')}`);
+    // Set Redis keys to block crime/search
     for (const w of activeWorkers) {
       if (dmNoLs.includes(w.username) && redis) {
         try {
@@ -2967,15 +3234,18 @@ async function start(apiKey, apiUrl, opts = {}) {
   }
   if (dmUnknown.length > 0) {
     log('warn', `⚠ Lifesavers unknown — live monitor: ${dmUnknown.join(', ')}`);
+    // Crime/search on these accounts will be skipped via safety hold until the live
+    // DM gateway listener detects a death (→ sets count) or confirms clean.
   }
   const dmSummaryParts = [];
   if (dmDeaths > 0) dmSummaryParts.push(`${dmDeaths} deaths`);
   if (dmLevelUps > 0) dmSummaryParts.push(`${dmLevelUps} level-ups`);
   if (dmUnknown.length > 0) dmSummaryParts.push(`${dmUnknown.length} pending`);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  DM check: ${dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean'}`);
+  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  DM check: ${dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean — no deaths or level-ups'}`);
+  console.log('');
+
+  console.log(`  ${rgb(139, 92, 246)}${c.bold}>>>${c.reset}  ${gradientText('Starting grind loops...', [139, 92, 246], [52, 211, 153])}`);
 
-  // ── Phase 3: Start grind loops ───────────────────────────────────
-  console.log(`  ${rgb(139, 92, 246)}>>>${c.reset}  Starting grind loops...`);
   // Phase 3: Start all grind loops (only for valid workers)
   for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();

package/lib/rawLogger.js

@@ -30,14 +30,7 @@ const memRing = [];
 let memIdx = 0;
 
 // ── Redis init ──
-async function init(redisUrlOrInstance) {
-  // Support passing an existing Redis instance directly (preferred)
-  if (redisUrlOrInstance && typeof redisUrlOrInstance.status !== 'undefined') {
-    redis = redisUrlOrInstance;
-    redisReady = redis.status === 'ready';
-    return;
-  }
-  const redisUrl = redisUrlOrInstance;
+async function init(redisUrl) {
   if (!redisUrl) {
     console.log('[rawLogger] No Redis URL — raw logging disabled');
     return;

package/package.json

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