dankgrinder 4.5.1 → 4.8.0

package/lib/commands/adventure.js

@@ -34,11 +34,10 @@
  */
 
 const {
-  LOG, c, sleep, humanDelay, getFullText, parseCoins, parseBalance,
-  getAllButtons, getAllSelectMenus, findButton, findSelectMenuOption,
-  safeClickButton, isHoldTight, logMsg, dumpMessage, needsItem,
+  LOG, c, sleep, humanDelay, getFullText, parseCoins,
+  getAllButtons, getAllSelectMenus, findButton,
+  safeClickButton, isHoldTight, logMsg,
 } = require('./utils');
-const { buyItem } = require('./shop');
 
 // ── Adventure type rotation (cycle through all types each run) ────
 let lastAdventureIndex = -1;
@@ -63,8 +62,7 @@ async function clickAndRefetch(channel, msg, btn) {
     LOG.error(`[adventure] Click error: ${e.message}`);
     return null;
   }
-  // Dank Memer edits the message after a button click
-  await sleep(500);
+  await sleep(250);
   return await refetchMsg(channel, msg.id);
 }
 
@@ -172,7 +170,7 @@ async function playAdventureRounds(channel, msg) {
       const choice = pickSafeChoice(choices);
       if (choice) {
         LOG.info(`[adventure] → Choosing: "${choice.label}"`);
-        await sleep(200);
+        await sleep(100);
         const afterChoice = await clickAndRefetch(channel, current, choice);
         if (afterChoice) {
           current = afterChoice;
@@ -194,7 +192,7 @@ async function playAdventureRounds(channel, msg) {
     const nextBtnNow = getNextButton(current);
     if (nextBtnNow && !nextBtnNow.disabled) {
       LOG.debug(`[adventure] Clicking Next arrow...`);
-      await sleep(200);
+      await sleep(100);
       const afterNext = await clickAndRefetch(channel, current, nextBtnNow);
       if (afterNext) {
         current = afterNext;
@@ -206,7 +204,7 @@ async function playAdventureRounds(channel, msg) {
     } else if (nextBtnNow && nextBtnNow.disabled) {
       // Next is disabled but no choices found — might be loading
       LOG.debug(`[adventure] Next disabled, no choices — waiting...`);
-      await sleep(600);
+      await sleep(300);
       const refreshed = await refetchMsg(channel, current.id);
       if (refreshed) {
         current = refreshed;
@@ -219,8 +217,7 @@ async function playAdventureRounds(channel, msg) {
       // No next button at all
       LOG.debug(`[adventure] No Next button — checking if done`);
       if (isAdventureDone(current)) break;
-      // Wait and re-fetch as Dank Memer might still be editing
-      await sleep(1500);
+      await sleep(500);
       const refreshed = await refetchMsg(channel, current.id);
       if (refreshed) {
         current = refreshed;
@@ -314,42 +311,10 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
     return { result: 'cooldown', coins: 0, nextCooldownSec: cooldownSec + 3 };
   }
 
-  // ── 4) If we need a ticket, try to buy one ─────────────────
+  // ── 4) If we need a ticket, skip (too expensive to auto-buy) ──
   if (needsTicket) {
-    LOG.warn(`[adventure] Need adventure ticket! Attempting to buy...`);
-
-    // Ticket costs 250,000 coins — check balance first to avoid wasting time in shop
-    const TICKET_COST = 250000;
-    let currentBalance = 0;
-    await channel.send('pls bal');
-    const balMsg = await waitForDankMemer(8000);
-    if (balMsg) {
-      currentBalance = parseBalance(balMsg);
-      LOG.info(`[adventure] Balance: ${c.yellow}⏣ ${currentBalance.toLocaleString()}${c.reset} (ticket costs ⏣ ${TICKET_COST.toLocaleString()})`);
-    }
-
-    if (currentBalance < TICKET_COST) {
-      LOG.warn(`[adventure] Not enough coins for ticket (⏣ ${currentBalance.toLocaleString()} < ⏣ ${TICKET_COST.toLocaleString()}). Grind more first.`);
-      return { result: `need ticket (⏣ ${currentBalance.toLocaleString()}/${TICKET_COST.toLocaleString()})`, coins: 0, nextCooldownSec: 120 };
-    }
-
-    const bought = await buyItem({
-      channel, waitForDankMemer, client,
-      itemName: 'Adventure Ticket', quantity: 1,
-    });
-
-    if (!bought) {
-      LOG.error('[adventure] Could not buy adventure ticket from shop.');
-      return { result: 'need ticket (buy failed)', coins: 0, nextCooldownSec: 120 };
-    }
-
-    LOG.success('[adventure] Tickets purchased! Re-running adventure...');
-    await sleep(1500);
-
-    await channel.send('pls adventure');
-    response = await waitForDankMemer(12000);
-    if (!response) return { result: 'no response after ticket buy', coins: 0, nextCooldownSec: null };
-    logMsg(response, 'adventure-after-buy');
+    LOG.warn(`[adventure] No ticket — skipping (too expensive to auto-buy)`);
+    return { result: 'no ticket', coins: 0, nextCooldownSec: 3600, skipReason: 'no_ticket' };
   }
 
   // ── Check if we're already mid-adventure (no select menu) ──

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/dig.js

@@ -45,7 +45,7 @@ async function runDig({ channel, waitForDankMemer, client }) {
     const bought = await buyItem({
       channel, waitForDankMemer, client,
       itemName: 'Shovel',
-      quantity: 3,
+      quantity: 1,
     });
 
     if (bought) {

package/lib/commands/gamble.js

@@ -1,23 +1,36 @@
 /**
- * Simple gambling command handlers.
- * Covers: coinflip, roulette, slots, snakeeyes
+ * Gambling command handlers.
+ * Covers: cointoss, roulette, slots, snakeeyes
  */
 
 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}>}
- */
+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) };
+  }
+  const coins = parseCoins(text);
+  if (coins > 0) {
+    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+  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 };
+}
+
 async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
   LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
 
@@ -36,52 +49,48 @@ async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Check for min bet error
+  const initText = getFullText(response);
+  const initLower = initText.toLowerCase();
+  if (initLower.includes("can't bet less than") || initLower.includes('cannot bet less than') || initLower.includes('minimum bet')) {
+    const betMatch = initText.match(/less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i) || initText.match(/(\d[\d,]+)/);
+    if (betMatch) {
+      const minBet = parseInt(betMatch[1].replace(/,/g, ''));
+      if (minBet > 0) return { result: `min bet ${minBet}`, coins: 0, newMinBet: minBet };
+    }
+    return { result: 'min bet error', coins: 0 };
+  }
+
   logMsg(response, cmdName);
   const text = getFullText(response);
-  const coins = parseCoins(text);
 
-  // Some gambles have buttons (e.g. pick heads/tails)
+  // For cointoss/gambles with buttons: click a random non-disabled button
   const buttons = getAllButtons(response);
   if (buttons.length > 0) {
-    const btn = buttons.find(b => !b.disabled);
-    if (btn) {
-      LOG.info(`[${cmdName}] Clicking "${btn.label}"`);
-      await humanDelay();
+    const clickable = buttons.filter(b => !b.disabled);
+    if (clickable.length > 0) {
+      const btn = clickable[Math.floor(Math.random() * clickable.length)];
+      LOG.info(`[${cmdName}] Clicking "${btn.label || '?'}"`);
+      await humanDelay(50, 200);
       try {
         const followUp = await safeClickButton(response, btn);
         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}`); }
     }
   }
 
-  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 };
-  }
-
-  return { result: `${cmdName} done`, coins: 0 };
+  return parseGambleResult(text, cmdName);
 }
 
-// Convenience wrappers
-async function runCoinflip({ channel, waitForDankMemer, betAmount = 5000 }) {
-  return runGamble({ channel, waitForDankMemer, cmdName: 'coinflip', cmdString: `pls coinflip ${betAmount} heads` });
+/**
+ * Cointoss: send "pls cointoss <bet>", then click Heads or Tails randomly.
+ */
+async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
+  return runGamble({ channel, waitForDankMemer, cmdName: 'cointoss', cmdString: `pls cointoss ${betAmount}` });
 }
 
 async function runRoulette({ channel, waitForDankMemer, betAmount = 5000 }) {
@@ -96,4 +105,4 @@ async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 5000 }) {
   return runGamble({ channel, waitForDankMemer, cmdName: 'snakeeyes', cmdString: `pls snakeeyes ${betAmount}` });
 }
 
-module.exports = { runGamble, runCoinflip, runRoulette, runSlots, runSnakeeyes };
+module.exports = { runGamble, runCointoss, runRoulette, runSlots, runSnakeeyes };

package/lib/commands/generic.js

@@ -45,7 +45,7 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
   const missing = needsItem(text);
   if (missing) {
     LOG.warn(`[${cmdName}] Missing ${c.bold}${missing}${c.reset} — auto-buying...`);
-    const bought = await buyItem({ channel, waitForDankMemer, client, itemName: missing, quantity: 3 });
+    const bought = await buyItem({ channel, waitForDankMemer, client, itemName: missing, quantity: 1 });
     if (bought) {
       LOG.success(`[${cmdName}] Bought ${missing}, retrying command...`);
       await sleep(3000);
@@ -65,11 +65,12 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
     return { result: `need ${missing} (buy failed)`, coins: 0 };
   }
 
-  // Handle buttons if present
+  // Handle buttons if present — pick a random non-disabled button
   const buttons = getAllButtons(response);
   if (buttons.length > 0) {
-    const btn = buttons.find(b => !b.disabled) || buttons[0];
-    if (btn && !btn.disabled) {
+    const clickable = buttons.filter(b => !b.disabled);
+    const btn = clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+    if (btn) {
       LOG.info(`[${cmdName}] Clicking "${btn.label || '?'}"`);
       await humanDelay();
       try {

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/hunt.js

@@ -45,7 +45,7 @@ async function runHunt({ channel, waitForDankMemer, client }) {
       const bought = await buyItem({
         channel, waitForDankMemer, client,
         itemName: 'Hunting Rifle',
-        quantity: 3,
+        quantity: 1,
       });
 
       if (bought) {

package/lib/commands/index.js

@@ -16,7 +16,7 @@ const { runScratch } = require('./scratch');
 const { runBlackjack } = require('./blackjack');
 const { runTrivia, triviaDB } = require('./trivia');
 const { runWorkShift } = require('./work');
-const { runCoinflip, runRoulette, runSlots, runSnakeeyes, runGamble } = require('./gamble');
+const { runCointoss, runRoulette, runSlots, runSnakeeyes, runGamble } = require('./gamble');
 const { runDeposit } = require('./deposit');
 const { runGeneric, runAlert } = require('./generic');
 const { runStream } = require('./stream');
@@ -39,7 +39,7 @@ module.exports = {
   runBlackjack,
   runTrivia,
   runWorkShift,
-  runCoinflip,
+  runCointoss,
   runRoulette,
   runSlots,
   runSnakeeyes,

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/shop.js

@@ -32,8 +32,12 @@ const ITEM_COSTS = {
  * @returns {Promise<boolean>} true if purchase succeeded
  */
 async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, client }) {
-  const MAX_RETRIES = 3;
-  const searchName = itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '').replace('adventure ', '');
+  const MAX_RETRIES = 1;
+  const searchNames = [
+    itemName.toLowerCase(),
+    itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '').replace('adventure ', ''),
+    itemName.toLowerCase().split(' ').pop(),
+  ];
 
   for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
     LOG.buy(`Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset} (attempt ${attempt}/${MAX_RETRIES})`);
@@ -120,30 +124,17 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
     logMsg(response, 'shop-after-nav');
 
     // Step 3: Find the Buy button for our item
-    let buyBtn = getAllButtons(response).find(b => b.label && b.label.toLowerCase().includes(searchName));
+    let buyBtn = getAllButtons(response).find(b => {
+      if (!b.label) return false;
+      const label = b.label.toLowerCase();
+      return searchNames.some(s => label.includes(s) || s.includes(label));
+    });
 
     if (!buyBtn) {
-      LOG.warn(`No Buy button found for "${itemName}" (searched: "${searchName}")`);
-      // Log all available buttons for debugging
+      LOG.warn(`No Buy button found for "${itemName}"`);
       const allBtns = getAllButtons(response);
       if (allBtns.length > 0) {
-        LOG.debug(`Available buttons: ${allBtns.map(b => `"${b.label}"`).join(', ')}`);
-      }
-      // Maybe we need to scroll/paginate?
-      const nextBtn = findButton(response, 'next') || findButton(response, '▶') || findButton(response, '→');
-      if (nextBtn && !nextBtn.disabled) {
-        LOG.buy('Clicking next page to find item...');
-        try {
-          const nextPage = await safeClickButton(response, nextBtn);
-          if (nextPage) {
-            response = nextPage;
-            logMsg(response, 'shop-page2');
-            // Try finding button again
-            buyBtn = getAllButtons(response).find(b => b.label && b.label.toLowerCase().includes(searchName));
-          }
-        } catch (e) {
-          LOG.error(`Page nav failed: ${e.message}`);
-        }
+        LOG.debug(`Available: ${allBtns.map(b => `"${b.label}"`).join(', ')}`);
       }
 
       if (!buyBtn) {

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

@@ -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;
 }
@@ -486,6 +509,7 @@ class AccountWorker {
     this.globalCooldownUntil = 0;
     this.commandQueue = null;
     this.lastHealthCheck = Date.now();
+    this.doneToday = new Map(); // in-memory dedup: cmd → expiry timestamp
   }
 
   get tag() { return `${this.color}${c.bold}${this.username}${c.reset}`; }
@@ -593,8 +617,8 @@ class AccountWorker {
     return null;
   }
 
-  async buyItem(itemName, quantity = 10) {
-    const MAX_RETRIES = 3;
+  async buyItem(itemName, quantity = 1) {
+    const MAX_RETRIES = 1;
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
       this.log('buy', `Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset}... (attempt ${attempt}/${MAX_RETRIES})`);
       if (this.account.use_slash) {
@@ -648,12 +672,18 @@ class AccountWorker {
       }
       await humanDelay(1000, 2000);
 
-      // Find Buy button
+      // Find Buy button — match by full name or partial name
       let buyBtn = null;
-      const searchName = itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '');
+      const searchNames = [
+        itemName.toLowerCase(),
+        itemName.toLowerCase().replace('hunting ', '').replace('fishing ', ''),
+        itemName.toLowerCase().split(' ')[0],
+      ];
       for (const row of response.components || []) {
         for (const comp of row.components || []) {
-          if (comp.type === 2 && comp.label && comp.label.toLowerCase().includes(searchName)) {
+          if (comp.type !== 2 || !comp.label) continue;
+          const label = comp.label.toLowerCase();
+          if (searchNames.some(s => label.includes(s) || s.includes(label))) {
             buyBtn = comp; break;
           }
         }
@@ -765,7 +795,7 @@ class AccountWorker {
       case 'dep max':     cmdString = `${prefix} dep max`; break;
       case 'with max':    cmdString = `${prefix} with max`; break;
       case 'blackjack':   cmdString = `${prefix} bj ${betAmount}`; break;
-      case 'coinflip':    cmdString = `${prefix} coinflip ${betAmount} heads`; break;
+      case 'cointoss':    cmdString = `${prefix} cointoss ${betAmount}`; break;
       case 'roulette':    cmdString = `${prefix} roulette ${betAmount} red`; break;
       case 'slots':       cmdString = `${prefix} slots ${betAmount}`; break;
       case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${betAmount}`; break;
@@ -803,7 +833,7 @@ class AccountWorker {
         case 'blackjack':   cmdResult = await commands.runBlackjack(cmdOpts); break;
         case 'trivia':      cmdResult = await commands.runTrivia(cmdOpts); break;
         case 'work shift':  cmdResult = await commands.runWorkShift(cmdOpts); break;
-        case 'coinflip':    cmdResult = await commands.runCoinflip(cmdOpts); break;
+        case 'cointoss':    cmdResult = await commands.runCointoss(cmdOpts); break;
         case 'roulette':    cmdResult = await commands.runRoulette(cmdOpts); break;
         case 'slots':       cmdResult = await commands.runSlots(cmdOpts); break;
         case 'snakeeyes':   cmdResult = await commands.runSnakeeyes(cmdOpts); break;
@@ -825,6 +855,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') ||
@@ -846,18 +885,24 @@ class AccountWorker {
         return;
       }
 
-      // Min bet detection — raise bet amount
-      if (resultLower.includes('cannot bet less than') || resultLower.includes('minimum bet')) {
-        const betMatch = result.match(/⏣\s*([\d,]+)/);
+      // Min bet detection — "You can't bet less than 10,000" or "cannot bet less than ⏣ 5,000"
+      if (resultLower.includes("can't bet less than") || resultLower.includes('cannot bet less than') || resultLower.includes('minimum bet')) {
+        const betMatch = result.match(/less than\s*\*?\*?\s*[⏣o]?\s*([\d,]+)/i) || result.match(/(\d[\d,]+)/);
         if (betMatch) {
           const minBet = parseInt(betMatch[1].replace(/,/g, ''));
           if (minBet > 0) {
             this.account.bet_amount = minBet;
-            this.log('info', `${cmdName} min bet: ⏣ ${minBet.toLocaleString()}`);
+            this.log('info', `${cmdName} min bet raised → ⏣ ${minBet.toLocaleString()}`);
           }
         }
         return;
       }
+      // Also handle newMinBet from gamble handler
+      if (cmdResult.newMinBet && cmdResult.newMinBet > (this.account.bet_amount || 0)) {
+        this.account.bet_amount = cmdResult.newMinBet;
+        this.log('info', `${cmdName} min bet raised → ⏣ ${cmdResult.newMinBet.toLocaleString()}`);
+        return;
+      }
 
       // Premium-only command detection — disable for 24h
       if (resultLower.includes('only available on premium') || resultLower.includes('premium') ||
@@ -867,32 +912,52 @@ class AccountWorker {
         return;
       }
 
-      // Already claimed today (daily/weekly) — set long cooldown
+      // Already claimed today (daily/weekly) — set long cooldown + mark done
       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>/);
+        let waitSec;
         if (timeMatch) {
           const nextAvail = parseInt(timeMatch[1]) * 1000;
-          const waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
-          await this.setCooldown(cmdName, waitSec);
+          waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
         } else {
-          await this.setCooldown(cmdName, cmdName === 'daily' ? 86400 : 604800);
+          waitSec = cmdName === 'daily' ? 86400 : 604800;
         }
+        await this.setCooldown(cmdName, waitSec);
+        this.doneToday.set(cmdName, Date.now() + waitSec * 1000);
+        if (redis) try { await redis.set(`dkg:done:${this.account.id}:${cmdName}`, '1', 'EX', waitSec); } catch {}
         return;
       }
 
-      // Scratch level-gate: if level too low, disable for 24h
+      // Skip reasons: level too low, no ticket, etc.
       if (cmdResult.skipReason === 'level') {
         this.log('warn', `${cmdName} level too low — retry in 24h`);
         await this.setCooldown(cmdName, 86400);
         return;
       }
+      if (cmdResult.skipReason === 'no_ticket') {
+        this.log('warn', `${cmdName} no ticket — retry in 1h`);
+        await this.setCooldown(cmdName, 3600);
+        return;
+      }
 
       const earned = Math.max(0, cmdResult.coins || 0);
       const spent = Math.max(0, cmdResult.lost || 0);
       if (earned > 0) this.stats.coins += earned;
       if (cmdResult.nextCooldownSec) await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
 
+      // Mark daily/drops as done so we don't re-run this session
+      if (cmdName === 'daily' && earned > 0) {
+        const expiry = Date.now() + 86400 * 1000;
+        this.doneToday.set('daily', expiry);
+        if (redis) try { await redis.set(`dkg:done:${this.account.id}:daily`, '1', 'EX', 86400); } catch {}
+      }
+      if (cmdName === 'drops') {
+        const expiry = Date.now() + 86400 * 1000;
+        this.doneToday.set('drops', expiry);
+        if (redis) 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`);
@@ -948,7 +1013,7 @@ class AccountWorker {
     { key: 'cmd_trivia', cmd: 'trivia', cdKey: 'cd_trivia', defaultCd: 10, priority: 2 },
     // Gambling (fast cycle)
     { key: 'cmd_blackjack', cmd: 'blackjack', cdKey: 'cd_blackjack', defaultCd: 3, priority: 3 },
-    { key: 'cmd_cointoss', cmd: 'coinflip', cdKey: 'cd_cointoss', defaultCd: 2, priority: 3 },
+    { key: 'cmd_cointoss', cmd: 'cointoss', cdKey: 'cd_cointoss', defaultCd: 2, priority: 3 },
     { key: 'cmd_roulette', cmd: 'roulette', cdKey: 'cd_roulette', defaultCd: 3, priority: 3 },
     { key: 'cmd_slots', cmd: 'slots', cdKey: 'cd_slots', defaultCd: 3, priority: 3 },
     { key: 'cmd_snakeeyes', cmd: 'snakeeyes', cdKey: 'cd_snakeeyes', defaultCd: 3, priority: 3 },
@@ -1104,6 +1169,30 @@ class AccountWorker {
       return;
     }
 
+    // Skip daily/drops if already done today (in-memory + Redis)
+    if (item.cmd === 'daily' || item.cmd === 'drops') {
+      const memExpiry = this.doneToday.get(item.cmd);
+      if (memExpiry && Date.now() < memExpiry) {
+        item.nextRunAt = memExpiry;
+        if (this.commandQueue) this.commandQueue.push(item);
+        this.tickTimeout = setTimeout(() => this.tick(), 100);
+        return;
+      }
+      if (redis) {
+        try {
+          const done = await redis.get(`dkg:done:${this.account.id}:${item.cmd}`);
+          if (done) {
+            const expiry = now + 86400 * 1000;
+            this.doneToday.set(item.cmd, expiry);
+            item.nextRunAt = expiry;
+            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;
@@ -1111,10 +1200,11 @@ class AccountWorker {
 
     await this.setCooldown(item.cmd, totalWait);
 
+    // Inter-command delay: 1-3s random (human-like spacing)
     const timeSinceLastCmd = now - (this.lastCommandRun || 0);
-    const globalJitter = 500 + Math.random() * 1000;
-    if (timeSinceLastCmd < globalJitter) {
-      await new Promise(r => setTimeout(r, globalJitter - timeSinceLastCmd));
+    const minGap = 1000 + Math.random() * 2000; // 1-3s
+    if (timeSinceLastCmd < minGap) {
+      await new Promise(r => setTimeout(r, minGap - timeSinceLastCmd));
     }
 
     const prefix = this.account.use_slash ? '/' : 'pls';
@@ -1270,7 +1360,7 @@ class AccountWorker {
           { key: 'cmd_stream', l: 'stream' }, { key: 'cmd_scratch', l: 'scratch' },
           { key: 'cmd_adventure', l: 'adv' }, { key: 'cmd_farm', l: 'farm' },
           { key: 'cmd_tidy', l: 'tidy' }, { key: 'cmd_blackjack', l: 'bj' },
-          { key: 'cmd_cointoss', l: 'flip' }, { key: 'cmd_roulette', l: 'roul' },
+          { key: 'cmd_cointoss', l: 'toss' }, { key: 'cmd_roulette', l: 'roul' },
           { key: 'cmd_slots', l: 'slots' }, { key: 'cmd_snakeeyes', l: 'snake' },
           { key: 'cmd_trivia', l: 'trivia' }, { key: 'cmd_use', l: 'use' },
           { key: 'cmd_deposit', l: 'dep' },           { key: 'cmd_drops', l: 'drops' },
@@ -1321,7 +1411,7 @@ async function start(apiKey, apiUrl) {
 
   console.log(colorBanner());
   console.log(
-    `  ${rgb(139, 92, 246)}v4.5${c.reset}` +
+    `  ${rgb(139, 92, 246)}v4.8${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.1",
+  "version": "4.8.0",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"