dankgrinder 7.1.0 → 7.7.0

package/lib/commands/farmVision.js

@@ -82,12 +82,11 @@ 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;
+  // Grayscale: removes hue confusion between dusty-brown and green
+  const gray = Math.round(r * 0.299 + g * 0.587 + b * 0.114);
+  const soil = r >= g && 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, gray, soil, whiteish };
 }
 
 function clamp01(n) {
@@ -95,59 +94,79 @@ 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));
-
-  // 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) } };
+  const {
+    harvestPct, plantPct, soilPct,
+    avgBrightness, grayStd,
+    brightGrayPct, darkGrayPct,
+    avgSat, avgR, avgG, avgB,
+    gMinusR, discordUiPct,
+  } = features;
+
+  // If Discord UI dominates this cell, the stats are meaningless
+  if (discordUiPct > 0.5) {
+    return { state: 'unknown', confidence: 0.1, scores: { harvest: 0, planted: 0, soil: 0 } };
   }
 
-  return {
-    state: bestState,
-    confidence: +confidence.toFixed(3),
-    scores: {
-      planted: +scorePlanted.toFixed(3),
-      wet: +scoreWet.toFixed(3),
-      tilled: +scoreTilled.toFixed(3),
-    },
-  };
+  // Actual farm pixel analysis from live screenshot:
+  // Water cells:   sat=0.15-0.20, B=14-21, darkPct=64-91%, G-R=-20 to +4
+  // Tilled cells:  sat=0.22-0.25, B=12-17, darkPct=64-81%, G-R=-8 to +11
+  // Harvest cells:  sat=0.22-0.25, B=12-17, darkPct=64-73%, G-R=+4 to +11, harv=41-46%
+  //
+  // Key insight: sat < 0.20 + B > 14 = water cells
+  // Higher sat (0.22+) + harvestPixels > 40% = harvest crops
+  // Higher sat (0.22+) + harv < 40% = tilled soil
+
+  const isLowSatWater = avgSat < 0.20 && avgB > 14;  // wet/dark soil
+  const isHighSatTilled = avgSat >= 0.20;              // tilled/planted soil
+  const isBright = brightGrayPct > 0.15;               // has bright crop pixels
+  const isDarkUniform = darkGrayPct > 0.55 && grayStd < 20; // very dark uniform (wet soil)
+
+  // ── HARVEST: Bright crops + high green + sat ≥ 0.20 ──
+  // Growing/ready crops: sat 0.22+, G-R > 5, harvestPixels > 40%
+  if (avgSat >= 0.20 && gMinusR > 5 && harvestPct > 0.40 && isBright) {
+    const excess = gMinusR - 5;
+    const confidence = clamp01(0.5 + excess * 0.06);
+    return { state: 'harvest', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
+  }
+
+  // ── WATER: Low saturation + blue dominant (wet soil) ──
+  // sat < 0.20 AND B > 14 catches actual wet cells from live screenshot
+  if (isLowSatWater || isDarkUniform) {
+    return { state: 'water', confidence: +clamp01(0.5 + darkGrayPct * 0.3).toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
+  }
+
+  // ── TILLED: Higher saturation (≥ 0.20) = soil/debris ──
+  // sat ≥ 0.20 covers tilled dirt, debris, and planted cells
+  if (isHighSatTilled) {
+    // Planted if some harvest pixels and some brightness
+    if (plantPct > 0.15 || gMinusR > 1) {
+      const confidence = clamp01(0.3 + avgSat * 0.8 + brightGrayPct * 0.5);
+      return { state: 'planted', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
+    }
+    const confidence = clamp01((avgSat - 0.15) * 1.5);
+    return { state: 'tilled', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
+  }
+
+  // ── UNKNOWN: Low signal / empty ──
+  const signal = Math.max(harvestPct, plantPct, soilPct, avgSat);
+  const confidence = signal * 1.5;
+  return { state: 'unknown', confidence: +confidence.toFixed(3), scores: { harvest: +harvestPct.toFixed(3), planted: +plantPct.toFixed(3), soil: +soilPct.toFixed(3) } };
 }
 
 async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
-  const { data, info } = await sharp(imgBuffer).raw().toBuffer({ resolveWithObject: true });
-  const { width, height, channels } = info;
+  // Convert to grayscale to eliminate hue confusion between dusty-brown and green
+  const grayBuf = await sharp(imgBuffer).grayscale().raw().toBuffer({ resolveWithObject: true });
+  const { data: grayData, info: grayInfo } = grayBuf;
+  const { width, height, channels } = grayInfo;
+
+  // Also get original for saturation analysis
+  const origBuf = await sharp(imgBuffer).raw().toBuffer({ resolveWithObject: true });
+  const { data: origData, info: origInfo } = origBuf;
+
+  if (origInfo.width !== width || origInfo.height !== height) {
+    throw new Error('Grayscale/Original dimension mismatch — should not happen');
+  }
+
   const cellW = Math.floor(width / cols);
   const cellH = Math.floor(height / rows);
 
@@ -159,65 +178,103 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
       const ex = Math.min(sx + cellW, width);
       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 csx = sx + padX;
-  const csy = sy + padY;
-  const cex = ex - padX;
-  const cey = ey - padY;
+      // Use 30% vertical padding to avoid Discord UI bar bleeding into top/bottom rows
+      const padX = Math.floor((ex - sx) * 0.20);
+      const padY = Math.floor((ey - sy) * 0.30);
+      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 whitePx = 0;
-      let brightSum = 0;
+      let harvestPx = 0;
+      let plantPx = 0;
+      let soilPx = 0;
+      let graySum = 0, graySqSum = 0;
+      let brightGrayPx = 0;
+      let darkGrayPx = 0;
+      let rSum = 0, gSum = 0, bSum = 0, satSum = 0;
+      let discordUiPx = 0;
+      const rawCellPixels = (cex - csx) * (cey - csy);
 
       for (let y = csy; y < cey; y++) {
         for (let x = csx; x < cex; x++) {
           const idx = (y * width + x) * channels;
-          const r = data[idx];
-          const g = data[idx + 1];
-          const b = data[idx + 2];
-          const s = colorStatsForPixel(r, g, b);
+          const r = origData[idx];
+          const g = origData[idx + 1];
+          const b = origData[idx + 2];
+          const gray = grayData[idx];
+
+          const maxC = Math.max(r, g, b);
+          const minC = Math.min(r, g, b);
+          const sat = maxC > 0 ? (maxC - minC) / 255 : 0;
+
+          // Skip Discord UI blue bar: very low saturation + blue dominant
+          if (b > 80 && sat < 0.08) {
+            discordUiPx++;
+            continue;
+          }
+
           total++;
-          brightSum += s.brightness;
-          if (s.greenStrong) greenPx++;
-          if (s.blueStrong) bluePx++;
-          if (s.brownish) brownPx++;
-          if (s.dark) darkPx++;
-          if (s.whiteish) whitePx++;
+          graySum += gray;
+          graySqSum += gray * gray;
+          rSum += r; gSum += g; bSum += b;
+          satSum += sat;
+
+          if (g > r * 1.25) harvestPx++;
+          else if (g > r * 1.08) plantPx++;
+          if (r >= g) soilPx++;
+          if (gray > 100) brightGrayPx++;
+          if (gray < 65) darkGrayPx++;
         }
       }
 
-      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 harvestPct = total > 0 ? harvestPx / total : 0;
+      const plantPct = total > 0 ? plantPx / total : 0;
+      const soilPct = total > 0 ? soilPx / total : 0;
+      const grayMean = total > 0 ? graySum / total : 0;
+      const grayVar = total > 0 ? (graySqSum / total) - (grayMean * grayMean) : 0;
+      const grayStd = Math.sqrt(Math.max(0, grayVar));
+      const avgSat = total > 0 ? satSum / total : 0;
+      const avgR = total > 0 ? rSum / total : 0;
+      const avgG = total > 0 ? gSum / total : 0;
+      const brightGrayPct = total > 0 ? brightGrayPx / total : 0;
+      const darkGrayPct = total > 0 ? darkGrayPx / total : 0;
+      const gMinusR = avgG - avgR;
+      const avgB = total > 0 ? bSum / total : 0;
+      const discordUiPct = rawCellPixels > 0 ? discordUiPx / rawCellPixels : 0;
+
+      const classified = classifyCell({
+        harvestPct, plantPct, soilPct,
+        avgR, avgG, avgB,
+        avgBrightness: grayMean,
+        avgSat, grayStd,
+        brightGrayPct, darkGrayPct,
+        gMinusR,
+        discordUiPct,
+      });
 
       cells.push({
-        row,
-        col,
+        row, col,
         state: classified.state,
         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),
+        harvestPct: +harvestPct.toFixed(3),
+        plantPct: +plantPct.toFixed(3),
+        soilPct: +soilPct.toFixed(3),
+        avgBrightness: +grayMean.toFixed(1),
+        avgSat: +avgSat.toFixed(3),
+        grayStd: +grayStd.toFixed(1),
+        brightGrayPct: +brightGrayPct.toFixed(3),
+        darkGrayPct: +darkGrayPct.toFixed(3),
+        avgR: +avgR.toFixed(1),
+        avgG: +avgG.toFixed(1),
+        avgB: +avgB.toFixed(1),
       });
     }
   }
 
