dankgrinder 7.6.0 → 7.11.0

package/lib/commands/farm.js

@@ -4,15 +4,10 @@ const {
   isCV2, ensureCV2, stripAnsi, needsItem, clickCV2SelectMenu,
 } = require('./utils');
 const { buyItem, buyItemsBatch } = require('./shop');
-const {
-  downloadImage,
-  extractFarmImageUrl,
-  analyzeFarmGrid,
-  gridToString,
-  evaluateActionNeed,
-  evaluateActionScores,
-  dumpFarmVisionDebug,
-} = require('./farmVision');
+const rawLogger = require('../../lib/rawLogger');
+// NOTE: Vision/ML image analysis is disabled — farm decisions are purely based on
+// ephemeral responses and text detection. Re-enable by importing:
+// const { downloadImage, extractFarmImageUrl, analyzeFarmGrid, gridToString } = require('./farmVision');
 
 const RE_TS = /<t:(\d+):R>/;
 const RE_MIN = /(\d+)\s*minute/i;
@@ -413,6 +408,7 @@ function logEphemeralLike(tag, payload) {
   else LOG.info(line);
 }
 
+/* DISABLED — vision-based image analysis for action scoring
 async function analyzeFarmImageForAction(msg, actionName) {
   try {
     const url = extractFarmImageUrl(msg);
@@ -485,6 +481,9 @@ function getVisionRepairPlan(actionName, score) {
   return null;
 }
 
+/* DISABLED — vision-based action scoring (no longer used)
+// ── Vision-based next-action inference ─────────────────────────────────────────
+// Rely purely on ephemeral responses instead of ML image analysis.
 function inferNextActionFromScore(actionName, score) {
   if (!score) return null;
   const planted = score.ratios?.planted || 0;
@@ -504,7 +503,9 @@ function inferNextActionFromScore(actionName, score) {
   }
   return null;
 }
+*/
 
+/* DISABLED — vision-based preferred action inference
 async function inferPreferredActionFromImage(msg) {
   try {
     const url = extractFarmImageUrl(msg);
@@ -517,43 +518,18 @@ async function inferPreferredActionFromImage(msg) {
       planted: (analysis?.counts?.planted || 0) / slots,
       unknown: (analysis?.counts?.unknown || 0) / slots,
     };
-
     let suggested = null;
-    // Image-first phase routing (3-state: tilled/planted/unknown, no separate wet state).
     if (ratios.planted >= 0.30) suggested = 'plant';
     else if (ratios.tilled >= 0.30) suggested = 'water';
     else suggested = 'hoe';
-
-    let dbg = null;
-    try {
-      dbg = await dumpFarmVisionDebug({
-        imgBuffer: buf,
-        analysis,
-        actionName: `phase-${suggested || 'unknown'}`,
-        sourceUrl: url,
-      });
-    } catch (e) {
-      LOG.warn(`[farm:phase-image] debug dump failed: ${e.message}`);
-    }
-
-    LOG.info(`[farm:phase-image] url=${url} grid=${gridToString(analysis)} counts=${JSON.stringify(analysis.counts)} conf=${analysis.avgConfidence} suggested=${suggested} ratios=${JSON.stringify({
-      tilled: +ratios.tilled.toFixed(3),
-      planted: +ratios.planted.toFixed(3),
-      unknown: +ratios.unknown.toFixed(3),
-    })}`);
-    if (dbg) {
-      const tileSummary = (analysis.cells || [])
-        .map(c => `r${c.row + 1}c${c.col + 1}:${c.state}:${c.confidence}`)
-        .join(' | ');
-      LOG.info(`[farm:phase-image] debug dir=${dbg.dir} source=${dbg.sourcePath} manifest=${dbg.manifestPath} tiles=${dbg.tileCount}`);
-      LOG.info(`[farm:phase-image] tile-summary ${tileSummary}`);
-    }
+    LOG.info(`[farm:phase-image] url=${url} grid=${gridToString(analysis)} suggested=${suggested}`);
     return suggested;
   } catch (e) {
     LOG.warn(`[farm:phase-image] inference failed: ${e.message}`);
     return null;
   }
 }
+*/
 
 function chooseSeedOption(menu) {
   const options = (menu?.options || []).filter(o => o && o.value);
@@ -641,11 +617,11 @@ async function ensurePlantSeedSelected({ response, waitForDankMemer, channel })
   }
 }
 
