dankgrinder 4.5.0 → 4.6.0

package/lib/commands/blackjack.js

@@ -1,6 +1,6 @@
 /**
  * Blackjack command handler.
- * Send "pls bj <bet>", play hit/stand based on card total.
+ * Smart hit/stand: follows basic strategy based on player total and dealer upcard.
  */
 
 const {
@@ -8,14 +8,50 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
 } = require('./utils');
 
+function parsePlayerTotal(text) {
+  // Match the player section: "username (Player)\n ♦ J ♦ 2  12"
+  // The number after the cards on the player line is the total
+  const playerSection = text.match(/\(Player\)[\s\S]*?(\d+)/i);
+  if (playerSection) return parseInt(playerSection[1]);
+  const totalMatch = text.match(/total[:\s]*\**(\d+)\**/i) || text.match(/value[:\s]*\**(\d+)\**/i);
+  return totalMatch ? parseInt(totalMatch[1]) : 0;
+}
+
+function parseDealerUpcard(text) {
+  // Match dealer section: "Dank Memer (Dealer)\n ♦ 10 ♣ 8  18"
+  const dealerSection = text.match(/\(Dealer\)[\s\S]*?(\d+)/i);
+  if (dealerSection) return parseInt(dealerSection[1]);
+  return 0;
+}
+
+function parseNetCoins(text) {
+  // Parse "Net: ⏣ -5,000" or "Net: ⏣ 5,000"
+  const netMatch = text.match(/Net:\s*[⏣o]\s*(-?[\d,]+)/i);
+  if (netMatch) {
+    return parseInt(netMatch[1].replace(/,/g, ''));
+  }
+  // Parse "Winnings: ⏣ 5,000"
+  const winMatch = text.match(/Winnings:\s*[⏣o]\s*([\d,]+)/i);
+  if (winMatch) return parseInt(winMatch[1].replace(/,/g, ''));
+  return 0;
+}
+
 /**
- * @param {object} opts
- * @param {object} opts.channel
- * @param {function} opts.waitForDankMemer
- * @param {number} [opts.betAmount=1000]
- * @returns {Promise<{result: string, coins: number}>}
+ * Basic strategy decision.
+ * - Always hit on ≤ 11
+ * - Stand on ≥ 17
+ * - 12-16: hit if dealer shows 7+ (strong upcard), else stand
  */
-async function runBlackjack({ channel, waitForDankMemer, betAmount = 1000 }) {
+function shouldHit(playerTotal, dealerTotal) {
+  if (playerTotal <= 11) return true;
+  if (playerTotal >= 17) return false;
+  // 12-16: dealer has strong hand (7+), we need to risk hitting
+  if (dealerTotal >= 7) return true;
+  // Dealer has weak hand (2-6), likely to bust — stand and wait
+  return false;
+}
+
+async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
   const cmd = `pls bj ${betAmount}`;
   LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
 
@@ -42,21 +78,22 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 1000 }) {
     const buttons = getAllButtons(current);
     if (buttons.length === 0 || buttons.every(b => b.disabled)) break;
 
-    // Parse player total
-    const totalMatch = text.match(/total[:\s]*\**(\d+)\**/i) || text.match(/value[:\s]*\**(\d+)\**/i);
-    const playerTotal = totalMatch ? parseInt(totalMatch[1]) : 0;
+    const playerTotal = parsePlayerTotal(text);
+    const dealerTotal = parseDealerUpcard(text);
 
     let targetBtn;
-    if (playerTotal >= 17 || playerTotal === 0) {
+    if (playerTotal === 0) {
       targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('stand')) || buttons[1];
-    } else {
+    } else if (shouldHit(playerTotal, dealerTotal)) {
       targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('hit')) || buttons[0];
+    } else {
+      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('stand')) || buttons[1];
     }
 
     if (!targetBtn || targetBtn.disabled) break;
 
