dankgrinder 5.16.0 → 5.19.0

package/lib/commands/farm.js

@@ -0,0 +1,1540 @@
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
+  safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  isCV2, ensureCV2, stripAnsi, needsItem, clickCV2SelectMenu,
+} = require('./utils');
+const { buyItem, buyItemsBatch } = require('./shop');
+const {
+  downloadImage,
+  extractFarmImageUrl,
+  analyzeFarmGrid,
+  gridToString,
+  evaluateActionNeed,
+  evaluateActionScores,
+  dumpFarmVisionDebug,
+} = require('./farmVision');
+
+const RE_TS = /<t:(\d+):R>/;
+const RE_MIN = /(\d+)\s*minute/i;
+const RE_HR = /(\d+)\s*hour/i;
+
+function parseFarmCooldownSec(text) {
+  const clean = String(text || '');
+  const lower = clean.toLowerCase();
+  const hasCooldownContext = /easy tiger|slow it down|already farmed|farm again|cooldown|can be used again|on cooldown/.test(lower);
+  if (!hasCooldownContext) return null;
+
+  const ts = clean.match(RE_TS);
+  if (ts) {
+    const diff = parseInt(ts[1], 10) - Math.floor(Date.now() / 1000);
+    if (diff > 0) return diff;
+  }
+  const mm = clean.match(RE_MIN);
+  if (mm) return parseInt(mm[1], 10) * 60;
+  const hh = clean.match(RE_HR);
+  if (hh) return parseInt(hh[1], 10) * 3600;
+  return null;
+}
+
+function parseFarmGrowReadySec(text) {
+  const clean = String(stripAnsi(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;
+
+  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);
+    }
+  }
+  if (tsNearReady.length > 0) return Math.max(5, Math.min(...tsNearReady));
+
+  // Fallback textual patterns.
+  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;
+}
+
+const FARM_RESTOCK_ORDER = ['hoe', 'watering can', 'seeds', 'water bucket'];
+const FARM_BUY_ALIASES = Object.freeze({
+  'hoe': ['hoe'],
+  'watering can': ['watering can', 'water can'],
+  'water bucket': ['water bucket', 'bucket'],
+  'seeds': ['seeds', 'seed', 'corn seeds'],
+});
+
+const FARM_TOTAL_SLOTS = 9;
+
+function parseMissingFarmItem(text) {
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+
+  // Reuse shared detector first.
+  const genericMissing = needsItem(lower);
+  if (genericMissing === 'hoe' || genericMissing === 'watering can' || genericMissing === 'water bucket' || genericMissing === 'seeds') {
+    return genericMissing;
+  }
+
+  const hasMissingHint = /(missing|need|needs|requires?|don['’]?t have|dont have|lack|you need)/i.test(lower)
+    || lower.includes('need the following items')
+    || lower.includes('need following items')
+    || lower.includes('missing items');
+  if (!hasMissingHint) return null;
+
+  if (lower.includes('watering can') || lower.includes('water can')) return 'watering can';
+  if (lower.includes('water bucket') || lower.includes('bucket')) return 'water bucket';
+  if (lower.includes('hoe') || lower.includes('till tool')) return 'hoe';
+  if (lower.includes('seeds') || lower.includes('seed')) return 'seeds';
+
+  return null;
+}
+
+function parseMissingFarmItems(text) {
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+  const hasMissingHint = /(missing|need|needs|requires?|don['’]?t have|dont have|lack|you need)/i.test(lower)
+    || lower.includes('need the following items')
+    || lower.includes('need following items')
+    || lower.includes('missing items');
+
+  if (!hasMissingHint) {
+    const single = parseMissingFarmItem(text);
+    return single ? [single] : [];
+  }
+
+  const found = [];
+
+  for (const item of FARM_RESTOCK_ORDER) {
+    if (item === 'watering can' && (lower.includes('watering can') || lower.includes('water can'))) {
+      found.push('watering can');
+      continue;
+    }
+    if (item === 'water bucket' && lower.includes('water bucket')) {
+      found.push('water bucket');
+      continue;
+    }
+    if (item === 'seeds' && (lower.includes('seeds') || lower.includes('seed'))) {
+      found.push('seeds');
+      continue;
+    }
+    if (item === 'hoe' && lower.includes('hoe')) {
+      found.push('hoe');
+      continue;
+    }
+  }
+
+  if (found.length > 0) return Array.from(new Set(found));
+
+  const single = parseMissingFarmItem(text);
+  return single ? [single] : [];
+}
+
+function normalizeSeedItemName(raw) {
+  const t = String(raw || '').replace(/[^a-zA-Z\s]/g, ' ').replace(/\s+/g, ' ').trim();
+  if (!t) return 'seeds';
+  const lower = t.toLowerCase();
+  if (lower.endsWith('seed') || lower.endsWith('seeds')) return lower;
+  return `${lower} seeds`;
+}
+
+function parseSeedStockFromText(text) {
+  const clean = String(stripAnsi(text || ''));
+  const patterns = [
+    /([a-z][a-z\s-]*seeds?)\s*[x×:]\s*(\d{1,5})/ig,
+    /([a-z][a-z\s-]*seeds?)\s*\((\d{1,5})\)/ig,
+    /\*{0,2}([a-z][a-z\s-]*seeds?)\*{0,2}\s*[⎯—─\-:]\s*`?(\d{1,5})`?/ig,
+  ];
+
+  let best = null;
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(clean)) !== null) {
+      const itemName = normalizeSeedItemName(m[1]);
+      const qty = parseInt(m[2], 10) || 0;
+      if (!best || qty > best.qty) best = { itemName, qty };
+    }
+  }
+  return best;
+}
+
+function parseSeedStockFromComponents(msg) {
+  const candidates = [];
+  for (const b of getAllButtons(msg)) {
+    const label = String(b?.label || '');
+    const m = label.match(/([a-z][a-z\s-]*seeds?)\s*\((\d{1,5})\)/i)
+      || label.match(/([a-z][a-z\s-]*seeds?)\s*[x×:]\s*(\d{1,5})/i);
+    if (m) {
+      candidates.push({ itemName: normalizeSeedItemName(m[1]), qty: parseInt(m[2], 10) || 0 });
+    }
+  }
+
+  for (const menu of getAllSelectMenus(msg)) {
+    for (const o of (menu.options || [])) {
+      const label = String(o?.label || '');
+      const m = label.match(/([a-z][a-z\s-]*seeds?)\s*\((\d{1,5})\)/i)
+        || label.match(/([a-z][a-z\s-]*seeds?)\s*[x×:]\s*(\d{1,5})/i);
+      if (m) {
+        candidates.push({ itemName: normalizeSeedItemName(m[1]), qty: parseInt(m[2], 10) || 0 });
+      }
+    }
+  }
+
+  if (candidates.length === 0) return null;
+  return candidates.sort((a, b) => b.qty - a.qty)[0];
+}
+
+function analyzeFarmState({ msg, text }) {
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+  const buttons = getAllButtons(msg).filter(b => !b.disabled);
+
+  const hasManage = buttons.some(b => hasLabelWord(b, 'manage'));
+  const hasActionMenu = buttons.some(b => hasAny(b, ['hoe', 'water', 'plant', 'harvest', 'fertiliz', 'reap', 'collect']));
+  const hasAll = buttons.some(b => hasAny(b, [' all', 'all ', ':all', 'hoe all', 'water all', 'plant all', 'harvest all', 'confirm all']));
+  const hasPickSlots = buttons.some(b => hasAny(b, ['pick slot', 'pick slots']));
+  const seedStock = parseSeedStockFromComponents(msg) || parseSeedStockFromText(text);
+  const missing = parseMissingFarmItem(text);
+
+  let stage = 'unknown';
+  if (missing) stage = 'blocked-missing-item';
+  else if (hasManage) stage = 'overview';
+  else if (seedStock) stage = 'seed-selection';
+  else if (hasActionMenu) stage = 'action-selection';
+  else if (hasAll || hasPickSlots) stage = 'slot-apply';
+  else if (/cooldown|farm again|already farmed/i.test(lower)) stage = 'cooldown';
+
+  return {
+    stage,
+    missing,
+    seedStock,
+    hasManage,
+    hasActionMenu,
+    hasAll,
+    hasPickSlots,
+  };
+}
+
+function getDisabledAllButtonForAction(msg, actionName) {
+  const allButtons = getAllButtons(msg); // include disabled
+  const keyMap = {
+    hoe: ['hoe all'],
+    water: ['water all'],
+    plant: ['plant all'],
+    harvest: ['harvest all'],
+    fertilize: ['fertilize all', 'fertilise all'],
+  };
+  const words = keyMap[actionName] || [];
+  return allButtons.find(b => b.disabled && words.some(w => String(b.label || '').toLowerCase().includes(w))) || null;
+}
+
+function isEphemeralFlags(flags) {
+  const f = typeof flags === 'number' ? flags : (flags?.bitfield ?? 0);
+  return (f & 64) !== 0;
+}
+
+function safeJson(value) {
+  const seen = new WeakSet();
+  return JSON.stringify(value, (k, v) => {
+    if (typeof v === 'bigint') return v.toString();
+    if (typeof v === 'function') return `[Function:${v.name || 'anon'}]`;
+    if (v && typeof v === 'object') {
+      if (seen.has(v)) return '[Circular]';
+      seen.add(v);
+    }
+    return v;
+  }, 2);
+}
+
+function attachmentList(msg) {
+  const a = msg?.attachments;
+  if (!a) return [];
+  if (Array.isArray(a)) return a;
+  if (typeof a.values === 'function') return Array.from(a.values());
+  return [];
+}
+
+function rawPayloadSnapshot(payload) {
+  if (!payload) return null;
+  const embeds = (payload.embeds || []).map((e, i) => ({
+    index: i,
+    title: e?.title || null,
+    description: e?.description || null,
+    url: e?.url || null,
+    image: e?.image?.url || null,
+    thumbnail: e?.thumbnail?.url || null,
+    footer: e?.footer?.text || null,
+    fields: (e?.fields || []).map(f => ({ name: f?.name || null, value: f?.value || null })),
+  }));
+  const attachments = attachmentList(payload).map((x, i) => ({
+    index: i,
+    id: x?.id || null,
+    name: x?.name || null,
+    contentType: x?.contentType || x?.content_type || null,
+    size: x?.size || null,
+    url: x?.url || null,
+    proxyURL: x?.proxyURL || x?.proxy_url || null,
+    height: x?.height || null,
+    width: x?.width || null,
+  }));
+
+  return {
+    id: payload?.id || null,
+    channelId: payload?.channel?.id || payload?.channelId || null,
+    author: payload?.author ? { id: payload.author.id, username: payload.author.username } : null,
+    createdTimestamp: payload?.createdTimestamp || null,
+    editedTimestamp: payload?.editedTimestamp || null,
+    flags: payload?.flags?.bitfield ?? payload?.flags ?? 0,
+    content: payload?.content || '',
+    embeds,
+    attachments,
+    components: payload?.components || null,
+    cv2Text: payload?._cv2text || null,
+    cv2Buttons: payload?._cv2buttons || null,
+    cv2Components: payload?._cv2 || null,
+  };
+}
+
+function logEphemeralLike(tag, payload) {
+  if (!payload) return;
+  const text = String(stripAnsi(getFullText(payload) || payload?.content || '')).replace(/\s+/g, ' ').trim();
+  const flags = payload?.flags?.bitfield ?? payload?.flags ?? 0;
+  const eph = isEphemeralFlags(flags);
+  const isInteresting = eph || /ephemeral|only you can see|broken|broke|cannot|can't|unable|missing/i.test(text);
+  const raw = safeJson(rawPayloadSnapshot(payload));
+  const line = `[farm:${tag}] interaction flags=${flags} ephemeral=${eph} text=${brief(text, 220) || '(empty)'} raw=${raw}`;
+  if (isInteresting) LOG.warn(line);
+  else LOG.info(line);
+}
+
+async function analyzeFarmImageForAction(msg, actionName) {
+  try {
+    const url = extractFarmImageUrl(msg);
+    if (!url) {
+      const embedCount = Array.isArray(msg?.embeds) ? msg.embeds.length : 0;
+      const compCount = Array.isArray(msg?.components) ? msg.components.length : 0;
+      const attCount = (() => {
+        const a = msg?.attachments;
+        if (!a) return 0;
+        if (Array.isArray(a)) return a.length;
+        if (typeof a.size === 'number') return a.size;
+        if (typeof a.values === 'function') return Array.from(a.values()).length;
+        return 0;
+      })();
+      LOG.info(`[farm:vision-img] no image url for action=${actionName} embeds=${embedCount} comps=${compCount} attachments=${attCount}`);
+      return { shouldRepeat: false, reason: 'no-image' };
+    }
+    const buf = await downloadImage(url);
+    const analysis = await analyzeFarmGrid(buf);
+    const shouldRepeat = evaluateActionNeed(actionName, analysis);
+    const score = evaluateActionScores(actionName, analysis);
+    let dbg = null;
+    try {
+      dbg = await dumpFarmVisionDebug({
+        imgBuffer: buf,
+        analysis,
+        actionName,
+        sourceUrl: url,
+      });
+    } catch (e) {
+      LOG.warn(`[farm:vision-img] debug dump failed (${actionName}): ${e.message}`);
+    }
+    LOG.info(`[farm:vision-img] action=${actionName} counts=${JSON.stringify(analysis.counts)} conf=${analysis.avgConfidence} grid=${gridToString(analysis)} score=${score.score}/${score.threshold} matched=${score.matched} reason=${score.reason} repeat=${shouldRepeat}`);
+    if (dbg) {
+      const tileSummary = (analysis.cells || [])
+        .map(c => `r${c.row + 1}c${c.col + 1}:${c.state}:${c.confidence}`)
+        .join(' | ');
+      LOG.info(`[farm:vision-img] debug dir=${dbg.dir} source=${dbg.sourcePath} manifest=${dbg.manifestPath} tiles=${dbg.tileCount}`);
+      LOG.info(`[farm:vision-img] tile-summary ${tileSummary}`);
+    }
+    return { shouldRepeat, analysis, score, reason: 'ok' };
+  } catch (e) {
+    LOG.warn(`[farm:vision-img] analysis failed (${actionName}): ${e.message}`);
+    return { shouldRepeat: false, reason: 'error' };
+  }
+}
+
+function getVisionRepairPlan(actionName, score) {
+  if (!score || score.matched) return null;
+
+  if (actionName === 'water') {
+    return { itemName: 'watering can', quantity: 1, label: 'watering can' };
+  }
+  if (actionName === 'plant') {
+    const planted = score.counts?.planted || 0;
+    const slots = score.counts?.slots || FARM_TOTAL_SLOTS;
+    const deficit = Math.max(1, Math.min(FARM_TOTAL_SLOTS, slots - planted));
+    return { itemName: 'seeds', quantity: deficit, label: 'seeds' };
+  }
+  if (actionName === 'hoe') {
+    const planted = score.ratios?.planted || 0;
+    const wet = score.ratios?.wet || 0;
+    if ((planted + wet) >= 0.45) {
+      // Farm likely already progressed beyond hoe stage.
+      return null;
+    }
+    return { itemName: 'hoe', quantity: 1, label: 'hoe' };
+  }
+
+  return null;
+}
+
+function inferNextActionFromScore(actionName, score) {
+  if (!score) return null;
+  const planted = score.ratios?.planted || 0;
+  const wet = score.ratios?.wet || 0;
+  const tilled = score.ratios?.tilled || 0;
+
+  if (actionName === 'hoe' && (planted + wet) >= 0.45) {
+    return 'water';
+  }
+  if (actionName === 'water' && planted >= 0.45) {
+    return 'plant';
+  }
+  if (actionName === 'harvest') {
+    // After harvest completes, always restart lifecycle from hoe.
+    if (tilled >= 0.45 || planted <= 0.35) return 'hoe';
+    // Still mostly planted -> keep harvest context; do not jump to plant.
+    return null;
+  }
+  return null;
+}
+
+async function inferPreferredActionFromImage(msg) {
+  try {
+    const url = extractFarmImageUrl(msg);
+    if (!url) return null;
+    const buf = await downloadImage(url);
+    const analysis = await analyzeFarmGrid(buf);
+    const slots = Math.max(1, (analysis?.rows || 3) * (analysis?.cols || 3));
+    const ratios = {
+      tilled: (analysis?.counts?.tilled || 0) / slots,
+      wet: (analysis?.counts?.wet || 0) / slots,
+      planted: (analysis?.counts?.planted || 0) / slots,
+      unknown: (analysis?.counts?.unknown || 0) / slots,
+    };
+
+    let suggested = null;
+    // Image-first phase routing.
+    if (ratios.planted >= 0.45) suggested = 'plant';
+    else if (ratios.wet >= 0.35) suggested = 'plant';
+    else if (ratios.tilled >= 0.35) 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),
+      wet: +ratios.wet.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}`);
+    }
+    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);
+  if (options.length === 0) return null;
+
+  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 };
+  });
+
+  const defaultOpt = withQty.find(x => x.isDefault && x.qty > 0);
+  if (defaultOpt) return defaultOpt.option;
+
+  const best = withQty.sort((a, b) => b.qty - a.qty)[0];
+  return best?.option || options[0];
+}
+
+function extractSelectMenusFromCv2Tree(nodes, out = []) {
+  for (const n of nodes || []) {
+    if (!n || typeof n !== 'object') continue;
+    const t = n.type;
+    if (t === 3 || t === 'SELECT_MENU' || t === 'STRING_SELECT') {
+      out.push(n);
+    }
+    if (Array.isArray(n.components) && n.components.length > 0) {
+      extractSelectMenusFromCv2Tree(n.components, out);
+    }
+    if (Array.isArray(n.items) && n.items.length > 0) {
+      extractSelectMenusFromCv2Tree(n.items, out);
+    }
+    if (Array.isArray(n.data?.items) && n.data.items.length > 0) {
+      extractSelectMenusFromCv2Tree(n.data.items, out);
+    }
+  }
+  return out;
+}
+
+async function ensurePlantSeedSelected({ response, waitForDankMemer, channel }) {
+  const menus = [
+    ...getAllSelectMenus(response),
+    ...extractSelectMenusFromCv2Tree(response?._cv2),
+  ];
+  const plantMenu = menus.find(m => (m.options || []).some(o => /seed|beans|potato|corn|carrot|wheat|pumpkin|plant/i.test(String(o?.label || ''))));
+  if (!plantMenu) return { response, selected: false, reason: 'no-plant-menu' };
+
+  const pick = chooseSeedOption(plantMenu);
+  if (!pick?.value) return { response, selected: false, reason: 'no-seed-option' };
+
+  LOG.info(`[farm:plant] selecting seed option label="${pick.label || '-'}" value="${pick.value}" default=${!!pick.default}`);
+  try {
+    const menuId = plantMenu.customId || plantMenu.custom_id || 0;
+    try {
+      await response.selectMenu(menuId, [pick.value]);
+    } catch (e) {
+      LOG.warn(`[farm:plant] selectMenu() failed, trying CV2 select fallback: ${e.message}`);
+      await clickCV2SelectMenu(response, menuId, [pick.value]);
+    }
+    let updated = await waitForDankMemer(7000);
+    if (!updated && response.id) {
+      const baseline = brief(getFullText(response), 300);
+      updated = await waitForEditedMessage(channel, response.id, baseline, 7000);
+    }
+    if (updated) {
+      if (isCV2(updated)) await ensureCV2(updated);
+      logMsg(updated, 'farm-plant-seed-selected');
+      logFarmState('plant-seed-selected', updated);
+      logFarmDeepState('plant-seed-selected', updated);
+      return { response: updated, selected: true, reason: 'selected' };
+    }
+    return { response, selected: true, reason: 'selected-no-update' };
+  } catch (e) {
+    LOG.warn(`[farm:plant] seed selection failed: ${e.message}`);
+    return { response, selected: false, reason: 'select-failed' };
+  }
+}
+
+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) {
+    LOG.info(`[farm:phase-score] phase=${phaseTag} action=${actionName} score=${s.score}/${s.threshold} matched=${s.matched} conf=${s.confidence} reason=${s.reason}`);
+  } else {
+    LOG.info(`[farm:phase-score] phase=${phaseTag} action=${actionName} score=unavailable reason=${check?.reason || 'unknown'}`);
+  }
+  return check;
+}
+
+function mergeBuyPlan(plan) {
+  const m = new Map();
+  for (const step of plan || []) {
+    if (!step?.item) continue;
+    const key = String(step.item).toLowerCase();
+    const qty = Math.max(1, Number(step.qty || 1));
+    m.set(key, Math.max(qty, m.get(key) || 0));
+  }
+  return Array.from(m.entries()).map(([item, qty]) => ({ item, qty }));
+}
+
+function extractActionQtyFromPage({ action, msg, text }) {
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+  const labels = [
+    ...getAllButtons(msg).map(b => String(b.label || '')),
+    ...getAllSelectMenus(msg).flatMap(m => (m.options || []).map(o => String(o.label || ''))),
+    String(stripAnsi(text || '')),
+  ];
+
+  const keyWords = {
+    hoe: ['hoe'],
+    water: ['water can', 'watering can', 'water bucket', 'bucket'],
+    plant: ['seed', 'seeds'],
+  };
+  const keys = keyWords[action] || [];
+
+  let bestQty = null;
+  let sawKeyword = false;
+
+  for (const src of labels) {
+    const s = String(src || '');
+    const sl = s.toLowerCase();
+    if (keys.some(k => sl.includes(k))) sawKeyword = true;
+
+    // patterns: Item (9), Item x9, Item: 9
+    for (const k of keys) {
+      const reList = [
+        new RegExp(`${k}[^\\d]{0,12}\\((\\d{1,5})\\)`, 'i'),
+        new RegExp(`${k}[^\\d]{0,12}[x×:]\\s*(\\d{1,5})`, 'i'),
+      ];
+      for (const re of reList) {
+        const m = s.match(re);
+        if (m) {
+          const q = parseInt(m[1], 10);
+          if (Number.isFinite(q) && (bestQty == null || q > bestQty)) bestQty = q;
+        }
+      }
+    }
+  }
+
+  return { sawKeyword, qty: bestQty };
+}
+
+async function tryBuyFarmItem({ missing, channel, waitForDankMemer, client }) {
+  return tryBuyFarmItemQty({ missing, quantity: 1, channel, waitForDankMemer, client });
+}
+
+async function tryBuyFarmItemQty({ missing, quantity = 1, channel, waitForDankMemer, client }) {
+  const aliases = FARM_BUY_ALIASES[missing] || [missing];
+  for (const itemName of aliases) {
+    const ok = await buyItem({ channel, waitForDankMemer, client, itemName, quantity });
+    if (ok) return { ok: true, itemName };
+  }
+  return { ok: false, itemName: aliases[0] || missing };
+}
+
+function brief(text, n = 140) {
+  return String(stripAnsi(text || '')).replace(/\s+/g, ' ').trim().slice(0, n);
+}
+
+function logFarmState(tag, msg) {
+  const text = brief(getFullText(msg), 180);
+  const buttons = getAllButtons(msg)
+    .map(b => `${b.disabled ? 'off' : 'on'}:${b.label || '-'}:${b.customId || b.custom_id || '-'}`)
+    .slice(0, 12);
+  const menus = getAllSelectMenus(msg);
+  LOG.info(`[farm:${tag}] text=${text || '(empty)'}`);
+  if (buttons.length > 0) LOG.info(`[farm:${tag}] buttons=${buttons.join(' | ')}`);
+  if (menus.length > 0) LOG.info(`[farm:${tag}] select_menus=${menus.length}`);
+}
+
+function logFarmDeepState(tag, msg) {
+  const buttons = getAllButtons(msg);
+  const menus = getAllSelectMenus(msg);
+  LOG.info(`[farm:${tag}] deep buttons=${buttons.length} menus=${menus.length}`);
+
+  if (buttons.length > 0) {
+    const lines = buttons.map((b, i) => {
+      const qty = parseButtonQty(b);
+      return `${i + 1}. ${b.disabled ? 'DIS' : 'EN'} label="${b.label || '-'}" qty=${qty ?? '-'} id="${b.customId || b.custom_id || '-'}"`;
+    });
+    LOG.info(`[farm:${tag}] deep button_list:\n${lines.join('\n')}`);
+  }
+
+  if (menus.length > 0) {
+    for (let i = 0; i < menus.length; i++) {
+      const m = menus[i];
+      const opts = (m.options || []).map((o, oi) => `${oi + 1}) ${o.label || '-'} [${o.value || '-'}]${o.default ? ' *default*' : ''}`);
+      LOG.info(`[farm:${tag}] deep menu#${i + 1} id="${m.customId || m.custom_id || '-'}" options=${(m.options || []).length}`);
+      if (opts.length > 0) LOG.info(`[farm:${tag}] deep menu#${i + 1} options: ${opts.join(' | ')}`);
+    }
+  }
+}
+
+function isFarmActionButton(btn) {
+  const label = String(btn?.label || '').toLowerCase();
+  const id = String(btn?.customId || btn?.custom_id || '').toLowerCase();
+  const hay = `${label} ${id}`;
+  return [
+    'harvest', 'water', 'plant', 'collect', 'claim', 'reap', 'fertiliz', 'spray', 'seed', 'crop', 'confirm',
+  ].some(k => hay.includes(k));
+}
+
+function buttonHay(btn) {
+  return `${String(btn?.label || '').toLowerCase()} ${String(btn?.customId || btn?.custom_id || '').toLowerCase()}`;
+}
+
+function hasAny(btn, words) {
+  const hay = buttonHay(btn);
+  return words.some(w => hay.includes(w));
+}
+
+function parseButtonQty(btn) {
+  const label = String(btn?.label || '');
+  const m = label.match(/\((\d+)\)/);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+function isNavOrUtilityButton(btn) {
+  const label = String(btn?.label || '').trim().toLowerCase();
+  const id = String(btn?.customId || btn?.custom_id || '').toLowerCase();
+  if (!label || label === '-' || label === 'back' || label === 'go back') return true;
+  if (id.includes('goback') || id.includes('selectfarm') || id.includes('changeSkin'.toLowerCase()) || id.includes('rename') || id.includes('buyplot') || id.includes('farm-farm')) return true;
+  return false;
+}
+
+function hasLabelWord(btn, word) {
+  const label = String(btn?.label || '').toLowerCase();
+  return new RegExp(`\\b${word}\\b`, 'i').test(label);
+}
+
+function getManageActionButtons(msg) {
+  const btns = getAllButtons(msg).filter(b => !b.disabled && !isNavOrUtilityButton(b));
+  const pickByLabel = (words) => btns.find(b => words.some(w => hasLabelWord(b, w))) || null;
+  const pickFallback = (words) => btns.find(b => hasAny(b, words)) || null;
+  const pick = (words) => pickByLabel(words) || pickFallback(words);
+  return {
+    hoe: pick(['hoe', 'till']),
+    water: pick(['water', 'watering']),
+    plant: pick(['plant', 'seed', 'sow']),
+    fertilize: pick(['fertiliz', 'compost', 'manure']),
+    harvest: pick(['harvest', 'reap', 'collect']),
+  };
+}
+
+async function restockFromManageCounts({ response, channel, waitForDankMemer, client }) {
+  const actions = getManageActionButtons(response);
+  const counts = {
+    hoe: parseButtonQty(actions.hoe),
+    water: parseButtonQty(actions.water),
+    plant: parseButtonQty(actions.plant),
+    fertilize: parseButtonQty(actions.fertilize),
+    harvest: parseButtonQty(actions.harvest),
+  };
+
+  LOG.info(`[farm] manage counts hoe=${counts.hoe ?? '-'} water=${counts.water ?? '-'} plant=${counts.plant ?? '-'} fert=${counts.fertilize ?? '-'} harvest=${counts.harvest ?? '-'}`);
+  LOG.info(`[farm] manage labels hoe="${actions.hoe?.label || '-'}" water="${actions.water?.label || '-'}" plant="${actions.plant?.label || '-'}" fert="${actions.fertilize?.label || '-'}" harvest="${actions.harvest?.label || '-'}"`);
+
+  const buyPlan = [];
+  if (counts.hoe === 0) buyPlan.push({ item: 'hoe', qty: 1 });
+  if (counts.water === 0) buyPlan.push({ item: 'watering can', qty: 1 });
+
+  // Plant count behaves like available seed quantity/options in many CV2 states.
+  if (counts.plant === 0) buyPlan.push({ item: 'seeds', qty: FARM_TOTAL_SLOTS });
+  else if (Number.isFinite(counts.plant) && counts.plant > 0 && counts.plant < FARM_TOTAL_SLOTS) {
+    buyPlan.push({ item: 'seeds', qty: FARM_TOTAL_SLOTS - counts.plant });
+  }
+
+  // Fertilizer is optional: use if present, never buy.
+
+  if (buyPlan.length === 0) return { boughtAny: false };
+
+  LOG.info(`[farm] restock plan: ${buyPlan.map(p => `${p.item} x${p.qty}`).join(', ')}`);
+
+  for (const step of buyPlan) {
+    LOG.warn(`[farm] Restock needed: ${step.item} x${step.qty}`);
+    const ok = await buyItem({ channel, waitForDankMemer, client, itemName: step.item, quantity: step.qty });
+    if (!ok) {
+      LOG.warn(`[farm] Could not buy ${step.item} x${step.qty} — retrying in 1h`);
+      return {
+        boughtAny: false,
+        failed: true,
+        result: `need ${step.item} x${step.qty} (buy failed)`,
+        coins: 0,
+        nextCooldownSec: 3600,
+        skipReason: 'farm_restock_failed',
+      };
+    }
+    await sleep(600);
+  }
+
+  return { boughtAny: true };
+}
+
+function findFarmButton(msg, words, { includeDisabled = false } = {}) {
+  const btns = getAllButtons(msg).filter(b => includeDisabled || !b.disabled);
+  return btns.find(b => hasAny(b, words)) || null;
+}
+
+function pickFarmActionButton(msg, text) {
+  const btns = getAllButtons(msg).filter(b => !b.disabled && !isNavOrUtilityButton(b));
+  const allBtns = getAllButtons(msg);
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+
+  const hasEnabledAll = (word) => allBtns.some(b => !b.disabled && String(b.label || '').toLowerCase().includes(word));
+  const hasDisabledAll = (word) => allBtns.some(b => b.disabled && String(b.label || '').toLowerCase().includes(word));
+
+  const byLabel = (word) => btns.find(b => hasLabelWord(b, word)) || null;
+
+  // Explicit empty-farm heuristic: always start with Hoe when possible.
+  if (/seems pretty empty|pretty empty|empty\.\.\./i.test(lower)) {
+    const hoeFirst = byLabel('hoe') || btns.find(b => hasAny(b, ['hoe', 'till', 'cleanup', 'clean']));
+    if (hoeFirst) return { action: 'hoe', button: hoeFirst };
+  }
+
+  // Progression-aware transitions for farm lifecycle.
+  // If current phase appears completed (its "All" got disabled), move forward.
+  if (hasDisabledAll('hoe all')) {
+    if (hasEnabledAll('water all') || byLabel('water')) {
+      const water = byLabel('water') || btns.find(b => hasAny(b, ['water', 'watering']));
+      if (water) return { action: 'water', button: water };
+    }
+  }
+  if (hasDisabledAll('water all')) {
+    if (hasEnabledAll('plant all') || byLabel('plant')) {
+      const plant = byLabel('plant') || btns.find(b => hasAny(b, ['plant', 'seed', 'sow']));
+      if (plant) return { action: 'plant', button: plant };
+    }
+  }
+  if (hasDisabledAll('plant all')) {
+    if (hasEnabledAll('fertilize all')) {
+      const fert = byLabel('fertilize') || btns.find(b => hasAny(b, ['fertiliz', 'compost', 'manure']));
+      if (fert) return { action: 'fertilize', button: fert };
+    }
+    // Only fast-forward to harvest when text indicates harvest-like state.
+    const harvestHint = /ready|harvest|ripe|wilt|dead plant|collect/i.test(lower);
+    if (harvestHint && (hasEnabledAll('harvest all') || byLabel('harvest'))) {
+      const harvest = byLabel('harvest') || btns.find(b => hasAny(b, ['harvest', 'reap', 'collect']));
+      if (harvest) return { action: 'harvest', button: harvest };
+    }
+  }
+
+  const buckets = [
+    { key: 'harvest', words: ['harvest', 'reap', 'collect'] },
+    { key: 'hoe', words: ['hoe', 'till', 'cleanup', 'clean'] },
+    { key: 'water', words: ['water', 'watering'] },
+    { key: 'plant', words: ['plant', 'seed', 'sow'] },
+    { key: 'fertilize', words: ['fertiliz', 'manure', 'compost'] },
+  ];
+
+  // Context-sensitive priority from farm status text.
+  const priority = [];
+  if (/harvest|wilt|dead plant|ready/i.test(lower)) priority.push('harvest');
+  if (/mess|debris|cleanup|empty|untilled|till/i.test(lower)) priority.push('hoe');
+  if (/dry|water/i.test(lower)) priority.push('water');
+  if (/seed|plant/i.test(lower)) priority.push('plant');
+  priority.push('harvest', 'hoe', 'water', 'plant', 'fertilize');
+
+  const seen = new Set();
+  const ordered = priority.filter(p => (seen.has(p) ? false : (seen.add(p), true)));
+
+  for (const p of ordered) {
+    const bucket = buckets.find(b => b.key === p);
+    if (!bucket) continue;
+    const hit = btns.find(b => bucket.words.some(w => hasLabelWord(b, w)))
+      || btns.find(b => hasAny(b, bucket.words));
+    if (hit) return { action: p, button: hit };
+  }
+
+  return null;
+}
+
+async function clickAndCapture({ channel, waitForDankMemer, response, button, tag, timeoutMs = 9000 }) {
+  const baseline = brief(getFullText(response), 400);
+  const clickRes = await safeClickButton(response, button);
+  logEphemeralLike(`${tag}-clickRes`, clickRes);
+  if (response?._lastInteractionAck) {
+    logEphemeralLike(`${tag}-interactionAck`, response._lastInteractionAck);
+    delete response._lastInteractionAck;
+  }
+
+  let post = clickRes || null;
+  if (!post && response.id) post = await waitForEditedMessage(channel, response.id, baseline, timeoutMs);
+  if (!post) post = await waitForDankMemer(timeoutMs);
+
+  if (!post) return null;
+  logEphemeralLike(`${tag}-post`, post);
+
+  // Capture any additional immediate callback message (often ephemeral-like
+  // "only you can see this" notices) that may be separate from edited CV2 post.
+  try {
+    const side = await waitForDankMemer(1500);
+    if (side && side.id !== post.id) {
+      logEphemeralLike(`${tag}-post-extra`, side);
+      post._farmExtraInteraction = side;
+    }
+  } catch {}
+
+  if (isCV2(post)) await ensureCV2(post);
+  logMsg(post, tag);
+  logFarmState(tag, post);
+  return post;
+}
+
+async function auditManageAndBuildBuyPlan({ response, channel, waitForDankMemer, client }) {
+  const rawPlan = [];
+  let current = response;
+  const auditSeq = [
+    { action: 'hoe', requiredItem: 'hoe' },
+    { action: 'water', requiredItem: 'watering can' },
+    { action: 'plant', requiredItem: 'seeds' },
+  ];
+
+  for (const step of auditSeq) {
+    const actions = getManageActionButtons(current);
+    const actionBtn = actions[step.action];
+    if (!actionBtn) continue;
+
+    // Move to the action tab to inspect *All state and any hidden warnings.
+    try {
+      const moved = await clickAndCapture({
+        channel,
+        waitForDankMemer,
+        response: current,
+        button: actionBtn,
+        tag: `farm-audit-${step.action}`,
+        timeoutMs: 8000,
+      });
+      if (moved) current = moved;
+    } catch (e) {
+      LOG.warn(`[farm] audit ${step.action} click failed: ${e.message}`);
+    }
+
+    const currentText = getFullText(current) || '';
+    const lower = String(stripAnsi(currentText)).toLowerCase();
+    const disabledAll = getDisabledAllButtonForAction(current, step.action);
+    const missingItems = parseMissingFarmItems(lower);
+    const actionQty = extractActionQtyFromPage({ action: step.action, msg: current, text: currentText });
+    LOG.info(`[farm:audit-${step.action}] qty=${actionQty.qty ?? '-'} sawKeyword=${actionQty.sawKeyword} disabledAll=${!!disabledAll}`);
+
+    if (step.action === 'plant') {
+      const seedInfo = analyzeFarmState({ msg: current, text: getFullText(current) }).seedStock;
+      if (seedInfo && Number.isFinite(seedInfo.qty)) {
+        const deficit = Math.max(0, FARM_TOTAL_SLOTS - seedInfo.qty);
+        if (deficit > 0) rawPlan.push({ item: seedInfo.itemName || 'seeds', qty: deficit });
+      } else if (Number.isFinite(actionQty.qty)) {
+        const deficit = Math.max(0, FARM_TOTAL_SLOTS - actionQty.qty);
+        if (deficit > 0) rawPlan.push({ item: 'seeds', qty: deficit });
+      }
+    } else {
+      if (Number.isFinite(actionQty.qty) && actionQty.qty <= 0) {
+        rawPlan.push({ item: step.requiredItem, qty: 1 });
+      } else if (disabledAll) {
+        rawPlan.push({ item: step.requiredItem, qty: 1 });
+      }
+    }
+
+    for (const mi of missingItems) {
+      if (mi === 'seeds') rawPlan.push({ item: 'seeds', qty: FARM_TOTAL_SLOTS });
+      else rawPlan.push({ item: mi, qty: 1 });
+    }
+
+    // Additional explicit seed-missing detection from current action text.
+    const actionText = String(stripAnsi(getFullText(current) || '')).toLowerCase();
+    if (step.action === 'plant') {
+      if (/no\s+seeds|need\s+seeds|missing\s+seeds|don['’]?t\s+have\s+.*seed/i.test(actionText)) {
+        rawPlan.push({ item: 'seeds', qty: FARM_TOTAL_SLOTS });
+      }
+    }
+  }
+
+  const buyPlan = mergeBuyPlan(rawPlan)
+    .filter(p => p.item !== 'fertilize' && p.item !== 'fertilizer')
+    .sort((a, b) => FARM_RESTOCK_ORDER.indexOf(a.item) - FARM_RESTOCK_ORDER.indexOf(b.item));
+
+  return { buyPlan, response: current };
+}
+
+function isFarmManagementButton(btn) {
+  const label = String(btn?.label || '').toLowerCase();
+  const id = String(btn?.customId || btn?.custom_id || '').toLowerCase();
+  const hay = `${label} ${id}`;
+  return [
+    'manage', 'rename', 'change skin', 'buy plot', 'upgrade', 'settings', 'refresh', 'selectfarm', 'farm-farm',
+  ].some(k => hay.includes(k));
+}
+
+async function waitForEditedMessage(channel, messageId, baselineText, timeoutMs = 9000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    await sleep(500);
+    try {
+      const fresh = await channel.messages.fetch(messageId);
+      if (!fresh) continue;
+      if (isCV2(fresh)) await ensureCV2(fresh, true);
+      const next = brief(getFullText(fresh), 400);
+      if (next && next !== baselineText) return fresh;
+    } catch {}
+  }
+  return null;
+}
+
+async function runFarm({ channel, waitForDankMemer, client, _buyRetryDepth = 0, _visionRetryDepth = 0, _preferredAction = null }) {
+  LOG.cmd(`${c.white}${c.bold}pls farm view${c.reset}`);
+
+  await channel.send('pls farm view');
+  let response = await waitForDankMemer(12000);
+
+  if (!response) {
+    LOG.warn('[farm] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[farm] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  if (isCV2(response)) await ensureCV2(response);
+  logMsg(response, 'farm');
+  logFarmState('initial', response);
+  logFarmDeepState('initial', response);
+
+  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 };
+  }
+
+  if (lower.includes('must specify a subcommand')) {
+    LOG.warn('[farm] Subcommand required response detected; retrying with "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 };
+    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 };
+  }
+
+  // Queue grow phase: if crops are still growing, wait until next ready window.
+  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.
+    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',
+    };
+  }
+
+  // Step 1: go to farm manage mode first (where Hoe/Water/Plant/etc live)
+  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;
+      text = getFullText(response);
+      clean = brief(text, 600);
+    }
+    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}`);
+      }
+    }
+  }
+
+  // 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 });
+    }
+  }
+
+  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 });
+    }
+    return { result: `auto-bought ${boughtItems.join(', ')}`, coins: 0, nextCooldownSec: 10 };
+  }
+
+  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,
+    };
+  }
+
+  let phaseScorePreApply = null;
+
+  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,
+    });
+    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);
+
+      // Phase checkpoint #1: image score before applying "All".
+      phaseScorePreApply = await capturePhaseVisionScore({
+        msg: response,
+        actionName,
+        phaseTag: `${actionName}-pre-apply`,
+      });
+    }
+  } 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 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 || '?'}"`);
+    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',
+            });
+          }
+        }
+
+        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',
+            });
+          }
+        }
+      }
+    } 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.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';
+
+      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 });
+        }
+      }
+    }
+    LOG.info('[farm] Only "Pick Slots" available; skipping slot-specific interaction this tick');
+  }
+
+  const coins = parseCoins(text);
+  let nextCd = parseFarmCooldownSec(text) || 10;
+  const missingEnd = parseMissingFarmItem(text);
+  if (missingEnd) {
+    LOG.warn(`[farm] Missing ${c.bold}${missingEnd}${c.reset} after action — 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`,
+  });
+
+  if (coins > 0) {
+    LOG.coin(`[farm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `farm ${actionName} → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: nextCd };
+  }
+
+  return { result: clean || 'farm done', coins: 0, nextCooldownSec: nextCd };
+}
+
+module.exports = { runFarm };