dankgrinder 8.16.0 → 8.18.0

package/lib/grinder.js

@@ -94,9 +94,6 @@ const c = {
   restoreCursor: '\x1b8',
 };
 
-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';
 
 // ── Safe options for search/crime ──────────────────────────
@@ -231,54 +228,11 @@ function gradientLine(text, from, to) {
 }
 
 function gradientText(text, from, to) {
-  return gradientLine(text, from, to);
-}
-
-// ── Sparkline graph for earnings trend ───────────────────────
-const SPARK_CHARS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
-function drawSparkline(data, width = 12) {
-  if (!data || data.length === 0) return c.dim + '·····' + c.reset;
-  const recent = data.slice(-width);
-  const min = Math.min(...recent);
-  const max = Math.max(...recent);
-  const range = max - min || 1;
-  return recent.map(v => {
-    const idx = Math.min(7, Math.floor(((v - min) / range) * 8));
-    const ch = SPARK_CHARS[idx] || '▁';
-    const t = (v - min) / range;
-    // Gradient from red->yellow->green based on relative value
-    const r = t < 0.5 ? 239 : lerp(251, 52, (t - 0.5) * 2);
-    const g = t < 0.5 ? lerp(68, 191, t * 2) : lerp(191, 211, (t - 0.5) * 2);
-    const b = t < 0.5 ? lerp(68, 36, t * 2) : lerp(36, 153, (t - 0.5) * 2);
-    return rgb(r, g, b) + ch + c.reset;
-  }).join('');
-}
-
-// ── Advanced progress bar ────────────────────────────────────
-function progressBar(value, max, width, filledColor, emptyColor) {
-  const pct = max > 0 ? Math.min(1, value / max) : 0;
-  const filled = Math.round(pct * width);
-  const empty = width - filled;
-  const fc = filledColor || [52, 211, 153];
-  const ec = emptyColor || [50, 50, 70];
-  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];
+  return text;
 }
 
 function colorBanner() {
-  return `
-DANKGRINDER v${PKG_VERSION}
-`;
+  return `DANKGRINDER v${PKG_VERSION}`;
 }
 
 // ── Simple Logging ─────────────────────────────────────────────
@@ -2692,37 +2646,23 @@ async function start(apiKey, apiUrl, opts = {}) {
   REDIS_URL = process.env.REDIS_URL || '';
   WEBHOOK_URL = process.env.WEBHOOK_URL || '';
 
-  const tw = Math.min(process.stdout.columns || 80, 78);
-  const bar = '─'.repeat(tw);
+  const tw = 80;
 
-  // Detect zlib-sync availability
-  let hasZlib = false;
-  try { require('zlib-sync'); hasZlib = true; } catch {}
-
-  console.log(colorBanner());
-  console.log(
-    `  ${rgb(139, 92, 246)}v${PKG_VERSION}${c.reset}` +
-    `  ${c.dim}·${c.reset}  ${c.white}${AccountWorker.COMMAND_MAP.length} Commands${c.reset}` +
-    `  ${c.dim}·${c.reset}  ${rgb(34, 211, 238)}${CLOUD_MODE ? 'Cloud Mode' : (CLUSTER_ENABLED ? 'Cluster Mode' : 'Standalone')}${c.reset}` +
-    `  ${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}`);
+  console.log(`DANKGRINDER v${PKG_VERSION} - ${AccountWorker.COMMAND_MAP.length} commands - Standalone`);
+  console.log('Fetching accounts...');
 
   const fetchOpts = CLOUD_MODE ? { cloud: true } : {};
   let data = await fetchConfig(4, 2000, fetchOpts);
   while (!data) {
-    log('error', `Cannot connect to API`);
-    log('warn', `Will retry in 10s (check internet/API URL if this repeats).`);
+    console.log('Cannot connect to API - retrying in 10s...');
     await new Promise((r) => setTimeout(r, 10000));
     data = await fetchConfig(4, 2000, fetchOpts);
   }
   if (data && data.error) {
-    log('error', `${data.error}`);
+    console.log(`API error: ${data.error}`);
     return;
   }
+  console.log(`Fetched ${data.accounts?.length || 0} accounts`);
 
   // Cloud mode: post heartbeat every 30s
   if (CLOUD_MODE) {
@@ -2753,24 +2693,21 @@ async function start(apiKey, apiUrl, opts = {}) {
 
   let { accounts } = data;
   if (!accounts || accounts.length === 0) {
-    log('error', 'No active accounts. Add them in the dashboard.');
+    console.log('No active accounts. Add them in the dashboard.');
     return;
   }
+  console.log(`Processing ${accounts.length} accounts...`);
 
   // Cluster mode: filter to only accounts this node can claim
   if (CLUSTER_ENABLED) {
     const totalBefore = accounts.length;
     accounts = await filterClaimableAccounts(accounts);
-    log('info', `${c.dim}Cluster: claimed ${accounts.length}/${totalBefore} accounts (others owned by peer nodes)${c.reset}`);
+    console.log(`Cluster: claimed ${accounts.length}/${totalBefore} accounts`);
     if (accounts.length === 0) {
-      log('warn', 'All accounts claimed by other nodes. Waiting for accounts...');
+      console.log('All accounts claimed by other nodes. Waiting...');
     }
   }
 
-  const checks = [];
-  checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}API${c.reset}`);
-  if (REDIS_URL) checks.push(redis ? `${rgb(52, 211, 153)}✓${c.reset} ${c.white}Redis${c.reset}` : `${rgb(251, 191, 36)}○${c.reset} ${c.dim}Redis (connecting...)${c.reset}`);
-
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
     rawLogger.init(REDIS_URL).catch(() => {});
@@ -2822,116 +2759,14 @@ async function start(apiKey, apiUrl, opts = {}) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
-  // ── 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`);
-  };
-
+  // ── Phase 1: Login ─────────────────────────────────────────────
   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(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));
 