-  const counts = { tilled: 0, wet: 0, planted: 0, unknown: 0 };
+  const counts = { harvest: 0, water: 0, 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 +285,7 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
 }
 
 function gridToString(analysis) {
-  const icon = { tilled: 'T', wet: 'W', planted: 'P', unknown: '?' };
+  const icon = { harvest: 'H', water: 'W', tilled: 'T', planted: 'P', unknown: '?' };
   const rows = [];
   for (let r = 0; r < (analysis?.rows || 0); r++) {
     const line = [];
@@ -243,93 +300,93 @@ function gridToString(analysis) {
 
 function evaluateActionNeed(actionName, analysis) {
   const c = analysis?.counts || {};
-  const tilled = c.tilled || 0;
-  const wet = c.wet || 0;
+  const harvest = c.harvest || 0;
   const planted = c.planted || 0;
+  const water = c.water || 0;
+  const tilled = (c.tilled || 0) + (c.soil || 0);  // soil = tilled cells
   const unknown = c.unknown || 0;
   const conf = analysis?.avgConfidence || 0;
   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.
+  // Rules (4-state model: harvest/water/tilled/planted):
+  // - hoe: repeat if farm has no soil (all harvest/unknown)
+  // - water: repeat if farm has tilled but not watered (R<58, not water)
+  // - plant: repeat if farm has watered tiles but no planted
+  // - harvest: repeat if any harvest-ready crops visible
   if (actionName === 'hoe') {
-    return (tilled + wet + planted) < slots && unknown < 6;
+    return harvest < 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 > 0 && water < slots;
   }
   if (actionName === 'plant') {
-    return planted < slots && (tilled + wet) > 0;
+    return planted < slots && (water + tilled) > 0;
   }
   if (actionName === 'harvest') {
-    // If many planted remain, harvest may still be pending.
-    return planted > 0;
+    return harvest > 0;
   }
-
-  // Fertilizer optional; do not force repeats.
   return false;
 }
 
 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 harvest = c.harvest || 0;
   const planted = c.planted || 0;
+  const water = c.water || 0;
+  const tilled = (c.tilled || 0) + (c.soil || 0);  // soil = tilled cells
   const unknown = c.unknown || 0;
   const conf = analysis?.avgConfidence || 0;
 
   const ratios = {
-    tilled: tilled / slots,
-    wet: wet / slots,
+    harvest: harvest / slots,
     planted: planted / slots,
+    water: water / slots,
+    tilled: tilled / 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);
+    // Hoe is good if farm has mostly soil, not harvest-ready crops
+    const base = (ratios.tilled * 0.7) + (ratios.water * 0.7) + (ratios.planted * 0.5) - (ratios.harvest * 0.9) - (ratios.unknown * 0.3);
     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';
+    threshold = 0.40;
+    if (ratios.unknown > 0.5) reason = 'too_many_unknown_cells';
+    else if (ratios.harvest >= 0.5) reason = 'farm_has_crops_to_harvest';
+    else if (ratios.harvest + ratios.planted < 0.3) reason = 'farm_needs_hoe';
   } 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);
+    // Water is good if there are tilled (dry) tiles to water
+    const base = (ratios.tilled * 0.95) - (ratios.water * 0.5) - (ratios.harvest * 0.5) - (ratios.unknown * 0.2);
     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.40;
+    if (ratios.harvest >= 0.5) reason = 'farm_has_crops_to_harvest';
+    else if (ratios.tilled < 0.3) reason = 'no_tilled_tiles';
   } 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 growing crops on watered soil