-    LOG.info(`[bj] Total: ${playerTotal} → ${targetBtn.label}`);
-    await humanDelay(500, 1200);
+    LOG.info(`[bj] You:${playerTotal} Dealer:${dealerTotal} → ${targetBtn.label}`);
+    await humanDelay(400, 900);
 
     try {
       const followUp = await safeClickButton(current, targetBtn);
@@ -70,15 +107,28 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 1000 }) {
   }
 
   const finalText = getFullText(current);
-  const coins = parseCoins(finalText);
+  const net = parseNetCoins(finalText);
   const lower = finalText.toLowerCase();
 
-  if (coins > 0) {
-    LOG.coin(`[bj] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-    return { result: `bj → +⏣ ${coins.toLocaleString()}`, coins };
+  if (net > 0) {
+    LOG.coin(`[bj] ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`);
+    return { result: `bj → +⏣ ${net.toLocaleString()}`, coins: net };
+  }
+  if (net < 0) {
+    LOG.warn(`[bj] ${c.red}-⏣ ${Math.abs(net).toLocaleString()}${c.reset}`);
+    return { result: `bj → -⏣ ${Math.abs(net).toLocaleString()}`, coins: 0, lost: Math.abs(net) };
   }
-  if (lower.includes('won')) return { result: `bj → ${c.green}won${c.reset}`, coins: 0 };
-  if (lower.includes('lost') || lower.includes('bust')) return { result: `bj → ${c.red}lost${c.reset}`, coins: 0 };
+  if (lower.includes('won') || lower.includes('beat')) {
+    const coins = parseCoins(finalText);
+    return { result: `bj → ${c.green}won${c.reset}`, coins };
+  }
+  if (lower.includes('lost') || lower.includes('bust') || lower.includes('lower score')) {
+    return { result: `bj → lost`, coins: 0, lost: betAmount };
+  }
+  if (lower.includes('tied') || lower.includes('push')) {
+    return { result: 'bj → push', coins: 0 };
+  }
+
   return { result: 'bj done', coins: 0 };
 }
 

package/lib/commands/gamble.js

@@ -4,20 +4,10 @@
  */
 
 const {
-  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  LOG, c, getFullText, parseCoins, parseNetCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
 } = require('./utils');
 
-/**
- * Generic gamble handler — works for coinflip, roulette, slots, snakeeyes.
- * 
- * @param {object} opts
- * @param {object} opts.channel
- * @param {function} opts.waitForDankMemer
- * @param {string} opts.cmdName - e.g. 'coinflip', 'roulette', 'slots', 'snakeeyes'
- * @param {string} opts.cmdString - Full command string e.g. 'pls coinflip 1000 heads'
- * @returns {Promise<{result: string, coins: number}>}
- */
 async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
   LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
 
@@ -38,9 +28,8 @@ async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
 
   logMsg(response, cmdName);
   const text = getFullText(response);
-  const coins = parseCoins(text);
 
-  // Some gambles have buttons (e.g. pick heads/tails)
+  // Some gambles have buttons (coinflip: pick heads/tails)
   const buttons = getAllButtons(response);
   if (buttons.length > 0) {
     const btn = buttons.find(b => !b.disabled);
@@ -52,34 +41,39 @@ async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
         if (followUp) {
           logMsg(followUp, `${cmdName}-result`);
           const fText = getFullText(followUp);
-          const fCoins = parseCoins(fText);
-          if (fCoins > 0) {
-            LOG.coin(`[${cmdName}] ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
-            return { result: `${cmdName} → +⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
-          }
-          if (fText.toLowerCase().includes('won')) return { result: `${cmdName} → ${c.green}won${c.reset}`, coins: 0 };
-          if (fText.toLowerCase().includes('lost')) return { result: `${cmdName} → ${c.red}lost${c.reset}`, coins: 0 };
+          return parseGambleResult(fText, cmdName);
         }
       } catch (e) { LOG.error(`[${cmdName}] Click error: ${e.message}`); }
     }
   }
 
+  return parseGambleResult(text, cmdName);
+}
+
+function parseGambleResult(text, cmdName) {
+  const net = parseNetCoins(text);
+  const lower = text.toLowerCase();
+
+  if (net > 0) {
+    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`);
+    return { result: `${cmdName} → +⏣ ${net.toLocaleString()}`, coins: net };
+  }
+  if (net < 0) {
+    LOG.warn(`[${cmdName}] ${c.red}-⏣ ${Math.abs(net).toLocaleString()}${c.reset}`);
+    return { result: `${cmdName} → -⏣ ${Math.abs(net).toLocaleString()}`, coins: 0, lost: Math.abs(net) };
+  }
+  // Fallback to parseCoins
+  const coins = parseCoins(text);
   if (coins > 0) {
     LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
   }
-
-  const lower = text.toLowerCase();
-  if (lower.includes('won')) return { result: `${cmdName} → won`, coins };
-  if (lower.includes('lost')) {
-    const lostCoins = parseCoins(text);
-    return { result: `${cmdName} → lost`, coins: 0, lost: lostCoins };
-  }
+  if (lower.includes('won') || lower.includes('beat')) return { result: `${cmdName} → won`, coins: 0 };
+  if (lower.includes('lost') || lower.includes('bust')) return { result: `${cmdName} → lost`, coins: 0, lost: coins };
 
   return { result: `${cmdName} done`, coins: 0 };
 }
 