+/* DISABLED — vision-based phase scoring
 async function capturePhaseVisionScore({ msg, actionName, phaseTag }) {
   if (!msg || !['hoe', 'water', 'plant', 'harvest'].includes(actionName)) {
     return null;
   }
-
   const check = await analyzeFarmImageForAction(msg, actionName);
   const s = check?.score;
   if (s) {
@@ -655,6 +631,7 @@ async function capturePhaseVisionScore({ msg, actionName, phaseTag }) {
   }
   return check;
 }
+*/
 
 function mergeBuyPlan(plan) {
   const m = new Map();
@@ -938,6 +915,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 +935,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 +967,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;
 }
 
@@ -1074,10 +1091,22 @@ async function waitForEditedMessage(channel, messageId, baselineText, timeoutMs
 // Determine the next action to take from the manage menu, given what the
 // farm image vision says about the current state.
 // Returns { action, button, reason } where action is null when the cycle is done.
-async function findNextFarmActionFromManage(msg, text, currentAction, imageAnalysis, forcedNextAction) {
+async function findNextFarmActionFromManage(msg, text, currentAction, forcedNextAction) {
   const btns = getAllButtons(msg).filter(b => !b.disabled && !isNavOrUtilityButton(b));
   const allBtns = getAllButtons(msg); // include disabled for state detection
-  if (btns.length === 0) return { action: null, button: null, reason: 'no-buttons' };
+  // If no non-utility buttons remain, check if any action tabs exist.
+  // This handles confirmation screens where Manage/Rename/Change Skin are all
+  // filtered as nav buttons — the manage menu's action tabs (Hoe/Water/Plant/Harvest)
+  // may still be accessible directly or via the manage button.
+  if (btns.length === 0) {
+    const actionTabs = allBtns.filter(b => !b.disabled && hasAny(b, ['hoe', 'water', 'plant', 'harvest', 'fertiliz']));
+    if (actionTabs.length > 0) {
+      // Action tabs exist but are buried behind a confirmation/nav screen.
+      // The caller will need to navigate back to the manage menu.
+      return { action: null, button: null, reason: 'confirmation-screen', actionTabs };
+    }
+    return { action: null, button: null, reason: 'no-buttons' };
+  }
 
   const managedActions = getManageActionButtons(msg);
   const lower = String(stripAnsi(text || '')).toLowerCase();
@@ -1108,6 +1137,7 @@ async function findNextFarmActionFromManage(msg, text, currentAction, imageAnaly
     if (btn) return { action: 'harvest', button: btn, reason: 'harvest-ready-text' };
   }
 
+  /* DISABLED — vision-based image analysis routing
   // Use image vision ratios if available.
   if (imageAnalysis) {
     const slots = Math.max(1, (imageAnalysis.rows || 3) * (imageAnalysis.cols || 3));
@@ -1116,7 +1146,6 @@ async function findNextFarmActionFromManage(msg, text, currentAction, imageAnaly
       planted: (imageAnalysis.counts?.planted || 0) / slots,
       unknown: (imageAnalysis.counts?.unknown || 0) / slots,
     };
-
     // Phase-aware selection: pick the earliest incomplete phase (3-state model).
     // Harvest when planted >= 30%.
     if (ratios.planted >= 0.30) {
@@ -1139,6 +1168,7 @@ async function findNextFarmActionFromManage(msg, text, currentAction, imageAnaly
       if (btn) return { action: 'hoe', button: btn, reason: `hoe-vision(t=${ratios.tilled.toFixed(2)},p=${ratios.planted.toFixed(2)})` };
     }
   }
+  */
 
   // Disabled-all detection: if the "All" for a phase is already disabled,
   // that phase is done — move to the next one.
@@ -1172,11 +1202,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)
@@ -1188,10 +1227,28 @@ async function advancePastConfirmation(response, waitForDankMemer) {
     await humanDelay(80, 220);
 
     const baseline = brief(getFullText(response), 400);
+    // NOTE: We do NOT register an ephemeral listener here.
+    // The outer listener (registered by the caller) captures ALL ephemerals
+    // including harvest results. Registering a second listener would clear
+    // the listeners array after the first fires, preventing the outer
+    // listener from seeing the ephemeral.
+
     let clicked;
     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 +1292,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');
@@ -1292,11 +1349,21 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   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) {
-    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.
-    const waitSec = Math.min(30, Math.min(6 * 3600, growReadySec + 2));
-    LOG.info(`[farm] crops growing (~${Math.ceil(growReadySec / 60)}m remaining); re-checking in ${waitSec}s`);
+    // Grow timer is active — schedule re-check based on how close crops are.
+    // Graduated wait: short when nearly ready, longer when far out.
+    // This avoids spamming Discord with farm commands when crops have hours left.
+    let waitSec;
+    if (growReadySec <= 300) {
+      // < 5 min: check every minute (crops nearly ready)
+      waitSec = 60;
+    } else if (growReadySec <= 3600) {
+      // 5-60 min: check every 5 minutes
+      waitSec = 300;
+    } else {
+      // > 1 hour: check every 15 minutes (long grow, no rush)
+      waitSec = 900;
+    }
+    LOG.info(`[farm] crops growing (~${Math.ceil(growReadySec / 60)}m remaining); re-checking in ${waitSec / 60}m`);
     return { result: `farm grow queue (${Math.ceil(growReadySec / 60)}m)`, coins: 0, nextCooldownSec: waitSec, skipReason: 'farm_grow_queue' };
   }
 
@@ -1333,19 +1400,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     }
   }
 