+    const base = (ratios.planted * 0.95) - (ratios.harvest * 0.1) - (ratios.tilled * 0.2) - (ratios.unknown * 0.1);
     score = withConf(base);
-    threshold = 0.72;
-    if (ratios.planted < 0.6) reason = 'not_enough_planted_tiles';
+    threshold = 0.50;
+    if (ratios.harvest >= 0.5) reason = 'farm_ready_to_harvest';
+    else if (ratios.water + ratios.tilled < 0.3) reason = 'farm_not_watered';
   } 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 harvest-ready tiles dominate
+    const base = (ratios.harvest * 0.95) - (ratios.tilled * 0.15) - (ratios.planted * 0.1) - (ratios.unknown * 0.1);
     score = withConf(base);
-    threshold = 0.68;
-    if (ratios.planted > 0.34) reason = 'too_many_unharvested_plants';
+    threshold = 0.40;
+    if (ratios.harvest < 0.3) reason = 'no_crops_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,11 +398,12 @@ function evaluateActionScores(actionName, analysis) {
     threshold: +threshold.toFixed(3),
     confidence: +conf.toFixed(3),
     reason,
-    counts: { tilled, wet, planted, unknown, slots },
+    counts: { harvest, planted, water, tilled, unknown, slots },
     ratios: {
-      tilled: +ratios.tilled.toFixed(3),
-      wet: +ratios.wet.toFixed(3),
+      harvest: +ratios.harvest.toFixed(3),
       planted: +ratios.planted.toFixed(3),
+      water: +ratios.water.toFixed(3),
+      tilled: +ratios.tilled.toFixed(3),
       unknown: +ratios.unknown.toFixed(3),
     },
   };