-// Convenience wrappers
 async function runCoinflip({ channel, waitForDankMemer, betAmount = 5000 }) {
   return runGamble({ channel, waitForDankMemer, cmdName: 'coinflip', cmdString: `pls coinflip ${betAmount} heads` });
 }

package/lib/commands/highlow.js

@@ -1,6 +1,6 @@
 /**
  * HighLow command handler.
- * Send "pls hl", parse the hint number, pick higher/lower/jackpot.
+ * Strategy: if hint > 50 → lower, if hint < 50 → higher, if exactly 50 → jackpot.
  */
 
 const {
@@ -8,38 +8,63 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
 } = require('./utils');
 
-/**
- * Recursively handle highlow rounds (multi-round game).
- */
+function parseHintNumber(text) {
+  // Dank Memer shows something like "your hint is **69**" or "The number is 42"
+  const hintMatch = text.match(/hint.*?\*\*(\d+)\*\*/i)
+    || text.match(/number.*?\*\*(\d+)\*\*/i)
+    || text.match(/hint.*?(\d+)/i)
+    || text.match(/number.*?(\d+)/i);
+  if (hintMatch) return parseInt(hintMatch[1]);
+  // Fallback: find any standalone number in the text (1-100 range)
+  const nums = text.match(/\b(\d{1,3})\b/g);
+  if (nums) {
+    for (const n of nums) {
+      const v = parseInt(n);
+      if (v >= 1 && v <= 100) return v;
+    }
+  }
+  return null;
+}
+
+function parseNetCoins(text) {
+  const netMatch = text.match(/Net:\s*[⏣o]\s*(-?[\d,]+)/i);
+  if (netMatch) return parseInt(netMatch[1].replace(/,/g, ''));
+  const winMatch = text.match(/Winnings:\s*[⏣o]\s*([\d,]+)/i);
+  if (winMatch) return parseInt(winMatch[1].replace(/,/g, ''));
+  return 0;
+}
+
 async function playHighLow(response, depth = 0) {
   if (!response || depth > 5) return { result: 'done', coins: 0 };
 
   const text = getFullText(response);
   const buttons = getAllButtons(response);
 
-  if (buttons.length === 0) {
-    const coins = parseCoins(text);
-    return { result: coins > 0 ? `+⏣ ${coins.toLocaleString()}` : 'done', coins };
+  if (buttons.length === 0 || buttons.every(b => b.disabled)) {
+    const net = parseNetCoins(text);
+    const coins = net > 0 ? net : parseCoins(text);
+    const lost = net < 0 ? Math.abs(net) : 0;
+    return { result: coins > 0 ? `+⏣ ${coins.toLocaleString()}` : 'done', coins, lost };
   }
 
-  // Parse the hint number
-  const match = text.match(/number.*?(\d+)/i) || text.match(/(\d+)/);
+  const hint = parseHintNumber(text);
   let targetBtn;
 
-  if (match && buttons.length >= 2) {
-    const num = parseInt(match[1]);
-    if (num > 50) {
-      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('lower')) || buttons[1];
-    } else if (num < 50) {
-      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('higher')) || buttons[0];
+  if (hint !== null && buttons.length >= 2) {
+    if (hint > 50) {
+      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('lower'));
+    } else if (hint < 50) {
+      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('higher'));
     } else {
-      const jackpot = buttons.find(b => (b.label || '').toLowerCase().includes('jackpot'));
-      targetBtn = jackpot || buttons[Math.floor(Math.random() * 2)];
+      // Exactly 50 — try jackpot, fallback to higher (slightly better odds)
+      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('jackpot'))
+        || buttons.find(b => (b.label || '').toLowerCase().includes('higher'));
     }