+  console.log(`Logging in ${accounts.length} accounts...`);
   const BATCH_SIZE = 10;
   for (let i = 0; i < accounts.length; i += BATCH_SIZE) {
     if (shutdownCalled) break;
@@ -2941,260 +2776,88 @@ 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 (worker._tokenInvalid) {
+        console.log(`  [${i + idx + 1}] FAIL - invalid token: ${acc.label || acc.id}`);
+      } else if (worker.channel) {
+        console.log(`  [${i + idx + 1}] OK - ${worker.username}`);
+      } else {
+        console.log(`  [${i + idx + 1}] TIMEOUT`);
+      }
     }));
     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(`\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('');
+  console.log(`Login complete: ${loginDone}/${accounts.length} connected`);
   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('');
+    for (const w of invalidWorkers) console.log(`  FAIL - invalid token: ${w.account.label || w.account.id}`);
+  }
+  if (timedOutWorkers.length > 0) {
+    console.log(`  WARN - ${timedOutWorkers.length} timed out (will retry in background)`);
   }
-  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 — 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++;
+  // ── Phase 2: Inventory check ────────────────────────────────────
+  console.log('Checking inventory...');
+  let invFailed = 0;
+  await Promise.all(activeWorkers.map(async (w) => {
+    try { await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
+    catch { invFailed++; }
   }));
-
-  clearInterval(invSpinnerInterval);
-  process.stdout.write(`\r\x1b[2K`);
-
   if (invFailed > 0) {
-    console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  ${c.bold}Inventory incomplete${c.reset}  ${rgb(52, 211, 153)}${invDone}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset} ${c.dim}done, ${rgb(239, 68, 68)}${invFailed} failed${c.reset}`);
-    log('error', `${c.red}Not starting grind loops — ${invFailed} accounts failed inventory.${c.reset}`);
+    console.log(`Inventory failed for ${invFailed} accounts. Not starting grind loops.`);
     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 — 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);
+  console.log('Inventory check complete');
 
-  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 = [];
+  // ── Phase 2.5: Balance check ───────────────────────────────────
+  console.log('Checking balances...');
   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);
+    try { await w.checkBalance(true); } catch {}
   }