package/lib/commands/utils.js

@@ -494,9 +494,19 @@ async function ensureCV2(msg, force = false) {
     if (rawParsed && rawParsed.components?.length > 0) {
       msg._cv2 = rawParsed.components;
       msg._cv2text = rawParsed.cv2Text || _extractCV2Text(rawParsed.components).trim();
-      msg._cv2buttons = rawParsed.buttons?.length > 0
+      const topLevel = rawParsed.buttons?.length > 0
         ? rawParsed.buttons.map(b => ({ type: 'BUTTON', label: b.label, customId: b.customId, style: b.style, url: null, disabled: b.disabled, emoji: b.emoji, _raw: b }))
-        : _extractCV2Buttons(rawParsed.components);
+        : [];
+      const nested = _extractCV2Buttons(rawParsed.components);
+      // Merge, deduplicating by customId so all buttons are captured (top-level cv2Buttons
+      // omits some nested "All" buttons that live inside ACTION_ROW containers).
+      const seen = new Set();
+      const merged = [...topLevel, ...nested].filter(b => {
+        const id = b.customId || b.custom_id || '';
+        if (!id || seen.has(id)) return false;
+        seen.add(id); return true;
+      });
+      msg._cv2buttons = merged;
       msg._cv2EditedTs = msgEditedTs;
       cv2Cache.set(msg.id, { components: rawParsed.components, editedTimestamp: msgEditedTs });
       return msg;
@@ -558,7 +568,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 nonce = `${BigInt(Date.now() - 1420070400000) << 22n}`;
+  const nonce = `${(BigInt(Date.now() - 1420070400000) << 22n)}`;
   const payloadObj = {
     type: 3,
     application_id: String(msg.applicationId || DANK_MEMER_ID),
@@ -574,7 +584,11 @@ async function clickCV2Button(msg, customId) {
   const resp = await _httpPost('https://discord.com/api/v9/interactions', {
     Authorization: token, 'Content-Type': 'application/json',
   }, payload);
-  if (resp.status >= 400) throw new Error(`CV2 click ${resp.status}: ${resp.body.substring(0, 200)}`);
+  if (resp.status >= 400) {
+    const errMsg = `CV2 click ${resp.status}: ${resp.body.substring(0, 300)}`;
+    LOG.warn(`[cv2] ${errMsg}`);
+    throw new Error(errMsg);
+  }
 
   let parsed = null;
   try {

package/lib/grinder.js

@@ -644,7 +644,11 @@ function renderDashboard() {
     if (ls === 0) lsStr = `${R}♥0${c.reset}`;
     else if (ls != null && ls <= 2) lsStr = `${Y}♥${ls}${c.reset}`;
     else if (ls != null) lsStr = `${G}♥${ls}${c.reset}`;
-    else lsStr = `${D}♥?${c.reset}`;
+    else {
+      // Unknown — pulse to show it's still being determined
+      const pulse = PULSE_CHARS[Math.floor(Date.now() / 400) % PULSE_CHARS.length];
+      lsStr = `${D}${pulse}♥?${c.reset}`;
+    }
 
     // ── Level indicator (fixed width so value changes don't jitter) ──
     const lvl = wk._level || 0;
@@ -1839,9 +1843,15 @@ class AccountWorker {
       }
     }
 
-    // ── Lifesaver protection: skip crime/search if 0 lifesavers ──
+    // ── Lifesaver protection: skip crime/search if 0 lifesavers or unknown ──
     if (cmdName === 'crime' || cmdName === 'search') {
-      // Fast path: check in-memory lifesaver count (set from inv + DM check)
+      // Unknown (null/undefined): DMs haven't confirmed safety — skip for safety.
+      if (this._lifesavers == null) {
+        this.log('warn', `[${cmdName}] SKIPPED — lifesavers unknown (safety hold)`);
+        await this.setCooldown(cmdName, 600);
+        return;
+      }
+      // Zero: depleted — disable for a long period.
       if (this._lifesavers === 0) {
         this.log('warn', `[${cmdName}] SKIPPED — 0 lifesavers (in-memory)`);
         await this.setCooldown(cmdName, 3600);
@@ -3125,19 +3135,43 @@ async function start(apiKey, apiUrl) {
   // Init rawLogger Redis (uses same URL — logs all raw gateway data)
   if (REDIS_URL) {
     rawLogger.init(REDIS_URL).catch(() => {});
-    // Listen for DM death events across all accounts
+    // Listen for DM events across all accounts — update worker state + dashboard LIVE
     rawLogger.onDmEvent((event, raw) => {
-      if (event.type === 'death' && event.lifesaversLeft === 0) {
-        const channelId = raw.channel_id;
-        // Find which worker uses this DM channel and disable their crime/search
-        for (const w of workers) {
-          if (w.client?.user?.dmChannel?.id === channelId || w.channel?.id) {
-            w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
-            w.setCooldown?.('crime', 86400);
-            w.setCooldown?.('search', 86400);
+      const channelId = raw.channel_id;
+      for (const w of workers) {
+        const isThisWorker = w.client?.user?.dmChannel?.id === channelId;
+        if (!isThisWorker && w.channel?.id !== channelId) continue;
+
+        if (event.type === 'death') {
+          // Update worker's lifesaver count so dashboard ♥ updates in real time
+          if (event.lifesaversLeft >= 0) {
+            const prev = w._lifesavers;
+            w._lifesavers = event.lifesaversLeft;
+            if (event.lifesaversLeft === 0) {
+              w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
+              w.setCooldown?.('crime', 86400);
+              w.setCooldown?.('search', 86400);
+              sendWebhook?.('DEATH ALERT (DM)', `**${w.username}** died in DMs! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
+            } else {
+              w.log?.('warn', `DEATH in DMs — ${event.lifesaversLeft} lifesavers remaining`);
+              if (prev !== event.lifesaversLeft) {
+                w.setCooldown?.('crime', 60);
+                w.setCooldown?.('search', 60);
+              }
+              if (event.lifesaversLeft <= 2) {
+                sendWebhook?.('LOW LIFESAVERS', `**${w.username}** has only **${event.lifesaversLeft}** lifesaver(s) left!`, 0xfbbf24);
+              }
+            }
+          }
+          scheduleRender();
+        }
+
+        if (event.type === 'levelup') {
+          if (event.to > 0) {
+            w._level = event.to;
+            scheduleRender();
           }
         }
-        sendWebhook?.('DEATH ALERT (DM)', `Account died! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
       }
     });
     checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}RawLog${c.reset}`);
@@ -3457,14 +3491,16 @@ async function start(apiKey, apiUrl) {
 
 
   // Phase 2.75: Check DM history for deaths/level-ups (sequential, fast)
-  console.log(`  ${rgb(139, 92, 246)}${BRAILLE_SPIN[0]}${c.reset}  ${c.dim}Checking DM history...${c.reset}`);
-  let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [];
+  const dmCheckPulse = BRAILLE_SPIN[Math.floor(Date.now() / 80) % BRAILLE_SPIN.length];
+  console.log(`  ${rgb(139, 92, 246)}${dmCheckPulse}${c.reset}  ${c.dim}Checking DM history...${c.reset}`);
+  let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [], dmUnknown = [];
   for (const w of activeWorkers) {
     try {
       const dm = await w.checkDmHistory();
       if (dm.deaths > 0) dmDeaths += dm.deaths;
       if (dm.levelUps > 0) dmLevelUps += dm.levelUps;
       if (dm.lifesavers === 0) dmNoLs.push(w.username);
+      if (dm.lifesavers === -1) dmUnknown.push(w.username);
       // Store level and lifesaver for dashboard
       if (dm.currentLevel > 0) w._level = dm.currentLevel;
       if (dm.lifesavers >= 0) w._lifesavers = dm.lifesavers;
@@ -3474,6 +3510,10 @@ async function start(apiKey, apiUrl) {
       if (dm.lifesavers >= 0) {
         const lc = dm.lifesavers === 0 ? rgb(239, 68, 68) : dm.lifesavers <= 2 ? rgb(251, 191, 36) : rgb(52, 211, 153);
         parts.push(`${lc}♥${dm.lifesavers}${c.reset}`);
+      } else {
+        // Unknown lifesavers — pulse to show pending
+        const pulse = PULSE_CHARS[Math.floor(Date.now() / 400) % PULSE_CHARS.length];
+        parts.push(`${D}${pulse}♥?${c.reset}`);
       }
       if (parts.length > 0) {
         console.log(`  ${c.dim}├${c.reset} ${c.bold}${w.username}${c.reset}  ${parts.join('  ')}`);
@@ -3492,7 +3532,16 @@ async function start(apiKey, apiUrl) {
       }
     }
   }
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}DM check${c.reset}  ${c.dim}${dmDeaths} deaths, ${dmLevelUps} level-ups found${c.reset}`);
+  if (dmUnknown.length > 0) {
+    console.log(`  ${rgb(251, 191, 36)}⚠${c.reset}  ${c.dim}Lifesavers unknown — live DM monitor active:${c.reset} ${dmUnknown.join(', ')}`);
+    // Crime/search on these accounts will be skipped via safety hold until the live
+    // DM gateway listener detects a death (→ sets count) or confirms clean.
+  }
+  const dmSummaryParts = [];
+  if (dmDeaths > 0) dmSummaryParts.push(`${dmDeaths} deaths`);
+  if (dmLevelUps > 0) dmSummaryParts.push(`${dmLevelUps} level-ups`);
+  if (dmUnknown.length > 0) dmSummaryParts.push(`${dmUnknown.length} pending`);
+  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}DM check${c.reset}  ${dmSummaryParts.length > 0 ? c.dim + dmSummaryParts.join(', ') + c.reset : c.dim + 'clean — no deaths or level-ups' + c.reset}`);
   console.log('');
 
   console.log(`  ${rgb(139, 92, 246)}${c.bold}>>>${c.reset}  ${gradientText('Starting grind loops...', [139, 92, 246], [52, 211, 153])}`);