dankgrinder 6.46.0 → 7.6.0

package/lib/commands/beg.js

@@ -1,20 +1,17 @@
 /**
  * Beg command handler.
  * Simple command: send "pls beg", parse coins from response.
- * Detects: positive coins, Life Saver drops, negative (no coins).
  */
 
 const { LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep } = require('./utils');
 
 const RE_NEWLINE = /\n/g;
-const RE_LIFE_SAVER = /life\s*saver/i;
-const RE_BEG_COINS = /you\s+received\s*:\s*[\s\S]{0,200}?([\d,]+)/i;
 
 /**
  * @param {object} opts
  * @param {object} opts.channel
  * @param {function} opts.waitForDankMemer
- * @returns {Promise<{result: string, coins: number, lifeSaver?: boolean}>}
+ * @returns {Promise<{result: string, coins: number}>}
  */
 async function runBeg({ channel, waitForDankMemer }) {
   LOG.cmd(`${c.white}${c.bold}pls beg${c.reset}`);
@@ -36,30 +33,11 @@ async function runBeg({ channel, waitForDankMemer }) {
 
   logMsg(response, 'beg');
   const text = getFullText(response);
-
-  // Extract coins: prefer "You received" pattern for beg responses
-  let coins = 0;
-  const begMatch = text.match(RE_BEG_COINS);
-  if (begMatch) {
-    coins = parseInt(begMatch[1].replace(/,/g, ''), 10) || 0;
-  }
-  // Fallback to general parseCoins
-  if (coins === 0) {
-    coins = parseCoins(text);
-  }
-
-  // Detect Life Saver drops
-  const lifeSaver = RE_LIFE_SAVER.test(text);
+  const coins = parseCoins(text);
 
   if (coins > 0) {
-    const lsNote = lifeSaver ? ` + ${c.cyan}Life Saver${c.reset}` : '';
-    LOG.coin(`[beg] ${c.green}+⏣ ${coins.toLocaleString()}${lsNote}${c.reset}`);
-    return { result: `beg → ${c.green}+⏣ ${coins.toLocaleString()}${lifeSaver ? ' + Life Saver' : ''}${c.reset}`, coins, lifeSaver };
-  }
-
-  if (lifeSaver) {
-    LOG.coin(`[beg] ${c.cyan}Life Saver${c.reset} (no coins)`);
-    return { result: 'beg → Life Saver', coins: 0, lifeSaver };
+    LOG.coin(`[beg] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `beg → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`, coins };
   }
 
   LOG.info(`[beg] ${text.substring(0, 80).replace(RE_NEWLINE, ' ')}`);

package/lib/commands/farm.js

@@ -474,8 +474,8 @@ function getVisionRepairPlan(actionName, score) {
   }
   if (actionName === 'hoe') {
     const planted = score.ratios?.planted || 0;
-    const wet = score.ratios?.wet || 0;
-    if ((planted + wet) >= 0.45) {
+    const tilled = score.ratios?.tilled || 0;
+    if (planted >= 0.30 || tilled >= 0.30) {
       // Farm likely already progressed beyond hoe stage.
       return null;
     }
@@ -488,10 +488,9 @@ function getVisionRepairPlan(actionName, score) {
 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) {
+  if (actionName === 'hoe' && (planted + tilled) >= 0.45) {
     return 'water';
   }
   if (actionName === 'water' && planted >= 0.45) {
@@ -515,16 +514,14 @@ async function inferPreferredActionFromImage(msg) {
     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';
+    // Image-first phase routing (3-state: tilled/planted/unknown, no separate wet state).
+    if (ratios.planted >= 0.30) suggested = 'plant';
+    else if (ratios.tilled >= 0.30) suggested = 'water';
     else suggested = 'hoe';
 
     let dbg = null;
@@ -541,7 +538,6 @@ async function inferPreferredActionFromImage(msg) {
 
     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),
     })}`);
@@ -1117,31 +1113,30 @@ async function findNextFarmActionFromManage(msg, text, currentAction, imageAnaly
     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) {
+    // Phase-aware selection: pick the earliest incomplete phase (3-state model).
+    // Harvest when planted >= 30%.
+    if (ratios.planted >= 0.30) {
       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) {
+    // Plant when tilled >= 30%.
+    if (ratios.tilled >= 0.30) {
       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)})` };
+      if (btn) return { action: 'plant', button: btn, reason: `plant-vision(tilled=${ratios.tilled.toFixed(2)})` };
     }
-    // Water when we have tilled tiles but not enough wet.
-    if (ratios.tilled >= 0.35 && ratios.wet < 0.35) {
+    // Water when we have tilled tiles.
+    if (ratios.tilled >= 0.15) {
       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)})` };
+      if (btn) return { action: 'water', button: btn, reason: `water-vision(tilled=${ratios.tilled.toFixed(2)})` };
     }
     // Hoe when farm is mostly unknown/empty.
-    if (ratios.tilled < 0.35 && ratios.wet < 0.35 && ratios.planted < 0.35) {
+    if (ratios.tilled < 0.15 && ratios.planted < 0.30) {
       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)})` };
+      if (btn) return { action: 'hoe', button: btn, reason: `hoe-vision(t=${ratios.tilled.toFixed(2)},p=${ratios.planted.toFixed(2)})` };
     }
   }
 

package/lib/commands/farmVision.js

@@ -82,12 +82,16 @@ function extractFarmImageUrl(msg) {
 function colorStatsForPixel(r, g, b) {
   const sum = r + g + b;
   const brightness = sum / 3;
-  const greenStrong = g > r * 1.12 && g > b * 1.1;
-  const blueStrong = b > r * 1.08 && b > g * 1.02;
-  const brownish = r > g * 1.03 && g > b * 1.03 && r > 45 && g > 28 && b < 95;
-  const dark = brightness < 56;
+  // Crop green — harvest phase: large bright leaves, G significantly > R and B
+  const greenStrong = g > r * 1.25 && g > b * 1.25 && g > 38;
+  // Weeds/grass — small scattered green, less intense than crop green
+  const weedGreen = g > r * 1.12 && g > b * 1.1 && g <= 38;
+  // Wet soil — rich dark brown, no blue, higher R than typical dry soil
+  const wetSoil = r > 50 && r > g * 1.5 && b < 20 && brightness < 45;
+  // Dry tilled soil — medium brown, debris textures
+  const drySoil = r > 35 && r > g * 1.2 && b < 30;
   const whiteish = brightness > 210 && Math.abs(r - g) < 20 && Math.abs(g - b) < 20;
-  return { brightness, greenStrong, blueStrong, brownish, dark, whiteish };
+  return { brightness, greenStrong, weedGreen, wetSoil, drySoil, whiteish };
 }
 
 function clamp01(n) {
@@ -97,52 +101,34 @@ function clamp01(n) {
 function classifyCell(features) {
   const { greenPct, bluePct, brownPct, darkPct, avgBrightness } = features;
 
-  // Score bands tuned for Dank farm palette.
-  const scorePlanted =
-    (greenPct * 1.9) +
-    (clamp01((120 - avgBrightness) / 120) * 0.2) -
-    (bluePct * 0.4);
-
-  const scoreWet =
-    (bluePct * 1.7) +
-    (darkPct * 0.7) +
-    (clamp01((105 - avgBrightness) / 105) * 0.15) -
-    (greenPct * 0.35);
-
-  const scoreTilled =
-    (brownPct * 1.9) +
-    (clamp01((125 - avgBrightness) / 125) * 0.1) -
-    (greenPct * 0.25) -
-    (bluePct * 0.2);
-
-  const scored = [
-    ['planted', scorePlanted],
-    ['wet', scoreWet],
-    ['tilled', scoreTilled],
-  ].sort((a, b) => b[1] - a[1]);
-
-  const [bestState, bestScore] = scored[0];
-  const secondScore = scored[1][1];
-  const margin = bestScore - secondScore;
-
-  // Confidence from score margin + minimum signal level.
-  const signal = Math.max(greenPct, bluePct, brownPct);
-  const confidence = clamp01((margin * 2.1) + (signal * 0.6));
+  // ── HARVEST: Bright green mature crops (G >> R,B, G>38) ──
+  // Detected by greenStrong pixel percentage — crop leaves are vivid green
+  if (greenPct >= 0.30) {
+    const confidence = clamp01(0.5 + (greenPct - 0.30) * 2.0);
+    return { state: 'planted', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
+  }
 
-  // Low-signal cells become unknown.
-  if (signal < 0.085 || confidence < 0.20) {
-    return { state: 'unknown', confidence: +confidence.toFixed(3), scores: { planted: +scorePlanted.toFixed(3), wet: +scoreWet.toFixed(3), tilled: +scoreTilled.toFixed(3) } };
+  // ── TILLED / WET: Brown soil — no meaningful green or blue ──
+  if (brownPct >= 0.15) {
+    // High brown percentage = definitely soil. Both hoe (dry) and water (wet)
+    // phases look like brown soil. We classify as 'tilled' — the farming
+    // logic handles water vs hoe state transition by phase context.
+    const confidence = clamp01((brownPct - 0.15) * 2.5 + (1 - darkPct) * 0.3);
+    return { state: 'tilled', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
   }
 
-  return {
-    state: bestState,
-    confidence: +confidence.toFixed(3),
-    scores: {
-      planted: +scorePlanted.toFixed(3),
-      wet: +scoreWet.toFixed(3),
-      tilled: +scoreTilled.toFixed(3),
-    },
-  };
+  // ── PLANTED (early stage): Soil with green weeds ──
+  // Cells with 5-30% green are likely soil with weeds/crops starting.
+  // This is distinct from harvest (30%+) which is handled above.
+  if (greenPct >= 0.05 && greenPct < 0.30) {
+    const confidence = clamp01((greenPct - 0.05) * 3.0);
+    return { state: 'planted', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
+  }
+
+  // ── UNKNOWN: Low signal — grass borders, artifacts, etc. ──
+  const signal = Math.max(greenPct, bluePct, brownPct);
+  const confidence = signal * 1.5;
+  return { state: 'unknown', confidence: +confidence.toFixed(3), scores: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
 }
 
 async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
@@ -160,18 +146,17 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
       const ey = Math.min(sy + cellH, height);
 
   // Sample center region only (ignore grass borders around each tile).
-  const padX = Math.floor((ex - sx) * 0.18);
-  const padY = Math.floor((ey - sy) * 0.18);
+  const padX = Math.floor((ex - sx) * 0.20);  // 20% padding to cut more grass
+  const padY = Math.floor((ey - sy) * 0.20);
   const csx = sx + padX;
   const csy = sy + padY;
   const cex = ex - padX;
   const cey = ey - padY;
 
       let total = 0;
-      let greenPx = 0;
-      let bluePx = 0;
-      let brownPx = 0;
-      let darkPx = 0;
+      let greenPx = 0;  // crop green: G > R*1.25 && G > B*1.25 && G > 38
+      let brownPx = 0;   // soil brown: R > G*1.2 && B < 30
+      let darkPx = 0;    // very dark: brightness < 56
       let whitePx = 0;
       let brightSum = 0;
 
@@ -184,22 +169,20 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
           const s = colorStatsForPixel(r, g, b);
           total++;
           brightSum += s.brightness;
-          if (s.greenStrong) greenPx++;
-          if (s.blueStrong) bluePx++;
-          if (s.brownish) brownPx++;
+          if (s.greenStrong) greenPx++;        // harvest green (vivid crop leaves)
+          if (s.drySoil || s.wetSoil) brownPx++; // soil — dry or wet
           if (s.dark) darkPx++;
           if (s.whiteish) whitePx++;
         }
       }
 
       const greenPct = greenPx / total;
-      const bluePct = bluePx / total;
       const brownPct = brownPx / total;
       const darkPct = darkPx / total;
       const whitePct = whitePx / total;
       const avgBrightness = brightSum / total;
 
-      const classified = classifyCell({ greenPct, bluePct, brownPct, darkPct, avgBrightness, whitePct });
+      const classified = classifyCell({ greenPct, brownPct, darkPct, avgBrightness });
 
       cells.push({
         row,
@@ -208,16 +191,14 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
         confidence: classified.confidence,
         scores: classified.scores,
         greenPct: +greenPct.toFixed(3),
-        bluePct: +bluePct.toFixed(3),
         brownPct: +brownPct.toFixed(3),
         darkPct: +darkPct.toFixed(3),
-        whitePct: +whitePct.toFixed(3),
         avgBrightness: +avgBrightness.toFixed(1),
       });
     }
   }
 
-  const counts = { tilled: 0, wet: 0, planted: 0, unknown: 0 };
+  const counts = { tilled: 0, planted: 0, unknown: 0 };
   for (const c of cells) counts[c.state] = (counts[c.state] || 0) + 1;
 
   const avgConfidence = cells.length > 0
@@ -228,7 +209,7 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
 }
 
 function gridToString(analysis) {
-  const icon = { tilled: 'T', wet: 'W', planted: 'P', unknown: '?' };
+  const icon = { tilled: 'T', planted: 'P', unknown: '?' };
   const rows = [];
   for (let r = 0; r < (analysis?.rows || 0); r++) {
     const line = [];
@@ -251,25 +232,23 @@ function evaluateActionNeed(actionName, analysis) {
   const slots = 9;
 
   // Avoid aggressive repeats when confidence is too low.
-  if (conf < 0.22) return false;
+  if (conf < 0.20) return false;
 
-  // Conservative rules: only request repeat if we have clear evidence.
+  // Simple rules:
+  // - hoe: repeat until farm has enough tilled/planted soil
+  // - water: skip (we don't distinguish wet vs tilled visually — use phase context instead)
+  // - plant: repeat until most cells show green crops
+  // - harvest: repeat if any planted crops visible
   if (actionName === 'hoe') {
-    return (tilled + wet + planted) < slots && unknown < 6;
-  }
-  if (actionName === 'water') {
-    // If still many plain-tilled (not watered/planted), water likely incomplete.
-    return tilled > 0 && (wet + planted) < slots;
+    return (tilled + planted) < slots && unknown < 6;
   }
   if (actionName === 'plant') {
-    return planted < slots && (tilled + wet) > 0;
+    return planted < slots && (tilled) > 0;
   }
   if (actionName === 'harvest') {
-    // If many planted remain, harvest may still be pending.
     return planted > 0;
   }
-
-  // Fertilizer optional; do not force repeats.
+  // water and others: don't force repeats
   return false;
 }
 
@@ -277,59 +256,45 @@ function evaluateActionScores(actionName, analysis) {
   const c = analysis?.counts || {};
   const slots = Math.max(1, (analysis?.rows || 3) * (analysis?.cols || 3));
   const tilled = c.tilled || 0;
-  const wet = c.wet || 0;
   const planted = c.planted || 0;
   const unknown = c.unknown || 0;
   const conf = analysis?.avgConfidence || 0;
 
   const ratios = {
     tilled: tilled / slots,
-    wet: wet / slots,
     planted: planted / slots,
     unknown: unknown / slots,
   };
 
   const clamp = (n) => Math.max(0, Math.min(1, n));
-  const withConf = (base, mult = 0.25) => clamp(base * (0.82 + (conf * mult)));
+  const withConf = (base) => clamp(base * (0.85 + conf * 0.3));
 
   let score = 0;
-  let threshold = 0.8;
+  let threshold = 0.7;
   let reason = 'ok';
 
   if (actionName === 'hoe') {
-    // Hoe is considered good if farm has mostly actionable soil/crops and little unknown noise.
-    const base = (ratios.tilled * 0.9) + (ratios.wet * 0.52) + (ratios.planted * 0.4) - (ratios.unknown * 0.32);
-    score = withConf(base);
-    threshold = 0.68;
-    if (ratios.unknown > 0.45) reason = 'too_many_unknown_cells';
-    else if (ratios.tilled < 0.45 && (ratios.wet + ratios.planted) < 0.35) reason = 'not_enough_tilled_or_progressed_tiles';
-  } else if (actionName === 'water') {
-    // After watering, we want wet/planted dominance and minimal plain-tilled.
-    const base = (ratios.wet * 0.92) + (ratios.planted * 0.34) - (ratios.tilled * 0.48) - (ratios.unknown * 0.22);
+    // Hoe is good if farm has mostly soil (tilled or planted)
+    const base = (ratios.tilled * 0.9) + (ratios.planted * 0.5) - (ratios.unknown * 0.4);
     score = withConf(base);
-    threshold = 0.7;
-    if (ratios.planted >= 0.45) {
-      // If many planted tiles are already visible, watering phase is effectively done.
-      score = Math.max(score, withConf(0.86));
-      reason = 'progressed_to_plant_phase';
-    }
-    if (ratios.wet < 0.45 && ratios.planted < 0.2) reason = 'not_enough_wet_tiles';
-    else if (ratios.tilled > 0.4) reason = 'too_many_dry_tilled_tiles';
+    threshold = 0.55;
+    if (ratios.unknown > 0.5) reason = 'too_many_unknown_cells';
+    else if (ratios.tilled + ratios.planted < 0.4) reason = 'farm_not_ready';
   } else if (actionName === 'plant') {
-    // Plant stage should end with mostly planted tiles.
-    const base = (ratios.planted * 0.96) + (ratios.wet * 0.12) - (ratios.tilled * 0.48) - (ratios.unknown * 0.2);
+    // Plant should end with mostly planted cells
+    const base = (ratios.planted * 0.98) - (ratios.tilled * 0.3) - (ratios.unknown * 0.2);
     score = withConf(base);
-    threshold = 0.72;
-    if (ratios.planted < 0.6) reason = 'not_enough_planted_tiles';
+    threshold = 0.65;
+    if (ratios.planted < 0.5) reason = 'not_enough_planted_tiles';
   } else if (actionName === 'harvest') {
-    // Harvest should reduce planted tiles; tilled/wet should dominate after collection.
-    const base = ((ratios.tilled + ratios.wet) * 0.86) - (ratios.planted * 0.76) - (ratios.unknown * 0.18);
+    // Harvest is good if planted tiles dominate
+    const base = (ratios.planted * 0.9) - (ratios.tilled * 0.1) - (ratios.unknown * 0.2);
     score = withConf(base);
-    threshold = 0.68;
-    if (ratios.planted > 0.34) reason = 'too_many_unharvested_plants';
+    threshold = 0.5;
+    if (ratios.planted < 0.3) reason = 'no_plants_to_harvest';
   } else {
-    score = withConf(0.7 - (ratios.unknown * 0.2));
-    threshold = 0.7;
+    score = withConf(0.6 - ratios.unknown * 0.3);
+    threshold = 0.6;
   }
 
   const matched = conf >= 0.2 && score >= threshold;
@@ -341,10 +306,9 @@ function evaluateActionScores(actionName, analysis) {
     threshold: +threshold.toFixed(3),
     confidence: +conf.toFixed(3),
     reason,
-    counts: { tilled, wet, planted, unknown, slots },
+    counts: { tilled, planted, unknown, slots },
     ratios: {
       tilled: +ratios.tilled.toFixed(3),
-      wet: +ratios.wet.toFixed(3),
       planted: +ratios.planted.toFixed(3),
       unknown: +ratios.unknown.toFixed(3),
     },

package/lib/commands/fishVision.js

@@ -11,27 +11,10 @@ const sharp = require('sharp');
 const https = require('https');
 const http = require('http');
 
-// Allowed CDN hostnames for image downloads (prevents SSRF).
-const ALLOWED_IMAGE_HOSTS = new Set([
-  'cdn.discordapp.com',
-  'media.discordapp.net',
-  'images.discordapp.net',
-]);
-
-const MAX_IMAGE_BYTES = 5 * 1024 * 1024; // 5 MB cap — prevents memory exhaustion
-
 /**
  * Download an image from a URL and return as Buffer.
- * Only allows Discord CDN URLs and enforces a max size limit.
  */
 function downloadImage(url) {
-  // ── SSRF check ──────────────────────────────────────────────
-  let hostname;
-  try { hostname = new URL(url).hostname; } catch { return Promise.reject(new Error('invalid URL')); }
-  if (!ALLOWED_IMAGE_HOSTS.has(hostname)) {
-    return Promise.reject(new Error(`disallowed host: ${hostname}`));
-  }
-
   return new Promise((resolve, reject) => {
     const proto = url.startsWith('https') ? https : http;
     const req = proto.get(url, res => {
@@ -39,16 +22,7 @@ function downloadImage(url) {
         return downloadImage(res.headers.location).then(resolve, reject);
       }
       const chunks = [];
-      let bytesReceived = 0;
-      res.on('data', c => {
-        bytesReceived += c.length;
-        if (bytesReceived > MAX_IMAGE_BYTES) {
-          req.destroy();
-          reject(new Error(`image too large: ${bytesReceived} bytes (max ${MAX_IMAGE_BYTES})`));
-          return;
-        }
-        chunks.push(c);
-      });
+      res.on('data', c => chunks.push(c));
       res.on('end', () => resolve(Buffer.concat(chunks)));
       res.on('error', reject);
     });

package/lib/commands/index.js

@@ -13,6 +13,7 @@ const { runHunt } = require('./hunt');
 const { runDig } = require('./dig');
 const { runFish, sellAllFish } = require('./fish');
 const { runPostMemes } = require('./postmemes');
+const { runScratch } = require('./scratch');
 const { runBlackjack } = require('./blackjack');
 const { runTrivia, triviaDB } = require('./trivia');
 const { runWorkShift } = require('./work');
@@ -38,6 +39,7 @@ module.exports = {
   runFish,
   sellAllFish,
   runPostMemes,
+  runScratch,
   runBlackjack,
   runTrivia,
   runWorkShift,

package/lib/commands/inventory.js

@@ -198,7 +198,7 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   LOG.cmd(`${c.white}${c.bold}pls inv${c.reset}`);
 
   await channel.send('pls inv');
-  let response = await waitForDankMemer(15000);
+  let response = await waitForDankMemer(10000);
 
   if (!response) {
     LOG.warn('[inv] No response');

package/lib/commands/scratch.js

@@ -0,0 +1,83 @@
+/**
+ * Scratch command handler.
+ * Send "pls scratch", click through scratch card buttons.
+ * Requires level 25 — checks profile level before running.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+const { meetsLevelRequirement } = require('./profile');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} [opts.accountId]
+ * @param {object} [opts.redis]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runScratch({ channel, waitForDankMemer, accountId, redis }) {
+  // Check level 25 requirement before wasting a command
+  const canRun = await meetsLevelRequirement({ channel, waitForDankMemer, accountId, redis }, 25);
+  if (!canRun) {
+    LOG.warn(`[scratch] Skipped — need level 25`);
+    return { result: 'skipped (need level 25)', coins: 0, skipReason: 'level' };
+  }
+  LOG.cmd(`${c.white}${c.bold}pls scratch${c.reset}`);
+
+  await channel.send('pls scratch');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[scratch] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[scratch] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'scratch');
+  const buttons = getAllButtons(response);
+
+  if (buttons.length === 0) {
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+    if (coins > 0) {
+      LOG.coin(`[scratch] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+      return { result: `scratch → +⏣ ${coins.toLocaleString()}`, coins };
+    }
+    return { result: text.substring(0, 60) || 'done', coins: 0 };
+  }
+
+  // Click through all scratch card cells
+  let lastResponse = response;
+  let clickCount = 0;
+  for (let i = 0; i < Math.min(buttons.length, 9); i++) {
+    const btn = buttons[i];
+    if (btn && !btn.disabled) {
+      await humanDelay(300, 700);
+      try {
+        const followUp = await safeClickButton(lastResponse, btn);
+        if (followUp) { lastResponse = followUp; clickCount++; }
+      } catch { break; }
+    }
+  }
+
+  const finalText = getFullText(lastResponse);
+  const coins = parseCoins(finalText);
+
+  if (coins > 0) {
+    LOG.coin(`[scratch] ${clickCount} clicks → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `scratch (${clickCount} clicks) → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  return { result: `scratch done (${clickCount} clicks)`, coins: 0 };
+}
+
+module.exports = { runScratch };

package/lib/commands/utils.js

@@ -558,8 +558,7 @@ async function clickCV2Button(msg, customId) {
   const gId = msg.guildId || msg.guild?.id;
   if (!token) throw new Error('No token for CV2 click');
   const sessionId = msg.client?.ws?.shards?.first?.()?.sessionId;
-  const { randomUUID } = require('crypto');
-  const nonce = randomUUID();
+  const nonce = `${(BigInt(Date.now() - 1420070400000) << 22n)}`;
   const payloadObj = {
     type: 3,
     application_id: String(msg.applicationId || DANK_MEMER_ID),
@@ -604,8 +603,7 @@ async function clickCV2SelectMenu(msg, customId, values = []) {
   const gId = msg.guildId || msg.guild?.id;
   if (!token) throw new Error('No token for CV2 select');
   const sessionId = msg.client?.ws?.shards?.first?.()?.sessionId;
-  const { randomUUID } = require('crypto');
-  const nonce = randomUUID();
+  const nonce = `${BigInt(Date.now() - 1420070400000) << 22n}`;
   const payloadObj = {
     type: 3,
     application_id: String(msg.applicationId || DANK_MEMER_ID),