-    LOG.info(`[hl] Number: ${num} → picking "${targetBtn.label}"`);
+    if (!targetBtn) targetBtn = buttons.find(b => !b.disabled);
+    LOG.info(`[hl] Hint: ${hint} → ${targetBtn?.label || '?'}`);
   } else {
     targetBtn = buttons.find(b => !b.disabled) || buttons[0];
-    LOG.info(`[hl] No hint, picking "${targetBtn.label}"`);
+    LOG.info(`[hl] No hint parsed → ${targetBtn?.label || '?'}`);
   }
 
   if (!targetBtn || targetBtn.disabled) {
@@ -47,26 +72,24 @@ async function playHighLow(response, depth = 0) {
     return { result: 'buttons disabled', coins };
   }
 
-  await humanDelay(500, 1200);
+  await humanDelay(400, 900);
 
   try {
     const followUp = await safeClickButton(response, targetBtn);
     if (followUp) {
       logMsg(followUp, `hl-round-${depth}`);
       const fText = getFullText(followUp);
-      const fCoins = parseCoins(fText);
 
-      // Check for more rounds
       const moreButtons = getAllButtons(followUp);
       if (moreButtons.length >= 2 && !moreButtons.every(b => b.disabled)) {
-        const deeper = await playHighLow(followUp, depth + 1);
-        return { result: deeper.result, coins: fCoins + deeper.coins };
+        return playHighLow(followUp, depth + 1);
       }
 
-      if (fCoins > 0) {
-        return { result: `${targetBtn.label} → +⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
-      }
-      return { result: `${targetBtn.label}`, coins: 0 };
+      // Final round — parse net earnings
+      const net = parseNetCoins(fText);
+      const coins = net > 0 ? net : parseCoins(fText);
+      const lost = net < 0 ? Math.abs(net) : 0;
+      return { result: `${targetBtn.label} → ${coins > 0 ? '+⏣ ' + coins.toLocaleString() : 'done'}`, coins, lost };
     }
   } catch (e) {
     LOG.error(`[hl] Click error: ${e.message}`);
@@ -75,12 +98,6 @@ async function playHighLow(response, depth = 0) {
   return { result: 'done', coins: 0 };
 }
 
-/**
- * @param {object} opts
- * @param {object} opts.channel
- * @param {function} opts.waitForDankMemer
- * @returns {Promise<{result: string, coins: number}>}
- */
 async function runHighLow({ channel, waitForDankMemer }) {
   LOG.cmd(`${c.white}${c.bold}pls hl${c.reset}`);
 
@@ -100,13 +117,13 @@ async function runHighLow({ channel, waitForDankMemer }) {
   }
 
   logMsg(response, 'hl');
-  const { result, coins } = await playHighLow(response);
+  const { result, coins, lost } = await playHighLow(response);
 
   if (coins > 0) {
     LOG.coin(`[hl] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
   }
 
-  return { result: `hl → ${result}`, coins };
+  return { result: `hl → ${result}`, coins, lost: lost || 0 };
 }
 
 module.exports = { runHighLow };

package/lib/commands/postmemes.js

@@ -54,15 +54,26 @@ async function runPostMemes({ channel, waitForDankMemer }) {
 
   // Check for cooldown or direct text response (no select menus)
   let selects = getAllSelectMenus(response);
+  const initText = getFullText(response);
+  const initLower = initText.toLowerCase();
+
+  // Detect "dead meme" / cooldown message → return with nextCooldownSec
+  if (initLower.includes('cannot post another meme') || initLower.includes('dead meme') ||
+      initLower.includes('another meme for another')) {
+    const minMatch = initText.match(/(\d+)\s*minute/i);
+    const cdSec = minMatch ? parseInt(minMatch[1]) * 60 : 120;
+    LOG.warn(`[pm] Cooldown: ${cdSec}s`);
+    return { result: `pm cooldown ${cdSec}s`, coins: 0, nextCooldownSec: cdSec };
+  }
+
   if (selects.length === 0) {
-    const text = getFullText(response);
-    const coins = parseCoins(text);
+    const coins = parseCoins(initText);
     if (coins > 0) {
       LOG.coin(`[pm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
       return { result: `pm → +⏣ ${coins.toLocaleString()}`, coins };
     }
-    LOG.info(`[pm] No menus: ${text.substring(0, 100).replace(/\n/g, ' ')}`);
-    return { result: text.substring(0, 60), coins: 0 };
+    LOG.info(`[pm] No menus: ${initText.substring(0, 100).replace(/\n/g, ' ')}`);
+    return { result: initText.substring(0, 60), coins: 0 };
   }
 
   const msgId = response.id;

package/lib/commands/utils.js

@@ -65,7 +65,22 @@ function getFullText(msg) {
 
 function parseCoins(text) {
   if (!text) return 0;
-  // Match ⏣ prefixed coins
+  // Prefer "Net:" if present (accurate earned/lost from Dank Memer)
+  const netMatch = text.match(/Net:\s*[⏣o]\s*(-?[\d,]+)/i);
+  if (netMatch) {
+    const net = parseInt(netMatch[1].replace(/,/g, ''));
+    return net > 0 ? net : 0;
+  }
+  // Prefer "Winnings:" over random coin values
+  const winMatch = text.match(/Winnings:\s*[⏣o]\s*([\d,]+)/i);
+  if (winMatch) {
+    const w = parseInt(winMatch[1].replace(/,/g, ''));
+    if (w > 0) return w;
+  }
+  // Prefer "placed in your wallet" pattern (daily, beg, etc.)
+  const walletMatch = text.match(/⏣\s*([\d,]+)\s*was placed/i);
+  if (walletMatch) return parseInt(walletMatch[1].replace(/,/g, ''));
+  // Fallback: max ⏣ number
   const matches = text.match(/⏣\s*([\d,]+)/g);
   if (!matches) return 0;
   let best = 0;
@@ -79,6 +94,13 @@ function parseCoins(text) {
   return best;
 }
 
+function parseNetCoins(text) {
+  if (!text) return 0;
+  const netMatch = text.match(/Net:\s*[⏣o]\s*(-?[\d,]+)/i);
+  if (netMatch) return parseInt(netMatch[1].replace(/,/g, ''));
+  return 0;
+}
+
 /**
  * Parse wallet balance from a balance response message.
  * Handles both embed-based and CV2 TEXT_DISPLAY component formats.
@@ -288,6 +310,7 @@ module.exports = {
   humanDelay,
   getFullText,
   parseCoins,
+  parseNetCoins,
   parseBalance,
   getAllButtons,
   getAllSelectMenus,

package/lib/grinder.js

@@ -1,7 +1,7 @@
 const { Client } = require('discord.js-selfbot-v13');
 const Redis = require('ioredis');
 const commands = require('./commands');
-const { setDashboardActive, getFullText } = require('./commands/utils');
+const { setDashboardActive } = require('./commands/utils');
 
 // ── Terminal Colors & ANSI ───────────────────────────────────
 const c = {
@@ -154,54 +154,75 @@ function renderDashboard() {
   lastRenderTime = Date.now();
 
   totalBalance = 0; totalCoins = 0; totalCommands = 0;
+  let totalErrors = 0;
   for (const w of workers) {
     totalBalance += w.stats.balance || 0;
     totalCoins += w.stats.coins || 0;
     totalCommands += w.stats.commands || 0;
+    totalErrors += w.stats.errors || 0;
   }
+  const successRate = totalCommands > 0 ? Math.round(((totalCommands - totalErrors) / totalCommands) * 100) : 100;
 
   const lines = [];
-  const tw = Math.min(process.stdout.columns || 80, 76);
+  const tw = Math.min(process.stdout.columns || 80, 78);
   const thinBar = c.dim + '─'.repeat(tw) + c.reset;
-  const thickTop = rgb(139, 92, 246) + c.bold + '═'.repeat(tw) + c.reset;
-  const thickBot = rgb(34, 211, 238) + c.bold + '═'.repeat(tw) + c.reset;
-
-  lines.push(thickTop);
+  const topBar = rgb(139, 92, 246) + c.bold + '━'.repeat(tw) + c.reset;
+  const botBar = rgb(34, 211, 238) + c.bold + '━'.repeat(tw) + c.reset;
+
+  // Status bar
+  lines.push(topBar);
+  const liveIcon = rgb(52, 211, 153) + '◉' + c.reset;
+  const balStr = `${rgb(192, 132, 252)}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}`;
+  const earnStr = `${rgb(52, 211, 153)}↑ ${formatCoins(totalCoins)}${c.reset}`;
+  const cmdStr = `${rgb(96, 165, 250)}${totalCommands}${c.reset}${c.dim} cmds${c.reset}`;
+  const rateStr = successRate >= 95
+    ? `${rgb(52, 211, 153)}${successRate}%${c.reset}`
+    : successRate >= 80 ? `${rgb(251, 191, 36)}${successRate}%${c.reset}`
+    : `${rgb(239, 68, 68)}${successRate}%${c.reset}`;
+  const upStr = `${rgb(251, 191, 36)}⏱ ${formatUptime()}${c.reset}`;
   lines.push(
-    `  ${rgb(192, 132, 252)}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}` +
-    ` ${c.dim}│${c.reset}` +
-    ` ${rgb(52, 211, 153)}+${formatCoins(totalCoins)}${c.reset}` +
-    ` ${c.dim}│${c.reset}` +
-    ` ${c.white}${totalCommands}${c.reset}${c.dim} cmds${c.reset}` +
-    ` ${c.dim}│${c.reset}` +
-    ` ${rgb(251, 191, 36)}${formatUptime()}${c.reset}` +
-    ` ${c.dim}│${c.reset}` +
-    ` ${rgb(52, 211, 153)}● LIVE${c.reset}`
+    `  ${liveIcon} ${balStr}  ${c.dim}│${c.reset}  ${earnStr}  ${c.dim}│${c.reset}  ${cmdStr} ${c.dim}(${c.reset}${rateStr}${c.dim})${c.reset}  ${c.dim}│${c.reset}  ${upStr}`
   );
   lines.push(thinBar);
 
-  const nameWidth = Math.min(14, tw > 60 ? 14 : 10);
-  const statusWidth = Math.max(12, tw - nameWidth - 30);
+  // Worker rows
+  const nameWidth = Math.min(16, tw > 65 ? 16 : 10);
+  const statusWidth = Math.max(16, tw - nameWidth - 34);
 
   for (const wk of workers) {
     const rawStatus = (wk.lastStatus || 'idle').replace(/\x1b\[[0-9;]*m/g, '');
     const last = rawStatus.substring(0, statusWidth);
-    const dot = wk.running
-      ? (wk.paused ? `${rgb(239, 68, 68)}⏸${c.reset}`
-        : wk.dashboardPaused ? `${rgb(251, 191, 36)}⏸${c.reset}`
-        : wk.busy ? `${rgb(251, 191, 36)}◉${c.reset}`
-        : `${rgb(52, 211, 153)}●${c.reset}`)
-      : `${rgb(239, 68, 68)}○${c.reset}`;
-    const name = `${wk.color}${c.bold}${(wk.username || '?').substring(0, nameWidth).padEnd(nameWidth)}${c.reset}`;
+
+    let dot, stateLabel;
+    if (!wk.running) {
+      dot = `${rgb(239, 68, 68)}○${c.reset}`;
+      stateLabel = `${c.dim}offline${c.reset}`;
+    } else if (wk.paused) {
+      dot = `${rgb(239, 68, 68)}⏸${c.reset}`;
+      stateLabel = `${rgb(239, 68, 68)}PAUSED${c.reset}`;
+    } else if (wk.dashboardPaused) {
+      dot = `${rgb(251, 191, 36)}⏸${c.reset}`;
+      stateLabel = `${rgb(251, 191, 36)}paused${c.reset}`;
+    } else if (wk.busy) {
+      dot = `${rgb(251, 191, 36)}◉${c.reset}`;
+      stateLabel = `${c.dim}${last}${c.reset}`;
+    } else {
+      dot = `${rgb(52, 211, 153)}●${c.reset}`;
+      stateLabel = `${c.dim}${last}${c.reset}`;
+    }
+
+    const name = `${wk.color}${c.bold}${(wk.username || '?').substring(0, nameWidth)}${c.reset}`;
     const bal = wk.stats.balance > 0
-      ? `${rgb(251, 191, 36)}⏣${c.reset}${c.white}${formatCoins(wk.stats.balance).padStart(6)}${c.reset}`
-      : `${c.dim}⏣    -${c.reset}`;
+      ? `${rgb(251, 191, 36)}⏣${c.reset} ${c.white}${formatCoins(wk.stats.balance).padStart(7)}${c.reset}`
+      : `${c.dim}⏣       -${c.reset}`;
     const earned = wk.stats.coins > 0
-      ? `${rgb(52, 211, 153)}+${formatCoins(wk.stats.coins)}${c.reset}`
-      : `${c.dim}+0${c.reset}`;
-    lines.push(`  ${dot} ${name} ${bal} ${earned} ${c.dim}${last}${c.reset}`);
+      ? `${rgb(52, 211, 153)}+${formatCoins(wk.stats.coins).padStart(6)}${c.reset}`
+      : `${c.dim}     +0${c.reset}`;
+
+    lines.push(`  ${dot} ${name.padEnd(nameWidth + wk.color.length + c.bold.length + c.reset.length)} ${bal}  ${earned}  ${stateLabel}`);
   }
 
+  // Log section
   if (recentLogs.length > 0) {
     lines.push(thinBar);
     for (const entry of recentLogs) {
@@ -209,7 +230,7 @@ function renderDashboard() {
     }
   }
 
-  lines.push(thickBot);
+  lines.push(botBar);
 
   if (dashboardLines > 0) {
     process.stdout.write(c.cursorUp(dashboardLines));
@@ -291,19 +312,21 @@ function safeParseJSON(str, fallback = []) {
   try { return JSON.parse(str || '[]'); } catch { return fallback; }
 }
 
-// ── Coin Parser (conservative — only ⏣ amounts) ─────────────
+// ── Coin Parser — prefers Net:/Winnings: fields, falls back to max ⏣ ──
 function parseCoins(text) {
   if (!text) return 0;
-  // Only match coins that are clearly ⏣ prefixed  
+  const netMatch = text.match(/Net:\s*[⏣o]\s*(-?[\d,]+)/i);
+  if (netMatch) { const n = parseInt(netMatch[1].replace(/,/g, '')); return n > 0 ? n : 0; }
+  const winMatch = text.match(/Winnings:\s*[⏣o]\s*([\d,]+)/i);
+  if (winMatch) { const w = parseInt(winMatch[1].replace(/,/g, '')); if (w > 0) return w; }
+  const walletMatch = text.match(/⏣\s*([\d,]+)\s*was placed/i);
+  if (walletMatch) return parseInt(walletMatch[1].replace(/,/g, ''));
   const matches = text.match(/⏣\s*([\d,]+)/g);
   if (!matches) return 0;
   let best = 0;
   for (const m of matches) {
     const numStr = m.replace(/[^\d]/g, '');
-    if (numStr) {
-      const val = parseInt(numStr);
-      if (val > 0 && val < 10000000) best = Math.max(best, val); // Cap at 10M sanity
-    }
+    if (numStr) { const val = parseInt(numStr); if (val > 0 && val < 10000000) best = Math.max(best, val); }
   }
   return best;
 }
@@ -825,6 +848,15 @@ class AccountWorker {
         return;
       }
 
+      // PostMemes / command-specific cooldown from response
+      if (resultLower.includes('cannot post another meme') || resultLower.includes('dead meme')) {
+        const minMatch = result.match(/(\d+)\s*minute/i);
+        const cdSec = minMatch ? parseInt(minMatch[1]) * 60 : 120;
+        this.log('warn', `${cmdName} on cooldown: ${cdSec}s`);
+        await this.setCooldown(cmdName, cdSec);
+        return;
+      }
+
       // Captcha/verification detection — deactivate account and stop
       if (resultLower.includes('captcha') || resultLower.includes('verification required') ||
           resultLower.includes('verify your account') || resultLower.includes('pass verification') ||
@@ -867,7 +899,7 @@ class AccountWorker {
         return;
       }
 
-      // Already claimed today (daily/weekly) — set long cooldown
+      // Already claimed today (daily/weekly) — set long cooldown + mark in Redis
       if (resultLower.includes('already got your daily') || resultLower.includes('try again <t:')) {
         this.log('info', `${cmdName} already claimed — waiting`);
         const timeMatch = result.match(/<t:(\d+):R>/);
@@ -875,8 +907,11 @@ class AccountWorker {
           const nextAvail = parseInt(timeMatch[1]) * 1000;
           const waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
           await this.setCooldown(cmdName, waitSec);
+          if (redis) try { await redis.set(`dkg:done:${this.account.id}:${cmdName}`, '1', 'EX', waitSec); } catch {}
         } else {
-          await this.setCooldown(cmdName, cmdName === 'daily' ? 86400 : 604800);
+          const fallbackSec = cmdName === 'daily' ? 86400 : 604800;
+          await this.setCooldown(cmdName, fallbackSec);
+          if (redis) try { await redis.set(`dkg:done:${this.account.id}:${cmdName}`, '1', 'EX', fallbackSec); } catch {}
         }
         return;
       }
@@ -893,6 +928,14 @@ class AccountWorker {
       if (earned > 0) this.stats.coins += earned;
       if (cmdResult.nextCooldownSec) await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
 
+      // Mark daily/drops as done in Redis so we don't re-run this session
+      if (redis && earned > 0 && cmdName === 'daily') {
+        try { await redis.set(`dkg:done:${this.account.id}:daily`, '1', 'EX', 86400); } catch {}
+      }
+      if (redis && cmdName === 'drops') {
+        try { await redis.set(`dkg:done:${this.account.id}:drops`, '1', 'EX', 86400); } catch {}
+      }
+
       if (cmdResult.holdTightReason) {
         const reason = cmdResult.holdTightReason;
         this.log('warn', `Hold Tight: /${reason} — 35s cooldown`);
@@ -1104,6 +1147,19 @@ class AccountWorker {
       return;
     }
 
+    // Skip daily/drops if already done today (Redis marker)
+    if (redis && (item.cmd === 'daily' || item.cmd === 'drops')) {
+      try {
+        const done = await redis.get(`dkg:done:${this.account.id}:${item.cmd}`);
+        if (done) {
+          item.nextRunAt = now + 86400 * 1000;
+          if (this.commandQueue) this.commandQueue.push(item);
+          this.tickTimeout = setTimeout(() => this.tick(), 100);
+          return;
+        }
+      } catch {}
+    }
+
     this.busy = true;
     const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
     const jitter = 1 + Math.random() * 3;
@@ -1321,7 +1377,7 @@ async function start(apiKey, apiUrl) {
 
   console.log(colorBanner());
   console.log(
-    `  ${rgb(139, 92, 246)}v4.5${c.reset}` +
+    `  ${rgb(139, 92, 246)}v4.6${c.reset}` +
     `  ${c.dim}·${c.reset}  ${c.white}30 Commands${c.reset}` +
     `  ${c.dim}·${c.reset}  ${rgb(34, 211, 238)}Priority Queue${c.reset}` +
     `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}Redis Cooldowns${c.reset}` +

package/package.json

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