-  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(', ')}`);
+  let totalCoins = 0;
+  for (const w of activeWorkers) {
+    totalCoins += w.stats?.balance || 0;
+    totalCoins += w.stats?.bankBalance || 0;
   }
-  console.log('');
+  console.log(`Balances: total ${totalCoins.toLocaleString()} coins across ${activeWorkers.length} accounts`);
 
-
-  // 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 = [];
+  // ── Phase 2.75: DM history check ────────────────────────────────
+  console.log('Checking DM history...');
+  let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [];
   for (const w of activeWorkers) {
     try {
       const dm = await w.checkDmHistory();
       if (dm.deaths > 0) dmDeaths += dm.deaths;
       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) {
+      // Block crime/search for accounts with 0 lifesavers
+      if (dm.lifesavers === 0 && redis) {
         try {
           await redis.set(`dkg:lifesavers:${w.account.id}`, '0', 'EX', 86400);
-          await redis.set(`raw:alert:no-lifesaver:${w.channel?.id}`, '1', 'EX', 86400);
         } catch {}
       }
-    }
-  }
-  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.
+    } catch {}
   }
-  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 — no deaths or level-ups'}`);
-  console.log('');
+  if (dmNoLs.length > 0) console.log(`  WARN - No lifesavers: ${dmNoLs.join(', ')}`);
+  const parts = [];
+  if (dmDeaths > 0) parts.push(`${dmDeaths} deaths`);
+  if (dmLevelUps > 0) parts.push(`${dmLevelUps} level-ups`);
+  console.log(`DM check: ${parts.length > 0 ? parts.join(', ') : 'clean'}`);
 
-  console.log(`  ${rgb(139, 92, 246)}${c.bold}>>>${c.reset}  ${gradientText('Starting grind loops...', [139, 92, 246], [52, 211, 153])}`);
-
-  // Phase 3: Start all grind loops (only for valid workers)
+  // ── Phase 3: Start grind loops ───────────────────────────────────
+  console.log(`Starting ${activeWorkers.length} grind loops...`);
   for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();
   }
-
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  All grind loops started — ${activeWorkers.length} accounts active`);
-  console.log(`  v${PKG_VERSION}  |  press Ctrl+C to stop`);
+  console.log(`All grind loops started. v${PKG_VERSION} | Ctrl+C to stop`);
 
   // Cluster heartbeat — lets other nodes see this node is alive
   if (CLUSTER_ENABLED) {
@@ -3263,31 +2926,23 @@ async function start(apiKey, apiUrl, opts = {}) {
     setDashboardActive(false);
     process.stdout.write(c.show);
 
-    const sepBar = rgb(139, 92, 246) + c.bold + '═'.repeat(tw) + c.reset;
     console.log('');
-    console.log(`  ${rgb(251, 191, 36)}${c.bold}Session Summary${c.reset}`);
-    console.log(sepBar);
+    console.log('Session Summary');
 
     // Collect stats from all workers (including rotated-out ones)
     let finalCoins = 0;
     let finalCmds = 0;
     for (const wk of workers) {
       const rate = wk.stats.commands > 0 ? ((wk.stats.successes / wk.stats.commands) * 100).toFixed(0) : 0;
-      console.log(
-        `  ${wk.color}${c.bold}${(wk.username || '?').padEnd(18)}${c.reset}` +
-        `  ${rgb(52, 211, 153)}+⏣ ${wk.stats.coins.toLocaleString().padStart(8)}${c.reset}` +
-        `  ${c.dim}${wk.stats.commands.toString().padStart(4)} cmds${c.reset}` +
-        `  ${c.dim}${rate}% success${c.reset}`
-      );
+      console.log(`  ${(wk.username || '?').padEnd(18)} +${wk.stats.coins.toLocaleString().padStart(8)} coins  ${wk.stats.commands} cmds  ${rate}% ok`);
       finalCoins += wk.stats.coins || 0;
       finalCmds += wk.stats.commands || 0;
     }
-    console.log(sepBar);
 
     const memFinal = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
     const avgEarn = globalEarningsEMA.get();
     const cpm = globalCmdRate.getRate().toFixed(1);
-    console.log(`  ${rgb(251, 191, 36)}${c.bold}Total: +⏣ ${finalCoins.toLocaleString()}${c.reset} ${c.dim}in ${formatUptime()} | ${finalCmds} cmds | ~${cpm} cmd/m | ${memFinal}MB | avg earn ⏣ ${Math.round(avgEarn)}${c.reset}`);
+    console.log(`Total: +${finalCoins.toLocaleString()} coins in ${formatUptime()} | ${finalCmds} cmds | ~${cpm} cmd/m | ${memFinal}MB`);
     console.log('');
 
     // Release all cluster claims before stopping workers

package/package.json

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