dankgrinder 6.25.0 → 6.34.0

package/lib/commands/farm.js

@@ -18,6 +18,50 @@ const RE_TS = /<t:(\d+):R>/;
 const RE_MIN = /(\d+)\s*minute/i;
 const RE_HR = /(\d+)\s*hour/i;
 
+// Redis key helpers for farm state persistence across runs.
+const FARM_KEYS = {
+  harvestTime: (accountId) => `dkg:farm:harvested_at:${accountId}`,
+  growDuration: (accountId) => `dkg:farm:grow_duration:${accountId}`,
+  lastCoins:   (accountId) => `dkg:farm:last_coins:${accountId}`,
+};
+
+const DEFAULT_GROW_DURATION_MS = 25 * 60 * 1000; // 25 min typical grow time
+
+// Stores harvest time in Redis so subsequent runs know when to re-check.
+async function recordHarvestInRedis(redis, accountId, growDurationMs) {
+  if (!redis) return;
+  try {
+    const key = FARM_KEYS.harvestTime(accountId);
+    await redis.set(key, String(Date.now()), 'EX', 7200);
+    if (growDurationMs) {
+      await redis.set(FARM_KEYS.growDuration(accountId), String(growDurationMs), 'EX', 7200);
+    }
+  } catch {}
+}
+
+// Checks Redis for last harvest time. If crops should be ready by now,
+// returns 0 so the cycle starts immediately instead of queuing.
+async function getHarvestRecoveryMs(redis, accountId) {
+  if (!redis) return null;
+  try {
+    const key = FARM_KEYS.harvestTime(accountId);
+    const harvestedAt = await redis.get(key);
+    if (!harvestedAt) return null;
+
+    const growDurKey = FARM_KEYS.growDuration(accountId);
+    const growDurationMs = parseInt(await redis.get(growDurKey) || '', 10) || DEFAULT_GROW_DURATION_MS;
+    const readyAt = parseInt(harvestedAt, 10) + growDurationMs;
+    const remaining = readyAt - Date.now();
+
+    // Crops should be ready — return 0 so we skip the grow queue
+    if (remaining <= 0) return 0;
+    // Still growing — return remaining ms
+    return remaining;
+  } catch {
+    return null;
+  }
+}
+
 function parseFarmCooldownSec(text) {
   const clean = String(text || '');
   const lower = clean.toLowerCase();
@@ -41,42 +85,59 @@ function parseFarmGrowReadySec(text) {
   const lower = clean.toLowerCase();
 
   // If crops are already harvestable, don't queue waiting.
-  if (/ready to harvest|harvest ready|can be harvested|wilt/.test(lower)) return 0;
+  if (/ready to harvest|harvest ready|can be harvested|wilts?/i.test(lower)) return 0;
+
+  // If the farm is empty / shows plantable / needs tilling, no grow queue needed.
+  // This handles the post-harvest state where Dank Memer shows
+  // "ready in 26m" for the NEXT planting rather than current crops.
+  const farmIsEmpty = /seems? pretty empty|pretty empty|empty\.{0,3}|start.*hoe|plant.*hoe|need.*hoe/i.test(lower);
+  if (farmIsEmpty) return null;
 
   const now = Math.floor(Date.now() / 1000);
 
-  // Prefer explicit Discord relative timestamps that appear on lines with "ready".
-  const tsNearReady = [];
-  const re = /<t:(\d+):R>/ig;
-  let m;
-  while ((m = re.exec(clean)) !== null) {
-    const t = parseInt(m[1], 10);
-    if (!Number.isFinite(t) || t <= now) continue;
-    const idx = m.index;
-    const left = clean.slice(Math.max(0, idx - 80), idx).toLowerCase();
-    const right = clean.slice(idx, Math.min(clean.length, idx + 30)).toLowerCase();
-    if (/ready|grow|seed/.test(left) || /ready/.test(right)) {
-      tsNearReady.push(t - now);
+  // Only treat timestamps as "growing" if they appear on the SAME LINE as
+  // grow/seed/crop context — NOT standalone timestamps that might be the
+  // next planting cooldown.
+  const lines = clean.split('\n');
+  let best = null;
+
+  for (const line of lines) {
+    const lineLower = line.toLowerCase();
+    // Only look for timestamps in lines that mention growing context
+    const isGrowingLine = /grow|seed|crop|plant|harvest|ripe/i.test(lineLower);
+
+    const tsMatches = [...line.matchAll(/<t:(\d+):R>/g)];
+    for (const match of tsMatches) {
+      const t = parseInt(match[1], 10);
+      if (!Number.isFinite(t) || t <= now) continue;
+      const sec = t - now;
+
+      // On "growing" lines, accept the timestamp as grow queue
+      if (isGrowingLine) {
+        if (best === null || sec < best) best = sec;
+      }
+    }
+
+    // Text patterns — only on growing context lines
+    if (isGrowingLine) {
+      for (const re of [
+        [/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*second/i, 1],
+        [/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*minute/i, 60],
+        [/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*hour/i, 3600],
+        [/ready\s+in\s+(\d+)\s*second/i, 1],
+        [/ready\s+in\s+(\d+)\s*minute/i, 60],
+        [/ready\s+in\s+(\d+)\s*hour/i, 3600],
+      ]) {
+        const m = line.match(re[0]);
+        if (m) {
+          const sec = Math.max(5, parseInt(m[1], 10) * re[1]);
+          if (best === null || sec < best) best = sec;
+        }
+      }
     }
   }
-  if (tsNearReady.length > 0) return Math.max(5, Math.min(...tsNearReady));
-
-  // Fallback textual patterns.
-  const willReadyH = clean.match(/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*hour/i);
-  if (willReadyH) return Math.max(5, parseInt(willReadyH[1], 10) * 3600);
-  const willReadyM = clean.match(/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*minute/i);
-  if (willReadyM) return Math.max(5, parseInt(willReadyM[1], 10) * 60);
-  const willReadyS = clean.match(/(?:will\s+be\s+)?ready\s+in\s+(\d+)\s*second/i);
-  if (willReadyS) return Math.max(5, parseInt(willReadyS[1], 10));
-
-  const h = clean.match(/ready\s+in\s+(\d+)\s*hour/i);
-  if (h) return Math.max(5, parseInt(h[1], 10) * 3600);
-  const mi = clean.match(/ready\s+in\s+(\d+)\s*minute/i);
-  if (mi) return Math.max(5, parseInt(mi[1], 10) * 60);
-  const s = clean.match(/ready\s+in\s+(\d+)\s*second/i);
-  if (s) return Math.max(5, parseInt(s[1], 10));
 
-  return null;
+  return best;
 }
 
 const FARM_RESTOCK_ORDER = ['hoe', 'watering can', 'seeds', 'water bucket'];
@@ -88,6 +149,12 @@ const FARM_BUY_ALIASES = Object.freeze({
 });
 
 const FARM_TOTAL_SLOTS = 9;
+const FARM_PHASE_ORDER = ['hoe', 'water', 'plant', 'harvest'];
+// Seed preference: random among potato/beans group, else carrot, else highest-qty fallback
+const SEED_PRIORITY_GROUPS = [
+  ['potato', 'beans', 'bean'],  // random pick when available
+  ['carrot'],                   // fallback
+];
 
 function parseMissingFarmItem(text) {
   const lower = String(stripAnsi(text || '')).toLowerCase();
@@ -480,12 +547,22 @@ function chooseSeedOption(menu) {
   const withQty = options.map(o => {
     const label = String(o.label || '');
     const m = label.match(/\((\d{1,5})\)/);
-    return { option: o, qty: m ? parseInt(m[1], 10) : 0, isDefault: !!o.default };
+    return { option: o, qty: m ? parseInt(m[1], 10) : 0, label };
   });
 
-  const defaultOpt = withQty.find(x => x.isDefault && x.qty > 0);
-  if (defaultOpt) return defaultOpt.option;
+  // Try each priority group in order
+  for (const group of SEED_PRIORITY_GROUPS) {
+    const matches = withQty.filter(x =>
+      x.qty > 0 && group.some(s => x.label.toLowerCase().includes(s))
+    );
+    if (matches.length > 0) {
+      const pick = matches[Math.floor(Math.random() * matches.length)];
+      LOG.info(`[farm:plant] seed group=[${group.join('/')}] picked="${pick.label}" qty=${pick.qty}`);
+      return pick.option;
+    }
+  }
 
+  // Fallback: highest qty
   const best = withQty.sort((a, b) => b.qty - a.qty)[0];
   return best?.option || options[0];
 }
@@ -976,7 +1053,175 @@ async function waitForEditedMessage(channel, messageId, baselineText, timeoutMs
   return null;
 }
 
-async function runFarm({ channel, waitForDankMemer, client, _buyRetryDepth = 0, _visionRetryDepth = 0, _preferredAction = null }) {
+// Advance past confirmation screens that appear after "Apply All".
+// Dank Memer shows things like "Hoe All (9)" then "Continue" / "Confirm".
+// Returns the next manage-menu screen (or the last confirmation screen if nothing to click).
+// 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) {
+  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' };
+
+  const managedActions = getManageActionButtons(msg);
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+
+  // If we were explicitly told to try a specific action (e.g., advancing from hoe→water),
+  // skip the empty-farm default. If that action's button is also disabled,
+  // cascade through the rest of the phase order.
+  if (forcedNextAction) {
+    const phaseOrder = FARM_PHASE_ORDER;
+    const forcedIdx = phaseOrder.indexOf(forcedNextAction);
+    // Try forced action first, then cascade through remaining phases
+    for (let i = forcedIdx; i < phaseOrder.length; i++) {
+      const phase = phaseOrder[i];
+      const btn = managedActions[phase] || btns.find(b => hasAny(b, [phase]));
+      if (btn) return { action: phase, button: btn, reason: `forced(${forcedNextAction}→${phase})` };
+    }
+  }
+
+  // If farm is empty, always start with hoe.
+  if (/seems pretty empty|pretty empty|empty\.{0,3}/i.test(lower)) {
+    const btn = managedActions.hoe || btns.find(b => hasAny(b, ['hoe', 'till']));
+    if (btn) return { action: 'hoe', button: btn, reason: 'farm-empty' };
+  }
+
+  // If crops are ready to harvest, go straight to harvest.
+  if (/ready to harvest|harvest ready|can be harvested|wilt/i.test(lower)) {
+    const btn = managedActions.harvest || btns.find(b => hasAny(b, ['harvest', 'reap', 'collect']));
+    if (btn) return { action: 'harvest', button: btn, reason: 'harvest-ready-text' };
+  }
+
+  // Use image vision ratios if available.
+  if (imageAnalysis) {
+    const slots = Math.max(1, (imageAnalysis.rows || 3) * (imageAnalysis.cols || 3));
+    const ratios = {
+      tilled: (imageAnalysis.counts?.tilled || 0) / slots,
+      wet: (imageAnalysis.counts?.wet || 0) / slots,
+      planted: (imageAnalysis.counts?.planted || 0) / slots,
+      unknown: (imageAnalysis.counts?.unknown || 0) / slots,
+    };
+
+    // Phase-aware selection: pick the earliest incomplete phase.
+    // Harvest when planted >= 45%.
+    if (ratios.planted >= 0.45) {
+      const btn = managedActions.harvest || btns.find(b => hasAny(b, ['harvest', 'reap', 'collect']));
+      if (btn) return { action: 'harvest', button: btn, reason: `harvest-ready-vision(planted=${ratios.planted.toFixed(2)})` };
+    }
+    // Plant when wet >= 45% or tilled >= 45%.
+    if (ratios.wet >= 0.45 || ratios.tilled >= 0.45) {
+      const btn = managedActions.plant || btns.find(b => hasAny(b, ['plant', 'seed', 'sow']));
+      if (btn) return { action: 'plant', button: btn, reason: `plant-vision(wet=${ratios.wet.toFixed(2)},tilled=${ratios.tilled.toFixed(2)})` };
+    }
+    // Water when we have tilled tiles but not enough wet.
+    if (ratios.tilled >= 0.35 && ratios.wet < 0.35) {
+      const btn = managedActions.water || btns.find(b => hasAny(b, ['water', 'watering']));
+      if (btn) return { action: 'water', button: btn, reason: `water-vision(tilled=${ratios.tilled.toFixed(2)},wet=${ratios.wet.toFixed(2)})` };
+    }
+    // Hoe when farm is mostly unknown/empty.
+    if (ratios.tilled < 0.35 && ratios.wet < 0.35 && ratios.planted < 0.35) {
+      const btn = managedActions.hoe || btns.find(b => hasAny(b, ['hoe', 'till']));
+      if (btn) return { action: 'hoe', button: btn, reason: `hoe-vision(t=${ratios.tilled.toFixed(2)},w=${ratios.wet.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.
+  const PHASE_ALL_DISABLED = [
+    { action: 'hoe',     word: 'hoe all' },
+    { action: 'water',   word: 'water all' },
+    { action: 'plant',   word: 'plant all' },
+    { action: 'harvest', word: 'harvest all' },
+  ];
+
+  // Find the first non-disabled action based on its All button state.
+  for (const phase of FARM_PHASE_ORDER) {
+    if (currentAction && FARM_PHASE_ORDER.indexOf(currentAction) >= FARM_PHASE_ORDER.indexOf(phase)) continue;
+    const def = PHASE_ALL_DISABLED.find(p => p.action === phase);
+    if (!def) continue;
+    const allDisabled = allBtns.some(b => b.disabled && buttonHay(b).includes(def.word));
+    if (!allDisabled) {
+      const btn = managedActions[phase];
+      if (btn) return { action: phase, button: btn, reason: `all-enabled-${phase}` };
+    }
+  }
+
+  // Fallback: use the existing priority logic.
+  const picked = pickFarmActionButton(msg, text);
+  if (picked?.button) return { action: picked.action, button: picked.button, reason: 'fallback-priority' };
+
+  return { action: null, button: null, reason: 'no-action-found' };
+}
+
+async function advancePastConfirmation(response, waitForDankMemer) {
+  if (!response) return null;
+
+  const CONFIRM_WORDS = ['continue', 'confirm', 'confirm all', 'done', 'back to farm', 'back', 'close'];
+  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)));
+
+    if (!confirmBtn) {
+      // No more confirmation buttons — return the current screen (should be manage menu)
+      LOG.info(`[farm:confirm] no confirm btn on page ${page}, returning current screen`);
+      return response;
+    }
+
+    LOG.info(`[farm:confirm] page ${page}: clicking "${confirmBtn.label || '-'}"`);
+    await humanDelay(80, 220);
+
+    const baseline = brief(getFullText(response), 400);
+    let clicked;
+    try {
+      clicked = await safeClickButton(response, confirmBtn);
+      logEphemeralLike(`confirm-page-${page}`, clicked);
+    } catch (e) {
+      LOG.warn(`[farm:confirm] click failed on page ${page}: ${e.message}`);
+      return response;
+    }
+
+    let next = clicked || null;
+    if (!next && response.id) {
+      next = await waitForEditedMessage(response.channel || (await response.fetchChannel?.()), response.id, baseline, 8000);
+    }
+    if (!next) {
+      next = await waitForDankMemer(7000);
+    }
+
+    if (!next) {
+      LOG.warn(`[farm:confirm] no response after confirm click page ${page}`);
+      return response;
+    }
+
+    if (isCV2(next)) await ensureCV2(next);
+    logMsg(next, `confirm-page-${page}`);
+    logFarmState(`confirm-page-${page}`, next);
+
+    // If we got the same message back with no changes, stop looping
+    if (next.id === response.id) {
+      const afterText = brief(getFullText(next), 200);
+      const btnsAfter = getAllButtons(next);
+      const hasConfirmBtn = btnsAfter.some(b => CONFIRM_WORDS.some(w => buttonHay(b).includes(w)));
+      if (!hasConfirmBtn) {
+        LOG.info(`[farm:confirm] screen unchanged after page ${page} click, returning`);
+        return next;
+      }
+    }
+
+    response = next;
+  }
+
+  LOG.info(`[farm:confirm] max confirmation pages (${MAX_PAGES}) reached`);
+  return response;
+}
+
+// ── 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 }) {
   LOG.cmd(`${c.white}${c.bold}pls farm view${c.reset}`);
 
   await channel.send('pls farm view');
@@ -1002,550 +1247,382 @@ async function runFarm({ channel, waitForDankMemer, client, _buyRetryDepth = 0,
   let text = getFullText(response);
   let clean = brief(text, 600);
   const lower = clean.toLowerCase();
-  let farmVision = analyzeFarmState({ msg: response, text });
-  LOG.info(`[farm:vision] stage=${farmVision.stage}${farmVision.seedStock ? ` seed=${farmVision.seedStock.itemName}:${farmVision.seedStock.qty}` : ''}${farmVision.missing ? ` missing=${farmVision.missing}` : ''}`);
-
-  if (farmVision.missing) {
-    const earlyMissingItems = [farmVision.missing];
-    LOG.warn(`[farm] Missing items: ${c.bold}${earlyMissingItems.join(', ')}${c.reset} — auto-buying...`);
-    const boughtItems = [];
-    for (const item of earlyMissingItems) {
-      const bought = await tryBuyFarmItem({ missing: item, channel, waitForDankMemer, client });
-      if (!bought.ok) {
-        LOG.warn(`[farm] Could not buy ${item} (insufficient coins or unavailable) — retrying in 1h`);
-        return { result: `need ${item} (buy failed)`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_missing_item' };
-      }
-      boughtItems.push(bought.itemName);
-    }
-    LOG.success(`[farm] Bought: ${boughtItems.join(', ')}. Retrying farm flow...`);
-    await sleep(1200);
-    if (_buyRetryDepth < 1) {
-  return runFarm({ channel, waitForDankMemer, client, _buyRetryDepth: _buyRetryDepth + 1, _visionRetryDepth });
-    }
-    return { result: `auto-bought ${boughtItems.join(', ')}`, coins: 0, nextCooldownSec: 10 };
-  }
 
+  // Subcommand required — retry once.
   if (lower.includes('must specify a subcommand')) {
-    LOG.warn('[farm] Subcommand required response detected; retrying with "pls farm view"');
+    LOG.warn('[farm] Subcommand required; retrying "pls farm view"');
     await channel.send('pls farm view');
     const retry = await waitForDankMemer(12000);
-  if (!retry) return { result: 'no response after farm view retry', coins: 0, nextCooldownSec: 120 };
+    if (!retry) return { result: 'no response after farm view retry', coins: 0, nextCooldownSec: 120 };
     response = retry;
     if (isCV2(response)) await ensureCV2(response);
     logMsg(response, 'farm-retry-view');
     logFarmState('retry-view', response);
-  logFarmDeepState('retry-view', response);
     text = getFullText(response);
     clean = brief(text, 600);
-    farmVision = analyzeFarmState({ msg: response, text });
   }
 
   const cd = parseFarmCooldownSec(text);
   if (cd || lower.includes('already farmed') || lower.includes('farm again') || lower.includes('on cooldown')) {
-    const sec = cd || 10;
-    return { result: `farm cooldown (${Math.ceil(sec / 60)}m)`, coins: 0, nextCooldownSec: sec };
+    return { result: `farm cooldown (${Math.ceil((cd || 10) / 60)}m)`, coins: 0, nextCooldownSec: cd || 10 };
   }
 
-  // Queue grow phase: if crops are still growing, wait until next ready window.
+  // Queue grow phase — don't enter the cycle if crops are still growing.
+  // But check Redis: if we recently harvested, crops may be ready now even if
+  // the game message shows a long cooldown (Dank Memer plants immediately after harvest).
+  const redisRecoveryMs = await getHarvestRecoveryMs(redis, accountId);
+  const redisRecovered = redisRecoveryMs === 0;
   const growReadySec = parseFarmGrowReadySec(text);
-  LOG.info(`[farm] grow-ready parse=${growReadySec == null ? 'none' : `${growReadySec}s`}`);
-  if (growReadySec && growReadySec > 20) {
-    // Keep image-first diagnostics even while queuing.
+  const textHasHarvestReady = /ready to harvest|harvest ready|can be harvested|wilts?/i.test(lower);
+  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) {
     await inferPreferredActionFromImage(response);
-    const waitSec = Math.min(6 * 3600, growReadySec + 2);
-    LOG.info(`[farm] crops growing; queuing harvest check in ${waitSec}s`);
-    return {
-      result: `farm grow queue (${Math.ceil(waitSec / 60)}m)` ,
-      coins: 0,
-      nextCooldownSec: waitSec,
-      skipReason: 'farm_grow_queue',
-    };
+    // 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`);
+    return { result: `farm grow queue (${Math.ceil(growReadySec / 60)}m)`, coins: 0, nextCooldownSec: waitSec, skipReason: 'farm_grow_queue' };
   }
 
-  // Step 1: go to farm manage mode first (where Hoe/Water/Plant/etc live)
+  // Check for missing items on the initial farm view — buy and retry once.
+  const farmVision0 = analyzeFarmState({ msg: response, text });
+  LOG.info(`[farm:vision] stage=${farmVision0.stage}${farmVision0.missing ? ` missing=${farmVision0.missing}` : ''}`);
+  if (farmVision0.missing) {
+    const bought = await tryBuyFarmItem({ missing: farmVision0.missing, channel, waitForDankMemer, client });
+    if (!bought.ok) {
+      return { result: `need ${farmVision0.missing} (buy failed)`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_missing_item' };
+    }
+    LOG.success(`[farm] Auto-bought ${bought.itemName}. Retrying farm flow...`);
+    await sleep(1200);
+    // Retry once with the same flow.
+    await channel.send('pls farm view');
+    response = await waitForDankMemer(12000);
+    if (!response) return { result: 'no response after retry', coins: 0, nextCooldownSec: 90 };
+    if (isCV2(response)) await ensureCV2(response);
+    text = getFullText(response);
+    clean = brief(text, 600);
+  }
+
+  // ── Open the manage menu ───────────────────────────────────────────────────
   const manageBtn = findFarmButton(response, ['manage', 'farm-farm:manage']);
   if (manageBtn) {
     LOG.info('[farm] Opening Manage menu');
     await humanDelay(90, 260);
-    try {
-      const managed = await clickAndCapture({
-        channel,
-        waitForDankMemer,
-        response,
-        button: manageBtn,
-        tag: 'farm-manage',
-      });
-      if (managed) {
-        response = managed;
-        text = getFullText(response);
-        clean = brief(text, 600);
-        farmVision = analyzeFarmState({ msg: response, text });
-        LOG.info(`[farm:vision] stage=${farmVision.stage}${farmVision.seedStock ? ` seed=${farmVision.seedStock.itemName}:${farmVision.seedStock.qty}` : ''}${farmVision.missing ? ` missing=${farmVision.missing}` : ''}`);
-        logFarmDeepState('after-manage', response);
-      }
-    } catch (e) {
-      LOG.error(`[farm] Manage click failed: ${e.message}`);
-    }
-  }
-
-  // Step 2: image-first phase suggestion. If we already know a target action,
-  // skip deep multi-action audit to avoid touching every phase every run.
-  const imageSuggestedAction = await inferPreferredActionFromImage(response);
-  const lowerNow = String(stripAnsi(text || '')).toLowerCase();
-  let textSuggestedAction = null;
-  if (/seems pretty empty|pretty empty|empty\.{0,3}/i.test(lowerNow)) {
-    textSuggestedAction = 'hoe';
-  } else if (/ready to harvest|harvest ready|can be harvested|wilt/i.test(lowerNow)) {
-    textSuggestedAction = 'harvest';
-  }
-  const harvestTextReady = /ready to harvest|can be harvested|harvest ready|wilt/i.test(String(stripAnsi(text || '')).toLowerCase());
-  const effectivePreferredAction = _preferredAction || textSuggestedAction || (harvestTextReady ? 'harvest' : imageSuggestedAction) || null;
-
-  if (!effectivePreferredAction) {
-    const audited = await auditManageAndBuildBuyPlan({ response, channel, waitForDankMemer, client });
-    if (audited?.response) {
-      response = audited.response;
+    const managed = await clickAndCapture({ channel, waitForDankMemer, response, button: manageBtn, tag: 'farm-manage' });
+    if (managed) {
+      response = managed;
       text = getFullText(response);
       clean = brief(text, 600);
+      logFarmDeepState('after-manage', response);
     }
-    if ((audited?.buyPlan || []).length > 0) {
-      LOG.info(`[farm] audit buy plan: ${(audited.buyPlan || []).map(p => `${p.item} x${p.qty}`).join(', ')}`);
-      const batch = await buyItemsBatch({
-        channel,
-        waitForDankMemer,
-        client,
-        items: audited.buyPlan.map(s => ({ itemName: s.item, quantity: s.qty })),
-      });
-
-      if (!batch.ok) {
-        const failed = (batch.results || []).find(r => !r.success);
-        const fItem = failed?.itemName || audited.buyPlan[0]?.item || 'item';
-        LOG.warn(`[farm] Batch buy failed for ${fItem} — retrying in 1h`);
-        return { result: `need ${fItem} (buy failed)`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_audit_restock_failed' };
-      }
-
-      for (const r of (batch.results || [])) {
-        if (r.success) LOG.success(`[farm] Bought ${r.itemName} (${r.reason || 'ok'})`);
-      }
-      LOG.success('[farm] audit restock complete, retrying farm flow...');
-      await sleep(1200);
-      if (_buyRetryDepth < 2) {
-        return runFarm({ channel, waitForDankMemer, client, _buyRetryDepth: _buyRetryDepth + 1, _visionRetryDepth, _preferredAction: effectivePreferredAction });
-      }
-    }
-  } else {
-    LOG.info(`[farm] skipping deep audit; phase-directed flow using action=${effectivePreferredAction}`);
   }
 
-  // Step 3: select menu if farm presents crop/options
-  const menus = getAllSelectMenus(response);
-  if (menus.length > 0) {
-    const menu = menus[0];
-    const options = (menu.options || []).filter(o => !o.default);
-    if (options.length > 0) {
-      const pick = options[Math.floor(Math.random() * options.length)];
-      LOG.info(`[farm] Selecting option: "${pick.label}"`);
-      try {
-        await response.selectMenu(menu.customId || menu.custom_id || 0, [pick.value]);
-        const upd = await waitForDankMemer(7000);
-        if (upd) {
-          response = upd;
-          if (isCV2(response)) await ensureCV2(response);
-          logMsg(response, 'farm-after-select');
-          logFarmState('after-select', response);
-          logFarmDeepState('after-select', response);
-          text = getFullText(response);
-          clean = brief(text, 600);
-          farmVision = analyzeFarmState({ msg: response, text });
-          LOG.info(`[farm:vision] stage=${farmVision.stage}${farmVision.seedStock ? ` seed=${farmVision.seedStock.itemName}:${farmVision.seedStock.qty}` : ''}${farmVision.missing ? ` missing=${farmVision.missing}` : ''}`);
-        }
-      } catch (e) {
-        LOG.error(`[farm] Select failed: ${e.message}`);
-      }
+  // ── 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}`);
   }
 
-  // Step 4: choose and click farm action (harvest/hoe/water/plant/...)
-  const countRestock = await restockFromManageCounts({ response, channel, waitForDankMemer, client });
-  if (countRestock.failed) {
-    return countRestock;
-  }
-  if (countRestock.boughtAny) {
-    LOG.success('[farm] Manage restock complete. Retrying farm flow...');
-    await sleep(1200);
-    if (_buyRetryDepth < 2) {
-  return runFarm({ channel, waitForDankMemer, client, _buyRetryDepth: _buyRetryDepth + 1, _visionRetryDepth });
-    }
-  }
+  // ── Cycle loop: hoe → water → plant → harvest ─────────────────────────────
+  let cycleDepth = 0;
+  let lastAction = null;
+  let cycleResponse = response;
+  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
 
-  const allButtons = getAllButtons(response).filter(b => !b.disabled);
-  const missingAfterManage = parseMissingFarmItems(text);
-  if (missingAfterManage.length > 0) {
-    LOG.warn(`[farm] Missing in manage flow: ${c.bold}${missingAfterManage.join(', ')}${c.reset} — auto-buying...`);
-    const boughtItems = [];
-    for (const item of missingAfterManage) {
-      const bought = await tryBuyFarmItem({ missing: item, channel, waitForDankMemer, client });
-      if (!bought.ok) {
-        LOG.warn(`[farm] Could not buy ${item} — retrying in 1h`);
-        return { result: `need ${item} (buy failed)`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_missing_item' };
-      }
-      boughtItems.push(bought.itemName);
-    }
-    LOG.success(`[farm] Bought: ${boughtItems.join(', ')}. Retrying farm flow...`);
-    await sleep(1200);
-    if (_buyRetryDepth < 1) {
-  return runFarm({ channel, waitForDankMemer, client, _buyRetryDepth: _buyRetryDepth + 1, _visionRetryDepth });
+  while (cycleDepth < 5) {
+    let actionResult;
+    try {
+      actionResult = await findNextFarmActionFromManage(cycleResponse, text, lastAction, initialAnalysis, forcedNextAction);
+    } catch (e) {
+      LOG.warn(`[farm:cycle] findNextFarmActionFromManage error: ${e.message}`);
+      break;
     }
-    return { result: `auto-bought ${boughtItems.join(', ')}`, coins: 0, nextCooldownSec: 10 };
-  }
+    const { action, button, reason } = actionResult;
+    forcedNextAction = null;
 
-  const preferredActions = getManageActionButtons(response);
-  const preferredBtn = effectivePreferredAction ? preferredActions[effectivePreferredAction] : null;
-  const pickedAction = preferredBtn
-    ? { action: effectivePreferredAction, button: preferredBtn }
-    : pickFarmActionButton(response, text);
-  const actionBtn = pickedAction?.button || allButtons.find(isFarmActionButton) || null;
-  const actionName = pickedAction?.action || 'action';
-  LOG.info(`[farm] action decision actionName=${actionName} preferred=${effectivePreferredAction || '-'} btn="${actionBtn?.label || '-'}"`);
-
-  if (!actionBtn) {
-    const labels = allButtons.map(b => (b.label || '-')).filter(Boolean);
-    const mgmtOnly = allButtons.length > 0 && allButtons.every(isFarmManagementButton);
-    if (labels.length > 0) {
-      LOG.info(`[farm] No actionable farm button found. visible=[${labels.join(', ')}]`);
-    }
-    const fallbackCd = mgmtOnly ? 300 : 60;
-    return {
-      result: mgmtOnly ? 'farm setup/management only (no crop actions yet)' : (clean || 'farm no actionable buttons'),
-      coins: 0,
-      nextCooldownSec: fallbackCd,
-    };
-  }
+    if (!action || !button) {
+      LOG.info(`[farm:cycle:${cycleDepth}] no action found (reason=${reason}) — breaking cycle`);
+      break;
+    }
 
-  let phaseScorePreApply = null;
+    LOG.info(`[farm:cycle:${cycleDepth}] action=${action} reason=${reason} btn="${button.label || '-'}"`);
 
-  LOG.info(`[farm] Clicking ${actionName}: "${actionBtn.label || '?'}"`);
-  await humanDelay(100, 280);
-  try {
-    const post = await clickAndCapture({
-      channel,
-      waitForDankMemer,
-      response,
-      button: actionBtn,
-      tag: 'farm-followup',
-      timeoutMs: 10000,
+    // Step 1: click the action tab (Hoe / Water / Plant / Harvest)
+    const actionResp = await clickAndCapture({
+      channel, waitForDankMemer, response: cycleResponse,
+      button, tag: `farm-cycle-${action}`, timeoutMs: 10000,
     });
-    if (post) {
-      response = post;
-      text = getFullText(response);
-      clean = brief(text, 600);
-      farmVision = analyzeFarmState({ msg: response, text });
-      LOG.info(`[farm:vision] stage=${farmVision.stage}${farmVision.seedStock ? ` seed=${farmVision.seedStock.itemName}:${farmVision.seedStock.qty}` : ''}${farmVision.missing ? ` missing=${farmVision.missing}` : ''}`);
-      logFarmDeepState('after-action', response);
+    if (!actionResp) { LOG.warn('[farm:cycle] action click returned null'); break; }
+    cycleResponse = actionResp;
+    text = getFullText(cycleResponse);
+    clean = brief(text, 600);
+    logFarmState(`after-${action}-tab`, cycleResponse);
+
+    // Step 2: buy missing items before applying
+    const missing = parseMissingFarmItem(text);
+    if (missing) {
+      const ok = await tryBuyFarmItem({ missing, channel, waitForDankMemer, client });
+      if (!ok) {
+        return { result: `need ${missing} (buy failed)`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_missing_item' };
+      }
+      LOG.success(`[farm] Bought ${missing}. Retrying cycle...`);
+      await sleep(1200);
+      // Restart the whole cycle after buying
+      await channel.send('pls farm view');
+      const re = await waitForDankMemer(12000);
+      if (!re) return { result: 'no response after restock retry', coins: 0, nextCooldownSec: 90 };
+      if (isCV2(re)) await ensureCV2(re);
+      const mb = findFarmButton(re, ['manage', 'farm-farm:manage']);
+      if (mb) {
+        const mr = await clickAndCapture({ channel, waitForDankMemer, response: re, button: mb, tag: 'farm-manage-restock' });
+        if (mr) { cycleResponse = mr; text = getFullText(cycleResponse); clean = brief(text, 600); }
+      } else { cycleResponse = re; text = getFullText(cycleResponse); clean = brief(text, 600); }
+    }
 
-      // Phase checkpoint #1: image score before applying "All".
-      phaseScorePreApply = await capturePhaseVisionScore({
-        msg: response,
-        actionName,
-        phaseTag: `${actionName}-pre-apply`,
-      });
+    // Step 3: seed selection for plant phase
+    if (action === 'plant') {
+      const seedPick = await ensurePlantSeedSelected({ response: cycleResponse, waitForDankMemer, channel });
+      if (seedPick?.response) { cycleResponse = seedPick.response; text = getFullText(cycleResponse); clean = brief(text, 600); }
+      LOG.info(`[farm:cycle:${cycleDepth}] plant seed selection selected=${!!seedPick?.selected} reason=${seedPick?.reason || 'unknown'}`);
     }
-  } catch (e) {
-    LOG.error(`[farm] Click failed: ${e.message}`);
-  }
 
-  // Seed top-up: if we know selected seed quantity and it's below 9 slots, buy only deficit.
-  if (actionName === 'plant') {
-    const seedInfo = farmVision.seedStock;
-    if (seedInfo && Number.isFinite(seedInfo.qty)) {
-      const deficit = Math.max(0, FARM_TOTAL_SLOTS - seedInfo.qty);
-      if (deficit > 0) {
-        LOG.warn(`[farm] ${seedInfo.itemName}: have ${seedInfo.qty}, need ${FARM_TOTAL_SLOTS} → buying ${deficit}`);
-        const bought = await buyItem({ channel, waitForDankMemer, client, itemName: seedInfo.itemName, quantity: deficit });
-        if (!bought) {
-          LOG.warn(`[farm] Could not buy ${deficit}x ${seedInfo.itemName} — retrying in 1h`);
-          return { result: `need ${seedInfo.itemName} +${deficit} (buy failed)`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_seed_deficit' };
-        }
-        LOG.success(`[farm] Bought ${deficit}x ${seedInfo.itemName}. Retrying farm flow...`);
-        await sleep(1200);
-        if (_buyRetryDepth < 2) {
-          return runFarm({ channel, waitForDankMemer, client, _buyRetryDepth: _buyRetryDepth + 1, _visionRetryDepth });
-        }
+    // Step 4: click the "All" button to apply to all tiles
+    const allBtn = findFarmButton(cycleResponse, [
+      ' all', 'all ', 'all)', 'all:', ':all',
+      'hoe all', 'water all', 'plant all', 'harvest all', 'confirm all',
+    ]);
+
+    // If no enabled "All" button — check if it's disabled (farm is empty for this phase).
+    // If disabled, treat as a no-op and set forcedNextAction for the next iteration.
+    if (!allBtn) {
+      const allBtnsInclDisabled = getAllButtons(cycleResponse);
+      const disabledAllBtn = allBtnsInclDisabled.find(b => {
+        const label = String(b.label || '').toLowerCase();
+        return (label.includes('all') || label.includes('hoe all') || label.includes('water all') ||
+          label.includes('plant all') || label.includes('harvest all') || label.includes('confirm')) && b.disabled;
+      });
+      if (disabledAllBtn) {
+        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;
       }
+      LOG.info(`[farm:cycle:${cycleDepth}] no All button for ${action} — breaking cycle`);
+      break;
     }
-  }
-
-  // Step 5: in plant phase, choose a seed in dropdown first (enables Plant All in many states)
-  if (actionName === 'plant') {
-    const seedPick = await ensurePlantSeedSelected({ response, waitForDankMemer, channel });
-    if (seedPick?.response) response = seedPick.response;
-    LOG.info(`[farm:plant] seed selection result selected=${!!seedPick?.selected} reason=${seedPick?.reason || 'unknown'}`);
-  }
 
-  // Step 6: for action prompts, click ALL to apply on all tiles (preferred over pick slots)
-  const allBtn = findFarmButton(response, [
-    ' all', 'all ', 'all)', 'all:', ':all', 'hoe all', 'water all', 'plant all', 'harvest all', 'confirm all',
-  ]);
-  const pickSlotsBtn = findFarmButton(response, ['pick slot', 'pick slots']);
-  const disabledAllBtn = getDisabledAllButtonForAction(response, actionName);
-  LOG.info(`[farm] apply decision allBtn="${allBtn?.label || '-'}" pickSlots="${pickSlotsBtn?.label || '-'}"`);
-  if (allBtn) {
-    LOG.info(`[farm] Applying action with "${allBtn.label || '?'}"`);
+    LOG.info(`[farm:cycle:${cycleDepth}] applying ${action} with "${allBtn.label || '?'}"`);
     await humanDelay(90, 260);
-    try {
-      const applied = await clickAndCapture({
-        channel,
-        waitForDankMemer,
-        response,
-        button: allBtn,
-        tag: 'farm-apply-all',
-      });
-      if (applied) {
-        response = applied;
-        text = getFullText(response);
-        clean = brief(text, 600);
-        farmVision = analyzeFarmState({ msg: response, text });
-        LOG.info(`[farm:vision] stage=${farmVision.stage}${farmVision.seedStock ? ` seed=${farmVision.seedStock.itemName}:${farmVision.seedStock.qty}` : ''}${farmVision.missing ? ` missing=${farmVision.missing}` : ''}`);
-        logFarmDeepState('after-apply', response);
-
-        // Image + score verification: repeat once and repair missing tools/seeds if score still fails.
-        if (['hoe', 'water', 'plant', 'harvest'].includes(actionName)) {
-          const imgCheck = await capturePhaseVisionScore({
-            msg: response,
-            actionName,
-            phaseTag: `${actionName}-post-apply`,
-          });
-          const score = imgCheck.score || null;
-          const scoreMismatch = !!(score && !score.matched);
-          const nextActionFromScore = inferNextActionFromScore(actionName, score);
-
-          if (scoreMismatch) {
-            LOG.warn(`[farm:vision-score] action=${actionName} score=${score.score}/${score.threshold} conf=${score.confidence} reason=${score.reason} ratios=${JSON.stringify(score.ratios)}`);
-          }
-
-          if (nextActionFromScore && _visionRetryDepth < 12) {
-            LOG.info(`[farm] Vision suggests switching phase (${actionName} -> ${nextActionFromScore}) instead of retrying same action (depth=${_visionRetryDepth})`);
-            await sleep(700);
-            return runFarm({
-              channel,
-              waitForDankMemer,
-              client,
-              _buyRetryDepth,
-              _visionRetryDepth: _visionRetryDepth + 1,
-              _preferredAction: nextActionFromScore,
-            });
-          }
-
-          if (imgCheck.shouldRepeat || scoreMismatch) {
-            const retryAllBtn = findFarmButton(response, [
-              ' all', 'all ', 'all)', 'all:', ':all',
-              `${actionName} all`,
-              'hoe all', 'water all', 'plant all', 'harvest all',
-            ]);
-            if (retryAllBtn) {
-              LOG.info(`[farm] image/score check says incomplete; re-applying with "${retryAllBtn.label || '?'}"`);
-              const reapplied = await clickAndCapture({
-                channel,
-                waitForDankMemer,
-                response,
-                button: retryAllBtn,
-                tag: 'farm-apply-all-repeat',
-              });
-              if (reapplied) {
-                response = reapplied;
-                text = getFullText(response);
-                clean = brief(text, 600);
-                farmVision = analyzeFarmState({ msg: response, text });
-                logFarmDeepState('after-apply-repeat', response);
-
-                const imgCheck2 = await capturePhaseVisionScore({
-                  msg: response,
-                  actionName,
-                  phaseTag: `${actionName}-post-repeat`,
-                });
-                const score2 = imgCheck2.score || null;
-                if (score2 && !score2.matched) {
-                  LOG.warn(`[farm:vision-score] post-repeat mismatch action=${actionName} score=${score2.score}/${score2.threshold} conf=${score2.confidence} reason=${score2.reason}`);
-
-                  if (actionName === 'hoe') {
-                    const tilled2 = score2.ratios?.tilled || 0;
-                    const progressed2 = (score2.ratios?.planted || 0) + (score2.ratios?.wet || 0);
-                    if (tilled2 < 0.6 && progressed2 < 0.25) {
-                      LOG.warn('[farm] Hoe did not till the whole farm; hoe is likely broken or missing.');
-                      return {
-                        result: 'need hoe (hoe not tilling whole farm)',
-                        coins: 0,
-                        nextCooldownSec: 3600,
-                        skipReason: 'farm_hoe_broken',
-                      };
-                    }
-                  }
-
-                  const nextAction = inferNextActionFromScore(actionName, score2);
-                  if (nextAction && _visionRetryDepth < 12) {
-                    LOG.info(`[farm] Vision indicates phase already advanced (${actionName} -> ${nextAction}); retrying with preferred action ${nextAction} (depth=${_visionRetryDepth})`);
-                    await sleep(700);
-                    return runFarm({
-                      channel,
-                      waitForDankMemer,
-                      client,
-                      _buyRetryDepth,
-                      _visionRetryDepth: _visionRetryDepth + 1,
-                      _preferredAction: nextAction,
-                    });
-                  }
-
-                  const repair = getVisionRepairPlan(actionName, score2);
-                  if (repair && _visionRetryDepth < 5) {
-                    LOG.warn(`[farm] Vision mismatch repair: buying ${repair.label} x${repair.quantity} and retrying`);
-                    const bought = await buyItem({
-                      channel,
-                      waitForDankMemer,
-                      client,
-                      itemName: repair.itemName,
-                      quantity: repair.quantity,
-                    });
-                    if (!bought) {
-                      LOG.warn(`[farm] Could not buy vision-repair item ${repair.label} x${repair.quantity} — retrying in 1h`);
-                      return {
-                        result: `need ${repair.label} x${repair.quantity} (vision mismatch buy failed)`,
-                        coins: 0,
-                        nextCooldownSec: 3600,
-                        skipReason: 'farm_vision_score_repair_failed',
-                      };
-                    }
-                    await sleep(1100);
-                    return runFarm({
-                      channel,
-                      waitForDankMemer,
-                      client,
-                      _buyRetryDepth: Math.min(_buyRetryDepth + 1, 2),
-                      _visionRetryDepth: _visionRetryDepth + 1,
-                      _preferredAction: null,
-                    });
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        const extraText = String(stripAnsi(getFullText(response?._farmExtraInteraction) || response?._farmExtraInteraction?.content || '')).toLowerCase();
-        if (actionName === 'plant' && /only\s+plant\s+seeds\s+on\s+an\s+empty\s+tile|tilled\s+and\s+watered/.test(extraText)) {
-          LOG.warn('[farm] Plant was rejected by Dank (needs empty+tilled+watered). Restarting phase flow at Hoe.');
-          if (_visionRetryDepth < 12) {
-            await sleep(700);
-            return runFarm({
-              channel,
-              waitForDankMemer,
-              client,
-              _buyRetryDepth,
-              _visionRetryDepth: _visionRetryDepth + 1,
-              _preferredAction: 'hoe',
-            });
-          }
+    lastApplyResp = await clickAndCapture({
+      channel, waitForDankMemer, response: cycleResponse,
+      button: allBtn, tag: `farm-cycle-${action}-apply`,
+    });
+    if (!applyResp) { LOG.warn('[farm:cycle] All click returned null'); break; }
+
+    // Step 5: advance past any confirmation screens back to the manage menu
+    cycleResponse = await advancePastConfirmation(applyResp, waitForDankMemer);
+    if (!cycleResponse) { LOG.warn('[farm:cycle] confirmation advance returned null'); break; }
+    actionsTaken++;
+    lastAction = action;
+    text = getFullText(cycleResponse);
+    clean = brief(text, 600);
+    logFarmState('after-confirm', cycleResponse);
+
+    // 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
+    // farm view, then continue to harvest.
+    const confirmText = brief(getFullText(lastApplyResp), 200);
+    const afterText = brief(getFullText(cycleResponse), 200);
+    const afterLower = afterText.toLowerCase();
+    const isPlantedConfirmation = /potato|seeds ready|planted|crop.*ready|ready.*\d/i.test(afterLower);
+    const afterBtns = getAllButtons(cycleResponse);
+    const backBtn = afterBtns.find(b => !b.disabled && /back|back to farm/i.test(String(b.label || '').toLowerCase()));
+
+    if (afterText === confirmText) {
+      if (isPlantedConfirmation && backBtn) {
+        // Plant was successful — click "Back" to return to farm view, then proceed.
+        LOG.info(`[farm:cycle:${cycleDepth}] plant confirmed (crops planted) — clicking Back`);
+        await humanDelay(80, 200);
+        const backResp = await clickAndCapture({
+          channel, waitForDankMemer, response: cycleResponse,
+          button: backBtn, tag: `farm-cycle-${action}-back`,
+        });
+        if (backResp) {
+          cycleResponse = backResp;
+          text = getFullText(cycleResponse);
+          clean = brief(text, 600);
+          logFarmState('after-plant-back', cycleResponse);
         }
+        // Plant succeeded — advance to harvest.
+        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'}`);
+        forcedNextAction = nextPhase;
+        if (!nextPhase) break;
+        cycleDepth++;
+        lastAction = nextPhase;
+        initialAnalysis = null;
+        await sleep(400);
+        continue;
+      }
+      // Truly a no-op (e.g., hoe-ing already-tilled soil).
+      const currentIdx = FARM_PHASE_ORDER.indexOf(action);
+      const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+      LOG.info(`[farm:cycle:${cycleDepth}] ${action} was no-op — next=${nextPhase || 'done'}`);
+      forcedNextAction = nextPhase;
+      if (!nextPhase) break;
+      cycleDepth++;
+      lastAction = nextPhase;
+      initialAnalysis = null;
+      await sleep(300);
+      continue;
+    }
+    text = getFullText(cycleResponse);
+    clean = brief(text, 600);
+    logFarmState('after-confirm', cycleResponse);
 
-        if (actionName === 'hoe' && /can only use .*hoe.*empty tile|after a harvest/.test(extraText)) {
-          LOG.warn('[farm] Extra interaction says hoe can only be used on empty tiles; moving to Water phase');
-          if (_visionRetryDepth < 5) {
-            await sleep(700);
-            return runFarm({
-              channel,
-              waitForDankMemer,
-              client,
-              _buyRetryDepth,
-              _visionRetryDepth: _visionRetryDepth + 1,
-              _preferredAction: 'water',
-            });
-          }
-        }
+    // 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.error(`[farm] All click failed: ${e.message}`);
-    }
-  } else if (pickSlotsBtn) {
-    if (disabledAllBtn) {
-      if (actionName === 'plant') {
-        const preScore = phaseScorePreApply?.score || null;
-        const plantedRatio = preScore?.ratios?.planted || 0;
-        if ((preScore && preScore.matched) || plantedRatio >= 0.6) {
-          LOG.info('[farm] Plant All disabled but image shows planted state; skipping seed rebuy and moving to harvest phase');
-          if (_visionRetryDepth < 12) {
-            await sleep(700);
-            return runFarm({
-              channel,
-              waitForDankMemer,
-              client,
-              _buyRetryDepth,
-              _visionRetryDepth: _visionRetryDepth + 1,
-              _preferredAction: 'harvest',
-            });
-          }
-        }
-      }
+      LOG.info(`[farm:cycle:${cycleDepth}:img] failed: ${e.message}`);
+    }
 
-      LOG.warn(`[farm] ${disabledAllBtn.label} is disabled while Pick Slots exists; inferring missing requirement for ${actionName}`);
-      let inferredItem = null;
-      if (actionName === 'hoe') inferredItem = 'hoe';
-      else if (actionName === 'water') inferredItem = 'watering can';
-      else if (actionName === 'plant') inferredItem = 'seeds';
+    const scoreResult = await capturePhaseVisionScore({ msg: cycleResponse, actionName: action, phaseTag: `farm-cycle-${action}` });
+    const score = scoreResult?.score || null;
+    const nextAction = inferNextActionFromScore(action, score);
+
+    // 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.');
+      lastAction = null;
+      cycleDepth++;
+      await sleep(400);
+      continue;
+    }
+    if (action === 'hoe' && /can only use.*hoe.*empty tile|after a harvest/.test(extraText)) {
+      LOG.warn('[farm:cycle] Hoe rejected — moving to water phase.');
+      lastAction = 'hoe';
+      cycleDepth++;
+      await sleep(400);
+      continue;
+    }
 
-      if (inferredItem) {
-        const qty = inferredItem === 'seeds' ? FARM_TOTAL_SLOTS : 1;
-        if (actionName === 'hoe') {
-          LOG.warn('[farm] Hoe All is not usable / full till failed — hoe is likely broken or missing.');
-        }
-        const ok = await buyItem({ channel, waitForDankMemer, client, itemName: inferredItem, quantity: qty });
-        if (!ok) {
-          LOG.warn(`[farm] Could not buy inferred requirement ${inferredItem} x${qty} — retrying in 1h`);
-          return { result: `need ${inferredItem} x${qty} (buy failed)`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_inferred_missing' };
-        }
-        LOG.success(`[farm] Bought inferred requirement ${inferredItem} x${qty}. Retrying farm flow...`);
-        await sleep(1200);
-        if (_buyRetryDepth < 2) {
-          return runFarm({ channel, waitForDankMemer, client, _buyRetryDepth: _buyRetryDepth + 1, _visionRetryDepth });
-        }
-      }
+    if (!nextAction) {
+      LOG.info(`[farm:cycle:${cycleDepth}] ${action} done — no next action (score=${score?.score ?? '?'}/${score?.threshold ?? '?'}, conf=${score?.confidence ?? '?'})`);
+      break;
     }
-    LOG.info('[farm] Only "Pick Slots" available; skipping slot-specific interaction this tick');
+
+    LOG.info(`[farm:cycle:${cycleDepth}] next action = ${nextAction} (after ${action})`);
+    lastAction = action;
+    cycleDepth++;
+    initialAnalysis = imgAnalysis; // pass updated analysis to next iteration
+    await sleep(300);
   }
 
-  const coins = parseCoins(text);
+  // ── Parse final result ─────────────────────────────────────────────────────
+  // If the cycle ended with a planted confirmation (harvest→plant→confirmed),
+  // the coins were shown on lastApplyResp (harvest confirmation). Parse from there too.
+  let coins = parseCoins(text);
+  if (coins <= 0 && lastApplyResp) {
+    const applyCoins = parseCoins(getFullText(lastApplyResp));
+    if (applyCoins > 0) coins = applyCoins;
+  }
   let nextCd = parseFarmCooldownSec(text) || 30;
   const growReadyEnd = parseFarmGrowReadySec(text);
+  // If the final screen is a planted confirmation, use its wilt timestamp as the
+  // grow queue timer — the crops are planted and will be ready at that time.
+  const finalLower = brief(text, 300).toLowerCase();
+  const isFinalPlanted = /potato|seeds ready|planted|crop.*ready|ready.*\d/i.test(finalLower);
+  if (isFinalPlanted && growReadyEnd === null) {
+    // Crops were planted. The wilt timestamp in the planted confirmation tells us
+    // when to harvest next. Set cooldown to that time, capped at a reasonable max.
+    const plantedCd = parseFarmCooldownSec(text);
+    if (plantedCd && plantedCd > 0) {
+      nextCd = Math.max(nextCd, Math.min(6 * 3600, plantedCd + 2));
+    }
+  }
   if (Number.isFinite(growReadyEnd) && growReadyEnd > 0) {
     nextCd = Math.max(nextCd, Math.min(6 * 3600, growReadyEnd + 2));
   }
   const missingEnd = parseMissingFarmItem(text);
   if (missingEnd) {
-    LOG.warn(`[farm] Missing ${c.bold}${missingEnd}${c.reset} after action — will retry in 1h`);
+    LOG.warn(`[farm] Missing ${c.bold}${missingEnd}${c.reset} after cycle — will retry in 1h`);
     return { result: `need ${missingEnd}`, coins: 0, nextCooldownSec: 3600, skipReason: 'farm_missing_item' };
   }
-
   if (coins <= 0) {
-    const finalVision = analyzeFarmState({ msg: response, text });
-    if (finalVision.stage === 'overview' || finalVision.stage === 'blocked-missing-item') {
-      nextCd = Math.max(nextCd, 300);
-    }
     if (/seems pretty empty|pretty empty|farm #\d+/i.test(String(stripAnsi(text || '')))) {
       nextCd = Math.max(nextCd, 300);
     }
   }
 
-  // Phase checkpoint #final: final image score for this action tick.
-  await capturePhaseVisionScore({
-    msg: response,
-    actionName,
-    phaseTag: `${actionName}-final`,
-  });
+  await capturePhaseVisionScore({ msg: cycleResponse, actionName: lastAction || 'harvest', phaseTag: 'farm-final' });
 
   if (coins > 0) {
     LOG.coin(`[farm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-    return { result: `farm ${actionName} → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: nextCd };
+    // After a harvest, Dank Memer auto-plants new crops. Record harvest time
+    // in Redis so the next run knows when crops should be ready.
+    // Also: if the farm shows "empty" or "manage" state (no grow timestamp),
+    // set a short re-check window instead of trusting a potentially stale grow queue.
+    const afterHarvestState = analyzeFarmState({ msg: cycleResponse, text });
+    const farmIsHarvested = afterHarvestState.stage === 'overview'
+      || /seems? pretty empty|empty\.{0,3}|hoe|water|plant|harvest/i.test(text);
+    if (farmIsHarvested) {
+      // Farm was harvested and is back to manage/empty state.
+      // Re-check in 30s to start the next cycle (hoe→water→plant→harvest).
+      nextCd = Math.min(nextCd, 30);
+      LOG.info(`[farm] harvest complete (+⏣ ${coins.toLocaleString()}), farm is ${afterHarvestState.stage} — re-checking in 30s`);
+    }
+    // Record in Redis for cross-instance awareness
+    let growDurMs = null;
+    if (Number.isFinite(growReadyEnd) && growReadyEnd > 0) {
+      growDurMs = Math.max(15 * 60 * 1000, growReadyEnd * 1000);
+    }
+    await recordHarvestInRedis(redis, accountId, growDurMs);
+    return { result: `farm harvest → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: nextCd };
+  }
+
+  // No coins earned — determine if the cycle actually did work or the farm was idle.
+  if (actionsTaken > 0) {
+    // Cycle ran but no coins — farm was likely already empty (pre-harvested).
+    // Set short re-check so we catch the next grow cycle.
+    const growEnd = parseFarmGrowReadySec(text);
+    if (growEnd && growEnd > 0) {
+      nextCd = Math.max(nextCd, Math.min(30, growEnd + 2));
+    } else {
+      nextCd = Math.min(nextCd, 30);
+    }
+    return { result: `farm cycle done (${actionsTaken} action${actionsTaken > 1 ? 's' : ''})`, coins: 0, nextCooldownSec: nextCd };
   }
 
-  return { result: clean || 'farm done', coins: 0, nextCooldownSec: nextCd };
+  return { result: clean ? `farm ${clean.slice(0, 50)}` : 'farm done', coins: 0, nextCooldownSec: nextCd };
 }
 
 module.exports = { runFarm };