-  // ── Initial image analysis to bootstrap cycle entry ────────────────────────
-  let initialAnalysis = null;
-  try {
-    const url = extractFarmImageUrl(response);
-    if (url) {
-      const buf = await downloadImage(url);
-      const grid = await analyzeFarmGrid(buf);
-      initialAnalysis = grid;
-      LOG.info(`[farm] initial image grid=${gridToString(grid)} counts=${JSON.stringify(grid.counts)} conf=${grid.avgConfidence}`);
-    }
-  } catch (e) {
-    LOG.info(`[farm] initial image analysis failed: ${e.message}`);
-  }
 
   // ── Cycle loop: hoe → water → plant → harvest ─────────────────────────────
   let cycleDepth = 0;
@@ -1354,11 +1408,14 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   let actionsTaken = 0; // Track how many farm actions were actually executed
   let forcedNextAction = null; // When advancing a phase, force the next action check
   let lastApplyResp = null; // Track the last apply response for coin/cooldown parsing
+  let lastRejectedAction = null; // Track last rejected action to break empty-farm loops
 
   while (cycleDepth < 5) {
+    // Reset per-cycle state
+    let justRejected = false;
     let actionResult;
     try {
-      actionResult = await findNextFarmActionFromManage(cycleResponse, text, lastAction, initialAnalysis, forcedNextAction);
+      actionResult = await findNextFarmActionFromManage(cycleResponse, text, lastAction, forcedNextAction);
     } catch (e) {
       LOG.warn(`[farm:cycle] findNextFarmActionFromManage error: ${e.message}`);
       break;
@@ -1367,6 +1424,23 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     forcedNextAction = null;
 
     if (!action || !button) {
+      if (reason === 'confirmation-screen') {
+        // We're on a confirmation/nav screen with no actionable buttons visible.
+        // Re-enter the manage menu to get action tabs back.
+        LOG.info(`[farm:cycle:${cycleDepth}] confirmation screen — re-entering manage menu`);
+        const mb = findFarmButton(cycleResponse, ['manage', 'farm-farm:manage']);
+        if (mb) {
+          const mr = await clickAndCapture({ channel, waitForDankMemer, response: cycleResponse, button: mb, tag: `farm-cycle-confirm-manage` });
+          if (mr) {
+            if (isCV2(mr)) await ensureCV2(mr);
+            cycleResponse = mr;
+            text = getFullText(cycleResponse);
+            clean = brief(text, 600);
+          }
+        }
+        await sleep(300);
+        continue;
+      }
       LOG.info(`[farm:cycle:${cycleDepth}] no action found (reason=${reason}) — breaking cycle`);
       break;
     }
@@ -1428,15 +1502,48 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
           label.includes('plant all') || label.includes('harvest all') || label.includes('confirm')) && b.disabled;
       });
       if (disabledAllBtn) {
+        // Farm state check: "Hoe All" disabled could mean (a) no Hoe item OR (b) no tiles to work.
+        // Check the farm text — if the farm is empty, there's nothing to hoe/water/plant,
+        // so buying is pointless. Skip buy and treat as a no-op phase.
+        const farmEmpty = /pretty empty|seems empty|empty\.{0,3}/i.test(clean);
         const currentIdx = FARM_PHASE_ORDER.indexOf(action);
         const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+        if (farmEmpty) {
+          LOG.info(`[farm:cycle:${cycleDepth}] ${action} all-btn disabled but farm is empty — skipping ${action}, advancing to ${nextPhase || 'done'}`);
+          lastAction = action;
+          forcedNextAction = nextPhase;
+          cycleDepth++;
+          if (!nextPhase) break;
+          await sleep(300);
+          continue;
+        }
+        // Farm has tiles but all-btn disabled — try to buy the item.
+        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 (farm not empty) — 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);
+            // Refresh the manage menu to pick up the new button state
+            const mb = findFarmButton(cycleResponse, ['manage', 'farm-farm:manage']);
+            if (mb) {
+              const mr = await clickAndCapture({ channel, waitForDankMemer, response: cycleResponse, button: mb, tag: 'farm-buy-retry-manage' });
+              if (mr) { if (isCV2(mr)) await ensureCV2(mr); cycleResponse = mr; text = getFullText(cycleResponse); clean = brief(text, 600); }
+            }
+            continue;
+          } else {
+            LOG.warn(`[farm:cycle:${cycleDepth}] Could not buy ${missingItem} — skipping to next phase`);
+          }
+        }
+
         LOG.info(`[farm:cycle:${cycleDepth}] ${action} all-btn disabled (no-op) — next=${nextPhase || 'done'}`);
         actionsTaken++;
         lastAction = action;
         forcedNextAction = nextPhase;
         cycleDepth++;
         if (!nextPhase) break;
