dankgrinder 5.23.0 → 5.25.0

package/lib/antiDetect.js

@@ -0,0 +1,211 @@
+/**
+ * Advanced Anti-Detection System
+ *
+ * Features:
+ *   - Adaptive human-like timing with context-aware delays
+ *   - Micro-pause injection for natural interaction patterns
+ *   - Activity-based variance (tired vs alert simulation)
+ *   - Session behavior drift (mimics human consistency changes)
+ *   - Randomized click timing within safe bounds
+ */
+
+'use strict';
+
+// ── Configuration ─────────────────────────────────────────────
+const CONFIG = Object.freeze({
+  // Base delay ranges in ms (tuned for natural human timing)
+  MIN_DELAY: 500,              // 0.5s minimum - natural human speed
+  MAX_DELAY: 1000,             // 1.0s maximum - not too slow
+
+  // Context multipliers (subtle variations)
+  MULT_FIRST_ACTION: 1.2,      // Slight hesitation on first action
+  MULT_REPEATED_ACTION: 0.85,  // Slightly faster on repeated actions
+  MULT_HIGH_VALUE: 1.1,        // Marginally slower for high-value actions
+  MULT_LOW_VALUE: 0.9,         // Slightly faster for low-value actions
+
+  // Micro-pause settings (subtle human-like hesitation)
+  MICRO_PAUSE_CHANCE: 0.25,    // 25% chance of micro-pause
+  MICRO_PAUSE_MIN: 50,
+  MICRO_PAUSE_MAX: 150,
+
+  // Minimal drift to avoid detectable patterns
+  DRIFT_FACTOR: 0.01,
+  DRIFT_MAX: 0.08,             // Max 8% drift
+
+  // Pattern randomization
+  PATTERN_RESET_CHANCE: 0.2,   // 20% chance to reset timing pattern
+});
+
+// ── Session State ─────────────────────────────────────────────
+const sessionState = {
+  actionCount: 0,
+  lastActionTime: 0,
+  currentDrift: 0,
+  patternSeed: Math.random(),
+  activityLevel: 1.0,  // Starts neutral
+};
+
+// ── Seeded Random for Reproducible Patterns ──────────────────
+function seededRandom(seed) {
+  const x = Math.sin(seed) * 10000;
+  return x - Math.floor(x);
+}
+
+// ── Adaptive Delay Calculation ────────────────────────────────
+/**
+ * Calculate human-like delay based on context.
+ * @param {Object} options
+ * @param {string} options.context - Action context ('first', 'repeated', 'high-value', 'low-value', 'normal')
+ * @param {number} options.baseMin - Minimum delay override
+ * @param {number} options.baseMax - Maximum delay override
+ * @param {boolean} options.skipMicroPause - Force skip micro-pause
+ * @returns {Promise<number>} - Delay in ms
+ */
+async function calcAdaptiveDelay(options = {}) {
+  const {
+    context = 'normal',
+    baseMin = CONFIG.MIN_DELAY,
+    baseMax = CONFIG.MAX_DELAY,
+    skipMicroPause = false,
+  } = options;
+
+  sessionState.actionCount++;
+  const now = Date.now();
+
+  // Time since last action affects speed (rush vs relaxed)
+  const timeSinceLast = now - sessionState.lastActionTime;
+  const rushFactor = timeSinceLast < 500 ? 0.8 : timeSinceLast > 5000 ? 1.15 : 1.0;
+
+  // Apply context multiplier
+  let multiplier = 1.0;
+  switch (context) {
+    case 'first':
+      multiplier = CONFIG.MULT_FIRST_ACTION;
+      break;
+    case 'repeated':
+      multiplier = CONFIG.MULT_REPEATED_ACTION;
+      break;
+    case 'high-value':
+      multiplier = CONFIG.MULT_HIGH_VALUE;
+      break;
+    case 'low-value':
+      multiplier = CONFIG.MULT_LOW_VALUE;
+      break;
+  }
+
+  // Apply drift (session behavior change)
+  sessionState.currentDrift += (Math.random() - 0.5) * CONFIG.DRIFT_FACTOR;
+  sessionState.currentDrift = Math.max(
+    -CONFIG.DRIFT_MAX,
+    Math.min(CONFIG.DRIFT_MAX, sessionState.currentDrift)
+  );
+  multiplier *= (1 + sessionState.currentDrift);
+
+  // Pattern reset for unpredictability
+  if (Math.random() < CONFIG.PATTERN_RESET_CHANCE) {
+    sessionState.patternSeed = Math.random();
+  }
+
+  // Calculate base delay with seeded randomness
+  const seed = sessionState.patternSeed + (sessionState.actionCount * 0.001);
+  const randomFactor = 0.5 + seededRandom(seed);  // 0.5 to 1.5 range
+  const baseDelay = baseMin + (baseMax - baseMin) * randomFactor;
+
+  // Apply all modifiers
+  let finalDelay = baseDelay * multiplier * rushFactor;
+
+  // Add micro-pause (simulates human hesitation)
+  if (!skipMicroPause && Math.random() < CONFIG.MICRO_PAUSE_CHANCE) {
+    const microPause = CONFIG.MICRO_PAUSE_MIN +
+      (CONFIG.MICRO_PAUSE_MAX - CONFIG.MICRO_PAUSE_MIN) * seededRandom(seed + 0.5);
+    finalDelay += microPause;
+  }
+
+  // Clamp to reasonable bounds
+  finalDelay = Math.max(50, Math.min(800, finalDelay));
+
+  sessionState.lastActionTime = Date.now();
+
+  return Math.round(finalDelay);
+}
+
+// ── Main Human Delay Function ─────────────────────────────────
+/**
+ * Wait with human-like timing.
+ * @param {Object} options - Same as calcAdaptiveDelay
+ */
+async function humanDelay(options = {}) {
+  const delay = await calcAdaptiveDelay(options);
+  return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+// ── Reset Session State ───────────────────────────────────────
+function resetSession() {
+  sessionState.actionCount = 0;
+  sessionState.lastActionTime = 0;
+  sessionState.currentDrift = 0;
+  sessionState.patternSeed = Math.random();
+  sessionState.activityLevel = 1.0;
+}
+
+// ── Get Session Stats (for debugging) ─────────────────────────
+function getSessionStats() {
+  return {
+    actionCount: sessionState.actionCount,
+    currentDrift: sessionState.currentDrift,
+    timeSinceLast: Date.now() - sessionState.lastActionTime,
+  };
+}
+
+// ── Smart Cooldown Calculator ─────────────────────────────────
+/**
+ * Calculate smart cooldown with safety buffer and variance.
+ * @param {number} baseCooldown - Base cooldown in seconds
+ * @param {Object} options
+ * @param {boolean} options.addBuffer - Add safety buffer
+ * @param {boolean} options.addVariance - Add random variance
+ * @returns {number} - Adjusted cooldown in seconds
+ */
+function calcSmartCooldown(baseCooldown, options = {}) {
+  const { addBuffer = true, addVariance = true } = options;
+
+  let adjusted = baseCooldown;
+
+  // Add safety buffer
+  if (addBuffer) {
+    adjusted += CONFIG.COOLDOWN_BUFFER_SEC;
+  }
+
+  // Add small variance (±2%) to avoid detectable patterns
+  if (addVariance && baseCooldown > 10) {
+    const variance = (Math.random() - 0.5) * 0.04 * baseCooldown;
+    adjusted += variance;
+  }
+
+  return Math.max(5, Math.round(adjusted));
+}
+
+// ── Exponential Backoff with Jitter ───────────────────────────
+/**
+ * Calculate backoff delay for retries.
+ * @param {number} attempt - Attempt number (0-indexed)
+ * @param {number} baseMs - Base delay in ms
+ * @param {number} maxMs - Maximum delay in ms
+ * @returns {number} - Delay in ms
+ */
+function calcBackoff(attempt, baseMs = 1000, maxMs = 30000) {
+  const exponential = baseMs * Math.pow(2, attempt);
+  const jitter = exponential * 0.2 * (Math.random() - 0.5);
+  return Math.min(maxMs, Math.round(exponential + jitter));
+}
+
+// ── Exports ───────────────────────────────────────────────────
+module.exports = {
+  humanDelay,
+  calcAdaptiveDelay,
+  calcSmartCooldown,
+  calcBackoff,
+  resetSession,
+  getSessionStats,
+  CONFIG,
+};

package/lib/commands/adventure.js

@@ -39,8 +39,7 @@ const {
   safeClickButton, isHoldTight, logMsg,
 } = require('./utils');
 
-const RE_DISCORD_TIMESTAMP = /<t:(\d+)(?::[tTdDfFR])?>/;
-const RE_ADVENTURE_AGAIN_LABEL = /adventure again in (\d+)\s*(minute|min|hour|second)/;
+const RE_DISCORD_TIMESTAMP = /<t:(\d+)(?::[tTdDfFR])?>/g;
 
 // ── Adventure type rotation (cycle through all types each run) ────
 let lastAdventureIndex = -1;
@@ -270,7 +269,7 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
 
   if (!response) {
     LOG.warn('[adventure] No response from Dank Memer');
-    return { result: 'no response', coins: 0, nextCooldownSec: null };
+    return { result: 'no response', coins: 0, nextCooldownSec: 180 };
   }
 
   // Check for Hold Tight
@@ -439,33 +438,45 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
 function buildResult(finalText, coins, interactions, rewards, msg) {
   let nextCooldownSec = null;
 
-  // 1) Best: Unix timestamp <t:UNIX:t> in final text or embed
-  const allText = msg ? getFullText(msg) : finalText;
-  const tsMatch = allText.match(RE_DISCORD_TIMESTAMP);
-  if (tsMatch) {
-    const unixTarget = parseInt(tsMatch[1]);
-    const nowUnix = Math.floor(Date.now() / 1000);
-    nextCooldownSec = Math.max(5, unixTarget - nowUnix);
-    LOG.info(`[adventure] Next at ${new Date(unixTarget * 1000).toLocaleTimeString()} (${c.yellow}${nextCooldownSec}s${c.reset})`);
-  }
-
-  // 2) Fallback: "Adventure again in X minutes" button label
-  if (!nextCooldownSec && msg) {
+  // 1) Best: button label after adventure ends (e.g. "Adventure again in 57m")
+  if (msg) {
     const rows = msg.components || [];
     for (let ri = 0; ri < rows.length; ri++) {
       const comps = rows[ri].components || [];
       for (let ci = 0; ci < comps.length; ci++) {
-        const comp = comps[ci];
-        const label = (comp.label || '').toLowerCase();
-        const btnMatch = label.match(RE_ADVENTURE_AGAIN_LABEL);
-        if (btnMatch) {
-          nextCooldownSec = parseInt(btnMatch[1]);
-          const unit = btnMatch[2].toLowerCase();
-          if (unit.startsWith('min')) nextCooldownSec *= 60;
-          if (unit.startsWith('hour')) nextCooldownSec *= 3600;
-          LOG.info(`[adventure] Next in ${c.yellow}${btnMatch[1]} ${btnMatch[2]}s${c.reset} (from button)`);
-        }
+        const label = String(comps[ci]?.label || '').toLowerCase();
+        if (!label.includes('adventure') || !label.includes('again')) continue;
+        const unitMatch = label.match(/(\d+)\s*(h|hr|hrs|hour|hours|m|min|mins|minute|minutes|s|sec|secs|second|seconds)\b/i);
+        if (!unitMatch) continue;
+        const n = parseInt(unitMatch[1], 10);
+        const u = unitMatch[2].toLowerCase();
+        if (!Number.isFinite(n) || n <= 0) continue;
+        if (u.startsWith('h')) nextCooldownSec = n * 3600;
+        else if (u.startsWith('m')) nextCooldownSec = n * 60;
+        else nextCooldownSec = n;
+        LOG.info(`[adventure] Next cooldown from button: ${c.yellow}${nextCooldownSec}s${c.reset}`);
+        break;
       }
+      if (nextCooldownSec) break;
+    }
+  }
+
+  // 2) Fallback: Unix timestamp <t:UNIX:*> in final text or embed
+  const allText = msg ? getFullText(msg) : finalText;
+  if (!nextCooldownSec) {
+    const nowUnix = Math.floor(Date.now() / 1000);
+    const tsMatches = Array.from(String(allText || '').matchAll(RE_DISCORD_TIMESTAMP));
+    let best = null;
+    for (const m of tsMatches) {
+      const unixTarget = parseInt(m[1], 10);
+      if (!Number.isFinite(unixTarget)) continue;
+      const diff = unixTarget - nowUnix;
+      if (diff <= 0) continue;
+      if (best == null || diff < best) best = diff;
+    }
+    if (best != null) {
+      nextCooldownSec = Math.max(5, best);
+      LOG.info(`[adventure] Next cooldown from timestamp: ${c.yellow}${nextCooldownSec}s${c.reset}`);
     }
   }
 

package/lib/commands/dig.js

@@ -4,11 +4,88 @@
  */
 
 const {
-  LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton, humanDelay,
+  logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
   isCV2, ensureCV2, stripAnsi,
 } = require('./utils');
 const { buyItem } = require('./shop');
 
+const DIG_LANE_LABELS = new Set(['left', 'middle', 'right']);
+
+async function waitForDigUpdate(channel, messageId, baselineText, waitForDankMemer, timeoutMs = 9000) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const msg = await waitForDankMemer(2200);
+    if (msg && msg.id === messageId) {
+      if (isCV2(msg)) await ensureCV2(msg, true);
+      const txt = stripAnsi(getFullText(msg)).replace(/\s+/g, ' ').trim();
+      if (!baselineText || (txt && txt !== baselineText)) return msg;
+    }
+
+    await sleep(350);
+    try {
+      const fresh = await channel.messages.fetch(messageId);
+      if (!fresh) continue;
+      if (isCV2(fresh)) await ensureCV2(fresh, true);
+      const txt = stripAnsi(getFullText(fresh)).replace(/\s+/g, ' ').trim();
+      if (!baselineText || (txt && txt !== baselineText)) return fresh;
+    } catch {}
+  }
+  return null;
+}
+
+function pickDigLaneButton(msg) {
+  const buttons = getAllButtons(msg).filter((b) => !b.disabled && DIG_LANE_LABELS.has(String(b.label || '').toLowerCase()));
+  if (buttons.length === 0) return null;
+
+  const textLower = stripAnsi(getFullText(msg)).replace(/\s+/g, ' ').trim().toLowerCase();
+
+  // If prompt text explicitly mentions a lane, follow it.
+  for (const lane of DIG_LANE_LABELS) {
+    if (new RegExp(`\\b${lane}\\b`, 'i').test(textLower)) {
+      const matched = buttons.find((b) => String(b.label || '').toLowerCase() === lane);
+      if (matched) return matched;
+    }
+  }
+
+  // Fallback: random lane (still better than skipping the minigame).
+  return buttons[Math.floor(Math.random() * buttons.length)];
+}
+
+async function resolveDigFlow({ channel, waitForDankMemer, response }) {
+  let current = response;
+
+  for (let round = 0; round < 3; round++) {
+    if (isCV2(current)) await ensureCV2(current, true);
+    const laneBtn = pickDigLaneButton(current);
+    if (!laneBtn) break;
+
+    LOG.info(`[dig] Minigame: clicking "${laneBtn.label}"`);
+    const baseline = stripAnsi(getFullText(current)).replace(/\s+/g, ' ').trim();
+    await humanDelay(110, 240);
+
+    let clicked = null;
+    try { clicked = await safeClickButton(current, laneBtn); } catch {}
+    if (clicked) current = clicked;
+
+    const updated = await waitForDigUpdate(channel, current.id, baseline, waitForDankMemer, 10000);
+    if (updated) {
+      current = updated;
+      logMsg(current, `dig-minigame-${round + 1}`);
+    } else {
+      break;
+    }
+  }
+
+  const cleanText = stripAnsi(getFullText(current)).replace(/\s+/g, ' ').trim();
+  const coins = parseCoins(cleanText);
+  if (coins > 0) {
+    LOG.coin(`[dig] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `dig → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+  return { result: cleanText.substring(0, 90) || 'done', coins: 0 };
+}
+
 /**
  * @param {object} opts
  * @param {object} opts.channel
@@ -66,25 +143,13 @@ async function runDig({ channel, waitForDankMemer, client }) {
       if (r2) {
         if (isCV2(r2)) await ensureCV2(r2);
         logMsg(r2, 'dig-retry');
-        const t2 = getFullText(r2);
-        const coins = parseCoins(t2);
-        if (coins > 0) {
-          LOG.coin(`[dig] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-          return { result: `dig → +⏣ ${coins.toLocaleString()}`, coins };
-        }
-        return { result: stripAnsi(t2).replace(/\s+/g, ' ').trim().substring(0, 60), coins: 0 };
+        return await resolveDigFlow({ channel, waitForDankMemer, response: r2 });
       }
     }
     return { result: 'need shovel (buy failed)', coins: 0 };
   }
 
-  const coins = parseCoins(cleanText);
-  if (coins > 0) {
-    LOG.coin(`[dig] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-    return { result: `dig → +⏣ ${coins.toLocaleString()}`, coins };
-  }
-
-  return { result: cleanText.substring(0, 60) || 'done', coins: 0 };
+  return await resolveDigFlow({ channel, waitForDankMemer, response });
 }
 
 module.exports = { runDig };

package/lib/commands/farm.js

@@ -62,6 +62,13 @@ function parseFarmGrowReadySec(text) {
   if (tsNearReady.length > 0) return Math.max(5, Math.min(...tsNearReady));
 
   // Fallback textual patterns.
+  const willReadyH = clean.match(/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*hour/i);
+  if (willReadyH) return Math.max(5, parseInt(willReadyH[1], 10) * 3600);
+  const willReadyM = clean.match(/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*minute/i);
+  if (willReadyM) return Math.max(5, parseInt(willReadyM[1], 10) * 60);
+  const willReadyS = clean.match(/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*second/i);
+  if (willReadyS) return Math.max(5, parseInt(willReadyS[1], 10));
+
   const h = clean.match(/ready\s+in\s+(\d+)\s*hour/i);
   if (h) return Math.max(5, parseInt(h[1], 10) * 3600);
   const mi = clean.match(/ready\s+in\s+(\d+)\s*minute/i);
@@ -977,7 +984,7 @@ async function runFarm({ channel, waitForDankMemer, client, _buyRetryDepth = 0,
 
   if (!response) {
     LOG.warn('[farm] No response');
-    return { result: 'no response', coins: 0 };
+    return { result: 'no response', coins: 0, nextCooldownSec: 90 };
   }
 
   if (isHoldTight(response)) {
@@ -1022,7 +1029,7 @@ async function runFarm({ channel, waitForDankMemer, client, _buyRetryDepth = 0,
     LOG.warn('[farm] Subcommand required response detected; retrying with "pls farm view"');
     await channel.send('pls farm view');
     const retry = await waitForDankMemer(12000);
-    if (!retry) return { result: 'no response after farm view retry', coins: 0 };
+  if (!retry) return { result: 'no response after farm view retry', coins: 0, nextCooldownSec: 120 };
     response = retry;
     if (isCV2(response)) await ensureCV2(response);
     logMsg(response, 'farm-retry-view');
@@ -1505,7 +1512,11 @@ async function runFarm({ channel, waitForDankMemer, client, _buyRetryDepth = 0,
   }
 
   const coins = parseCoins(text);
-  let nextCd = parseFarmCooldownSec(text) || 10;
+  let nextCd = parseFarmCooldownSec(text) || 30;
+  const growReadyEnd = parseFarmGrowReadySec(text);
+  if (Number.isFinite(growReadyEnd) && growReadyEnd > 0) {
+    nextCd = Math.max(nextCd, Math.min(6 * 3600, growReadyEnd + 2));
+  }
   const missingEnd = parseMissingFarmItem(text);
   if (missingEnd) {
     LOG.warn(`[farm] Missing ${c.bold}${missingEnd}${c.reset} after action — will retry in 1h`);

package/lib/commands/inventory.js

@@ -233,6 +233,7 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   allItems.push(...parseInventoryPage(response));
 
   let guard = 0;
+  let noChangeCount = 0;
   while (page < total && guard < Math.max(20, total + 6)) {
     guard++;
     const buttons = getAllButtons(response);
@@ -312,12 +313,17 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
     delete response._cv2buttons;
 
     let pageChanged = false;
-    for (let attempt = 0; attempt < 4; attempt++) {
-      await sleep(attempt === 0 ? 600 : 1200);
+    for (let attempt = 0; attempt < 7; attempt++) {
+      await sleep(attempt === 0 ? 700 : 1100 + Math.min(attempt * 150, 600));
       try {
-        const fresh = await channel.messages.fetch(response.id);
+        const fresh = await response.fetch(true);
         if (fresh) response = fresh;
-      } catch {}
+      } catch {
+        try {
+          const fresh = await channel.messages.fetch(response.id);
+          if (fresh) response = fresh;
+        } catch {}
+      }
       if (isCV2(response)) await ensureCV2(response, true);
       const pageInfo = parsePageInfo(response);
       if (pageInfo.page > page && !visitedPages.has(pageInfo.page)) {
@@ -337,7 +343,16 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
       delete response._cv2buttons;
     }
 
-    if (!pageChanged) break;
+    if (!pageChanged) {
+      noChangeCount++;
+      if (noChangeCount < 3) {
+        LOG.warn(`[inv] Page stuck at ${page}/${total}; retrying paginator click (${noChangeCount}/2)`);
+        await sleep(900 + Math.floor(Math.random() * 500));
+        continue;
+      }
+      break;
+    }
+    noChangeCount = 0;
     allItems.push(...parseInventoryPage(response));
   }
 

package/lib/commands/stream.js

@@ -8,6 +8,7 @@ const { buyItem } = require('./shop');
 const STREAM_ITEMS = Object.freeze(['keyboard', 'mouse']);
 const STREAM_ACTION_LABELS = Object.freeze(['run ad', 'read chat', 'collect donations']);
 const RE_STREAM_INTERACT_MIN = /interact\s+with\s+your\s+stream\s+every\s+`?(\d+)`?\s*minutes?/i;
+const RE_STREAM_TS = /<t:(\d+)(?::[tTdDfFR])?>/g;
 
 function normalizeLower(text) {
   return String(text || '')
@@ -123,11 +124,40 @@ function isActionResultText(lowerText) {
 
 function parseStreamInteractCooldownSec(text) {
   const clean = String(stripAnsi(text || '')).replace(/\s+/g, ' ').trim();
+
+  // Primary: explicit interaction cadence from dashboard text.
   const mm = clean.match(RE_STREAM_INTERACT_MIN);
   if (mm) {
     const mins = parseInt(mm[1], 10);
     if (Number.isFinite(mins) && mins > 0) return mins * 60;
   }
+
+  // Secondary: derive from "last streamed" marker (10m base cooldown).
+  const lower = normalizeLower(clean);
+  const now = Math.floor(Date.now() / 1000);
+  const tsMatches = Array.from(clean.matchAll(RE_STREAM_TS));
+  for (const m of tsMatches) {
+    const ts = parseInt(m[1], 10);
+    if (!Number.isFinite(ts) || ts <= 0) continue;
+    const idx = m.index ?? 0;
+    const left = lower.slice(Math.max(0, idx - 70), idx);
+    if (!left.includes('last streamed')) continue;
+    const elapsed = Math.max(0, now - ts);
+    const remain = Math.max(5, 600 - elapsed);
+    return remain;
+  }
+
+  // Textual fallback: "last streamed X minutes ago".
+  const ago = lower.match(/last\s+streamed[^\d]{0,24}(\d+)\s*(hour|hr|hrs|minute|min|mins|second|sec|secs)\s+ago/i);
+  if (ago) {
+    const n = parseInt(ago[1], 10);
+    const unit = ago[2].toLowerCase();
+    if (Number.isFinite(n) && n >= 0) {
+      const elapsed = unit.startsWith('h') ? n * 3600 : unit.startsWith('m') ? n * 60 : n;
+      return Math.max(5, 600 - elapsed);
+    }
+  }
+
   return 600;
 }
 
@@ -171,7 +201,7 @@ async function runStream({ channel, waitForDankMemer, client }) {
 
   if (!response) {
     LOG.warn('[stream] No response');
-    return { result: 'no response', coins: 0 };
+    return { result: 'no response', coins: 0, nextCooldownSec: 120 };
   }
 
   if (isHoldTight(response)) {
@@ -199,14 +229,14 @@ async function runStream({ channel, waitForDankMemer, client }) {
 
     for (const item of itemsToBuy) {
       const bought = await buyItem({ channel, waitForDankMemer, client, itemName: item, quantity: 1 });
-      if (!bought) return { result: `need ${item} (buy failed)`, coins: 0 };
+      if (!bought) return { result: `need ${item} (buy failed)`, coins: 0, nextCooldownSec: 1800 };
       await humanDelay(500, 1000);
     }
 
     await sleep(2000);
     await channel.send('pls stream');
     response = await waitForDankMemer(12000);
-    if (!response) return { result: 'no response after buy', coins: 0 };
+  if (!response) return { result: 'no response after buy', coins: 0, nextCooldownSec: 180 };
     await hydrate(response);
     logMsg(response, 'stream-retry');
     text = getFullText(response);

package/lib/commands/utils.js

@@ -94,8 +94,26 @@ const RE_HOLD_TIGHT_REASON = /Reason:\s*\/(\w+)/i;
 // ── Sleep ────────────────────────────────────────────────────
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
-function humanDelay(min = 50, max = 200) {
-  return new Promise(r => setTimeout(r, min + Math.random() * (max - min)));
+// ── Advanced Human Delay (Anti-Detection) ────────────────────
+// Natural human-like timing: 0.5-1.0s base with subtle variations
+let _antiDetect = null;
+try {
+  _antiDetect = require('../antiDetect');
+} catch {}
+
+function humanDelay(contextOrMin, max) {
+  // Backward compatibility: if called with numeric args, use simple delay
+  if (typeof contextOrMin === 'number') {
+    const min = contextOrMin;
+    const maxVal = typeof max === 'number' ? max : 1000;
+    return new Promise(r => setTimeout(r, min + Math.random() * (maxVal - min)));
+  }
+  // New API: context-based adaptive delay (uses 0.5-1s range)
+  if (_antiDetect && typeof contextOrMin === 'object') {
+    return _antiDetect.humanDelay(contextOrMin);
+  }
+  // Default: natural human timing (0.5-1.0s)
+  return new Promise(r => setTimeout(r, 500 + Math.random() * 500));
 }
 
 // ── Message Parsing ──────────────────────────────────────────

package/lib/commands/work.js

@@ -23,7 +23,7 @@ const {
 
 const RE_MEMORY_BACKTICK_CHUNK = /`([^`]+)`/g;
 const RE_BACKTICK_STRIP = /`/g;
-const RE_WORK_COOLDOWN_TS = /<t:(\d+):R>/;
+const RE_WORK_COOLDOWN_TS = /<t:(\d+)(?::[tTdDfFR])?>/g;
 const RE_WORK_COOLDOWN_MINUTES = /(\d+)\s*minute/i;
 const RE_WORK_COOLDOWN_HOURS = /(\d+)\s*hour/i;
 
@@ -78,18 +78,42 @@ function parseMemoryOrder(text) {
  * Patterns: "next shift <t:TIMESTAMP:R>", "X minutes", "X hours"
  */
 function parseWorkCooldown(text) {
-  // Unix timestamp pattern: <t:TIMESTAMP:R>
-  const tsMatch = text.match(RE_WORK_COOLDOWN_TS);
-  if (tsMatch) {
-    const ts = parseInt(tsMatch[1]);
-    const now = Math.floor(Date.now() / 1000);
-    const diff = ts - now;
-    return diff > 0 ? diff : 3600;
+  const clean = String(stripAnsi(text || ''));
+  const lower = normalizeLower(clean).replace(/\s+/g, ' ').trim();
+
+  // Unix timestamp pattern: <t:TIMESTAMP:*>
+  const now = Math.floor(Date.now() / 1000);
+  const tsMatches = Array.from(clean.matchAll(RE_WORK_COOLDOWN_TS));
+  if (tsMatches.length > 0) {
+    let best = null;
+    for (const m of tsMatches) {
+      const ts = parseInt(m[1], 10);
+      if (!Number.isFinite(ts)) continue;
+      const diff = ts - now;
+      if (diff <= 0) continue;
+      if (best == null || diff < best) best = diff;
+    }
+    if (best != null) return Math.max(5, best);
+  }
+
+  // Compact forms frequently seen in buttons/messages: "1h", "54m", "30s"
+  if (/(next shift|work again|cooldown|already done|shift)/i.test(lower)) {
+    const short = lower.match(/(\d+)\s*(h|hr|hrs|m|min|mins|s|sec|secs)\b/i);
+    if (short) {
+      const n = parseInt(short[1], 10);
+      const u = short[2].toLowerCase();
+      if (Number.isFinite(n) && n > 0) {
+        if (u.startsWith('h')) return n * 3600;
+        if (u.startsWith('m')) return n * 60;
+        return n;
+      }
+    }
   }
+
   // "X minutes" / "X hours" pattern
-  const minMatch = text.match(RE_WORK_COOLDOWN_MINUTES);
+  const minMatch = clean.match(RE_WORK_COOLDOWN_MINUTES);
   if (minMatch) return parseInt(minMatch[1]) * 60;
-  const hrMatch = text.match(RE_WORK_COOLDOWN_HOURS);
+  const hrMatch = clean.match(RE_WORK_COOLDOWN_HOURS);
   if (hrMatch) return parseInt(hrMatch[1]) * 3600;
   return null;
 }
@@ -311,7 +335,7 @@ async function runWorkShift({ channel, waitForDankMemer }) {
 
   if (!current) {
     LOG.warn('[work] No response');
-    return { result: 'no response', coins: 0 };
+    return { result: 'no response', coins: 0, nextCooldownSec: 120 };
   }
 
   if (isHoldTight(current)) {
@@ -351,7 +375,7 @@ async function runWorkShift({ channel, waitForDankMemer }) {
 
     await channel.send('pls work shift');
     current = await waitForDankMemer(10000);
-    if (!current) return { result: 'no response after apply', coins: 0 };
+  if (!current) return { result: 'no response after apply', coins: 0, nextCooldownSec: 180 };
     if (isCV2(current)) await ensureCV2(current);
     logMsg(current, 'work-after-apply');
     text = getFullText(current);
@@ -425,7 +449,7 @@ async function runWorkShift({ channel, waitForDankMemer }) {
     return { result: 'work shift completed', coins: 0, nextCooldownSec: finalCd || 3600 };
   }
 
-  return { result: `work done`, coins: 0, nextCooldownSec: finalCd || null };
+  return { result: `work done`, coins: 0, nextCooldownSec: finalCd || 1800 };
 }
 
 module.exports = { runWorkShift, autoApplyForJob, resignFromJob, JOBS };

package/lib/cooldownManager.js

@@ -0,0 +1,347 @@
+/**
+ * Advanced Cooldown Manager with Smart CD Calculations
+ *
+ * Features:
+ *   - EMA-based cooldown prediction (learns from history)
+ *   - Command chaining with optimal timing
+ *   - Priority queue for scheduling
+ *   - Redis-backed shared state (cluster mode)
+ *   - Predictive readiness estimation
+ */
+
+'use strict';
+
+const { LRUCache, MinHeap } = require('./structures');
+const { calcSmartCooldown } = require('./antiDetect');
+
+// ── Command Cooldown Config ───────────────────────────────────
+const COMMAND_CONFIG = Object.freeze({
+  // Base cooldowns in seconds
+  beg: { base: 120, priority: 3, category: 'income' },
+  crime: { base: 1200, priority: 2, category: 'income' },
+  search: { base: 150, priority: 3, category: 'income' },
+  work: { base: 3600, priority: 1, category: 'income' },
+  dig: { base: 600, priority: 2, category: 'income' },
+  fish: { base: 900, priority: 2, category: 'income' },
+  hunt: { base: 120, priority: 3, category: 'income' },
+  farm: { base: 300, priority: 2, category: 'income' },
+  stream: { base: 120, priority: 3, category: 'income' },
+  trivia: { base: 180, priority: 2, category: 'income' },
+  highlow: { base: 120, priority: 2, category: 'income' },
+  gamble: { base: 30, priority: 1, category: 'gambling' },
+  blackjack: { base: 30, priority: 1, category: 'gambling' },
+  roulette: { base: 30, priority: 1, category: 'gambling' },
+  slots: { base: 30, priority: 1, category: 'gambling' },
+  adventure: { base: 1800, priority: 1, category: 'special' },
+  postmeme: { base: 300, priority: 2, category: 'social' },
+  meme: { base: 300, priority: 2, category: 'social' },
+  vote: { base: 7200, priority: 1, category: 'special' },
+  daily: { base: 86400, priority: 1, category: 'special' },
+  weekly: { base: 604800, priority: 1, category: 'special' },
+  monthly: { base: 2592000, priority: 1, category: 'special' },
+});
+
+// ── EMA Calculator ────────────────────────────────────────────
+/**
+ * Exponential Moving Average for cooldown prediction.
+ * Gives more weight to recent observations.
+ */
+class EMACalculator {
+  constructor(alpha = 0.3) {
+    this.alpha = alpha;  // Smoothing factor (0-1)
+    this.ema = null;
+  }
+
+  update(value) {
+    if (this.ema === null) {
+      this.ema = value;
+    } else {
+      this.ema = this.alpha * value + (1 - this.alpha) * this.ema;
+    }
+    return this.ema;
+  }
+
+  getPrediction() {
+    return this.ema;
+  }
+
+  reset() {
+    this.ema = null;
+  }
+}
+
+// ── Cooldown Tracker ──────────────────────────────────────────
+class CooldownTracker {
+  constructor(userId, redis = null, clusterEnabled = false) {
+    this.userId = userId;
+    this.redis = redis;
+    this.clusterEnabled = clusterEnabled;
+
+    // Local caches
+    this.cooldowns = new Map();  // command -> readyAt (timestamp)
+    this.emaTrackers = new Map();  // command -> EMACalculator
+    this.historyCache = new LRUCache(50);  // Last 50 cooldown observations per command
+  }
+
+  /**
+   * Record a cooldown for a command.
+   * @param {string} command - Command name
+   * @param {number} cooldownSec - Observed cooldown in seconds
+   */
+  recordCooldown(command, cooldownSec) {
+    const now = Date.now();
+    const readyAt = now + (cooldownSec * 1000);
+
+    // Store in local map
+    this.cooldowns.set(command, readyAt);
+
+    // Update EMA prediction
+    if (!this.emaTrackers.has(command)) {
+      this.emaTrackers.set(command, new EMACalculator(0.3));
+    }
+    const ema = this.emaTrackers.get(command);
+    ema.update(cooldownSec);
+
+    // Store in Redis for cluster mode
+    if (this.redis && this.clusterEnabled) {
+      const key = `dkg:cd:${this.userId}:${command}`;
+      this.redis.setex(key, cooldownSec + 60, JSON.stringify({
+        readyAt,
+        ema: ema.getPrediction(),
+        recorded: now,
+      })).catch(() => {});
+    }
+
+    // Cache history
+    const history = this.historyCache.get(command) || [];
+    history.push({ cooldownSec, timestamp: now });
+    if (history.length > 50) history.shift();
+    this.historyCache.set(command, history);
+  }
+
+  /**
+   * Check if a command is ready.
+   * @param {string} command - Command name
+   * @returns {Object} - { ready: boolean, waitMs: number, predicted: number|null }
+   */
+  isReady(command) {
+    const readyAt = this.cooldowns.get(command);
+    if (!readyAt) {
+      return { ready: true, waitMs: 0, predicted: null };
+    }
+
+    const now = Date.now();
+    const waitMs = Math.max(0, readyAt - now);
+
+    // Add smart buffer
+    const config = COMMAND_CONFIG[command];
+    if (config) {
+      const buffered = calcSmartCooldown(waitMs / 1000, { addBuffer: true, addVariance: false });
+      return {
+        ready: waitMs <= 0,
+        waitMs: waitMs > 0 ? buffered * 1000 : 0,
+        predicted: this.emaTrackers.get(command)?.getPrediction() || null,
+      };
+    }
+
+    return {
+      ready: waitMs <= 0,
+      waitMs,
+      predicted: this.emaTrackers.get(command)?.getPrediction() || null,
+    };
+  }
+
+  /**
+   * Get predicted cooldown for a command.
+   * @param {string} command - Command name
+   * @returns {number|null} - Predicted cooldown in seconds
+   */
+  getPredictedCooldown(command) {
+    return this.emaTrackers.get(command)?.getPrediction() || null;
+  }
+
+  /**
+   * Get optimal command order based on cooldowns.
+   * @param {string[]} commands - List of commands to consider
+   * @returns {Array} - Sorted commands with timing info
+   */
+  getOptimalOrder(commands) {
+    const now = Date.now();
+    const order = commands.map(cmd => {
+      const config = COMMAND_CONFIG[cmd] || { priority: 5 };
+      const status = this.isReady(cmd);
+      return {
+        command: cmd,
+        ready: status.ready,
+        waitMs: status.waitMs,
+        priority: config.priority,
+        category: config.category,
+        predicted: status.predicted,
+      };
+    });
+
+    // Sort: ready commands first (by priority), then by wait time
+    order.sort((a, b) => {
+      if (a.ready && !b.ready) return -1;
+      if (!a.ready && b.ready) return 1;
+      if (a.ready && b.ready) return a.priority - b.priority;
+      return a.waitMs - b.waitMs;
+    });
+
+    return order;
+  }
+
+  /**
+   * Get all commands that will be ready within a time window.
+   * @param {number} windowMs - Time window in milliseconds
+   * @returns {Array} - Commands ready within window
+   */
+  getReadyInWindow(windowMs) {
+    const now = Date.now();
+    const ready = [];
+
+    for (const [command, readyAt] of this.cooldowns.entries()) {
+      const waitMs = readyAt - now;
+      if (waitMs <= windowMs) {
+        ready.push({
+          command,
+          waitMs: Math.max(0, waitMs),
+          readyAt,
+        });
+      }
+    }
+
+    ready.sort((a, b) => a.waitMs - b.waitMs);
+    return ready;
+  }
+
+  /**
+   * Clear cooldown for a command.
+   * @param {string} command - Command name
+   */
+  clearCooldown(command) {
+    this.cooldowns.delete(command);
+  }
+
+  /**
+   * Clear all cooldowns.
+   */
+  clearAll() {
+    this.cooldowns.clear();
+  }
+}
+
+// ── Command Scheduler (Priority Queue) ────────────────────────
+class CommandScheduler {
+  constructor(tracker) {
+    this.tracker = tracker;
+    this.queue = new MinHeap((a, b) => a.executeAt - b.executeAt);
+    this.pending = new Map();  // command -> node reference
+  }
+
+  /**
+   * Schedule a command for execution.
+   * @param {string} command - Command name
+   * @param {Function} executeFn - Function to execute
+   * @param {number} executeAt - Timestamp to execute at
+   */
+  schedule(command, executeFn, executeAt) {
+    // Remove existing scheduled command if any
+    this.unschedule(command);
+
+    const node = {
+      command,
+      executeFn,
+      executeAt,
+      added: Date.now(),
+    };
+
+    this.queue.push(node);
+    this.pending.set(command, node);
+
+    return node;
+  }
+
+  /**
+   * Cancel a scheduled command.
+   * @param {string} command - Command name
+   */
+  unschedule(command) {
+    const node = this.pending.get(command);
+    if (node) {
+      this.queue.remove(node);
+      this.pending.delete(command);
+    }
+  }
+
+  /**
+   * Get next command to execute.
+   * @returns {Object|null} - Next command node or null
+   */
+  peekNext() {
+    return this.queue.peek();
+  }
+
+  /**
+   * Execute next command if it's time.
+   * @returns {Object|null} - Executed command node or null
+   */
+  async executeNext() {
+    const node = this.queue.peek();
+    if (!node) return null;
+
+    const now = Date.now();
+    if (node.executeAt <= now) {
+      this.queue.pop();
+      this.pending.delete(node.command);
+
+      try {
+        await node.executeFn();
+        return node;
+      } catch (e) {
+        console.error(`[scheduler] Error executing ${node.command}:`, e);
+        throw e;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get queue size.
+   */
+  size() {
+    return this.queue.size();
+  }
+}
+
+// ── Factory Function ──────────────────────────────────────────
+/**
+ * Create a cooldown manager for a user.
+ * @param {string} userId - User ID
+ * @param {Object} options
+ * @param {Object} options.redis - Redis client (optional)
+ * @param {boolean} options.clusterEnabled - Cluster mode flag
+ * @returns {Object} - { tracker, scheduler, COMMAND_CONFIG }
+ */
+function createCooldownManager(userId, options = {}) {
+  const { redis = null, clusterEnabled = false } = options;
+
+  const tracker = new CooldownTracker(userId, redis, clusterEnabled);
+  const scheduler = new CommandScheduler(tracker);
+
+  return {
+    tracker,
+    scheduler,
+    COMMAND_CONFIG,
+  };
+}
+
+// ── Exports ───────────────────────────────────────────────────
+module.exports = {
+  EMACalculator,
+  CooldownTracker,
+  CommandScheduler,
+  createCooldownManager,
+  COMMAND_CONFIG,
+};

package/lib/grinder.js

@@ -316,37 +316,48 @@ function renderDashboard() {
   const tw = Math.min(process.stdout.columns || 80, 78);
   const thinBar = c.dim + '─'.repeat(tw) + c.reset;
   const bar = rgb(139, 92, 246) + c.bold + '━'.repeat(tw) + c.reset;
+  const doubleBar = rgb(139, 92, 246) + '╔' + '═'.repeat(tw - 2) + '╗' + c.reset;
+  const doubleBarBot = rgb(139, 92, 246) + '╚' + '═'.repeat(tw - 2) + '╝' + c.reset;
 
   // Header with dynamic version, command count, and status
-  lines.push(bar);
+  lines.push(doubleBar);
   const cmdCount = AccountWorker.COMMAND_MAP.length;
   const activeCount = workers.filter(w => w.running && !w.paused && !w.dashboardPaused).length;
   const mode = CLUSTER_ENABLED ? `${rgb(34, 211, 238)}Cluster${c.reset}` : `${c.dim}Standalone${c.reset}`;
+
+  // Animated spinner based on time
+  const spinners = ['◐', '◓', '◑', '◒'];
+  const spinner = spinners[Math.floor(Date.now() / 250) % 4];
+  const animatedSpinner = `${rgb(52, 211, 153)}${spinner}${c.reset}`;
+
   lines.push(
     `  ${rgb(139, 92, 246)}${c.bold}DankGrinder${c.reset} ${c.dim}v${PKG_VERSION}${c.reset}` +
     `  ${c.dim}·${c.reset}  ${c.white}${cmdCount} Cmds${c.reset}` +
     `  ${c.dim}·${c.reset}  ${mode}` +
-    `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}${activeCount}${c.reset}${c.dim}/${c.reset}${c.white}${workers.length}${c.reset} ${c.dim}Live${c.reset}`
+    `  ${c.dim}·${c.reset}  ${animatedSpinner} ${rgb(52, 211, 153)}${activeCount}${c.reset}${c.dim}/${c.reset}${c.white}${workers.length}${c.reset} ${c.dim}Live${c.reset}`
   );
 
-  // Stats row
-  const liveIcon = rgb(52, 211, 153) + '◉' + c.reset;
+  // Stats row with enhanced visual indicators
+  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 earnStr = `${rgb(52, 211, 153)}▲ ${formatCoins(totalCoins)}${c.reset}`;
   // Coins/hour rate
   const elapsedHrs = (Date.now() - startTime) / 3_600_000;
   const coinsPerHr = elapsedHrs > 0.01 ? Math.round(totalCoins / elapsedHrs) : 0;
   const rateLabel = `${rgb(52, 211, 153)}${formatCoins(coinsPerHr)}/h${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}`;
-  // Memory usage (RSS in MB)
+    ? `${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}`;
+  // Memory usage (RSS in MB) with bar indicator
   const memMB = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
+  const memPct = Math.min(100, (memMB / 1024) * 100);
+  const memBarWidth = Math.floor((memPct / 100) * 10);
+  const memBar = rgb(52, 211, 153) + '▅'.repeat(memBarWidth) + c.dim + '▅'.repeat(10 - memBarWidth) + c.reset;
   const memColor = memMB > 900 ? rgb(239, 68, 68) : memMB > 600 ? rgb(251, 191, 36) : rgb(52, 211, 153);
-  const memStr = `${memColor}${memMB}MB${c.reset}`;
+  const memStr = `${memColor}${memMB}MB${c.reset} ${memBar}`;
   // Commands/minute from SlidingWindowCounter
   const cpmVal = globalCmdRate.getRate().toFixed(1);
   const cpmStr = `${rgb(34, 211, 238)}${cpmVal}${c.reset}${c.dim}/m${c.reset}`;
@@ -394,9 +405,16 @@ function renderDashboard() {
     const bal = wk.stats.balance > 0
       ? `${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).padStart(6)}${c.reset}`
-      : `${c.dim}     +0${c.reset}`;
+
+    // Mini progress bar for earned coins (visual indicator of activity)
+    const earnedNum = wk.stats.coins || 0;
+    const earnedBarWidth = earnedNum > 0 ? Math.min(5, Math.max(1, Math.floor(Math.log10(earnedNum + 1)))) : 0;
+    const earnedBar = earnedNum > 0
+      ? `${rgb(52, 211, 153)}${'▰'.repeat(earnedBarWidth)}${c.dim}${'▱'.repeat(5 - earnedBarWidth)}${c.reset}`
+      : `${c.dim}▱▱▱▱▱${c.reset}`;
+    const earned = earnedNum > 0
+      ? `${rgb(52, 211, 153)}+${formatCoins(earnedNum)}${c.reset} ${earnedBar}`
+      : `${c.dim}+0${c.reset} ${earnedBar}`;
 
     lines.push(`  ${dot} ${name.padEnd(nameWidth + wk.color.length + c.bold.length + c.reset.length)} ${bal}  ${earned}  ${stateLabel}`);
   };
@@ -451,7 +469,7 @@ function renderDashboard() {
     }
   }
 
-  lines.push(bar);
+  lines.push(doubleBarBot);
 
   // Absolute cursor home — always draw from row 1
   process.stdout.write('\x1b[H');
@@ -764,6 +782,13 @@ class MinHeap {
 // ══════════════════════════════════════════════════════════════
 
 class AccountWorker {
+  static SMART_CD_FLOORS = Object.freeze({
+    'farm': 30,
+    'adventure': 300,
+    'stream': 600,
+    'work shift': 1800,
+  });
+
   constructor(account, idx) {
     this.account = account;
     this.idx = idx;
@@ -1147,7 +1172,7 @@ class AccountWorker {
           lastErr = e;
           if (attempt < tries) {
             this.log('warn', `Inventory attempt ${attempt}/${tries} failed (${e.message}). Retrying...`);
-            await sleep(1500 + Math.floor(Math.random() * 1500));
+            await new Promise((r) => setTimeout(r, 1500 + Math.floor(Math.random() * 1500)));
             continue;
           }
         }
@@ -1667,7 +1692,7 @@ class AccountWorker {
     { key: 'cmd_snakeeyes', cmd: 'snakeeyes',   cdKey: 'cd_snakeeyes', defaultCd: 3,      priority: 7 },
     // Fast grinders — 10s CD
     { key: 'cmd_hl',        cmd: 'hl',          cdKey: 'cd_hl',        defaultCd: 10,     priority: 6 },
-    { key: 'cmd_farm',      cmd: 'farm',        cdKey: 'cd_farm',      defaultCd: 10,     priority: 6 },
+  { key: 'cmd_farm',      cmd: 'farm',        cdKey: 'cd_farm',      defaultCd: 30,     priority: 4 },
     { key: 'cmd_trivia',    cmd: 'trivia',      cdKey: 'cd_trivia',    defaultCd: 10,     priority: 6 },
     { key: 'cmd_use',       cmd: 'use',         cdKey: 'cd_use',       defaultCd: 10,     priority: 2 },
     // Medium grinders — 20-25s CD
@@ -1681,10 +1706,10 @@ class AccountWorker {
     { key: 'cmd_crime',     cmd: 'crime',       cdKey: 'cd_crime',     defaultCd: 40,     priority: 5 },
     { key: 'cmd_tidy',      cmd: 'tidy',        cdKey: 'cd_tidy',      defaultCd: 40,     priority: 2 },
     // Interactive — response-driven CD (handler sets nextCooldownSec)
-    { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 10,     priority: 3 },
-    { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',    defaultCd: 10,     priority: 3 },
+  { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 300,    priority: 3 },
+  { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',    defaultCd: 600,    priority: 3 },
     { key: 'cmd_scratch',   cmd: 'scratch',     cdKey: 'cd_scratch',   defaultCd: 10,     priority: 3 },
-    { key: 'cmd_work',      cmd: 'work shift',  cdKey: 'cd_work',      defaultCd: 10,     priority: 3 },
+  { key: 'cmd_work',      cmd: 'work shift',  cdKey: 'cd_work',      defaultCd: 1800,   priority: 3 },
     // Time-gated (run ASAP when available)
     { key: 'cmd_daily',     cmd: 'daily',       cdKey: 'cd_daily',     defaultCd: 86400,  priority: 10 },
     { key: 'cmd_weekly',    cmd: 'weekly',       cdKey: 'cd_weekly',    defaultCd: 604800, priority: 10 },
@@ -2029,8 +2054,6 @@ class AccountWorker {
     const microPause = Math.random() < 0.08 ? 1.5 + Math.random() * 3 : 0;
     const totalWait = cd + jitterBase + microPause;
 
-    await this.setCooldown(item.cmd, totalWait);
-
     const timeSinceLastCmd = now - (this.lastCommandRun || 0);
     const gapBase = cd <= 5 ? 1500 : cd <= 20 ? 2000 : 2500;
     const jitterGap = patternMod.minDelay + Math.random() * (patternMod.maxDelay - patternMod.minDelay);
@@ -2059,7 +2082,7 @@ class AccountWorker {
     // Grace period for interactive (button-click) commands — Dank Memer
     // needs time to process the interaction before accepting the next command.
     // Without this, the next command gets "Hold Tight" errors.
-    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'scratch', 'adventure', 'stream', 'fish']);
+    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'scratch', 'adventure', 'stream', 'fish', 'farm', 'work shift']);
     if (INTERACTIVE_CMDS.has(item.cmd)) {
       await new Promise(r => setTimeout(r, 2500 + Math.random() * 1500));
     }
@@ -2078,8 +2101,7 @@ class AccountWorker {
       this.failStreak = 0;
     }
 
-    this.lastCommandRun = Date.now();
-    await this.setCooldown(item.cmd, totalWait);
+  this.lastCommandRun = Date.now();
 
     // Exponential backoff: if too many consecutive failures, slow down
     const backoffMultiplier = this.failStreak > 5 ? Math.min(this.failStreak - 4, 5) : 1;
@@ -2087,12 +2109,25 @@ class AccountWorker {
     const MIN_FAIL_COOLDOWN = 5;
 
     if (this.commandQueue && this.running && !shutdownCalled) {
-      let effectiveWait = this._lastCooldownOverride || totalWait;
+      const hasOverride = Number.isFinite(this._lastCooldownOverride) && this._lastCooldownOverride > 0;
+      let effectiveWait = hasOverride ? this._lastCooldownOverride : totalWait;
       this._lastCooldownOverride = null;
+
+      // Smart fallback floors for long/interactive commands when parser misses exact cooldown.
+      if (!hasOverride) {
+        const floor = AccountWorker.SMART_CD_FLOORS[item.cmd];
+        if (Number.isFinite(floor) && floor > 0) {
+          effectiveWait = Math.max(effectiveWait, floor);
+        }
+      }
+
       if (earned <= 0 && !noFailCmds.includes(item.cmd) && effectiveWait < MIN_FAIL_COOLDOWN) {
         effectiveWait = MIN_FAIL_COOLDOWN;
       }
-      item.nextRunAt = Date.now() + effectiveWait * 1000 * backoffMultiplier;
+
+      const scheduledWaitSec = Math.max(1, effectiveWait * backoffMultiplier);
+      await this.setCooldown(item.cmd, scheduledWaitSec);
+      item.nextRunAt = Date.now() + scheduledWaitSec * 1000;
       this.commandQueue.push(item);
     }
 
@@ -2438,17 +2473,31 @@ async function start(apiKey, apiUrl) {
   console.log('');
 
   // Phase 1: Login all accounts (staggered to avoid 429s)
-  const BATCH_SIZE = 5;
-  const BATCH_DELAY_MS = 3000;
+  const LOGIN_PROGRESS_EVERY = 5;
+  const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '100'), 10);
+  const parsedGapMax = Number.parseInt(String(process.env.LOGIN_GAP_MAX_MS || '300'), 10);
+  const LOGIN_GAP_MIN_MS = Number.isFinite(parsedGapMin) && parsedGapMin >= 0 ? parsedGapMin : 100;
+  const LOGIN_GAP_MAX_MS = Number.isFinite(parsedGapMax) && parsedGapMax >= LOGIN_GAP_MIN_MS ? parsedGapMax : Math.max(LOGIN_GAP_MIN_MS, 300);
+
+  const randomLoginGap = () => {
+    if (LOGIN_GAP_MAX_MS <= LOGIN_GAP_MIN_MS) return LOGIN_GAP_MIN_MS;
+    return LOGIN_GAP_MIN_MS + Math.floor(Math.random() * (LOGIN_GAP_MAX_MS - LOGIN_GAP_MIN_MS + 1));
+  };
+
   for (let i = 0; i < accounts.length; i++) {
     if (shutdownCalled) break;
     const worker = new AccountWorker(accounts[i], i);
     workers.push(worker);
     workerMap.set(accounts[i].id, worker);
     await worker.start();
-    if ((i + 1) % BATCH_SIZE === 0 && i + 1 < accounts.length) {
-      log('info', `${c.dim}Logged in ${i + 1}/${accounts.length}, next batch in ${BATCH_DELAY_MS / 1000}s...${c.reset}`);
-      await new Promise(r => setTimeout(r, BATCH_DELAY_MS));
+    if (i + 1 < accounts.length) {
+      const gapMs = randomLoginGap();
+      if ((i + 1) % LOGIN_PROGRESS_EVERY === 0) {
+        log('info', `${c.dim}Logged in ${i + 1}/${accounts.length}, next account in ${gapMs}ms...${c.reset}`);
+      }
+      await new Promise(r => setTimeout(r, gapMs));
+    }
+    if ((i + 1) % LOGIN_PROGRESS_EVERY === 0) {
       hintGC();
     }
   }

package/package.json

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