dankgrinder 5.24.0 → 5.260.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/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 };