dankgrinder 7.6.0 → 7.7.0

package/lib/commands/farm.js

@@ -4,6 +4,7 @@ const {
   isCV2, ensureCV2, stripAnsi, needsItem, clickCV2SelectMenu,
 } = require('./utils');
 const { buyItem, buyItemsBatch } = require('./shop');
+const rawLogger = require('../../lib/rawLogger');
 const {
   downloadImage,
   extractFarmImageUrl,
@@ -938,6 +939,17 @@ function pickFarmActionButton(msg, text) {
   return null;
 }
 
+// Captures the ephemeral interaction response content from a CV2 ack object.
+// Dank Memer sends error/success text in the interaction ACK (type 4/7) content field.
+function captureCvvAckContent(ack) {
+  if (!ack) return '';
+  const flags = ack?.flags ?? ack?.data?.flags ?? 0;
+  const content = String(stripAnsi(ack?.content || ack?.data?.content || '')).trim();
+  if (!content) return '';
+  const isEphemeral = (flags & 64) !== 0;
+  return `[ephemeral=${isEphemeral}] ${content}`;
+}
+
 async function clickAndCapture({ channel, waitForDankMemer, response, button, tag, timeoutMs = 9000 }) {
   const baseline = brief(getFullText(response), 400);
   const clickRes = await safeClickButton(response, button);
@@ -947,7 +959,30 @@ async function clickAndCapture({ channel, waitForDankMemer, response, button, ta
     delete response._lastInteractionAck;
   }
 
-  let post = clickRes || null;
+  // CV2 HTTP fallback returns the interaction ACK (not the updated message).
+  // If clickRes looks like an ack rather than a message, extract it and wait for
+  // the edited message instead.
+  const isAckObject = clickRes && typeof clickRes === 'object' && !clickRes.id && (clickRes.interactionStatus || clickRes.interactionType);
+  const capturedAck = isAckObject ? clickRes : null;
+
+  // Register a one-time callback to capture ephemeral responses (e.g. "You harvested: Nothing")
+  // from the raw gateway packet — the only place where ephemeral embeds/CV2 text are preserved.
+  let capturedEphemeral = null;
+  rawLogger.onNextEphemeral((parsed) => {
+    capturedEphemeral = parsed;
+    const cv2t = parsed.cv2Text || '';
+    const allt = parsed.allText || '';
+    const txt = cv2t || allt;
+    if (txt.includes('harvested')) LOG.info(`${tag}-ephemeral harvest: ${txt.slice(0, 200)}`);
+    else LOG.info(`${tag}-ephemeral ${txt.slice(0, 200)}`);
+  });
+
+  // Extra grace period: the ephemeral often arrives after safeClickButton resolves
+  // (the library may return the stale message immediately, before the gateway delivers the
+  // ephemeral). This ensures we capture it even when it arrives late.
+  await sleep(1500);
+
+  let post = (!isAckObject && clickRes) ? clickRes : null;
   if (!post && response.id) post = await waitForEditedMessage(channel, response.id, baseline, timeoutMs);
   if (!post) post = await waitForDankMemer(timeoutMs);
 
@@ -956,17 +991,23 @@ async function clickAndCapture({ channel, waitForDankMemer, response, button, ta
 
   // Capture any additional immediate callback message (often ephemeral-like
   // "only you can see this" notices) that may be separate from edited CV2 post.
+  let extraMsg = null;
   try {
     const side = await waitForDankMemer(1500);
     if (side && side.id !== post.id) {
       logEphemeralLike(`${tag}-post-extra`, side);
-      post._farmExtraInteraction = side;
+      extraMsg = side;
     }
   } catch {}
 
   if (isCV2(post)) await ensureCV2(post);
   logMsg(post, tag);
   logFarmState(tag, post);
+
+  // Attach captured ack and extra message so callers can access them.
+  post._capturedAck = capturedAck;
+  post._farmExtraMsg = extraMsg;
+  post._capturedEphemeral = capturedEphemeral;
   return post;
 }
 
@@ -1172,11 +1213,20 @@ async function advancePastConfirmation(response, waitForDankMemer) {
   if (!response) return null;
 
   const CONFIRM_WORDS = ['continue', 'confirm', 'confirm all', 'done', 'back to farm', 'back', 'close'];
+  // Also treat "All" buttons as confirmation actions (e.g. "Hoe All", "Water All").
+  // Skip the plain "back" word to avoid matching the Back arrow button; prefer explicit
+  // confirm words first, then fall back to "All" buttons as confirmation.
+  const ALL_AS_CONFIRM = ['hoe all', 'water all', 'plant all', 'harvest all', 'fertilize all'];
   const MAX_PAGES = 3;
 
   for (let page = 0; page < MAX_PAGES; page++) {
     const btns = getAllButtons(response).filter(b => !b.disabled);
-    const confirmBtn = btns.find(b => CONFIRM_WORDS.some(w => buttonHay(b).includes(w)));
+    let confirmBtn = btns.find(b => CONFIRM_WORDS.some(w => buttonHay(b).includes(w)));
+    // Also treat "All" buttons as confirmation (e.g. clicking "Plant All" again on the
+    // confirmation screen advances past it). But prefer explicit confirm words first.
+    if (!confirmBtn) {
+      confirmBtn = btns.find(b => ALL_AS_CONFIRM.some(w => buttonHay(b).includes(w)));
+    }
 
     if (!confirmBtn) {
       // No more confirmation buttons — return the current screen (should be manage menu)
@@ -1192,6 +1242,18 @@ async function advancePastConfirmation(response, waitForDankMemer) {
     try {
       clicked = await safeClickButton(response, confirmBtn);
       logEphemeralLike(`confirm-page-${page}`, clicked);
+      // Preserve CV2 ack so cycle can check for ephemeral errors.
+      if (clicked?._lastInteractionAck) {
+        response._lastInteractionAck = clicked._lastInteractionAck;
+      }
+      // Also capture ephemeral ack content for logging
+      const ackContent = captureCvvAckContent(clicked);
+      if (ackContent) {
+        const flags = clicked?.flags ?? 0;
+        const isEphemeral = (flags & 64) !== 0;
+        const level = isEphemeral ? LOG.warn : LOG.info;
+        level(`[farm:confirm:${page}] ephemeral=${isEphemeral} ack="${ackContent.slice(0, 300)}"`);
+      }
     } catch (e) {
       LOG.warn(`[farm:confirm] click failed on page ${page}: ${e.message}`);
       return response;
@@ -1235,7 +1297,7 @@ async function advancePastConfirmation(response, waitForDankMemer) {
 // ── Single-cycle farm orchestrator ──────────────────────────────────────────
 // Sends `pls farm view` once, then completes the full hoe→water→plant→harvest
 // cycle by looping on the returned manage menu — no additional command sends.
-async function runFarm({ channel, waitForDankMemer, client, redis, accountId }) {
+async function runFarm({ channel, waitForDankMemer, client, redis, accountId, forceRun }) {
   LOG.cmd(`${c.white}${c.bold}pls farm view${c.reset}`);
 
   await channel.send('pls farm view');
@@ -1291,7 +1353,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   if (textHasHarvestReady) LOG.info(`[farm] DETECTED harvest-ready in text (growReadySec=${growReadySec})`);
   if (growReadySec > 0) LOG.info(`[farm] GROW-QUEUE DEBUG: lower=${lower.slice(0, 400)}`);
   LOG.info(`[farm] grow-ready parse=${growReadySec == null ? 'none' : `${growReadySec}s`} redis_recovery=${redisRecoveryMs != null ? `${redisRecoveryMs}ms` : 'n/a'}`);
-  if (!redisRecovered && growReadySec && growReadySec > 20) {
+  if (!forceRun && !redisRecovered && growReadySec && growReadySec > 20) {
     await inferPreferredActionFromImage(response);
     // Re-check every 30s instead of waiting the full grow duration.
     // This ensures the next harvest cycle starts as soon as crops are ready.
@@ -1428,6 +1490,30 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
           label.includes('plant all') || label.includes('harvest all') || label.includes('confirm')) && b.disabled;
       });
       if (disabledAllBtn) {
+        // For harvest: disabled means nothing to harvest — skip to hoe.
+        // For hoe/water/plant: disabled means we don't have the item — try to buy it.
+        const ITEM_FOR_ACTION = { hoe: 'Hoe', water: 'Watering Can', plant: 'Seeds' };
+        const missingItem = ITEM_FOR_ACTION[action];
+        if (missingItem) {
+          LOG.info(`[farm:cycle:${cycleDepth}] ${action} all-btn disabled — trying to buy ${missingItem}`);
+          const bought = await tryBuyFarmItem({ missing: missingItem, channel, waitForDankMemer, client });
+          if (bought.ok) {
+            LOG.success(`[farm:cycle:${cycleDepth}] Bought ${bought.itemName} — retrying ${action}`);
+            await sleep(1200);
+            // Restart the cycle from farm view to refresh button state
+            await channel.send('pls farm view');
+            const re = await waitForDankMemer(12000);
+            if (!re) { LOG.warn('[farm:cycle] no response after buy retry'); break; }
+            if (isCV2(re)) await ensureCV2(re);
+            cycleResponse = re;
+            text = getFullText(cycleResponse);
+            clean = brief(text, 600);
+            initialAnalysis = null;
+            continue;
+          } else {
+            LOG.warn(`[farm:cycle:${cycleDepth}] Could not buy ${missingItem} — skipping to next phase`);
+          }
+        }
         const currentIdx = FARM_PHASE_ORDER.indexOf(action);
         const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
         LOG.info(`[farm:cycle:${cycleDepth}] ${action} all-btn disabled (no-op) — next=${nextPhase || 'done'}`);
@@ -1455,12 +1541,98 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     // Step 5: advance past any confirmation screens back to the manage menu
     cycleResponse = await advancePastConfirmation(lastApplyResp, waitForDankMemer);
     if (!cycleResponse) { LOG.warn('[farm:cycle] confirmation advance returned null'); break; }
+    if (isCV2(cycleResponse)) await ensureCV2(cycleResponse);
     actionsTaken++;
     lastAction = action;
     text = getFullText(cycleResponse);
     clean = brief(text, 600);
     logFarmState('after-confirm', cycleResponse);
 
+    // ── Farm text detection: determine next action from farm state ─────────────────
+    // After confirmation advances, we may be on the farm view (no action tabs visible).
+    // Use farm text patterns to determine what to do next — this is more reliable
+    // than the button state check (which fails on the farm view).
+    {
+      const postBtns = getAllButtons(cycleResponse);
+      const postActionBtns = postBtns.filter(b => !b.disabled && !isNavOrUtilityButton(b));
+      const postHasActionTabs = postActionBtns.some(b => hasAny(b, ['hoe', 'water', 'plant', 'harvest', 'fertiliz']));
+      const postLower = clean.toLowerCase();
+      const hasSeedsReady = /seeds ready|seeds.*ready|planted|crop.*ready/i.test(postLower);
+      const hasHarvestReady = /ready to harvest|harvest ready|can be harvest|can harvest|wilt/i.test(postLower);
+      const isEmpty = /pretty empty|seems empty|empty\.{0,3}/i.test(postLower) && !hasSeedsReady && !hasHarvestReady;
+      if (!postHasActionTabs && !isEmpty) {
+        // Farm has crops (planted/growing). Force harvest.
+        // cycleResponse is still the farm view (no action tabs) after advancePastConfirmation.
+        // Re-enter the manage menu so findNextFarmActionFromManage has buttons to work with.
+        const mb = findFarmButton(cycleResponse, ['manage', 'farm-farm:manage']);
+        if (mb) {
+          LOG.info(`[farm:cycle:${cycleDepth}] farm-text: re-entering manage menu to force harvest`);
+          const mr = await clickAndCapture({ channel, waitForDankMemer, response: cycleResponse, button: mb, tag: 'farm-farmtext-harvest-manage' });
+          if (mr) {
+            if (isCV2(mr)) await ensureCV2(mr);
+            cycleResponse = mr;
+            text = getFullText(cycleResponse);
+            clean = brief(text, 600);
+          }
+        }
+        forcedNextAction = 'harvest';
+        lastAction = null;
+        cycleDepth++;
+        initialAnalysis = null;
+        await sleep(300);
+        continue;
+      }
+      if (!postHasActionTabs && isEmpty) {
+        // Farm is empty after the action. Re-enter manage menu before forcing hoe.
+        const mb = findFarmButton(cycleResponse, ['manage', 'farm-farm:manage']);
+        if (mb) {
+          LOG.info(`[farm:cycle:${cycleDepth}] farm-text: re-entering manage menu (empty farm)`);
+          const mr = await clickAndCapture({ channel, waitForDankMemer, response: cycleResponse, button: mb, tag: 'farm-farmtext-hoe-manage' });
+          if (mr) {
+            if (isCV2(mr)) await ensureCV2(mr);
+            cycleResponse = mr;
+            text = getFullText(cycleResponse);
+            clean = brief(text, 600);
+          }
+        }
+        forcedNextAction = 'hoe';
+        lastAction = null;
+        cycleDepth++;
+        initialAnalysis = null;
+        await sleep(300);
+        continue;
+      }
+      // Otherwise: we're on manage menu or have action tabs — proceed to find next action.
+    }
+
+    // ── Harvest ephemeral: parse "You harvested: Nothing" to detect no-op ──────────
+    if (action === 'harvest') {
+      const ephemeral = lastApplyResp?._capturedEphemeral;
+      if (ephemeral) {
+        const cv2t = ephemeral.cv2Text || '';
+        const allt = ephemeral.allText || '';
+        const harvestText = cv2t || allt;
+        LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] "${harvestText.slice(0, 300)}"`);
+        // If nothing was harvested, cells are now empty (post-harvest debris).
+        // Force the cycle to proceed to hoe rather than re-analyzing the same state.
+        if (/nothing|0\s*x\s*\w|no\s+crops|\bnone\b/i.test(harvestText)) {
+          LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] Nothing harvested — forcing next action to hoe`);
+          forcedNextAction = 'hoe';
+          lastAction = 'harvest';
+          cycleDepth++;
+          initialAnalysis = null;
+          await sleep(300);
+          continue;
+        }
+        // Something was actually harvested — parse what and log it.
+        const itemMatches = [...harvestText.matchAll(/-?\s*(\d+)\s*x?\s*([A-Za-z]+)/g)];
+        if (itemMatches.length > 0) {
+          const items = itemMatches.map(m => `${m[1]}x ${m[2]}`).join(', ');
+          LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] Harvested: ${items}`);
+        }
+      }
+    }
+
     // If confirmation screen is identical to post-confirmation screen,
     // check whether we're on a planted confirmation (Dank Memer planted crops
     // and shows "ready at X"). In that case, click "Back" to return to the
@@ -1532,17 +1704,38 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     const score = scoreResult?.score || null;
     const nextAction = inferNextActionFromScore(action, score);
 
+    // Collect all error/rejection text sources:
+    // 1. Extra follow-up messages from farm actions
+    // 2. CV2 interaction ACK (ephemeral or success/error response)
+    // 3. The main message text after the action
+    const ackContent = captureCvvAckContent(lastApplyResp?._capturedAck);
+    const extraContent = lastApplyResp?._farmExtraMsg
+      ? String(stripAnsi(getFullText(lastApplyResp._farmExtraMsg) || '')).replace(/\s+/g, ' ').trim()
+      : '';
+    const postContent = String(stripAnsi(getFullText(lastApplyResp) || '')).replace(/\s+/g, ' ').trim();
+
+    if (ackContent || extraContent) {
+      const flags = lastApplyResp?._capturedAck?.flags ?? 0;
+      const isEphemeral = (flags & 64) !== 0;
+      const level = isEphemeral ? LOG.warn : LOG.info;
+      level(`[farm:cycle:${cycleDepth}:ephemeral] ephemeral=${isEphemeral} ack="${ackContent.slice(0, 300)}" extra="${extraContent.slice(0, 200)}"`);
+    }
+
+    // Build combined error text for rejection detection
+    const allErrorText = [extraContent, ackContent].filter(Boolean).join(' ');
+
     // Handle rejection messages that indicate wrong phase.
-    const extraText = String(stripAnsi(getFullText(cycleResponse?._farmExtraInteraction) || '')).toLowerCase();
-    if (action === 'plant' && /only\s+plant\s+seeds\s+on\s+an\s+empty\s+tile|tilled\s+and\s+watered/.test(extraText)) {
-      LOG.warn('[farm:cycle] Plant rejected — need hoe first. Restarting from hoe.');
+    if (action === 'plant' && /only\s+plant\s+seeds\s+on\s+an\s+empty\s+tile|tilled\s+and\s+watered|can only plant seeds on an empty tile/.test(allErrorText)) {
+      LOG.warn(`[farm:cycle] Plant rejected — need hoe+water first. Restarting from hoe. err="${allErrorText.slice(0, 200)}"`);
+      forcedNextAction = 'hoe';
       lastAction = null;
       cycleDepth++;
       await sleep(400);
       continue;
     }
-    if (action === 'hoe' && /can only use.*hoe.*empty tile|after a harvest/.test(extraText)) {
+    if (action === 'hoe' && /can only use.*hoe.*empty tile|after a harvest/.test(allErrorText)) {
       LOG.warn('[farm:cycle] Hoe rejected — moving to water phase.');
+      forcedNextAction = 'water';
       lastAction = 'hoe';
       cycleDepth++;
       await sleep(400);
@@ -1551,6 +1744,22 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
 
     if (!nextAction) {
       LOG.info(`[farm:cycle:${cycleDepth}] ${action} done — no next action (score=${score?.score ?? '?'}/${score?.threshold ?? '?'}, conf=${score?.confidence ?? '?'})`);
+      // Enforce strict phase ordering: after water → harvest. Never route to plant from image analysis.
+      if (action === 'water') {
+        const harvestIdx = FARM_PHASE_ORDER.indexOf('harvest');
+        if (harvestIdx >= 0) {
+          const harvestBtn = managedActions.harvest || getAllButtons(cycleResponse).find(b => hasAny(b, ['harvest', 'reap', 'collect']));
+          if (harvestBtn) {
+            LOG.info(`[farm:cycle:${cycleDepth}] enforcing harvest after water (strict phase order)`);
+            forcedNextAction = 'harvest';
+            cycleDepth++;
+            lastAction = 'water';
+            initialAnalysis = null;
+            await sleep(300);
+            continue;
+          }
+        }
+      }
       break;
     }
 

package/lib/commands/farmVision.js

@@ -82,16 +82,11 @@ function extractFarmImageUrl(msg) {
 function colorStatsForPixel(r, g, b) {
   const sum = r + g + b;
   const brightness = sum / 3;
-  // Crop green — harvest phase: large bright leaves, G significantly > R and B
-  const greenStrong = g > r * 1.25 && g > b * 1.25 && g > 38;
-  // Weeds/grass — small scattered green, less intense than crop green
-  const weedGreen = g > r * 1.12 && g > b * 1.1 && g <= 38;
-  // Wet soil — rich dark brown, no blue, higher R than typical dry soil
-  const wetSoil = r > 50 && r > g * 1.5 && b < 20 && brightness < 45;
-  // Dry tilled soil — medium brown, debris textures
-  const drySoil = r > 35 && r > g * 1.2 && b < 30;
+  // Grayscale: removes hue confusion between dusty-brown and green
+  const gray = Math.round(r * 0.299 + g * 0.587 + b * 0.114);
+  const soil = r >= g && b < 30;
   const whiteish = brightness > 210 && Math.abs(r - g) < 20 && Math.abs(g - b) < 20;
-  return { brightness, greenStrong, weedGreen, wetSoil, drySoil, whiteish };
+  return { brightness, gray, soil, whiteish };
 }
 
 function clamp01(n) {
@@ -99,41 +94,79 @@ function clamp01(n) {
 }
 
 function classifyCell(features) {
-  const { greenPct, bluePct, brownPct, darkPct, avgBrightness } = features;
+  const {
+    harvestPct, plantPct, soilPct,
+    avgBrightness, grayStd,
+    brightGrayPct, darkGrayPct,
+    avgSat, avgR, avgG, avgB,
+    gMinusR, discordUiPct,
+  } = features;
+
+  // If Discord UI dominates this cell, the stats are meaningless
+  if (discordUiPct > 0.5) {
+    return { state: 'unknown', confidence: 0.1, scores: { harvest: 0, planted: 0, soil: 0 } };
+  }
 
-  // ── HARVEST: Bright green mature crops (G >> R,B, G>38) ──
-  // Detected by greenStrong pixel percentage — crop leaves are vivid green
-  if (greenPct >= 0.30) {
-    const confidence = clamp01(0.5 + (greenPct - 0.30) * 2.0);
-    return { state: 'planted', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
+  // Actual farm pixel analysis from live screenshot:
+  // Water cells:   sat=0.15-0.20, B=14-21, darkPct=64-91%, G-R=-20 to +4
+  // Tilled cells:  sat=0.22-0.25, B=12-17, darkPct=64-81%, G-R=-8 to +11
+  // Harvest cells:  sat=0.22-0.25, B=12-17, darkPct=64-73%, G-R=+4 to +11, harv=41-46%
+  //
+  // Key insight: sat < 0.20 + B > 14 = water cells
+  // Higher sat (0.22+) + harvestPixels > 40% = harvest crops
+  // Higher sat (0.22+) + harv < 40% = tilled soil
+
+  const isLowSatWater = avgSat < 0.20 && avgB > 14;  // wet/dark soil
+  const isHighSatTilled = avgSat >= 0.20;              // tilled/planted soil
+  const isBright = brightGrayPct > 0.15;               // has bright crop pixels
+  const isDarkUniform = darkGrayPct > 0.55 && grayStd < 20; // very dark uniform (wet soil)
+
+  // ── HARVEST: Bright crops + high green + sat ≥ 0.20 ──
+  // Growing/ready crops: sat 0.22+, G-R > 5, harvestPixels > 40%
+  if (avgSat >= 0.20 && gMinusR > 5 && harvestPct > 0.40 && isBright) {
+    const excess = gMinusR - 5;
+    const confidence = clamp01(0.5 + excess * 0.06);
+    return { state: 'harvest', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
   }
 
-  // ── TILLED / WET: Brown soil — no meaningful green or blue ──
-  if (brownPct >= 0.15) {
-    // High brown percentage = definitely soil. Both hoe (dry) and water (wet)
-    // phases look like brown soil. We classify as 'tilled' — the farming
-    // logic handles water vs hoe state transition by phase context.
-    const confidence = clamp01((brownPct - 0.15) * 2.5 + (1 - darkPct) * 0.3);
-    return { state: 'tilled', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
+  // ── WATER: Low saturation + blue dominant (wet soil) ──
+  // sat < 0.20 AND B > 14 catches actual wet cells from live screenshot
+  if (isLowSatWater || isDarkUniform) {
+    return { state: 'water', confidence: +clamp01(0.5 + darkGrayPct * 0.3).toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
   }
 
-  // ── PLANTED (early stage): Soil with green weeds ──
-  // Cells with 5-30% green are likely soil with weeds/crops starting.
-  // This is distinct from harvest (30%+) which is handled above.
-  if (greenPct >= 0.05 && greenPct < 0.30) {
-    const confidence = clamp01((greenPct - 0.05) * 3.0);
-    return { state: 'planted', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
+  // ── TILLED: Higher saturation (≥ 0.20) = soil/debris ──
+  // sat ≥ 0.20 covers tilled dirt, debris, and planted cells
+  if (isHighSatTilled) {
+    // Planted if some harvest pixels and some brightness
+    if (plantPct > 0.15 || gMinusR > 1) {
+      const confidence = clamp01(0.3 + avgSat * 0.8 + brightGrayPct * 0.5);
+      return { state: 'planted', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
+    }
+    const confidence = clamp01((avgSat - 0.15) * 1.5);
+    return { state: 'tilled', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
   }
 
-  // ── UNKNOWN: Low signal — grass borders, artifacts, etc. ──
-  const signal = Math.max(greenPct, bluePct, brownPct);
+  // ── UNKNOWN: Low signal / empty ──
+  const signal = Math.max(harvestPct, plantPct, soilPct, avgSat);
   const confidence = signal * 1.5;
-  return { state: 'unknown', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
+  return { state: 'unknown', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
 }
 
 async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
-  const { data, info } = await sharp(imgBuffer).raw().toBuffer({ resolveWithObject: true });
-  const { width, height, channels } = info;
+  // Convert to grayscale to eliminate hue confusion between dusty-brown and green
+  const grayBuf = await sharp(imgBuffer).grayscale().raw().toBuffer({ resolveWithObject: true });
+  const { data: grayData, info: grayInfo } = grayBuf;
+  const { width, height, channels } = grayInfo;
+
+  // Also get original for saturation analysis
+  const origBuf = await sharp(imgBuffer).raw().toBuffer({ resolveWithObject: true });
+  const { data: origData, info: origInfo } = origBuf;
+
+  if (origInfo.width !== width || origInfo.height !== height) {
+    throw new Error('Grayscale/Original dimension mismatch — should not happen');
+  }
+
   const cellW = Math.floor(width / cols);
   const cellH = Math.floor(height / rows);
 
@@ -145,60 +178,103 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
       const ex = Math.min(sx + cellW, width);
       const ey = Math.min(sy + cellH, height);
 
-  // Sample center region only (ignore grass borders around each tile).
-  const padX = Math.floor((ex - sx) * 0.20);  // 20% padding to cut more grass
-  const padY = Math.floor((ey - sy) * 0.20);
-  const csx = sx + padX;
-  const csy = sy + padY;
-  const cex = ex - padX;
-  const cey = ey - padY;
+      // Use 30% vertical padding to avoid Discord UI bar bleeding into top/bottom rows
+      const padX = Math.floor((ex - sx) * 0.20);
+      const padY = Math.floor((ey - sy) * 0.30);
+      const csx = sx + padX;
+      const csy = sy + padY;
+      const cex = ex - padX;
+      const cey = ey - padY;
 
       let total = 0;
-      let greenPx = 0;  // crop green: G > R*1.25 && G > B*1.25 && G > 38
-      let brownPx = 0;   // soil brown: R > G*1.2 && B < 30
-      let darkPx = 0;    // very dark: brightness < 56
-      let whitePx = 0;
-      let brightSum = 0;
+      let harvestPx = 0;
+      let plantPx = 0;
+      let soilPx = 0;
+      let graySum = 0, graySqSum = 0;
+      let brightGrayPx = 0;
+      let darkGrayPx = 0;
+      let rSum = 0, gSum = 0, bSum = 0, satSum = 0;
+      let discordUiPx = 0;
+      const rawCellPixels = (cex - csx) * (cey - csy);
 
       for (let y = csy; y < cey; y++) {
         for (let x = csx; x < cex; x++) {
           const idx = (y * width + x) * channels;
-          const r = data[idx];
-          const g = data[idx + 1];
-          const b = data[idx + 2];
-          const s = colorStatsForPixel(r, g, b);
+          const r = origData[idx];
+          const g = origData[idx + 1];
+          const b = origData[idx + 2];
+          const gray = grayData[idx];
+
+          const maxC = Math.max(r, g, b);
+          const minC = Math.min(r, g, b);
+          const sat = maxC > 0 ? (maxC - minC) / 255 : 0;
+
+          // Skip Discord UI blue bar: very low saturation + blue dominant
+          if (b > 80 && sat < 0.08) {
+            discordUiPx++;
+            continue;
+          }
+
           total++;
-          brightSum += s.brightness;
-          if (s.greenStrong) greenPx++;        // harvest green (vivid crop leaves)
-          if (s.drySoil || s.wetSoil) brownPx++; // soil — dry or wet
-          if (s.dark) darkPx++;
-          if (s.whiteish) whitePx++;
+          graySum += gray;
+          graySqSum += gray * gray;
+          rSum += r; gSum += g; bSum += b;
+          satSum += sat;
+
+          if (g > r * 1.25) harvestPx++;
+          else if (g > r * 1.08) plantPx++;
+          if (r >= g) soilPx++;
+          if (gray > 100) brightGrayPx++;
+          if (gray < 65) darkGrayPx++;
         }
       }
 
-      const greenPct = greenPx / total;
-      const brownPct = brownPx / total;
-      const darkPct = darkPx / total;
-      const whitePct = whitePx / total;
-      const avgBrightness = brightSum / total;
-
-      const classified = classifyCell({ greenPct, brownPct, darkPct, avgBrightness });
+      const harvestPct = total > 0 ? harvestPx / total : 0;
+      const plantPct = total > 0 ? plantPx / total : 0;
+      const soilPct = total > 0 ? soilPx / total : 0;
+      const grayMean = total > 0 ? graySum / total : 0;
+      const grayVar = total > 0 ? (graySqSum / total) - (grayMean * grayMean) : 0;
+      const grayStd = Math.sqrt(Math.max(0, grayVar));
+      const avgSat = total > 0 ? satSum / total : 0;
+      const avgR = total > 0 ? rSum / total : 0;
+      const avgG = total > 0 ? gSum / total : 0;
+      const brightGrayPct = total > 0 ? brightGrayPx / total : 0;
+      const darkGrayPct = total > 0 ? darkGrayPx / total : 0;
+      const gMinusR = avgG - avgR;
+      const avgB = total > 0 ? bSum / total : 0;
+      const discordUiPct = rawCellPixels > 0 ? discordUiPx / rawCellPixels : 0;
+
+      const classified = classifyCell({
+        harvestPct, plantPct, soilPct,
+        avgR, avgG, avgB,
+        avgBrightness: grayMean,
+        avgSat, grayStd,
+        brightGrayPct, darkGrayPct,
+        gMinusR,
+        discordUiPct,
+      });
 
       cells.push({
-        row,
-        col,
+        row, col,
         state: classified.state,
         confidence: classified.confidence,
         scores: classified.scores,
-        greenPct: +greenPct.toFixed(3),
-        brownPct: +brownPct.toFixed(3),
-        darkPct: +darkPct.toFixed(3),
-        avgBrightness: +avgBrightness.toFixed(1),
+        harvestPct: +harvestPct.toFixed(3),
+        plantPct: +plantPct.toFixed(3),
+        soilPct: +soilPct.toFixed(3),
+        avgBrightness: +grayMean.toFixed(1),
+        avgSat: +avgSat.toFixed(3),
+        grayStd: +grayStd.toFixed(1),
+        brightGrayPct: +brightGrayPct.toFixed(3),
+        darkGrayPct: +darkGrayPct.toFixed(3),
+        avgR: +avgR.toFixed(1),
+        avgG: +avgG.toFixed(1),
+        avgB: +avgB.toFixed(1),
       });
     }
   }
 
-  const counts = { tilled: 0, planted: 0, unknown: 0 };
+  const counts = { harvest: 0, water: 0, tilled: 0, planted: 0, unknown: 0 };
   for (const c of cells) counts[c.state] = (counts[c.state] || 0) + 1;
 
   const avgConfidence = cells.length > 0
@@ -209,7 +285,7 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
 }
 
 function gridToString(analysis) {
-  const icon = { tilled: 'T', planted: 'P', unknown: '?' };
+  const icon = { harvest: 'H', water: 'W', tilled: 'T', planted: 'P', unknown: '?' };
   const rows = [];
   for (let r = 0; r < (analysis?.rows || 0); r++) {
     const line = [];
@@ -224,9 +300,10 @@ function gridToString(analysis) {
 
 function evaluateActionNeed(actionName, analysis) {
   const c = analysis?.counts || {};
-  const tilled = c.tilled || 0;
-  const wet = c.wet || 0;
+  const harvest = c.harvest || 0;
   const planted = c.planted || 0;
+  const water = c.water || 0;
+  const tilled = (c.tilled || 0) + (c.soil || 0);  // soil = tilled cells
   const unknown = c.unknown || 0;
   const conf = analysis?.avgConfidence || 0;
   const slots = 9;
@@ -234,35 +311,41 @@ function evaluateActionNeed(actionName, analysis) {
   // Avoid aggressive repeats when confidence is too low.
   if (conf < 0.20) return false;
 
-  // Simple rules:
-  // - hoe: repeat until farm has enough tilled/planted soil
-  // - water: skip (we don't distinguish wet vs tilled visually — use phase context instead)
-  // - plant: repeat until most cells show green crops
-  // - harvest: repeat if any planted crops visible
+  // Rules (4-state model: harvest/water/tilled/planted):
+  // - hoe: repeat if farm has no soil (all harvest/unknown)
+  // - water: repeat if farm has tilled but not watered (R<58, not water)
+  // - plant: repeat if farm has watered tiles but no planted
+  // - harvest: repeat if any harvest-ready crops visible
   if (actionName === 'hoe') {
-    return (tilled + planted) < slots && unknown < 6;
+    return harvest < slots && unknown < 6;
+  }
+  if (actionName === 'water') {
+    return tilled > 0 && water < slots;
   }
   if (actionName === 'plant') {
-    return planted < slots && (tilled) > 0;
+    return planted < slots && (water + tilled) > 0;
   }
   if (actionName === 'harvest') {
-    return planted > 0;
+    return harvest > 0;
   }
-  // water and others: don't force repeats
   return false;
 }
 
 function evaluateActionScores(actionName, analysis) {
   const c = analysis?.counts || {};
   const slots = Math.max(1, (analysis?.rows || 3) * (analysis?.cols || 3));
-  const tilled = c.tilled || 0;
+  const harvest = c.harvest || 0;
   const planted = c.planted || 0;
+  const water = c.water || 0;
+  const tilled = (c.tilled || 0) + (c.soil || 0);  // soil = tilled cells
   const unknown = c.unknown || 0;
   const conf = analysis?.avgConfidence || 0;
 
   const ratios = {
-    tilled: tilled / slots,
+    harvest: harvest / slots,
     planted: planted / slots,
+    water: water / slots,
+    tilled: tilled / slots,
     unknown: unknown / slots,
   };
 
@@ -274,24 +357,33 @@ function evaluateActionScores(actionName, analysis) {
   let reason = 'ok';
 
   if (actionName === 'hoe') {
-    // Hoe is good if farm has mostly soil (tilled or planted)
-    const base = (ratios.tilled * 0.9) + (ratios.planted * 0.5) - (ratios.unknown * 0.4);
+    // Hoe is good if farm has mostly soil, not harvest-ready crops
+    const base = (ratios.tilled * 0.7) + (ratios.water * 0.7) + (ratios.planted * 0.5) - (ratios.harvest * 0.9) - (ratios.unknown * 0.3);
     score = withConf(base);
-    threshold = 0.55;
+    threshold = 0.40;
     if (ratios.unknown > 0.5) reason = 'too_many_unknown_cells';
-    else if (ratios.tilled + ratios.planted < 0.4) reason = 'farm_not_ready';
+    else if (ratios.harvest >= 0.5) reason = 'farm_has_crops_to_harvest';
+    else if (ratios.harvest + ratios.planted < 0.3) reason = 'farm_needs_hoe';
+  } else if (actionName === 'water') {
+    // Water is good if there are tilled (dry) tiles to water
+    const base = (ratios.tilled * 0.95) - (ratios.water * 0.5) - (ratios.harvest * 0.5) - (ratios.unknown * 0.2);
+    score = withConf(base);
+    threshold = 0.40;
+    if (ratios.harvest >= 0.5) reason = 'farm_has_crops_to_harvest';
+    else if (ratios.tilled < 0.3) reason = 'no_tilled_tiles';
   } else if (actionName === 'plant') {
-    // Plant should end with mostly planted cells
-    const base = (ratios.planted * 0.98) - (ratios.tilled * 0.3) - (ratios.unknown * 0.2);
+    // Plant should end with growing crops on watered soil
+    const base = (ratios.planted * 0.95) - (ratios.harvest * 0.1) - (ratios.tilled * 0.2) - (ratios.unknown * 0.1);
     score = withConf(base);
-    threshold = 0.65;
-    if (ratios.planted < 0.5) reason = 'not_enough_planted_tiles';
+    threshold = 0.50;
+    if (ratios.harvest >= 0.5) reason = 'farm_ready_to_harvest';
+    else if (ratios.water + ratios.tilled < 0.3) reason = 'farm_not_watered';
   } else if (actionName === 'harvest') {
-    // Harvest is good if planted tiles dominate
-    const base = (ratios.planted * 0.9) - (ratios.tilled * 0.1) - (ratios.unknown * 0.2);
+    // Harvest is good if harvest-ready tiles dominate
+    const base = (ratios.harvest * 0.95) - (ratios.tilled * 0.15) - (ratios.planted * 0.1) - (ratios.unknown * 0.1);
     score = withConf(base);
-    threshold = 0.5;
-    if (ratios.planted < 0.3) reason = 'no_plants_to_harvest';
+    threshold = 0.40;
+    if (ratios.harvest < 0.3) reason = 'no_crops_to_harvest';
   } else {
     score = withConf(0.6 - ratios.unknown * 0.3);
     threshold = 0.6;
@@ -306,10 +398,12 @@ function evaluateActionScores(actionName, analysis) {
     threshold: +threshold.toFixed(3),
     confidence: +conf.toFixed(3),
     reason,
-    counts: { tilled, planted, unknown, slots },
+    counts: { harvest, planted, water, tilled, unknown, slots },
     ratios: {
-      tilled: +ratios.tilled.toFixed(3),
+      harvest: +ratios.harvest.toFixed(3),
       planted: +ratios.planted.toFixed(3),
+      water: +ratios.water.toFixed(3),
+      tilled: +ratios.tilled.toFixed(3),
       unknown: +ratios.unknown.toFixed(3),
     },
   };

package/lib/commands/utils.js

@@ -494,9 +494,19 @@ async function ensureCV2(msg, force = false) {
     if (rawParsed && rawParsed.components?.length > 0) {
       msg._cv2 = rawParsed.components;
       msg._cv2text = rawParsed.cv2Text || _extractCV2Text(rawParsed.components).trim();
-      msg._cv2buttons = rawParsed.buttons?.length > 0
+      const topLevel = 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);
+        : [];
+      const nested = _extractCV2Buttons(rawParsed.components);
+      // Merge, deduplicating by customId so all buttons are captured (top-level cv2Buttons
+      // omits some nested "All" buttons that live inside ACTION_ROW containers).
+      const seen = new Set();
+      const merged = [...topLevel, ...nested].filter(b => {
+        const id = b.customId || b.custom_id || '';
+        if (!id || seen.has(id)) return false;
+        seen.add(id); return true;
+      });
+      msg._cv2buttons = merged;
       msg._cv2EditedTs = msgEditedTs;
       cv2Cache.set(msg.id, { components: rawParsed.components, editedTimestamp: msgEditedTs });
       return msg;
@@ -574,7 +584,11 @@ async function clickCV2Button(msg, customId) {
   const resp = await _httpPost('https://discord.com/api/v9/interactions', {
     Authorization: token, 'Content-Type': 'application/json',
   }, payload);
-  if (resp.status >= 400) throw new Error(`CV2 click ${resp.status}: ${resp.body.substring(0, 200)}`);
+  if (resp.status >= 400) {
+    const errMsg = `CV2 click ${resp.status}: ${resp.body.substring(0, 300)}`;
+    LOG.warn(`[cv2] ${errMsg}`);
+    throw new Error(errMsg);
+  }
 
   let parsed = null;
   try {

package/lib/grinder.js

@@ -644,7 +644,11 @@ function renderDashboard() {
     if (ls === 0) lsStr = `${R}♥0${c.reset}`;
     else if (ls != null && ls <= 2) lsStr = `${Y}♥${ls}${c.reset}`;
     else if (ls != null) lsStr = `${G}♥${ls}${c.reset}`;
-    else lsStr = `${D}♥?${c.reset}`;
+    else {
+      // Unknown — pulse to show it's still being determined
+      const pulse = PULSE_CHARS[Math.floor(Date.now() / 400) % PULSE_CHARS.length];
+      lsStr = `${D}${pulse}♥?${c.reset}`;
+    }
 
     // ── Level indicator (fixed width so value changes don't jitter) ──
     const lvl = wk._level || 0;
@@ -1839,9 +1843,15 @@ class AccountWorker {
       }
     }
 
-    // ── Lifesaver protection: skip crime/search if 0 lifesavers ──
+    // ── Lifesaver protection: skip crime/search if 0 lifesavers or unknown ──
     if (cmdName === 'crime' || cmdName === 'search') {
-      // Fast path: check in-memory lifesaver count (set from inv + DM check)
+      // Unknown (null/undefined): DMs haven't confirmed safety — skip for safety.
+      if (this._lifesavers == null) {
+        this.log('warn', `[${cmdName}] SKIPPED — lifesavers unknown (safety hold)`);
+        await this.setCooldown(cmdName, 600);
+        return;
+      }
+      // Zero: depleted — disable for a long period.
       if (this._lifesavers === 0) {
         this.log('warn', `[${cmdName}] SKIPPED — 0 lifesavers (in-memory)`);
         await this.setCooldown(cmdName, 3600);
@@ -3125,19 +3135,43 @@ async function start(apiKey, apiUrl) {
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
     rawLogger.init(REDIS_URL).catch(() => {});
-    // Listen for DM death events across all accounts
+    // Listen for DM events across all accounts — update worker state + dashboard LIVE
     rawLogger.onDmEvent((event, raw) => {
-      if (event.type === 'death' && event.lifesaversLeft === 0) {
-        const channelId = raw.channel_id;
-        // Find which worker uses this DM channel and disable their crime/search
-        for (const w of workers) {
-          if (w.client?.user?.dmChannel?.id === channelId || w.channel?.id) {
-            w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
-            w.setCooldown?.('crime', 86400);
-            w.setCooldown?.('search', 86400);
+      const channelId = raw.channel_id;
+      for (const w of workers) {
+        const isThisWorker = w.client?.user?.dmChannel?.id === channelId;
+        if (!isThisWorker && w.channel?.id !== channelId) continue;
+
+        if (event.type === 'death') {
+          // Update worker's lifesaver count so dashboard ♥ updates in real time
+          if (event.lifesaversLeft >= 0) {
+            const prev = w._lifesavers;
+            w._lifesavers = event.lifesaversLeft;
+            if (event.lifesaversLeft === 0) {
+              w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
+              w.setCooldown?.('crime', 86400);
+              w.setCooldown?.('search', 86400);
+              sendWebhook?.('DEATH ALERT (DM)', `**${w.username}** died in DMs! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
+            } else {
+              w.log?.('warn', `DEATH in DMs — ${event.lifesaversLeft} lifesavers remaining`);
+              if (prev !== event.lifesaversLeft) {
+                w.setCooldown?.('crime', 60);
+                w.setCooldown?.('search', 60);
+              }
+              if (event.lifesaversLeft <= 2) {
+                sendWebhook?.('LOW LIFESAVERS', `**${w.username}** has only **${event.lifesaversLeft}** lifesaver(s) left!`, 0xfbbf24);
+              }
+            }
+          }
+          scheduleRender();
+        }
+
+        if (event.type === 'levelup') {
+          if (event.to > 0) {
+            w._level = event.to;
+            scheduleRender();
           }
         }
-        sendWebhook?.('DEATH ALERT (DM)', `Account died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
       }
     });
     checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}RawLog${c.reset}`);
@@ -3457,14 +3491,16 @@ async function start(apiKey, apiUrl) {
 
 
   // Phase 2.75: Check DM history for deaths/level-ups (sequential, fast)
-  console.log(`  ${rgb(139, 92, 246)}${BRAILLE_SPIN[0]}${c.reset}  ${c.dim}Checking DM history...${c.reset}`);
-  let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [];
+  const dmCheckPulse = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+  console.log(`  ${rgb(139, 92, 246)}${dmCheckPulse}${c.reset}  ${c.dim}Checking DM history...${c.reset}`);
+  let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [], dmUnknown = [];
   for (const w of activeWorkers) {
     try {
       const dm = await w.checkDmHistory();
       if (dm.deaths > 0) dmDeaths += dm.deaths;
       if (dm.levelUps > 0) dmLevelUps += dm.levelUps;
       if (dm.lifesavers === 0) dmNoLs.push(w.username);
+      if (dm.lifesavers === -1) dmUnknown.push(w.username);
       // Store level and lifesaver for dashboard
       if (dm.currentLevel > 0) w._level = dm.currentLevel;
       if (dm.lifesavers >= 0) w._lifesavers = dm.lifesavers;
@@ -3474,6 +3510,10 @@ async function start(apiKey, apiUrl) {
       if (dm.lifesavers >= 0) {
         const lc = dm.lifesavers === 0 ? rgb(239, 68, 68) : dm.lifesavers <= 2 ? rgb(251, 191, 36) : rgb(52, 211, 153);
         parts.push(`${lc}♥${dm.lifesavers}${c.reset}`);
+      } else {
+        // Unknown lifesavers — pulse to show pending
+        const pulse = PULSE_CHARS[Math.floor(Date.now() / 400) % PULSE_CHARS.length];
+        parts.push(`${D}${pulse}♥?${c.reset}`);
       }
       if (parts.length > 0) {
         console.log(`  ${c.dim}├${c.reset} ${c.bold}${w.username}${c.reset}  ${parts.join('  ')}`);
@@ -3492,7 +3532,16 @@ async function start(apiKey, apiUrl) {
       }
     }
   }
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}DM check${c.reset}  ${c.dim}${dmDeaths} deaths, ${dmLevelUps} level-ups found${c.reset}`);
+  if (dmUnknown.length > 0) {
+    console.log(`  ${rgb(251, 191, 36)}⚠${c.reset}  ${c.dim}Lifesavers unknown — live DM monitor active:${c.reset} ${dmUnknown.join(', ')}`);
+    // Crime/search on these accounts will be skipped via safety hold until the live
+    // DM gateway listener detects a death (→ sets count) or confirms clean.
+  }
+  const dmSummaryParts = [];
+  if (dmDeaths > 0) dmSummaryParts.push(`${dmDeaths} deaths`);
+  if (dmLevelUps > 0) dmSummaryParts.push(`${dmLevelUps} level-ups`);
+  if (dmUnknown.length > 0) dmSummaryParts.push(`${dmUnknown.length} pending`);
+  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}DM check${c.reset}  ${dmSummaryParts.length > 0 ? c.dim + dmSummaryParts.join(', ') + c.reset : c.dim + 'clean — no deaths or level-ups' + c.reset}`);
   console.log('');
 
   console.log(`  ${rgb(139, 92, 246)}${c.bold}>>>${c.reset}  ${gradientText('Starting grind loops...', [139, 92, 246], [52, 211, 153])}`);

package/lib/rawLogger.js

@@ -471,6 +471,19 @@ function verboseLog(event, parsed) {
 const dmListeners = [];
 function onDmEvent(fn) { dmListeners.push(fn); }
 
+// ── Ephemeral message callbacks ──
+const ephemeralListeners = [];
+function onNextEphemeral(fn) { ephemeralListeners.push(fn); }
+
+function _notifyEphemeral(parsed) {
+  if (!ephemeralListeners.length) return;
+  const listeners = [...ephemeralListeners];
+  ephemeralListeners.length = 0;
+  for (const fn of listeners) {
+    try { fn(parsed); } catch {}
+  }
+}
+
 /**
  * Attach DM logger — monitors Dank Memer DMs for:
  *   - Level ups: "You leveled up from level X to Y"
@@ -585,8 +598,15 @@ function attachRawLogger(client, opts = {}) {
 
     const event = packet.t === 'MESSAGE_CREATE' ? 'CREATE' : 'UPDATE';
     const parsed = store(d, event); // async but we don't await (fire-and-forget)
-    if (parsed.then) parsed.then(p => verboseLog(event, p)).catch(() => {});
-    else verboseLog(event, parsed);
+    if (parsed.then) {
+      parsed.then(p => {
+        verboseLog(event, p);
+        if (p?.isEphemeral) _notifyEphemeral(p);
+      }).catch(() => {});
+    } else {
+      verboseLog(event, parsed);
+      if (parsed?.isEphemeral) _notifyEphemeral(parsed);
+    }
   });
 }
 
@@ -673,6 +693,7 @@ module.exports = {
   attachRawLogger,
   attachDmLogger,
   onDmEvent,
+  onNextEphemeral,
   setVerbose,
   // Memory reads
   getRawMessage,

package/package.json

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