-        initialAnalysis = null;
         await sleep(300);
         continue;
       }
@@ -1453,14 +1560,210 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     if (!lastApplyResp) { LOG.warn('[farm:cycle] All click returned null'); break; }
 
     // Step 5: advance past any confirmation screens back to the manage menu
+    // Register the ephemeral listener BEFORE advancePastConfirmation so we capture
+    // the confirmation ephemeral (e.g., harvest "You harvested:") which arrives
+    // asynchronously after the HTTP response.
+    let confirmEphemeral = null;
+    rawLogger.onNextEphemeral((parsed) => {
+      confirmEphemeral = parsed;
+    });
     cycleResponse = await advancePastConfirmation(lastApplyResp, waitForDankMemer);
     if (!cycleResponse) { LOG.warn('[farm:cycle] confirmation advance returned null'); break; }
+    if (isCV2(cycleResponse)) await ensureCV2(cycleResponse);
+    // Ephemeral fires asynchronously after HTTP response — wait briefly for it to arrive
+    // before the harvest block checks cycleResponse._capturedEphemeral.
+    await sleep(200);
+    if (confirmEphemeral) cycleResponse._capturedEphemeral = confirmEphemeral;
+    else if (cycleResponse?._capturedEphemeral) { /* already set by advancePastConfirmation */ }
     actionsTaken++;
     lastAction = action;
     text = getFullText(cycleResponse);
     clean = brief(text, 600);
     logFarmState('after-confirm', cycleResponse);
 
