dankgrinder 7.7.0 → 7.12.0

package/bin/dankgrinder.js

@@ -33,7 +33,7 @@ if (args.includes('--version') || args.includes('-v')) {
   process.exit(0);
 }
 
-let apiKey = process.env.DANKGRINDER_KEY || '';
+let apiKey = process.env.DANKGRINDER_KEY || process.env.GRINDER_API_KEY || '';
 let apiUrl = '';
 let redisUrl = '';
 
@@ -43,7 +43,7 @@ for (let i = 0; i < args.length; i++) {
   if (args[i] === '--redis' && args[i + 1]) redisUrl = args[i + 1];
 }
 
-apiUrl = apiUrl || process.env.DANKGRINDER_URL || DEFAULT_URL;
+apiUrl = apiUrl || process.env.DANKGRINDER_URL || process.env.GRINDER_URL || DEFAULT_URL;
 if (redisUrl) process.env.REDIS_URL = redisUrl;
 
 // Keep process alive on transient discord interaction fetch failures.

package/lib/commands/farm.js

@@ -5,15 +5,9 @@ const {
 } = require('./utils');
 const { buyItem, buyItemsBatch } = require('./shop');
 const rawLogger = require('../../lib/rawLogger');
-const {
-  downloadImage,
-  extractFarmImageUrl,
-  analyzeFarmGrid,
-  gridToString,
-  evaluateActionNeed,
-  evaluateActionScores,
-  dumpFarmVisionDebug,
-} = require('./farmVision');
+// 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;
@@ -414,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);
@@ -486,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;
@@ -505,7 +503,9 @@ function inferNextActionFromScore(actionName, score) {
   }
   return null;
 }
+*/
 
+/* DISABLED — vision-based preferred action inference
 async function inferPreferredActionFromImage(msg) {
   try {
     const url = extractFarmImageUrl(msg);
@@ -518,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);
@@ -642,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) {
@@ -656,6 +631,7 @@ async function capturePhaseVisionScore({ msg, actionName, phaseTag }) {
   }
   return check;
 }
+*/
 
 function mergeBuyPlan(plan) {
   const m = new Map();
@@ -1115,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();
@@ -1149,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));
@@ -1157,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) {
@@ -1180,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.
@@ -1238,6 +1227,12 @@ 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);
@@ -1353,12 +1348,22 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
   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 (!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.
-    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`);
+  if (!redisRecovered && growReadySec && growReadySec > 20) {
+    // 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' };
   }
 
@@ -1395,19 +1400,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
     }
   }
 
-  // ── 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;
@@ -1416,11 +1408,15 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
   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
+  let lastRejectedAction2 = null; // Track previous rejected action to detect 3-in-a-row 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;
@@ -1429,6 +1425,23 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
     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;
     }
@@ -1490,39 +1503,48 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
           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.
+        // 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 — trying to buy ${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);
-            // 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;
+            // 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`);
           }
         }
-        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'}`);
         actionsTaken++;
         lastAction = action;
         forcedNextAction = nextPhase;
         cycleDepth++;
         if (!nextPhase) break;
-        initialAnalysis = null;
         await sleep(300);
         continue;
       }
@@ -1539,20 +1561,146 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
     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);
 
-    // ── 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).
+    // ── 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();
+
+      // Generic "nothing to X" no-op: when an action completes but has nothing to act on,
+      // cascade forward without treating it as a rejection. Also use this as a safety break
+      // when the same action keeps getting rejected (stuck in a loop).
+      if (
+        // "Nothing to water/hoe/plant/harvest" — action succeeded but was a no-op
+        /nothing to (water|hoe|plant|harvest)|no crops? (to |to )?(water|harvest)|0 x [a-z]|nothing to do/i.test(ephemText) ||
+        // Safety: if the same action was rejected 3+ cycles in a row, something is stuck — break
+        (lastRejectedAction === action && lastRejectedAction2 === action)
+      ) {
+        LOG.warn(`[farm:cycle:${cycleDepth}:reject] ${action} is a no-op or stuck loop (${ephemText.slice(0, 80)}) — cascading to next phase`);
+        const currentIdx = FARM_PHASE_ORDER.indexOf(action);
+        const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+        lastRejectedAction2 = lastRejectedAction;
+        lastRejectedAction = action;
+        forcedNextAction = nextPhase;
+        lastAction = action;
+        justRejected = true;
+        cycleDepth++;
+        if (!nextPhase) { forcedNextAction = null; break; }
+        await reenterManage();
+        await sleep(300);
+        continue;
+      }
+
+      // 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;
+        lastRejectedAction2 = lastRejectedAction;
+        lastRejectedAction = action;
+        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;
+        lastRejectedAction2 = lastRejectedAction;
+        lastRejectedAction = action;
+        forcedNextAction = nextPhase;
+        lastAction = action;
+        justRejected = true;
+        // Break oscillation guard: if we bounced back here from plant, stop.
+        if (lastRejectedAction2 === 'plant' && lastRejectedAction === '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;
+        lastRejectedAction2 = lastRejectedAction;
+        lastRejectedAction = action;
+        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']));
@@ -1562,6 +1710,14 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
       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']);
@@ -1578,12 +1734,13 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
         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.
+        // 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)`);
@@ -1595,10 +1752,19 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
             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++;
-        initialAnalysis = null;
         await sleep(300);
         continue;
       }
