dankgrinder 7.6.0 → 7.11.0

package/lib/commands/farmVision.js

@@ -82,16 +82,11 @@ function extractFarmImageUrl(msg) {
 function colorStatsForPixel(r, g, b) {
   const sum = r + g + b;
   const brightness = sum / 3;
-  // 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;
+  // 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, weedGreen, wetSoil, drySoil, whiteish };
+  return { brightness, gray, soil, whiteish };
 }
 
 function clamp01(n) {
@@ -99,41 +94,79 @@ function clamp01(n) {
 }
 
 function classifyCell(features) {
-  const { greenPct, bluePct, brownPct, darkPct, avgBrightness } = features;
+  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 } };
+  }
 
-  // ── 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) } };
+  // 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) } };
   }
 
-  // ── 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) } };
+  // ── 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) } };
   }
 
-  // ── 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) } };
+  // ── 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 — grass borders, artifacts, etc. ──
-  const signal = Math.max(greenPct, bluePct, brownPct);
+  // ── 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: { planted: +greenPct.toFixed(3), wet: +darkPct.toFixed(3), tilled: +brownPct.toFixed(3) } };
+  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);
 
@@ -145,60 +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.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;
+      // 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;  // 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;
+      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++;        // harvest green (vivid crop leaves)
-          if (s.drySoil || s.wetSoil) brownPx++; // soil — dry or wet
-          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 brownPct = brownPx / total;
-      const darkPct = darkPx / total;
-      const whitePct = whitePx / total;
-      const avgBrightness = brightSum / total;
-
-      const classified = classifyCell({ greenPct, brownPct, darkPct, avgBrightness });
+      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),
-        brownPct: +brownPct.toFixed(3),
-        darkPct: +darkPct.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, 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
@@ -209,7 +285,7 @@ async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
 }
 
 function gridToString(analysis) {
-  const icon = { tilled: 'T', 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 = [];
@@ -224,9 +300,10 @@ 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;
@@ -234,35 +311,41 @@ function evaluateActionNeed(actionName, analysis) {
   // Avoid aggressive repeats when confidence is too low.
   if (conf < 0.20) return false;
 
-  // 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
+  // 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 + planted) < slots && unknown < 6;
+    return harvest < slots && unknown < 6;
+  }
+  if (actionName === 'water') {
+    return tilled > 0 && water < slots;
   }
   if (actionName === 'plant') {
-    return planted < slots && (tilled) > 0;
+    return planted < slots && (water + tilled) > 0;
   }
   if (actionName === 'harvest') {
-    return planted > 0;
+    return harvest > 0;
   }
-  // water and others: don't 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 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,
+    harvest: harvest / slots,
     planted: planted / slots,
+    water: water / slots,
+    tilled: tilled / slots,
     unknown: unknown / slots,
   };
 
@@ -274,24 +357,33 @@ function evaluateActionScores(actionName, analysis) {
   let reason = 'ok';
 
   if (actionName === 'hoe') {
-    // 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);
+    // 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.55;
+    threshold = 0.40;
     if (ratios.unknown > 0.5) reason = 'too_many_unknown_cells';
-    else if (ratios.tilled + ratios.planted < 0.4) reason = 'farm_not_ready';
+    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') {
+    // 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.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 should end with mostly planted cells
-    const base = (ratios.planted * 0.98) - (ratios.tilled * 0.3) - (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.65;
-    if (ratios.planted < 0.5) 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 is good if planted tiles dominate
-    const base = (ratios.planted * 0.9) - (ratios.tilled * 0.1) - (ratios.unknown * 0.2);
+    // 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.5;
-    if (ratios.planted < 0.3) reason = 'no_plants_to_harvest';
+    threshold = 0.40;
+    if (ratios.harvest < 0.3) reason = 'no_crops_to_harvest';
   } else {
     score = withConf(0.6 - ratios.unknown * 0.3);
     threshold = 0.6;
@@ -306,10 +398,12 @@ function evaluateActionScores(actionName, analysis) {
     threshold: +threshold.toFixed(3),
     confidence: +conf.toFixed(3),
     reason,
-    counts: { tilled, planted, unknown, slots },
+    counts: { harvest, planted, water, tilled, unknown, slots },
     ratios: {
-      tilled: +ratios.tilled.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;
@@ -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}`);
@@ -3180,10 +3214,12 @@ async function start(apiKey, apiUrl) {
   loginLines.push(`  ${'─'.repeat(loginVis)}`);
   for (const l of loginLines) console.log(l);
 
-  // Dynamically capture the starting row of the login table via DSR
+  // Dynamically capture the starting row of the login table via DSR.
+  // Write MARKER to stderr (not stdout) to avoid PTY cooked-mode echoing
+  // of the visible "@MARKER@@" text portion, which was causing the DSR
+  // response to be swallowed or delayed.
   let loginBaseRow = 1;
   const captureLoginRow = () => new Promise(resolve => {
-    process.stdout.write(MARKER);
     const chunks = [];
     const handler = (chunk) => {
       chunks.push(chunk);
@@ -3196,6 +3232,8 @@ async function start(apiKey, apiUrl) {
       }
     };
     process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
     setTimeout(resolve, 50);
   });
   await captureLoginRow();
@@ -3297,7 +3335,7 @@ async function start(apiKey, apiUrl) {
   const invVis = 7 + iColNum + iColName + iColItems + iColVal + 12;
 
   // Print a unique marker, query its position, then overwrite it with the table
-  process.stdout.write(MARKER);
+  // Set up stdin handler BEFORE writing MARKER (same fix as Phase 1 — avoids race)
   let invBaseRow = 1;
   const captureRow = () => new Promise(resolve => {
     const chunks = [];
@@ -3312,6 +3350,8 @@ async function start(apiKey, apiUrl) {
       }
     };
     process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
     setTimeout(resolve, 50);
   });
   await captureRow();
@@ -3380,7 +3420,7 @@ async function start(apiKey, apiUrl) {
   const balVis = 7 + bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 14;
 
   // Capture starting row for balance phase
-  process.stdout.write(MARKER);
+  // Set up stdin handler BEFORE writing MARKER (same fix — avoids race + PTY echo)
   let balBaseRow = 1;
   const balCaptureRow = () => new Promise(resolve => {
     const chunks = [];
@@ -3395,6 +3435,8 @@ async function start(apiKey, apiUrl) {
       }
     };
     process.stdin.on('data', handler);
+    // Write to stderr so PTY doesn't echo the visible MARKER text to stdout
+    process.stderr.write(MARKER);
     setTimeout(resolve, 50);
   });
   await balCaptureRow();
@@ -3457,14 +3499,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 +3518,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 +3540,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])}`);