dankgrinder 4.1.2 → 4.3.1

package/bin/dankgrinder.js

@@ -19,10 +19,11 @@ if (args.includes('--help') || args.includes('-h')) {
     npx dankgrinder --key <API_KEY>
 
   ${C.b}Options:${C.r}
-    --key <key>     API key from dashboard (required)
-    --url <url>     Override dashboard URL (default: ${DEFAULT_URL})
-    --help, -h      Show this help
-    --version, -v   Show version
+    --key <key>       API key from dashboard (required)
+    --url <url>       Override dashboard URL (default: ${DEFAULT_URL})
+    --redis <url>     Redis URL for cooldowns & trivia DB
+    --help, -h        Show this help
+    --version, -v     Show version
 `);
   process.exit(0);
 }
@@ -34,13 +35,16 @@ if (args.includes('--version') || args.includes('-v')) {
 
 let apiKey = process.env.DANKGRINDER_KEY || '';
 let apiUrl = '';
+let redisUrl = '';
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--key' && args[i + 1]) apiKey = args[i + 1];
   if (args[i] === '--url' && args[i + 1]) apiUrl = args[i + 1];
+  if (args[i] === '--redis' && args[i + 1]) redisUrl = args[i + 1];
 }
 
 apiUrl = apiUrl || process.env.DANKGRINDER_URL || DEFAULT_URL;
+if (redisUrl) process.env.REDIS_URL = redisUrl;
 
 if (!apiKey) {
   console.error(`\n  ${C.red}✗ Missing API key.${C.r}\n`);

package/lib/commands/adventure.js

@@ -365,9 +365,12 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
 
   // ── Select adventure type from dropdown ─────────────────────
   if (menus.length > 0) {
-    // Re-fetch message to get hydrated components (minValues/maxValues)
-    const freshMsg = await channel.messages.fetch(response.id).catch(() => null);
-    if (freshMsg) response = freshMsg;
+    try {
+      if (channel.messages && typeof channel.messages.fetch === 'function') {
+        const freshMsg = await channel.messages.fetch(response.id);
+        if (freshMsg) response = freshMsg;
+      }
+    } catch { /* proceed with original */ }
 
     // Find the select menu row index
     let menuRowIdx = -1;

package/lib/commands/crime.js

@@ -12,21 +12,38 @@ const SAFE_CRIME_OPTIONS = [
   'tax evasion', 'fraud', 'cybercrime', 'hacking', 'identity theft',
   'money laundering', 'tax fraud', 'insurance fraud', 'scam',
 ];
+const SAFE_CRIME_SET = new Set(SAFE_CRIME_OPTIONS);
+
+const RISKY_CRIME_OPTIONS = new Set([
+  'murder', 'arson', 'assault', 'kidnap', 'terrorism',
+]);
 
 function pickSafeButton(buttons, customSafe) {
   if (!buttons || buttons.length === 0) return null;
+  const clickable = buttons.filter(b => !b.disabled);
+  if (clickable.length === 0) return null;
+
   if (customSafe && customSafe.length > 0) {
-    for (const btn of buttons) {
+    const customSet = new Set(customSafe.map(s => s.toLowerCase()));
+    for (const btn of clickable) {
       const label = (btn.label || '').toLowerCase();
-      if (customSafe.some(s => label.includes(s.toLowerCase()))) return btn;
+      for (const s of customSet) { if (label.includes(s)) return btn; }
     }
   }
-  for (const btn of buttons) {
+
+  for (const btn of clickable) {
     const label = (btn.label || '').toLowerCase();
-    if (SAFE_CRIME_OPTIONS.some(s => label.includes(s))) return btn;
+    for (const s of SAFE_CRIME_SET) { if (label.includes(s)) return btn; }
   }
-  const clickable = buttons.filter(b => !b.disabled);
-  return clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+
+  const safe = clickable.filter(b => {
+    const label = (b.label || '').toLowerCase();
+    for (const r of RISKY_CRIME_OPTIONS) { if (label.includes(r)) return false; }
+    return true;
+  });
+
+  const pool = safe.length > 0 ? safe : clickable;
+  return pool[Math.floor(Math.random() * pool.length)];
 }
 
 /**

package/lib/commands/generic.js

@@ -99,9 +99,12 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
   // Handle select menus
   const menus = getAllSelectMenus(response);
   if (menus.length > 0) {
-    // Re-fetch for hydrated components (minValues/maxValues)
-    const freshMsg = await channel.messages.fetch(response.id).catch(() => null);
-    if (freshMsg) response = freshMsg;
+    try {
+      if (channel.messages && typeof channel.messages.fetch === 'function') {
+        const freshMsg = await channel.messages.fetch(response.id);
+        if (freshMsg) response = freshMsg;
+      }
+    } catch { /* proceed with original */ }
     // Find row index of first select menu
     let menuRowIdx = -1;
     for (let i = 0; i < (response.components || []).length; i++) {

package/lib/commands/index.js

@@ -19,6 +19,7 @@ const { runWorkShift } = require('./work');
 const { runCoinflip, runRoulette, runSlots, runSnakeeyes, runGamble } = require('./gamble');
 const { runDeposit } = require('./deposit');
 const { runGeneric, runAlert } = require('./generic');
+const { runStream } = require('./stream');
 const { buyItem, ITEM_COSTS } = require('./shop');
 const { getPlayerLevel, meetsLevelRequirement } = require('./profile');
 
@@ -45,6 +46,7 @@ module.exports = {
   runDeposit,
   runGeneric,
   runAlert,
+  runStream,
   buyItem,
 
   // Profile / Level

package/lib/commands/search.js

@@ -14,24 +14,39 @@ const SAFE_SEARCH_LOCATIONS = [
   'closet', 'shoe', 'vacuum', 'toilet', 'sink', 'shower',
   'tree', 'grass', 'bushes', 'garden', 'park', 'backyard',
 ];
+const SAFE_SET = new Set(SAFE_SEARCH_LOCATIONS);
+
+const DANGEROUS_LOCATIONS = new Set([
+  'police', 'area 51', 'jail', 'hospital', 'sewer',
+  'gun', 'warehouse', 'casino', 'bank', 'airport',
+]);
 
 function pickSafeButton(buttons, customSafe) {
   if (!buttons || buttons.length === 0) return null;
-  // Try custom safe list first
+  const clickable = buttons.filter(b => !b.disabled);
+  if (clickable.length === 0) return null;
+
   if (customSafe && customSafe.length > 0) {
-    for (const btn of buttons) {
+    const customSet = new Set(customSafe.map(s => s.toLowerCase()));
+    for (const btn of clickable) {
       const label = (btn.label || '').toLowerCase();
-      if (customSafe.some(s => label.includes(s.toLowerCase()))) return btn;
+      for (const s of customSet) { if (label.includes(s)) return btn; }
     }
   }
-  // Try built-in safe list
-  for (const btn of buttons) {
+
+  for (const btn of clickable) {
     const label = (btn.label || '').toLowerCase();
-    if (SAFE_SEARCH_LOCATIONS.some(s => label.includes(s))) return btn;
+    for (const s of SAFE_SET) { if (label.includes(s)) return btn; }
   }
-  // Fallback: random non-disabled
-  const clickable = buttons.filter(b => !b.disabled);
-  return clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+
+  const safe = clickable.filter(b => {
+    const label = (b.label || '').toLowerCase();
+    for (const d of DANGEROUS_LOCATIONS) { if (label.includes(d)) return false; }
+    return true;
+  });
+
+  const pool = safe.length > 0 ? safe : clickable;
+  return pool[Math.floor(Math.random() * pool.length)];
 }
 
 /**

package/lib/commands/shop.js

@@ -16,6 +16,8 @@ const ITEM_COSTS = {
   'shovel': 25000,
   'fishing pole': 25000,
   'adventure ticket': 250000,
+  'keyboard': 10000,
+  'mouse': 10000,
 };
 
 /**
@@ -77,9 +79,13 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
     }
 
     // Step 2: Navigate to Coin Shop tab
-    // Re-fetch message to get hydrated components (minValues/maxValues for selectMenu)
-    const freshShopMsg = await channel.messages.fetch(response.id).catch(() => null);
-    if (freshShopMsg) response = freshShopMsg;
+    // Try re-fetch for hydrated components; skip if unavailable
+    try {
+      if (channel.messages && typeof channel.messages.fetch === 'function') {
+        const freshShopMsg = await channel.messages.fetch(response.id);
+        if (freshShopMsg) response = freshShopMsg;
+      }
+    } catch { /* proceed with original response */ }
 
     const csInfo = findSelectMenuOption(response, 'Coin Shop');
     if (csInfo) {

package/lib/commands/stream.js

@@ -0,0 +1,96 @@
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons,
+  safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, needsItem,
+} = require('./utils');
+const { buyItem } = require('./shop');
+
+const STREAM_ITEMS = ['keyboard', 'mouse'];
+
+async function runStream({ channel, waitForDankMemer, client }) {
+  LOG.cmd(`${c.white}${c.bold}pls stream${c.reset}`);
+
+  await channel.send('pls stream');
+  let response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[stream] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[stream] Hold Tight${reason ? ` (reason: /${reason})` : ''}`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'stream');
+  let text = getFullText(response);
+
+  const lower = text.toLowerCase();
+  if (lower.includes('missing items') || lower.includes('need following items') || lower.includes('need a keyboard') || lower.includes('need a mouse')) {
+    const itemsToBuy = [];
+    if (lower.includes('keyboard')) itemsToBuy.push('keyboard');
+    if (lower.includes('mouse')) itemsToBuy.push('mouse');
+
+    if (itemsToBuy.length === 0) itemsToBuy.push(...STREAM_ITEMS);
+
+    LOG.warn(`[stream] Missing items: ${c.bold}${itemsToBuy.join(', ')}${c.reset} — auto-buying...`);
+
+    for (const item of itemsToBuy) {
+      const bought = await buyItem({ channel, waitForDankMemer, client, itemName: item, quantity: 1 });
+      if (bought) {
+        LOG.success(`[stream] Bought ${c.bold}${item}${c.reset}`);
+      } else {
+        LOG.error(`[stream] Failed to buy ${item}`);
+        return { result: `need ${item} (buy failed)`, coins: 0 };
+      }
+      await humanDelay(1500, 2500);
+    }
+
+    LOG.info('[stream] Retrying stream after buying items...');
+    await sleep(3000);
+    await channel.send('pls stream');
+    response = await waitForDankMemer(10000);
+    if (!response) return { result: 'no response after buy', coins: 0 };
+    logMsg(response, 'stream-retry');
+    text = getFullText(response);
+  }
+
+  const coins = parseCoins(text);
+
+  const buttons = getAllButtons(response);
+  if (buttons.length > 0) {
+    const actionBtn = buttons.find(b => !b.disabled && b.label &&
+      !b.label.toLowerCase().includes('end') && !b.label.toLowerCase().includes('stop'));
+    const btn = actionBtn || buttons.find(b => !b.disabled);
+    if (btn) {
+      LOG.info(`[stream] Clicking "${btn.label || '?'}"`);
+      await humanDelay();
+      try {
+        await safeClickButton(response, btn);
+        const followUp = await waitForDankMemer(8000);
+        if (followUp) {
+          logMsg(followUp, 'stream-action');
+          const fText = getFullText(followUp);
+          const fCoins = parseCoins(fText);
+          if (fCoins > 0) {
+            LOG.coin(`[stream] ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
+            return { result: `+⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
+          }
+        }
+      } catch (e) {
+        LOG.error(`[stream] Click error: ${e.message}`);
+      }
+    }
+  }
+
+  if (coins > 0) {
+    LOG.coin(`[stream] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `+⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  return { result: text.substring(0, 60) || 'streamed', coins: 0, nextCooldownSec: 600 };
+}
+
+module.exports = { runStream };

package/lib/commands/utils.js

@@ -13,7 +13,13 @@ const c = {
 };
 
 // ── Logging ──────────────────────────────────────────────────
+// When dashboard is active, suppress direct console output from command handlers.
+// grinder.js sets this to true once the live dashboard starts rendering.
+let _dashboardActive = false;
+function setDashboardActive(val) { _dashboardActive = val; }
+
 function log(label, msg) {
+  if (_dashboardActive) return;
   const time = new Date().toLocaleTimeString('en-US', { hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit' });
   console.log(`  ${c.dim}${time}${c.reset}  ${label}  ${msg}`);
 }
@@ -250,18 +256,26 @@ function dumpMessage(msg, label) {
 }
 
 // ── Item Detection ───────────────────────────────────────────
+const ITEM_PATTERNS = [
+  { item: 'shovel',         patterns: ["don't have a shovel", 'need a shovel', 'you need a shovel'] },
+  { item: 'fishing pole',   patterns: ["don't have a fishing", 'need a fishing', 'you need a fishing pole'] },
+  { item: 'hunting rifle',  patterns: ["don't have a hunting rifle", 'need a hunting rifle', 'you need a rifle'] },
+  { item: 'adventure ticket', patterns: ["don't have a ticket", "don't have an adventure", 'need a ticket', 'need an adventure ticket'] },
+  { item: 'keyboard',       patterns: ["don't have a keyboard", 'need a keyboard', 'you need a keyboard', 'need following items'] },
+  { item: 'mouse',          patterns: ["don't have a mouse", 'need a mouse', 'you need a mouse'] },
+];
+
 function needsItem(text) {
   const lower = text.toLowerCase();
-  if (lower.includes("don't have a shovel") || (lower.includes('need') && lower.includes('shovel')) || lower.includes('you need a shovel'))
-    return 'shovel';
-  if (lower.includes("don't have a fishing") || lower.includes('need a fishing') || lower.includes('you need a fishing pole'))
-    return 'fishing pole';
-  if (lower.includes("don't have a hunting rifle") || lower.includes('need a hunting rifle') || lower.includes('you need a rifle'))
-    return 'hunting rifle';
-  if (lower.includes("don't have") && lower.includes('ticket'))
-    return 'adventure ticket';
-  if (lower.includes('need') && lower.includes('ticket'))
-    return 'adventure ticket';
+  for (const { item, patterns } of ITEM_PATTERNS) {
+    for (const p of patterns) {
+      if (lower.includes(p)) return item;
+    }
+  }
+  if (lower.includes('need following items') || lower.includes('missing items')) {
+    if (lower.includes('keyboard')) return 'keyboard';
+    if (lower.includes('mouse')) return 'mouse';
+  }
   return null;
 }
 
@@ -269,6 +283,7 @@ module.exports = {
   DANK_MEMER_ID,
   c,
   LOG,
+  setDashboardActive,
   sleep,
   humanDelay,
   getFullText,

package/lib/grinder.js

@@ -1,6 +1,7 @@
 const { Client } = require('discord.js-selfbot-v13');
 const Redis = require('ioredis');
 const commands = require('./commands');
+const { setDashboardActive } = require('./commands/utils');
 
 // ── Terminal Colors & ANSI ───────────────────────────────────
 const c = {
@@ -108,6 +109,8 @@ function colorBanner() {
 let dashboardLines = 0;
 let dashboardStarted = false;
 let dashboardRendering = false;
+let lastRenderTime = 0;
+let renderPending = false;
 let totalBalance = 0;
 let totalCoins = 0;
 let totalCommands = 0;
@@ -115,6 +118,7 @@ let startTime = Date.now();
 let shutdownCalled = false;
 const recentLogs = [];
 const MAX_LOGS = 4;
+const RENDER_THROTTLE_MS = 250;
 
 function formatUptime() {
   const s = Math.floor((Date.now() - startTime) / 1000);
@@ -132,9 +136,22 @@ function formatCoins(n) {
   return n.toLocaleString();
 }
 
+function scheduleRender() {
+  if (renderPending || !dashboardStarted) return;
+  const now = Date.now();
+  const elapsed = now - lastRenderTime;
+  if (elapsed >= RENDER_THROTTLE_MS) {
+    renderDashboard();
+  } else {
+    renderPending = true;
+    setTimeout(() => { renderPending = false; renderDashboard(); }, RENDER_THROTTLE_MS - elapsed);
+  }
+}
+
 function renderDashboard() {
-  if (!dashboardStarted || workers.length === 0 || dashboardRendering) return;
+  if (!dashboardStarted || workers.length === 0 || dashboardRendering || shutdownCalled) return;
   dashboardRendering = true;
+  lastRenderTime = Date.now();
 
   totalBalance = 0; totalCoins = 0; totalCommands = 0;
   for (const w of workers) {
@@ -144,7 +161,7 @@ function renderDashboard() {
   }
 
   const lines = [];
-  const tw = Math.min(process.stdout.columns || 80, 78);
+  const tw = Math.min(process.stdout.columns || 80, 76);
   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;
@@ -152,30 +169,37 @@ function renderDashboard() {
   lines.push(thickTop);
   lines.push(
     `  ${rgb(192, 132, 252)}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}` +
-    `  ${c.dim}│${c.reset}` +
-    `  ${rgb(52, 211, 153)}${c.bold}+${formatCoins(totalCoins)}${c.reset} ${c.dim}earned${c.reset}` +
-    `  ${c.dim}│${c.reset}` +
-    `  ${c.white}${c.bold}${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)}●${c.reset} ${c.dim}LIVE${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}`
   );
   lines.push(thinBar);
 
+  const nameWidth = Math.min(14, tw > 60 ? 14 : 10);
+  const statusWidth = Math.max(12, tw - nameWidth - 30);
+
   for (const wk of workers) {
-    const last = (wk.lastStatus || 'idle').substring(0, 32);
+    const rawStatus = (wk.lastStatus || 'idle').replace(/\x1b\[[0-9;]*m/g, '');
+    const last = rawStatus.substring(0, statusWidth);
     const dot = wk.running
-      ? (wk.paused ? `${rgb(251, 191, 36)}⏸${c.reset}` : wk.busy ? `${rgb(251, 191, 36)}◉${c.reset}` : `${rgb(52, 211, 153)}●${c.reset}`)
+      ? (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, 16).padEnd(16)}${c.reset}`;
+    const name = `${wk.color}${c.bold}${(wk.username || '?').substring(0, nameWidth).padEnd(nameWidth)}${c.reset}`;
     const bal = wk.stats.balance > 0
-      ? `${rgb(251, 191, 36)}⏣${c.reset}${c.white}${c.bold}${formatCoins(wk.stats.balance).padStart(7)}${c.reset}`
-      : `${c.dim}⏣      -${c.reset}`;
+      ? `${rgb(251, 191, 36)}⏣${c.reset}${c.white}${formatCoins(wk.stats.balance).padStart(6)}${c.reset}`
+      : `${c.dim}⏣    -${c.reset}`;
     const earned = wk.stats.coins > 0
-      ? `${rgb(52, 211, 153)}+${formatCoins(wk.stats.coins).padStart(6)}${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)}${c.reset}`
+      : `${c.dim}+0${c.reset}`;
+    lines.push(`  ${dot} ${name} ${bal} ${earned} ${c.dim}${last}${c.reset}`);
   }
 
   if (recentLogs.length > 0) {
@@ -203,12 +227,15 @@ function log(type, msg, label) {
     info: '·', success: '✓', error: '✗', warn: '!',
     cmd: '▸', coin: '$', buy: '♦', bal: '◈', debug: '·',
   };
-  const tag = label ? (label.replace(/\x1b\[[0-9;]*m/g, '') + ' ') : '';
+  const tagRaw = label ? label.replace(/\x1b\[[0-9;]*m/g, '').substring(0, 12) : '';
   const stripped = msg.replace(/\x1b\[[0-9;]*m/g, '');
+  const tw = Math.min(process.stdout.columns || 80, 76);
   if (dashboardStarted) {
-    recentLogs.push(`${time} ${icons[type] || '·'} ${tag}${stripped}`.substring(0, 72));
+    const maxLen = tw - 4;
+    const entry = `${time} ${icons[type] || '·'} ${tagRaw ? tagRaw + ' ' : ''}${stripped}`;
+    recentLogs.push(entry.substring(0, maxLen));
     while (recentLogs.length > MAX_LOGS) recentLogs.shift();
-    renderDashboard();
+    scheduleRender();
   } else {
     const colorIcons = {
       info: `${c.dim}·${c.reset}`, success: `${rgb(52, 211, 153)}✓${c.reset}`,
@@ -454,6 +481,8 @@ class AccountWorker {
     this.cycleCount = 0;
     this.lastCommandRun = 0;
     this.paused = false;
+    this.dashboardPaused = false;
+    this.failStreak = 0;
     this.globalCooldownUntil = 0;
     this.commandQueue = null;
     this.lastHealthCheck = Date.now();
@@ -463,13 +492,13 @@ class AccountWorker {
 
   log(type, msg) {
     const stripped = msg.replace(/\x1b\[[0-9;]*m/g, '');
-    this.lastStatus = stripped.substring(0, 40);
+    if (type !== 'debug') this.lastStatus = stripped.substring(0, 28);
     log(type, msg, this.tag);
   }
 
   setStatus(text) {
     this.lastStatus = text;
-    if (dashboardStarted) renderDashboard();
+    if (dashboardStarted) scheduleRender();
   }
 
   waitForDankMemer(timeout = 15000) {
@@ -540,15 +569,27 @@ class AccountWorker {
     });
   }
 
-  // ── Needs Item Detection ────────────────────────────────────
+  // ── Needs Item Detection (Trie-like pattern match) ─────────
+  static ITEM_PATTERNS = [
+    { item: 'shovel',          patterns: ["don't have a shovel", 'need a shovel', 'you need a shovel'] },
+    { item: 'fishing pole',    patterns: ["don't have a fishing", 'need a fishing', 'you need a fishing pole'] },
+    { item: 'hunting rifle',   patterns: ["don't have a hunting rifle", 'need a hunting rifle', 'you need a rifle'] },
+    { item: 'adventure ticket', patterns: ["don't have a ticket", "don't have an adventure", 'need a ticket'] },
+    { item: 'keyboard',        patterns: ["don't have a keyboard", 'need a keyboard', 'you need a keyboard'] },
+    { item: 'mouse',           patterns: ["don't have a mouse", 'need a mouse', 'you need a mouse'] },
+  ];
+
   needsItem(text) {
     const lower = text.toLowerCase();
-    if (lower.includes("don't have a shovel") || (lower.includes('need') && lower.includes('shovel')) || lower.includes('you need a shovel'))
-      return 'shovel';
-    if (lower.includes("don't have a fishing") || lower.includes('need a fishing') || lower.includes('you need a fishing pole'))
-      return 'fishing pole';
-    if (lower.includes("don't have a hunting rifle") || lower.includes('need a hunting rifle') || lower.includes('you need a rifle'))
-      return 'hunting rifle';
+    for (const { item, patterns } of AccountWorker.ITEM_PATTERNS) {
+      for (const p of patterns) {
+        if (lower.includes(p)) return item;
+      }
+    }
+    if (lower.includes('need following items') || lower.includes('missing items')) {
+      if (lower.includes('keyboard')) return 'keyboard';
+      if (lower.includes('mouse')) return 'mouse';
+    }
     return null;
   }
 
@@ -767,6 +808,7 @@ class AccountWorker {
         case 'snakeeyes':   cmdResult = await commands.runSnakeeyes(cmdOpts); break;
         case 'dep max':     cmdResult = await commands.runDeposit(cmdOpts); break;
         case 'alert':       cmdResult = await commands.runAlert(cmdOpts); break;
+        case 'stream':      cmdResult = await commands.runStream(cmdOpts); break;
         default:            cmdResult = await commands.runGeneric({ ...cmdOpts, cmdString, cmdName }); break;
       }
 
@@ -775,7 +817,7 @@ class AccountWorker {
 
       // Rate limit detection
       if (resultLower.includes('slow down') || resultLower.includes('rate limit') || resultLower.includes('too fast')) {
-        this.log('warn', `${c.yellow}⚠ Rate limited!${c.reset} Setting 60s global cooldown for ${this.username}`);
+        this.log('warn', `Rate limited! 60s global cooldown`);
         this.globalCooldownUntil = Date.now() + 60000;
         await this.setCooldown(cmdName, 60);
         return;
@@ -784,13 +826,34 @@ class AccountWorker {
       // Captcha/verification detection — pause immediately
       if (resultLower.includes('captcha') || resultLower.includes('verification') ||
           resultLower.includes('are you human') || resultLower.includes("prove you're not a bot")) {
-        this.log('error', `${c.red}${c.bold}🚨 CAPTCHA/VERIFICATION DETECTED for ${this.username}!${c.reset}`);
-        this.log('error', `${c.red}URGENT: Worker PAUSED. Re-enable manually from the dashboard.${c.reset}`);
+        this.log('error', `CAPTCHA DETECTED! Worker PAUSED.`);
         this.paused = true;
         await sendLog(this.username, cmdString, 'CAPTCHA DETECTED — worker paused', 'error');
         return;
       }
 
+      // Premium-only command detection — disable for 24h
+      if (resultLower.includes('only available on premium') || resultLower.includes('premium') ||
+          resultLower.includes('buy the ability to use this command')) {
+        this.log('warn', `${cmdName} requires premium — skipping for 24h`);
+        await this.setCooldown(cmdName, 86400);
+        return;
+      }
+
+      // Already claimed today (daily/weekly) — set long cooldown
+      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>/);
+        if (timeMatch) {
+          const nextAvail = parseInt(timeMatch[1]) * 1000;
+          const waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
+          await this.setCooldown(cmdName, waitSec);
+        } else {
+          await this.setCooldown(cmdName, cmdName === 'daily' ? 86400 : 604800);
+        }
+        return;
+      }
+
       const earned = Math.max(0, cmdResult.coins || 0);
       const spent = Math.max(0, cmdResult.lost || 0);
       if (earned > 0) this.stats.coins += earned;
@@ -798,7 +861,7 @@ class AccountWorker {
 
       if (cmdResult.holdTightReason) {
         const reason = cmdResult.holdTightReason;
-        this.log('warn', `Hold Tight caused by /${reason} — setting 35s cooldown on "${reason}"`);
+        this.log('warn', `Hold Tight: /${reason} — 35s cooldown`);
         const reasonMap = { postmemes: 'pm', highlow: 'hl', blackjack: 'bj', 'work shift': 'work shift' };
         const mappedCmd = reasonMap[reason] || reason;
         await this.setCooldown(mappedCmd, 35);
@@ -806,7 +869,7 @@ class AccountWorker {
       }
 
       this.stats.successes++;
-      const shortResult = result.substring(0, 50).replace(/\n/g, ' ');
+      const shortResult = result.substring(0, 30).replace(/\n/g, ' ');
       this.setStatus(`${cmdName} → ${shortResult}`);
       await sendLog(this.username, cmdString, result, 'success');
       reportEarnings(this.account.id, this.username, earned, spent, cmdName);
@@ -869,15 +932,55 @@ class AccountWorker {
   buildCommandQueue() {
     const heap = new MinHeap();
     const now = Date.now();
-    const enabled = AccountWorker.COMMAND_MAP.filter(
-      ci => this.account[ci.key] === true || this.account[ci.key] === 1
+    let enabled = AccountWorker.COMMAND_MAP.filter(
+      ci => Boolean(this.account[ci.key])
     );
+
+    if (enabled.length === 0) {
+      this.log('warn', `No commands enabled — auto-enabling safe defaults`);
+      const safeDefaults = ['cmd_hunt', 'cmd_dig', 'cmd_beg', 'cmd_search', 'cmd_hl', 'cmd_crime', 'cmd_pm'];
+      for (const key of safeDefaults) this.account[key] = true;
+      enabled = AccountWorker.COMMAND_MAP.filter(ci => Boolean(this.account[ci.key]));
+    }
+
     for (const info of enabled) {
       heap.push({ cmd: info.cmd, nextRunAt: now, priority: info.priority, info });
     }
     return heap;
   }
 
+  // Merge config changes into existing queue without resetting cooldown timings.
+  // Uses a HashMap to drain old items, then rebuilds preserving nextRunAt.
+  mergeCommandQueue() {
+    const enabled = new Set(
+      AccountWorker.COMMAND_MAP.filter(ci => Boolean(this.account[ci.key])).map(ci => ci.cmd)
+    );
+    if (enabled.size === 0) return;
+
+    const existing = new Map();
+    if (this.commandQueue) {
+      while (this.commandQueue.size > 0) {
+        const item = this.commandQueue.pop();
+        existing.set(item.cmd, item);
+      }
+    }
+
+    const heap = new MinHeap();
+    const now = Date.now();
+    for (const info of AccountWorker.COMMAND_MAP) {
+      if (!enabled.has(info.cmd)) continue;
+      const old = existing.get(info.cmd);
+      if (old) {
+        old.info = info;
+        old.priority = info.priority;
+        heap.push(old);
+      } else {
+        heap.push({ cmd: info.cmd, nextRunAt: now, priority: info.priority, info });
+      }
+    }
+    this.commandQueue = heap;
+  }
+
   // ── Health Check: verify Discord client is still connected ──
   async healthCheck() {
     if (!this.running || shutdownCalled) return;
@@ -906,7 +1009,12 @@ class AccountWorker {
   async tick() {
     if (!this.running || shutdownCalled) return;
     if (this.paused) {
-      this.setStatus(`${c.red}${c.bold}PAUSED (captcha/verification)${c.reset}`);
+      this.setStatus('PAUSED (captcha)');
+      this.tickTimeout = setTimeout(() => this.tick(), 5000);
+      return;
+    }
+    if (this.dashboardPaused) {
+      this.setStatus('paused (dashboard)');
       this.tickTimeout = setTimeout(() => this.tick(), 5000);
       return;
     }
@@ -915,46 +1023,46 @@ class AccountWorker {
       return;
     }
 
-    // Global rate-limit cooldown
     const now = Date.now();
+
     if (now < this.globalCooldownUntil) {
       const waitSec = Math.ceil((this.globalCooldownUntil - now) / 1000);
-      this.setStatus(`${c.yellow}rate limited (${waitSec}s)${c.reset}`);
+      this.setStatus(`rate limited (${waitSec}s)`);
       this.tickTimeout = setTimeout(() => this.tick(), 2000);
       return;
     }
 
-    // Periodic health check
     try { await this.healthCheck(); } catch (e) {
       this.log('error', `Health check error: ${e.message}`);
     }
 
-    // Rebuild queue if it doesn't exist or is empty (e.g. after config refresh)
     if (!this.commandQueue || this.commandQueue.size === 0) {
       this.commandQueue = this.buildCommandQueue();
     }
-
-    if (this.commandQueue.size === 0) {
+    if (!this.commandQueue || this.commandQueue.size === 0) {
       this.tickTimeout = setTimeout(() => this.tick(), 15000);
       return;
     }
 
-    // Peek the top item — is it ready?
     const top = this.commandQueue.peek();
     if (top.nextRunAt > now) {
       const waitMs = Math.min(top.nextRunAt - now, 2000);
-      this.setStatus(`${c.dim}waiting for cooldowns...${c.reset}`);
+      this.setStatus('cooldown...');
       this.tickTimeout = setTimeout(() => this.tick(), waitMs);
       return;
     }
 
-    // Pop the command, check Redis cooldown as a secondary gate
     const item = this.commandQueue.pop();
+    if (!item) {
+      this.tickTimeout = setTimeout(() => this.tick(), 1000);
+      return;
+    }
+
     const ready = await this.isCooldownReady(item.cmd);
     if (!ready) {
       const cd = (this.account[item.info.cdKey] || item.info.defaultCd);
       item.nextRunAt = now + cd * 1000;
-      this.commandQueue.push(item);
+      if (this.commandQueue) this.commandQueue.push(item);
       this.tickTimeout = setTimeout(() => this.tick(), 100);
       return;
     }
@@ -966,7 +1074,6 @@ class AccountWorker {
 
     await this.setCooldown(item.cmd, totalWait);
 
-    // Global jitter between commands
     const timeSinceLastCmd = now - (this.lastCommandRun || 0);
     const globalJitter = 1500 + Math.random() * 1500;
     if (timeSinceLastCmd < globalJitter) {
@@ -974,15 +1081,28 @@ class AccountWorker {
     }
 
     const prefix = this.account.use_slash ? '/' : 'pls';
-    this.setStatus(`${c.white}pls ${item.cmd}${c.reset}`);
+    this.setStatus(`pls ${item.cmd}`);
+
+    const beforeCoins = this.stats.coins;
     await this.runCommand(item.cmd, prefix);
+    const earned = this.stats.coins - beforeCoins;
+
+    if (earned <= 0 && item.cmd !== 'dep max' && item.cmd !== 'alert') {
+      this.failStreak++;
+    } else {
+      this.failStreak = 0;
+    }
 
     this.lastCommandRun = Date.now();
     await this.setCooldown(item.cmd, totalWait);
 
-    // Push the command back into the heap with its next available time
-    item.nextRunAt = Date.now() + totalWait * 1000;
-    this.commandQueue.push(item);
+    // Exponential backoff: if too many consecutive failures, slow down
+    const backoffMultiplier = this.failStreak > 5 ? Math.min(this.failStreak - 4, 5) : 1;
+
+    if (this.commandQueue && this.running && !shutdownCalled) {
+      item.nextRunAt = Date.now() + totalWait * 1000 * backoffMultiplier;
+      this.commandQueue.push(item);
+    }
 
     this.busy = false;
     this.cycleCount++;
@@ -994,7 +1114,9 @@ class AccountWorker {
       this.busy = false;
     }
 
-    this.tickTimeout = setTimeout(() => this.tick(), 100);
+    if (this.running && !shutdownCalled) {
+      this.tickTimeout = setTimeout(() => this.tick(), 100);
+    }
   }
 
   async grindLoop() {
@@ -1002,6 +1124,8 @@ class AccountWorker {
     this.running = true;
     this.busy = false;
     this.paused = false;
+    this.dashboardPaused = false;
+    this.failStreak = 0;
     this.cycleCount = 0;
     this.lastCommandRun = 0;
     this.commandQueue = this.buildCommandQueue();
@@ -1011,23 +1135,23 @@ class AccountWorker {
       if (!this.running) return;
       await this.refreshConfig();
 
-      // Dashboard can un-pause a captcha-paused worker by re-activating it
       if (this.account.active && this.paused) {
-        this.log('success', 'Account re-activated from dashboard! Resuming from captcha pause...');
+        this.log('success', 'Captcha cleared! Resuming...');
         this.paused = false;
-        this.busy = false;
+        this.dashboardPaused = false;
       }
 
-      if (!this.account.active && !this.busy) {
+      if (!this.account.active && !this.dashboardPaused) {
         this.log('warn', 'Account deactivated from dashboard. Pausing...');
-        this.busy = true;
-      } else if (this.account.active && this.busy && !this.paused) {
+        this.dashboardPaused = true;
+      } else if (this.account.active && this.dashboardPaused) {
         this.log('success', 'Account re-activated! Resuming...');
-        this.busy = false;
+        this.dashboardPaused = false;
       }
 
-      // Rebuild the command queue on config refresh so newly enabled/disabled commands take effect
-      this.commandQueue = this.buildCommandQueue();
+      if (this.commandQueue && !shutdownCalled) {
+        this.mergeCommandQueue();
+      }
     }, 15000);
 
     const safeTickLoop = async () => {
@@ -1095,10 +1219,11 @@ class AccountWorker {
           { key: 'cmd_trivia', l: 'trivia' }, { key: 'cmd_use', l: 'use' },
           { key: 'cmd_deposit', l: 'dep' }, { key: 'cmd_drops', l: 'drops' },
           { key: 'cmd_alert', l: 'alert' },
-        ].filter((ci) => this.account[ci.key] === true || this.account[ci.key] === 1);
+        ].filter((ci) => Boolean(this.account[ci.key]));
 
-        const cmdList = enabledCmds.map(ci => ci.l).join(' ');
-        this.log('success', `${this.tag} ${c.dim}#${(this.channel.name || '?').substring(0, 12)}${c.reset} ${c.dim}[${enabledCmds.length} cmds: ${cmdList}]${c.reset}`);
+        const chName = (this.channel.name || '?').substring(0, 12);
+        this.log('success', `#${chName} · ${enabledCmds.length} cmds`);
+        this.setStatus('starting...');
 
         await this.checkBalance();
         this.grindLoop();
@@ -1112,8 +1237,10 @@ class AccountWorker {
   stop() {
     this.running = false;
     this.paused = false;
-    if (this.tickTimeout) clearTimeout(this.tickTimeout);
-    if (this.configInterval) clearInterval(this.configInterval);
+    this.dashboardPaused = false;
+    this.busy = false;
+    if (this.tickTimeout) { clearTimeout(this.tickTimeout); this.tickTimeout = null; }
+    if (this.configInterval) { clearInterval(this.configInterval); this.configInterval = null; }
     this.commandQueue = null;
     try { this.client.destroy(); } catch {}
   }
@@ -1135,7 +1262,7 @@ async function start(apiKey, apiUrl) {
 
   console.log(colorBanner());
   console.log(
-    `  ${rgb(139, 92, 246)}v4.1${c.reset}` +
+    `  ${rgb(139, 92, 246)}v4.3${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}` +
@@ -1153,7 +1280,7 @@ async function start(apiKey, apiUrl) {
   const data = await fetchConfig();
   if (!data) {
     log('error', `Cannot connect to API`);
-    log('error', `Pass ${c.white}--url${c.reset} with your Railway URL or set ${c.white}DANKGRINDER_URL${c.reset}`);
+    log('error', `Check your API key or API URL and try again.`);
     process.exit(1);
   }
 
@@ -1178,17 +1305,32 @@ async function start(apiKey, apiUrl) {
   console.log('');
   startTime = Date.now();
   dashboardStarted = true;
+  setDashboardActive(true);
   process.stdout.write(c.hide);
 
-  setInterval(() => renderDashboard(), 1000);
-  renderDashboard();
+  setInterval(() => scheduleRender(), 1000);
+  scheduleRender();
 
+  let sigintHandled = false;
   process.on('SIGINT', () => {
+    if (sigintHandled) return;
+    sigintHandled = true;
     shutdownCalled = true;
-    process.stdout.write(c.show);
     dashboardStarted = false;
+    setDashboardActive(false);
+    process.stdout.write(c.show);
+
+    // Clear the dashboard area before printing summary
+    if (dashboardLines > 0) {
+      process.stdout.write(c.cursorUp(dashboardLines));
+      for (let i = 0; i < dashboardLines; i++) {
+        process.stdout.write(c.clearLine + '\r\n');
+      }
+      process.stdout.write(c.cursorUp(dashboardLines));
+    }
+
     const sepBar = rgb(139, 92, 246) + c.bold + '═'.repeat(tw) + c.reset;
-    console.log('\n');
+    console.log('');
     console.log(`  ${rgb(251, 191, 36)}${c.bold}Session Summary${c.reset}`);
     console.log(sepBar);
     for (const wk of workers) {
@@ -1202,9 +1344,15 @@ async function start(apiKey, apiUrl) {
       wk.stop();
     }
     console.log(sepBar);
-    console.log(`  ${rgb(251, 191, 36)}${c.bold}Total: +⏣ ${totalCoins.toLocaleString()}${c.reset} ${c.dim}in ${formatUptime()}${c.reset}`);
+
+    // Recalculate totals for accurate summary
+    let finalCoins = 0;
+    for (const wk of workers) finalCoins += wk.stats.coins || 0;
+    console.log(`  ${rgb(251, 191, 36)}${c.bold}Total: +⏣ ${finalCoins.toLocaleString()}${c.reset} ${c.dim}in ${formatUptime()}${c.reset}`);
     console.log('');
-    setTimeout(() => process.exit(0), 2000);
+
+    if (redis) { try { redis.disconnect(); } catch {} }
+    setTimeout(() => process.exit(0), 1500);
   });
 }
 

package/package.json

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