+    // ── Rejection ephemeral: detect "wrong phase" errors and cascade ─────────────
+    // advancePastConfirmation registers no ephemeral listener (confirmation ephemerals
+    // are captured by the outer listener below). The action's ephemeral (from clicking
+    // the action tab) remains on lastApplyResp._capturedEphemeral.
+    {
+      const ephem = lastApplyResp?._capturedEphemeral;
+      const ephemText = (ephem?.cv2Text || ephem?.allText || '').toLowerCase();
+
+      // Helper: re-enter the manage menu from the farm view so the next
+      // findNextFarmActionFromManage iteration has buttons to work with.
+      async function reenterManage() {
+        const allBtns = getAllButtons(cycleResponse);
+        const mb = findFarmButton(cycleResponse, ['manage', 'farm-farm:manage']);
+        LOG.info(`[farm:cycle:${cycleDepth}:reenter] findFarmButton result: ${mb ? mb.label + ' / ' + mb.customId : 'NULL'}`);
+        if (!mb) {
+          LOG.warn(`[farm:cycle:${cycleDepth}:reenter] no Manage button found! available btns: ${allBtns.map(b => b.label).join(', ')}`);
+          return false;
+        }
+        const mr = await clickAndCapture({ channel, waitForDankMemer, response: cycleResponse, button: mb, tag: `farm-cycle-reject-manage` });
+        LOG.info(`[farm:cycle:${cycleDepth}:reenter] clickAndCapture result: ${mr ? 'got response' : 'NULL'}`);
+        if (!mr) return false;
+        if (isCV2(mr)) await ensureCV2(mr);
+        cycleResponse = mr;
+        const postBtns = getAllButtons(cycleResponse);
+        LOG.info(`[farm:cycle:${cycleDepth}:reenter] post-manage btns: ${postBtns.length}, ${postBtns.map(b => b.label).join(', ')}`);
+        return true;
+      }
+
+      // "You can only use a Hoe on empty tiles or after a harvest" → skip to water
+      if (action === 'hoe' && /can only use.*hoe.*empty|only use.*hoe.*empty/.test(ephemText)) {
+        LOG.warn(`[farm:cycle:${cycleDepth}:reject] Hoe rejected: tiles not empty — cascading to water`);
+        const currentIdx = FARM_PHASE_ORDER.indexOf(action);
+        const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+        forcedNextAction = nextPhase;
+        lastAction = action;
+        justRejected = true;
+        cycleDepth++;
+        if (!nextPhase) break;
+        await reenterManage();
+        await sleep(300);
+        continue;
+      }
+
+      // "You can only use a Watering Can on tilled tiles" (not hoed) → cascade forward to plant
+      // Do NOT cascade back to hoe — that creates an infinite hoe↔water oscillation.
+      if (action === 'water' && (ephemText.includes('can only use') || ephemText.includes('can only water'))) {
+        LOG.warn(`[farm:cycle:${cycleDepth}:reject] Water rejected (${ephemText.slice(0, 100)}) — cascading to plant`);
+        const currentIdx = FARM_PHASE_ORDER.indexOf(action);
+        const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+        forcedNextAction = nextPhase;
+        lastAction = action;
+        justRejected = true;
+        // Break oscillation guard: if we bounced back here from plant, stop.
+        if (lastRejectedAction === 'plant' && action === 'water') {
+          LOG.warn(`[farm:cycle:${cycleDepth}:reject] hoe→water→plant oscillation detected — breaking`);
+          break;
+        }
+        cycleDepth++;
+        if (!nextPhase) break;
+        await reenterManage();
+        await sleep(300);
+        continue;
+      }
+
+      // "You can only plant seeds on an empty tile that is tilled and watered" → cascade to harvest
+      // Do NOT cascade back to hoe — that creates an infinite hoe↔water oscillation.
+      if (action === 'plant' && /can only plant|can only use.*seed|plant.*not.*water/.test(ephemText)) {
+        LOG.warn(`[farm:cycle:${cycleDepth}:reject] Plant rejected (${ephemText.slice(0, 100)}) — cascading to harvest`);
+        const currentIdx = FARM_PHASE_ORDER.indexOf(action);
+        const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+        forcedNextAction = nextPhase;
+        lastAction = action;
+        justRejected = true;
+        cycleDepth++;
+        if (!nextPhase) {
+          // Plant is last phase — advance to harvest in next cycle.
+          await sleep(300);
+          continue;
+        }
+        await reenterManage();
+        await sleep(300);
+        continue;
+      }
+    }
+
+    // ── Farm text detection: determine next action from farm state ─────────────────
+    // Skip entirely if a rejection just fired — the rejection cascade handles the
+    // next action; farm-text should not override forcedNextAction.
+    if (!justRejected) {
+      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.
+        // BUT: if the current action was 'harvest' and we're on a planted confirmation
+        // screen (no action tabs, not empty), it means nothing was harvested.
+        // Breaking here lets the grow queue handle the planted crops.
+        const justHarvested = (action === 'harvest');
+        if (justHarvested) {
+          LOG.info(`[farm:cycle:${cycleDepth}] farm-text: nothing harvested (planted confirmation) — breaking, grow queue will handle`);
+          break;
+        }
+        // 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++;
+        await sleep(300);
+        continue;
+      }
+      if (!postHasActionTabs && isEmpty) {
+        // Farm is empty after the action. Re-enter manage menu and check if there's
+        // actually anything to work. If all "All" buttons are still disabled, the
+        // farm is truly empty — nothing to hoe/water/plant, break the cycle.
+        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);
+          }
+        }
+        // Double-check: after re-entering manage, if hoe/water/plant all-btn are all still
+        // disabled, the farm is truly empty — no tiles to work. Break the cycle.
+        const allBtnsNow = getAllButtons(cycleResponse);
+        const hoeAllEnabled = allBtnsNow.some(b => !b.disabled && buttonHay(b).includes('hoe all'));
+        const waterAllEnabled = allBtnsNow.some(b => !b.disabled && buttonHay(b).includes('water all'));
+        const plantAllEnabled = allBtnsNow.some(b => !b.disabled && buttonHay(b).includes('plant all'));
+        if (!hoeAllEnabled && !waterAllEnabled && !plantAllEnabled) {
+          LOG.info(`[farm:cycle:${cycleDepth}] all action all-btns still disabled after manage re-entry — farm is truly empty, breaking`);
+          break;
+        }
+        forcedNextAction = 'hoe';
+        lastAction = null;
+        cycleDepth++;
+        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 = cycleResponse?._capturedEphemeral || lastApplyResp?._capturedEphemeral;
+      if (ephemeral) {
+        const cv2t = ephemeral.cv2Text || '';
+        const allt = ephemeral.allText || '';
+        const harvestText = cv2t || allt;
+        LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] cv2Text="${cv2t.slice(0,200)}" allText="${allt.slice(0,200)}"`);
+        // If nothing was harvested, cells are now empty (post-harvest debris).
+        // Clear forcedNextAction and break — farm is done.
+        if (/nothing|0\s*x\s*\w|no\s+crops|\bnone\b|^you harvested\s*$/im.test(harvestText) || (/\byou harvested\b/i.test(harvestText) && /\b(nothing|none)\b/i.test(harvestText))) {
+          LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] Nothing harvested — farm cycle complete`);
+          forcedNextAction = null;
+          break;
+        }
+        // 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
@@ -1488,6 +1791,9 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
           logFarmState('after-plant-back', cycleResponse);
         }
         // Plant succeeded — advance to harvest.
