dankgrinder 6.8.1 → 6.14.0

package/lib/commands/highlow.js

@@ -1,21 +1,22 @@
 /**
  * HighLow command handler.
  * Strategy: if hint > 50 → lower, if hint < 50 → higher, if exactly 50 → jackpot.
+ * Fast clicks with retry.
  */
 
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  logMsg, isHoldTight, getHoldTightReason, sleep,
 } = require('./utils');
 
-// Pre-compiled regex — avoid V8 recompilation on every call
 const RE_HINT_BOLD = /hint.*?\*\*(\d+)\*\*/i;
 const RE_NUMBER_BOLD = /number.*?\*\*(\d+)\*\*/i;
 const RE_HINT_PLAIN = /hint.*?(\d+)/i;
 const RE_NUMBER_PLAIN = /number.*?(\d+)/i;
 const RE_STANDALONE_NUM = /\b(\d{1,3})\b/g;
 const RE_HL_NET = /Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i;
-const RE_HL_WIN = /Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([\d,]+)/i;
+const RE_HL_WIN = /(?:Winnings|won)\s*\*{0,2}\s*[⏣]?\s*\*{0,2}([\d,]+)/i;
+const RE_HL_WON = /won\s+[⏣]\s*([\d,]+)/i;
 
 function parseHintNumber(text) {
   const hintMatch = text.match(RE_HINT_BOLD)
@@ -23,11 +24,13 @@ function parseHintNumber(text) {
     || text.match(RE_HINT_PLAIN)
     || text.match(RE_NUMBER_PLAIN);
   if (hintMatch) return parseInt(hintMatch[1]);
+
+  // Fallback: find a number 1-100 in the text
   RE_STANDALONE_NUM.lastIndex = 0;
   const nums = text.match(RE_STANDALONE_NUM);
   if (nums) {
-    for (let i = 0; i < nums.length; i++) {
-      const v = parseInt(nums[i]);
+    for (const n of nums) {
+      const v = parseInt(n);
       if (v >= 1 && v <= 100) return v;
     }
   }
@@ -35,6 +38,9 @@ function parseHintNumber(text) {
 }
 
 function parseNetCoins(text) {
+  // Try "You won ⏣ 6,303" first
+  const wonMatch = text.match(RE_HL_WON);
+  if (wonMatch) return parseInt(wonMatch[1].replace(/,/g, ''));
   const netMatch = text.match(RE_HL_NET);
   if (netMatch) return parseInt(netMatch[1].replace(/,/g, ''));
   const winMatch = text.match(RE_HL_WIN);
@@ -42,12 +48,31 @@ function parseNetCoins(text) {
   return 0;
 }
 
+// Fast click with retry
+async function clickFast(msg, btn, retries = 2) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      await sleep(50 + Math.random() * 100); // 50-150ms
+      const result = await safeClickButton(msg, btn);
+      if (result) return result;
+    } catch (e) {
+      if (attempt === retries) {
+        LOG.error(`[hl] Click failed: ${e.message}`);
+        return null;
+      }
+      await sleep(200);
+    }
+  }
+  return null;
+}
+
 async function playHighLow(response, depth = 0) {
   if (!response || depth > 5) return { result: 'done', coins: 0 };
 
   const text = getFullText(response);
   const buttons = getAllButtons(response);
 
+  // Game over — no buttons or all disabled
   if (buttons.length === 0 || buttons.every(b => b.disabled)) {
     const net = parseNetCoins(text);
     const coins = net > 0 ? net : parseCoins(text);
@@ -64,7 +89,7 @@ async function playHighLow(response, depth = 0) {
     } else if (hint < 50) {
       targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('higher'));
     } else {
-      // Exactly 50 — try jackpot, fallback to higher (slightly better odds)
+      // 50 = jackpot attempt, fallback to higher
       targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('jackpot'))
         || buttons.find(b => (b.label || '').toLowerCase().includes('higher'));
     }
@@ -72,7 +97,7 @@ async function playHighLow(response, depth = 0) {
     LOG.info(`[hl] Hint: ${hint} → ${targetBtn?.label || '?'}`);
   } else {
     targetBtn = buttons.find(b => !b.disabled) || buttons[0];
-    LOG.info(`[hl] No hint parsed → ${targetBtn?.label || '?'}`);
+    LOG.info(`[hl] No hint → ${targetBtn?.label || '?'}`);
   }
 
   if (!targetBtn || targetBtn.disabled) {
@@ -80,27 +105,22 @@ async function playHighLow(response, depth = 0) {
     return { result: 'buttons disabled', coins };
   }
 
-  await humanDelay(150, 400);
-
-  try {
-    const followUp = await safeClickButton(response, targetBtn);
-    if (followUp) {
-      logMsg(followUp, `hl-round-${depth}`);
-      const fText = getFullText(followUp);
-
-      const moreButtons = getAllButtons(followUp);
-      if (moreButtons.length >= 2 && !moreButtons.every(b => b.disabled)) {
-        return playHighLow(followUp, depth + 1);
-      }
+  const followUp = await clickFast(response, targetBtn);
+  if (followUp) {
+    logMsg(followUp, `hl-round-${depth}`);
+    const fText = getFullText(followUp);
 
-      // Final round — parse net earnings
-      const net = parseNetCoins(fText);
-      const coins = net > 0 ? net : parseCoins(fText);
-      const lost = net < 0 ? Math.abs(net) : 0;
-      return { result: `${targetBtn.label} → ${coins > 0 ? '+⏣ ' + coins.toLocaleString() : 'done'}`, coins, lost };
+    // Check if there are more rounds
+    const moreButtons = getAllButtons(followUp);
+    if (moreButtons.length >= 2 && !moreButtons.every(b => b.disabled)) {
+      return playHighLow(followUp, depth + 1);
     }
-  } catch (e) {
-    LOG.error(`[hl] Click error: ${e.message}`);
+
+    // Final round — parse result
+    const net = parseNetCoins(fText);
+    const coins = net > 0 ? net : parseCoins(fText);
+    const lost = net < 0 ? Math.abs(net) : 0;
+    return { result: `${targetBtn.label} → ${coins > 0 ? '+⏣ ' + coins.toLocaleString() : 'done'}`, coins, lost };
   }
 
   return { result: 'done', coins: 0 };
@@ -110,7 +130,7 @@ async function runHighLow({ channel, waitForDankMemer }) {
   LOG.cmd(`${c.white}${c.bold}pls hl${c.reset}`);
 
   await channel.send('pls hl');
-  const response = await waitForDankMemer(10000);
+  const response = await waitForDankMemer(12000);
 
   if (!response) {
     LOG.warn('[hl] No response');
@@ -119,7 +139,7 @@ async function runHighLow({ channel, waitForDankMemer }) {
 
   if (isHoldTight(response)) {
     const reason = getHoldTightReason(response);
-    LOG.warn(`[hl] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    LOG.warn(`[hl] Hold Tight${reason ? ` (/${reason})` : ''} — waiting 30s`);
     await sleep(30000);
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }

package/lib/commands/hunt.js

@@ -1,26 +1,87 @@
 /**
  * Hunt command handler.
  * Send "pls hunt", detect if rifle is missing, auto-buy if needed.
+ * Handles dragon fireball dodge minigame (Left/Middle/Right).
  */
 
 const {
-  LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
   isCV2, ensureCV2, stripAnsi,
 } = require('./utils');
 const { buyItem } = require('./shop');
 
+// Fast click with retry
+async function clickFast(msg, btn, retries = 2) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      await sleep(50 + Math.random() * 100);
+      const result = await safeClickButton(msg, btn);
+      if (result) return result;
+    } catch (e) {
+      if (attempt === retries) {
+        LOG.error(`[hunt] Click failed: ${e.message}`);
+        return null;
+      }
+      await sleep(200);
+    }
+  }
+  return null;
+}
+
 /**
- * @param {object} opts
- * @param {object} opts.channel
- * @param {function} opts.waitForDankMemer
- * @param {object} [opts.client] - Discord client for modal handling
- * @returns {Promise<{result: string, coins: number, needsRifle: boolean}>}
+ * Dragon fireball dodge minigame.
+ * The embed description has emoji layout showing where the dragon is.
+ * Dragon can be on left, middle, or right — pick a different lane.
+ *
+ * Pattern: Dragon emoji in the description indicates its position.
+ * - If dragon is on the left side → pick Middle or Right
+ * - If dragon is on the right side → pick Left or Middle
+ * - If dragon is in the middle → pick Left or Right
+ * - Default: pick randomly
  */
+function detectDragonPosition(text) {
+  const lower = (text || '').toLowerCase();
+  // Look at the line with the dragon emoji
+  // Format: # <emptyspace><emptyspace><Dragon>  (right)
+  // Format: # <Dragon><emptyspace><emptyspace>  (left)
+  // Format: # <emptyspace><Dragon><emptyspace>  (middle)
+  const lines = text.split('\n');
+  for (const line of lines) {
+    if (!line.includes('Dragon') && !line.includes('dragon') && !line.includes('Fireball') && !line.includes('fireball')) continue;
+    // Count position of dragon relative to emptyspace
+    const parts = line.split(/[<>]+/).filter(p => p.includes('Dragon') || p.includes('emptyspace'));
+    let dragonIdx = -1;
+    let total = 0;
+    for (let i = 0; i < parts.length; i++) {
+      if (parts[i].includes('Dragon') || parts[i].includes('dragon')) dragonIdx = total;
+      total++;
+    }
+    if (dragonIdx === 0) return 'left';
+    if (dragonIdx >= total - 1) return 'right';
+    return 'middle';
+  }
+  return null;
+}
+
+function pickDodgeLane(dragonPos, buttons) {
+  const labels = buttons.map(b => (b.label || '').toLowerCase());
+  const leftBtn = buttons.find(b => (b.label || '').toLowerCase() === 'left');
+  const midBtn = buttons.find(b => (b.label || '').toLowerCase() === 'middle');
+  const rightBtn = buttons.find(b => (b.label || '').toLowerCase() === 'right');
+
+  if (dragonPos === 'left') return midBtn || rightBtn || buttons[1] || buttons[0];
+  if (dragonPos === 'right') return leftBtn || midBtn || buttons[0] || buttons[1];
+  if (dragonPos === 'middle') return leftBtn || rightBtn || buttons[0] || buttons[2];
+  // Unknown position — pick randomly from non-middle (safer)
+  return buttons[Math.floor(Math.random() * buttons.length)];
+}
+
 async function runHunt({ channel, waitForDankMemer, client }) {
   LOG.cmd(`${c.white}${c.bold}pls hunt${c.reset}`);
 
   await channel.send('pls hunt');
-  const response = await waitForDankMemer(10000);
+  const response = await waitForDankMemer(12000);
 
   if (!response) {
     LOG.warn('[hunt] No response');
@@ -29,7 +90,7 @@ async function runHunt({ channel, waitForDankMemer, client }) {
 
   if (isHoldTight(response)) {
     const reason = getHoldTightReason(response);
-    LOG.warn(`[hunt] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    LOG.warn(`[hunt] Hold Tight${reason ? ` (/${reason})` : ''} — waiting 30s`);
     await sleep(30000);
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, needsRifle: false, holdTightReason: reason };
   }
@@ -39,47 +100,107 @@ async function runHunt({ channel, waitForDankMemer, client }) {
   const text = getFullText(response);
   const cleanText = stripAnsi(text).replace(/\s+/g, ' ').trim();
   const textLower = cleanText.toLowerCase();
-  const missing = needsItem(cleanText);
 
+  // Check for missing rifle
+  const missing = needsItem(cleanText);
   const rifleMissing = missing === 'hunting rifle'
-    || /(?:don['’]?t have|do not have|need|needs|requires?|missing|must have|you need|lack)\s+(?:a\s+)?(?:hunting\s+)?rifle/.test(textLower)
+    || /(?:don['']?t have|do not have|need|needs|requires?|missing|must have|you need|lack)\s+(?:a\s+)?(?:hunting\s+)?rifle/.test(textLower)
     || ((textLower.includes('following items') || textLower.includes('missing items')) && textLower.includes('rifle'));
 
-  // Check if we need a rifle
   if (rifleMissing) {
-    LOG.warn('[hunt] No rifle! Attempting to buy...');
-
-    const bought = await buyItem({
-      channel, waitForDankMemer, client,
-      itemName: 'Hunting Rifle',
-      quantity: 1,
-    });
-
+    LOG.warn('[hunt] No rifle! Buying...');
+    const bought = await buyItem({ channel, waitForDankMemer, client, itemName: 'Hunting Rifle', quantity: 1 });
     if (bought) {
-      LOG.success('[hunt] Rifle purchased! Re-running hunt...');
-      // Drain stale shop messages
-      while (await waitForDankMemer(1500)) { /* drain */ }
+      LOG.success('[hunt] Rifle bought! Retrying...');
+      while (await waitForDankMemer(1500)) {}
       await sleep(1000);
-
       await channel.send('pls hunt');
-      const r2 = await waitForDankMemer(10000);
+      const r2 = await waitForDankMemer(12000);
       if (r2) {
         if (isCV2(r2)) await ensureCV2(r2);
         logMsg(r2, 'hunt-retry');
-        const t2 = getFullText(r2);
-        const c2 = parseCoins(t2);
-        if (c2 > 0) {
-          LOG.coin(`[hunt] ${c.green}+⏣ ${c2.toLocaleString()}${c.reset}`);
-          return { result: `hunt → +⏣ ${c2.toLocaleString()}`, coins: c2, needsRifle: false };
-        }
-        return { result: stripAnsi(t2).replace(/\s+/g, ' ').trim().substring(0, 60), coins: 0, needsRifle: false };
+        // Handle minigame on retry too
+        return await handleHuntResponse(r2, channel, waitForDankMemer);
       }
       return { result: 'no response after rifle buy', coins: 0, needsRifle: false };
     }
-
     return { result: 'need rifle (buy failed)', coins: 0, needsRifle: true };
   }
 
+  return await handleHuntResponse(response, channel, waitForDankMemer);
+}
+
+async function handleHuntResponse(response, channel, waitForDankMemer) {
+  const text = getFullText(response);
+  const cleanText = stripAnsi(text).replace(/\s+/g, ' ').trim();
+  const textLower = cleanText.toLowerCase();
+
+  // Check for minigame buttons (dragon dodge, etc.)
+  const buttons = getAllButtons(response).filter(b => !b.disabled && b.label);
+  if (buttons.length >= 2) {
+    const labels = buttons.map(b => (b.label || '').toLowerCase());
+    const isDragonDodge = textLower.includes('dragon') || textLower.includes('fireball') || textLower.includes('dodge');
+    const isLaneGame = labels.includes('left') || labels.includes('middle') || labels.includes('right');
+
+    if (isDragonDodge && isLaneGame) {
+      // Dragon fireball dodge
+      const dragonPos = detectDragonPosition(text);
+      const btn = pickDodgeLane(dragonPos, buttons);
+      LOG.info(`[hunt] Dragon at ${dragonPos || '?'} → dodging "${btn.label}"`);
+      const followUp = await clickFast(response, btn);
+      if (followUp) {
+        logMsg(followUp, 'hunt-dodge');
+        const fText = getFullText(followUp);
+        const coins = parseCoins(fText);
+        if (coins > 0) {
+          LOG.coin(`[hunt] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+          return { result: `hunt dodge → +⏣ ${coins.toLocaleString()}`, coins, needsRifle: false };
+        }
+        return { result: stripAnsi(fText).replace(/\s+/g, ' ').trim().substring(0, 60) || 'dodged', coins: 0, needsRifle: false };
+      }
+      // Click didn't return followup — wait for edit
+      await sleep(2000);
+      try {
+        const edited = await channel.messages.fetch(response.id);
+        if (edited) {
+          const eText = getFullText(edited);
+          const coins = parseCoins(eText);
+          if (coins > 0) {
+            LOG.coin(`[hunt] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+            return { result: `hunt dodge → +⏣ ${coins.toLocaleString()}`, coins, needsRifle: false };
+          }
+          return { result: stripAnsi(eText).replace(/\s+/g, ' ').trim().substring(0, 60) || 'dodged', coins: 0, needsRifle: false };
+        }
+      } catch {}
+    } else {
+      // Generic minigame — click first available button
+      const btn = buttons[0];
+      LOG.info(`[hunt] Minigame → clicking "${btn.label}"`);
+      const followUp = await clickFast(response, btn);
+      if (followUp) {
+        logMsg(followUp, 'hunt-minigame');
+        const fText = getFullText(followUp);
+        const coins = parseCoins(fText);
+        return { result: stripAnsi(fText).replace(/\s+/g, ' ').trim().substring(0, 60), coins: coins || 0, needsRifle: false };
+      }
+    }
+  }
+
+  // Wait for message update (hunt animates sometimes)
+  await sleep(2000);
+  try {
+    const edited = await channel.messages.fetch(response.id);
+    if (edited) {
+      const eText = getFullText(edited);
+      const coins = parseCoins(eText);
+      if (coins > 0) {
+        LOG.coin(`[hunt] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+        return { result: `hunt → +⏣ ${coins.toLocaleString()}`, coins, needsRifle: false };
+      }
+      return { result: stripAnsi(eText).replace(/\s+/g, ' ').trim().substring(0, 60) || 'done', coins: 0, needsRifle: false };
+    }
+  } catch {}
+
   const coins = parseCoins(cleanText);
   if (coins > 0) {
     LOG.coin(`[hunt] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);

package/lib/commands/profile.js

@@ -12,8 +12,8 @@ const {
 const levelCache = {};
 const CACHE_TTL = 10 * 60 * 1000; // 10 minutes
 
-const RE_PROFILE_LEVEL = /(?:level|lvl)\s*:?\s*(\d+)/i;
-const RE_PROFILE_PRESTIGE_LEVEL = /prestige\s+\d+\s+level\s+(\d+)/i;
+const RE_PROFILE_LEVEL = /(?:level|lvl)\s*:?\s*`?(\d+)`?/i;
+const RE_PROFILE_PRESTIGE_LEVEL = /prestige\s+\d+\s+level\s+`?(\d+)`?/i;
 
 /**
  * Parse level from profile response text.
@@ -77,9 +77,10 @@ async function getPlayerLevel({ channel, waitForDankMemer, accountId = 'default'
   if (level !== null) {
     LOG.info(`[profile] Level: ${c.bold}${level}${c.reset}`);
     levelCache[accountId] = { level, checkedAt: Date.now() };
-    // Persist to Redis for 10 min
+    // Persist to Redis — longer TTL for higher levels since they only go up
     if (redis) {
-      try { await redis.set(`dkg:level:${accountId}`, String(level), 'EX', 600); } catch {}
+      const ttl = level >= 25 ? 2592000 : 600; // 30 days if ≥25, 10 min otherwise
+      try { await redis.set(`dkg:level:${accountId}`, String(level), 'EX', ttl); } catch {}
     }
   } else {
     LOG.warn(`[profile] Could not parse level from: ${text.substring(0, 100)}`);

package/lib/commands/search.js

@@ -130,6 +130,14 @@ async function runSearch({ channel, waitForDankMemer, safeAnswers }) {
       const locKey = (btn.label || '').toLowerCase();
       const prev = locationEarnings.get(locKey) || 0;
       locationEarnings.set(locKey, prev + coins);
+
+      // Check for death
+      const textLower = text.toLowerCase();
+      if (textLower.includes('you died') || textLower.includes('lifesaver protected')) {
+        LOG.error(`[search] DEATH DETECTED! Lifesaver may have been used.`);
+        return { result: `you died during search`, coins: 0, died: true };
+      }
+
       if (coins > 0) {
         LOG.coin(`[search] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
         return { result: `${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };

package/lib/commands/utils.js

@@ -11,6 +11,7 @@
 
 const https = require('https');
 const { AhoCorasick, LRUCache, StringPool, ObjectPool } = require('../structures');
+const rawLogger = require('../rawLogger');
 
 // ── HTTPS Keep-Alive Agent ───────────────────────────────────
 // At 10K accounts, every CV2 fetch without keep-alive creates a new
@@ -470,17 +471,29 @@ async function ensureCV2(msg, force = false) {
       delete msg._cv2EditedTs;
       cv2Cache.delete(msg.id);
     }
+
+    // ── PRIMARY: Use raw gateway logger (always has CV2 data) ──
+    const rawParsed = rawLogger.getRawMessage(msg.id);
+    if (rawParsed && rawParsed.components?.length > 0) {
+      msg._cv2 = rawParsed.components;
+      msg._cv2text = rawParsed.cv2Text || _extractCV2Text(rawParsed.components).trim();
+      msg._cv2buttons = rawParsed.buttons?.length > 0
+        ? rawParsed.buttons.map(b => ({ type: 'BUTTON', label: b.label, customId: b.customId, style: b.style, url: null, disabled: b.disabled, emoji: b.emoji, _raw: b }))
+        : _extractCV2Buttons(rawParsed.components);
+      msg._cv2EditedTs = msgEditedTs;
+      cv2Cache.set(msg.id, { components: rawParsed.components, editedTimestamp: msgEditedTs });
+      return msg;
+    }
+
+    // ── FALLBACK: LRU cache ──
     const token = msg.client?.token;
     const chId = msg.channelId || msg.channel?.id;
     if (!token || !chId) return msg;
 
-    // LRU cache hit — O(1) lookup avoids redundant HTTP fetches
     const cached = cv2Cache.get(msg.id);
     if (cached && !force) {
       const cachedComponents = Array.isArray(cached) ? cached : cached.components;
       const cachedEditedTs = Array.isArray(cached) ? null : (cached.editedTimestamp || null);
-
-      // If message has been edited since cache snapshot, ignore stale cache.
       if (!msgEditedTs || cachedEditedTs === msgEditedTs) {
         msg._cv2 = cachedComponents;
         msg._cv2text = _extractCV2Text(cachedComponents).trim();
@@ -490,6 +503,7 @@ async function ensureCV2(msg, force = false) {
       }
     }
 
+    // ── LAST RESORT: HTTP fetch (may fail for selfbot tokens) ──
     let raw = null;
     try {
       raw = await _httpGet(
@@ -501,11 +515,13 @@ async function ensureCV2(msg, force = false) {
     }
 
     if (!raw || !raw.components) {
-      const msgs = await _httpGet(
-        `https://discord.com/api/v9/channels/${chId}/messages?limit=5&around=${msg.id}`,
-        { Authorization: token }
-      );
-      raw = Array.isArray(msgs) ? msgs.find(m => m.id === msg.id) : null;
+      try {
+        const msgs = await _httpGet(
+          `https://discord.com/api/v9/channels/${chId}/messages?limit=5&around=${msg.id}`,
+          { Authorization: token }
+        );
+        raw = Array.isArray(msgs) ? msgs.find(m => m.id === msg.id) : null;
+      } catch { raw = null; }
     }
 
     if (raw?.components) {

package/lib/commands/work.js

@@ -27,6 +27,25 @@ 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;
 
+// Color-word pair parser for color memory minigame
+// Format: <:Black:123> `toddler`  <:Green:456> `pacifier`  <:White:789> `behave`
+const RE_COLOR_WORD = /<:(\w+):\d+>\s*`([^`]+)`/g;
+const KNOWN_COLORS = new Set(['black', 'green', 'white', 'yellow', 'red', 'blue', 'purple', 'orange', 'pink']);
+
+function parseColorWordPairs(text) {
+  const pairs = {};
+  let m;
+  const re = new RegExp(RE_COLOR_WORD.source, 'g');
+  while ((m = re.exec(text)) !== null) {
+    const color = m[1].toLowerCase();
+    const word = m[2].toLowerCase().trim();
+    if (KNOWN_COLORS.has(color)) {
+      pairs[word] = color;
+    }
+  }
+  return pairs;
+}
+
 function normalizeLower(text) {
   return String(text || '')
     .normalize('NFKC')
@@ -285,6 +304,63 @@ async function handleRepeatWord({ current, wordOrder }) {
   return current;
 }
 
+/**
+ * Handle the "Color Memory" minigame.
+ * Phase 1: Shows color-word pairs like <:Black:123> `toddler` <:Green:456> `pacifier`
+ * Phase 2: "What color was next to the word `behave`?" with color buttons
+ *
+ * We parse the pairs from Phase 1's raw embed description, then answer Phase 2.
+ */
+async function handleColorMemory({ channel, current, colorWordPairs, waitForDankMemer }) {
+  LOG.info(`[work] Color pairs: ${JSON.stringify(colorWordPairs)}`);
+  const msgId = current.id;
+
+  // Wait for Phase 2 — "What color was next to the word X?"
+  let phase2 = await waitForDankMemer(8000);
+  if (!phase2) phase2 = await refetchMsg(channel, msgId);
+  if (!phase2) {
+    LOG.warn('[work] No Phase 2 for color memory');
+    return current;
+  }
+
+  logMsg(phase2, 'work-color-phase2');
+  current = phase2;
+
+  const p2Text = getFullText(current);
+  const p2Lower = p2Text.toLowerCase();
+
+  // Extract the word being asked about: "What color was next to the word `behave`?"
+  const wordMatch = p2Text.match(/word\s*`([^`]+)`/i);
+  if (!wordMatch) {
+    LOG.warn('[work] Could not parse asked word from color memory');
+    return await handleGenericMinigame({ channel, current, waitForDankMemer });
+  }
+
+  const askedWord = wordMatch[1].toLowerCase().trim();
+  const correctColor = colorWordPairs[askedWord];
+  LOG.info(`[work] Asked: "${askedWord}" → color: "${correctColor || '?'}"`);
+
+  if (correctColor) {
+    const buttons = getAllButtons(current);
+    const btn = buttons.find(b => !b.disabled && (b.label || '').toLowerCase() === correctColor);
+    if (btn) {
+      LOG.info(`[work] Clicking "${btn.label}"`);
+      await sleep(50 + Math.random() * 100);
+      try {
+        const result = await safeClickButton(current, btn);
+        if (result) return result;
+      } catch (e) { LOG.error(`[work] Color click error: ${e.message}`); }
+      // Fallback: wait for update
+      await sleep(1500);
+      const updated = await refetchMsg(channel, msgId);
+      if (updated) return updated;
+    }
+  }
+
+  // Fallback: generic click
+  return await handleGenericMinigame({ channel, current, waitForDankMemer });
+}
+
 /**
  * Handle generic button-clicking minigame (color match, emoji match, etc.)
  * Falls back to clicking buttons in display order if we can't determine the game type.
@@ -385,7 +461,17 @@ async function runWorkShift({ channel, waitForDankMemer }) {
   const tLower = text.toLowerCase();
   const wordOrder = parseMemoryOrder(text);
 
-  if (wordOrder.length > 0 && tLower.includes('remember')) {
+  // Get raw embed description (preserves <:Color:ID> emoji format for color memory)
+  const rawEmbedDesc = (current.embeds?.[0]?.description || current.embeds?.[0]?.data?.description || '');
+  const colorWordPairs = parseColorWordPairs(rawEmbedDesc);
+  const hasColorPairs = Object.keys(colorWordPairs).length >= 2;
+
+  if (hasColorPairs && (tLower.includes('color') || tLower.includes('look at each color') || tLower.includes('closely'))) {
+    // Color Memory minigame — Phase 1: memorize color-word pairs
+    LOG.info(`[work] Minigame: Color Memory (${Object.keys(colorWordPairs).length} pairs)`);
+    current = await handleColorMemory({ channel, current, colorWordPairs, waitForDankMemer });
+
+  } else if (wordOrder.length > 0 && tLower.includes('remember')) {
     // Word Memory minigame — Phase 1: memorize order
     LOG.info(`[work] Minigame: Word Memory (${wordOrder.length} words)`);
     current = await handleWordMemory({ channel, current, wordOrder, waitForDankMemer });
@@ -408,13 +494,15 @@ async function runWorkShift({ channel, waitForDankMemer }) {
       current = phase2;
       logMsg(current, 'work-phase2');
       const p2Text = getFullText(current).toLowerCase();
+      const p2RawDesc = (current.embeds?.[0]?.description || current.embeds?.[0]?.data?.description || '');
 
-      if (p2Text.includes('correct order') || p2Text.includes('click the buttons')) {
-        // Word memory Phase 2 arrived — we have the word order from Phase 1
+      // Check if Phase 2 is a color memory question
+      if (p2Text.includes('what color') && hasColorPairs) {
+        current = await handleColorMemory({ channel, current: phase2, colorWordPairs, waitForDankMemer: async () => null });
+      } else if (p2Text.includes('correct order') || p2Text.includes('click the buttons')) {
         if (wordOrder.length > 0) {
           current = await handleWordMemory({ channel, current, wordOrder, waitForDankMemer });
         } else {
-          // Re-parse from Phase 2 if word order was in Phase 1 content
           current = await handleGenericMinigame({ channel, current, waitForDankMemer });
         }
       } else {