@@ -1607,22 +1773,18 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
 
     // ── Harvest ephemeral: parse "You harvested: Nothing" to detect no-op ──────────
     if (action === 'harvest') {
-      const ephemeral = lastApplyResp?._capturedEphemeral;
+      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] "${harvestText.slice(0, 300)}"`);
+        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).
-        // 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;
+        // 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)];
@@ -1660,6 +1822,9 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
           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'}`);
@@ -1667,7 +1832,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
         if (!nextPhase) break;
         cycleDepth++;
         lastAction = nextPhase;
-        initialAnalysis = null;
         await sleep(400);
         continue;
       }
@@ -1679,7 +1843,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
       if (!nextPhase) break;
       cycleDepth++;
       lastAction = nextPhase;
-      initialAnalysis = null;
       await sleep(300);
       continue;
     }
@@ -1687,22 +1850,11 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
     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}`);
-    }
-
-    const scoreResult = await capturePhaseVisionScore({ msg: cycleResponse, actionName: action, phaseTag: `farm-cycle-${action}` });
-    const score = scoreResult?.score || null;
-    const nextAction = inferNextActionFromScore(action, score);
+    // 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
@@ -1754,7 +1906,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
             forcedNextAction = 'harvest';
             cycleDepth++;
             lastAction = 'water';
-            initialAnalysis = null;
+
             await sleep(300);
             continue;
           }
@@ -1766,7 +1918,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
     LOG.info(`[farm:cycle:${cycleDepth}] next action = ${nextAction} (after ${action})`);
     lastAction = action;
     cycleDepth++;
-    initialAnalysis = imgAnalysis; // pass updated analysis to next iteration
+
     await sleep(300);
   }
 
@@ -1806,7 +1958,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId, fo
     }
   }
 
-  await capturePhaseVisionScore({ msg: cycleResponse, actionName: lastAction || 'harvest', phaseTag: 'farm-final' });
+
 
   if (coins > 0) {
     LOG.coin(`[farm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);

package/lib/grinder.js

@@ -3214,10 +3214,12 @@ async function start(apiKey, apiUrl) {
   loginLines.push(`  ${'─'.repeat(loginVis)}`);
   for (const l of loginLines) console.log(l);
 
-  // Dynamically capture the starting row of the login table via DSR
+  // Dynamically capture the starting row of the login table via DSR.
+  // Write MARKER to stderr (not stdout) to avoid PTY cooked-mode echoing
+  // of the visible "@MARKER@@" text portion, which was causing the DSR
+  // response to be swallowed or delayed.
   let loginBaseRow = 1;
   const captureLoginRow = () => new Promise(resolve => {
-    process.stdout.write(MARKER);
     const chunks = [];
     const handler = (chunk) => {
       chunks.push(chunk);
@@ -3230,6 +3232,8 @@ async function start(apiKey, apiUrl) {
       }
     };
     process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
     setTimeout(resolve, 50);
   });
   await captureLoginRow();
@@ -3331,7 +3335,7 @@ async function start(apiKey, apiUrl) {
   const invVis = 7 + iColNum + iColName + iColItems + iColVal + 12;
 
   // Print a unique marker, query its position, then overwrite it with the table
-  process.stdout.write(MARKER);
+  // Set up stdin handler BEFORE writing MARKER (same fix as Phase 1 — avoids race)
   let invBaseRow = 1;
   const captureRow = () => new Promise(resolve => {
     const chunks = [];
@@ -3346,6 +3350,8 @@ async function start(apiKey, apiUrl) {
       }
     };
     process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
     setTimeout(resolve, 50);
   });
   await captureRow();
@@ -3414,7 +3420,7 @@ async function start(apiKey, apiUrl) {
   const balVis = 7 + bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 14;
 
   // Capture starting row for balance phase
-  process.stdout.write(MARKER);
+  // Set up stdin handler BEFORE writing MARKER (same fix — avoids race + PTY echo)
   let balBaseRow = 1;
   const balCaptureRow = () => new Promise(resolve => {
     const chunks = [];
@@ -3429,6 +3435,8 @@ async function start(apiKey, apiUrl) {
       }
     };
     process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
     setTimeout(resolve, 50);
   });
   await balCaptureRow();

package/package.json

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