+        // cycleResponse is now the farm view (after clicking Back).
+        // Re-enter manage so findNextFarmActionFromManage has buttons on the next loop.
+        await reenterManage();
         const currentIdx = FARM_PHASE_ORDER.indexOf(action);
         const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
         LOG.info(`[farm:cycle:${cycleDepth}] plant done, advancing to ${nextPhase || 'done'}`);
@@ -1495,7 +1801,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
         if (!nextPhase) break;
         cycleDepth++;
         lastAction = nextPhase;
-        initialAnalysis = null;
         await sleep(400);
         continue;
       }
@@ -1507,7 +1812,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
       if (!nextPhase) break;
       cycleDepth++;
       lastAction = nextPhase;
-      initialAnalysis = null;
       await sleep(300);
       continue;
     }
@@ -1515,34 +1819,44 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     clean = brief(text, 600);
     logFarmState('after-confirm', cycleResponse);
 
-    // Step 6: run image analysis to decide next action
-    let imgAnalysis = null;
-    try {
-      const url = extractFarmImageUrl(cycleResponse);
-      if (url) {
-        const buf = await downloadImage(url);
-        imgAnalysis = await analyzeFarmGrid(buf);
-        LOG.info(`[farm:cycle:${cycleDepth}:img] grid=${gridToString(imgAnalysis)} counts=${JSON.stringify(imgAnalysis.counts)} conf=${imgAnalysis.avgConfidence}`);
-      }
-    } catch (e) {
-      LOG.info(`[farm:cycle:${cycleDepth}:img] failed: ${e.message}`);
+    // Step 6: NO image analysis — rely purely on ephemeral + text for next action decision
+    // let imgAnalysis = null;  // DISABLED vision
+    // const scoreResult = await capturePhaseVisionScore({ msg: cycleResponse, actionName: action, phaseTag: `farm-cycle-${action}` });
+    // const nextAction = inferNextActionFromScore(action, scoreResult?.score || null);  // DISABLED
+    const nextAction = null; // DISABLED — purely ephemeral-based flow
+
+    // 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)}"`);
     }
 
-    const scoreResult = await capturePhaseVisionScore({ msg: cycleResponse, actionName: action, phaseTag: `farm-cycle-${action}` });
-    const score = scoreResult?.score || null;
-    const nextAction = inferNextActionFromScore(action, score);
+    // 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,13 +1865,29 @@ 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';
+
+            await sleep(300);
+            continue;
+          }
+        }
+      }
       break;
     }
 
     LOG.info(`[farm:cycle:${cycleDepth}] next action = ${nextAction} (after ${action})`);
     lastAction = action;
     cycleDepth++;
-    initialAnalysis = imgAnalysis; // pass updated analysis to next iteration
+
     await sleep(300);
   }
 
@@ -1597,7 +1927,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     }
   }
 
-  await capturePhaseVisionScore({ msg: cycleResponse, actionName: lastAction || 'harvest', phaseTag: 'farm-final' });
+
 
   if (coins > 0) {
     LOG.coin(`[farm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);