mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/correlations-parser.js

@@ -0,0 +1,231 @@
+"use strict";
+
+// Black Box Correlations parser — V5 wishlist item (V5_CLOSED_LOOP:1039).
+//
+// Correlates daily-note Battery signals (sleep hours, protein, energy
+// rating) against output signals (tasksDone, sessionCount). Computes
+// Pearson correlation coefficient over the trailing N days.
+//
+// Designed to be HONEST under low-data conditions:
+//   - <14 days: returns { available: false, reason: 'needs_more_data', haveDays: N }
+//   - >=14 days but Battery section empty: returns { available: false, reason: 'no_battery_data' }
+//   - With data: returns array of correlation entries, each with
+//     { x_signal, y_signal, r, n, sample_window_days }
+//
+// No fake patterns. The UI module shows the underlying numbers, not just
+// a verdict like "good sleep = better output." Codex ethics: surface the
+// truth, not the convenient interpretation.
+
+const fs = require("fs");
+const path = require("path");
+
+const MIN_DAYS = 14;
+const DEFAULT_WINDOW = 30;
+
+function dailiesDir(vault) {
+  return path.join(vault, "02_Areas", "Engine", "Dailies");
+}
+
+function safeRead(filePath) {
+  try { return fs.readFileSync(filePath, "utf8"); } catch { return ""; }
+}
+
+// Parse a Daily Note for the metrics we care about.
+// Returns { date, sleepHours, proteinG, energy, tasksDone, sessionCount,
+//          hasBatterySection } or null.
+//
+// User-reported bug 2026-05-24: parser said "Daily Notes don't have Battery
+// section data yet · coverage sleep=0 protein=0 energy=0" — but vault has
+// ## Battery section in every May daily. The catch: section is a markdown
+// TABLE, values are [TBD] placeholders, and metric names differ from the
+// regex labels. Two fixes here:
+//   1. Match both `Sleep: 7h 30m` AND markdown-table `| Sleep | 7h 30m |`
+//   2. Reject placeholder values like `[TBD]`, `—`, `(none)`, `n/a`
+//   3. Emit hasBatterySection so the UI can distinguish "no section" from
+//      "section exists but unfilled" — the user's real state.
+function parseDaily(filePath, dateKey) {
+  const text = safeRead(filePath);
+  if (!text) return null;
+  const entry = { date: dateKey, sleepHours: null, proteinG: null, energy: null, tasksDone: null, sessionCount: null, hasBatterySection: false };
+
+  // Detect Battery section presence (independent of value extraction).
+  entry.hasBatterySection = /^##\s+Battery\b/im.test(text);
+
+  // T242 bug hunt fix (B#9): scope value matching to within the
+  // `## Battery` section only. Previous version did `text.match` against
+  // the whole file, so any Session Log line containing "Energy: high" or
+  // a quoted "Sleep: 8h" anywhere in the note would match and pollute
+  // the metric. Now: locate the Battery header, slice to the NEXT
+  // top-level header (or EOF), and match only within that slice.
+  let batterySlice = "";
+  if (entry.hasBatterySection) {
+    const startIdx = text.search(/^##\s+Battery\b/im);
+    if (startIdx >= 0) {
+      const after = text.slice(startIdx);
+      // Find the next `##` heading (any level 2+) that's NOT the Battery one.
+      const nextHeader = after.slice(8).search(/^##\s+\S/m);
+      batterySlice = nextHeader > 0 ? after.slice(0, 8 + nextHeader) : after;
+    }
+  }
+  const valueText = batterySlice || ""; // Only match inside Battery slice.
+
+  // Combined regex: capture value after `:`/`=` OR after a `|` pipe (table).
+  // Reject placeholder values like [TBD], —, (none), n/a, ?, TBD.
+  const isReal = (v) => v && !/^(?:\[?[Tt][Bb][Dd]\]?|[—–-]+|n\/?a|\(?none\)?|\?+|tbd|pending)$/i.test(v.trim());
+
+  // Sleep — "Sleep: 7h 30m" OR "| Sleep | 7h 30m |"
+  const sleepMatch = valueText.match(/(?:Sleep|Slept)\s*(?:[:=]|\|)\s*([^|\n]+?)(?=\s*\||\s*$)/im);
+  if (sleepMatch && isReal(sleepMatch[1])) {
+    const sub = sleepMatch[1].trim().match(/(\d+(?:\.\d+)?)\s*h?(?:\s*(\d+)\s*m)?/);
+    if (sub) {
+      const h = parseFloat(sub[1]);
+      const m = sub[2] ? parseFloat(sub[2]) : 0;
+      entry.sleepHours = Number.isFinite(h) ? h + (Number.isFinite(m) ? m / 60 : 0) : null;
+    }
+  }
+
+  // Protein — "Protein: 120g" OR "| Protein | 120g |"
+  const proteinMatch = valueText.match(/Protein\s*(?:[:=]|\|)\s*([^|\n]+?)(?=\s*\||\s*$)/im);
+  if (proteinMatch && isReal(proteinMatch[1])) {
+    const sub = proteinMatch[1].trim().match(/(\d+(?:\.\d+)?)\s*g?/);
+    if (sub) entry.proteinG = parseFloat(sub[1]);
+  }
+
+  // Energy — "Energy: 7/10" OR "| Energy | 7/10 |"
+  const energyMatch = valueText.match(/Energy\s*(?:[:=]|\|)\s*([^|\n]+?)(?=\s*\||\s*$)/im);
+  if (energyMatch && isReal(energyMatch[1])) {
+    const sub = energyMatch[1].trim().match(/(\d+(?:\.\d+)?)/);
+    if (sub) entry.energy = parseFloat(sub[1]);
+  }
+
+  // Tasks — count "- [x]" and "- [ ]"
+  const doneCount = (text.match(/^\s*[-*]\s*\[x\]/gmi) || []).length;
+  const totalCount = (text.match(/^\s*[-*]\s*\[[ x]\]/gmi) || []).length;
+  if (totalCount > 0) {
+    entry.tasksDone = doneCount;
+    entry.tasksTotal = totalCount;
+  }
+
+  // Session count — count "## Session" or "Session 1, Session 2" headers
+  const sessionMatch = text.match(/##\s*Session/gi);
+  if (sessionMatch) entry.sessionCount = sessionMatch.length;
+
+  return entry;
+}
+
+// Walk daily notes for the trailing N days.
+function collectEntries(vault, windowDays) {
+  const dDir = dailiesDir(vault);
+  if (!fs.existsSync(dDir)) return [];
+  const entries = [];
+  const cutoff = Date.now() - windowDays * 86400000;
+  let months;
+  try {
+    months = fs.readdirSync(dDir).filter((d) => /^\d{4}-\d{2}$/.test(d)).sort().reverse();
+  } catch { return []; }
+  for (const mDir of months) {
+    if (entries.length >= windowDays * 2) break; // safety
+    let files;
+    try {
+      files = fs.readdirSync(path.join(dDir, mDir)).filter((f) => /^Daily - \d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+    } catch { continue; }
+    for (const f of files) {
+      const m = f.match(/(\d{4})-(\d{2})-(\d{2})/);
+      if (!m) continue;
+      const dateKey = m[0];
+      const t = Date.parse(`${m[1]}-${m[2]}-${m[3]}`);
+      if (!Number.isFinite(t) || t < cutoff) continue;
+      const parsed = parseDaily(path.join(dDir, mDir, f), dateKey);
+      if (parsed) entries.push(parsed);
+    }
+  }
+  return entries;
+}
+
+// Pearson correlation coefficient over paired (x, y) values.
+// Returns null if N < 3 or zero variance.
+function pearson(xs, ys) {
+  const n = Math.min(xs.length, ys.length);
+  if (n < 3) return null;
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+  for (let i = 0; i < n; i++) {
+    const x = xs[i], y = ys[i];
+    sumX += x; sumY += y;
+    sumXY += x * y;
+    sumX2 += x * x;
+    sumY2 += y * y;
+  }
+  const num = n * sumXY - sumX * sumY;
+  const den = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
+  if (den === 0) return null;
+  return num / den;
+}
+
+function correlate(entries, xKey, yKey) {
+  const pairs = entries
+    .map(e => ({ x: e[xKey], y: e[yKey] }))
+    .filter(p => Number.isFinite(p.x) && Number.isFinite(p.y));
+  if (pairs.length < 3) return null;
+  const r = pearson(pairs.map(p => p.x), pairs.map(p => p.y));
+  if (r == null) return null;
+  return {
+    x_signal: xKey,
+    y_signal: yKey,
+    r: Math.round(r * 1000) / 1000,
+    n: pairs.length,
+    direction: r > 0.1 ? "positive" : r < -0.1 ? "negative" : "none",
+    strength: Math.abs(r) > 0.6 ? "strong" : Math.abs(r) > 0.3 ? "moderate" : "weak",
+  };
+}
+
+function compute({ vault, windowDays = DEFAULT_WINDOW } = {}) {
+  if (!vault) return { available: false, reason: "no_vault" };
+  const entries = collectEntries(vault, windowDays);
+  if (entries.length < MIN_DAYS) {
+    return {
+      available: false,
+      reason: "needs_more_data",
+      haveDays: entries.length,
+      neededDays: MIN_DAYS,
+      windowDays,
+    };
+  }
+  const haveSleep = entries.filter(e => Number.isFinite(e.sleepHours)).length;
+  const haveProtein = entries.filter(e => Number.isFinite(e.proteinG)).length;
+  const haveEnergy = entries.filter(e => Number.isFinite(e.energy)).length;
+  // Distinguish "no Battery section anywhere" from "section exists but
+  // values are placeholders ([TBD]/—/n/a)". The empty-state copy in the
+  // UI changes depending on which — telling someone with [TBD]s "you
+  // don't have a Battery section" is gaslighting, the truth is "fill in
+  // your placeholders."
+  const haveBatterySection = entries.filter(e => e.hasBatterySection).length;
+  if (haveSleep < MIN_DAYS && haveProtein < MIN_DAYS && haveEnergy < MIN_DAYS) {
+    return {
+      available: false,
+      reason: haveBatterySection > 0 ? "battery_section_unfilled" : "no_battery_section",
+      haveDays: entries.length,
+      windowDays,
+      batterySectionDays: haveBatterySection,
+      coverage: { sleep: haveSleep, protein: haveProtein, energy: haveEnergy },
+    };
+  }
+  const pairs = [
+    ["sleepHours", "tasksDone"],
+    ["sleepHours", "sessionCount"],
+    ["sleepHours", "energy"],
+    ["proteinG", "energy"],
+    ["proteinG", "tasksDone"],
+    ["energy", "tasksDone"],
+    ["energy", "sessionCount"],
+  ];
+  const correlations = pairs.map(([x, y]) => correlate(entries, x, y)).filter(Boolean);
+  return {
+    available: true,
+    windowDays,
+    haveDays: entries.length,
+    coverage: { sleep: haveSleep, protein: haveProtein, energy: haveEnergy },
+    correlations,
+  };
+}
+
+module.exports = { compute, parseDaily, pearson };

package/src/dashboard/lib/daily-note-resolver.js

@@ -0,0 +1,228 @@
+"use strict";
+
+const path = require("path");
+const fs = require("fs");
+const { dailiesDir, dailyNotePath, exists, safeRead, safeListDir } = require("./paths");
+
+// Resolves Daily Notes — supports YYYY-MM/Daily - YYYY-MM-DD.md format.
+// Returns streak, today's note, last-N notes, total count.
+
+function fmtDate(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${dd}`;
+}
+
+function resolveDailyNotes(vault, options = {}) {
+  // T245 — apply the Mover OS session-day convention. Before 05:00, the
+  // session belongs to YESTERDAY (matches /log, /analyse-day, /plan-tomorrow
+  // workflows). Without this, at 03:00 the dashboard reports "no Daily
+  // Note for today" while the user has been actively editing yesterday's
+  // note all night — gives a ghost "missing daily" warning every late
+  // session.
+  let sessionDate = options.sessionDate;
+  if (!sessionDate) {
+    const now = new Date();
+    sessionDate = new Date(now);
+    if (now.getHours() < 5) sessionDate.setDate(sessionDate.getDate() - 1);
+  }
+  const lookback = options.lookback || 30;
+
+  const out = {
+    available: true,
+    today: null,
+    streak: 0,
+    recentNotes: [],
+    totalThisMonth: 0,
+    totalThisYear: 0
+  };
+
+  // Check today's note
+  const todayPath = dailyNotePath(vault, sessionDate);
+  if (exists(todayPath)) {
+    const text = safeRead(todayPath, "");
+    out.today = {
+      date: fmtDate(sessionDate),
+      path: todayPath,
+      exists: true,
+      ...analyzeNoteText(text)
+    };
+  } else {
+    out.today = { date: fmtDate(sessionDate), path: todayPath, exists: false };
+  }
+
+  // Streak — count consecutive days backwards including today
+  let streakCount = 0;
+  for (let i = 0; i < 365; i++) {
+    const d = new Date(sessionDate);
+    d.setDate(d.getDate() - i);
+    const p = dailyNotePath(vault, d);
+    if (exists(p)) {
+      streakCount++;
+    } else if (i === 0) {
+      // No daily note today — streak counts from yesterday backwards
+      continue;
+    } else {
+      break;
+    }
+  }
+  out.streak = streakCount;
+
+  // Recent notes (last N days)
+  const recent = [];
+  for (let i = 0; i < lookback; i++) {
+    const d = new Date(sessionDate);
+    d.setDate(d.getDate() - i);
+    const p = dailyNotePath(vault, d);
+    if (exists(p)) {
+      const text = safeRead(p, "");
+      recent.push({ date: fmtDate(d), path: p, exists: true, ...analyzeNoteText(text) });
+    } else {
+      recent.push({ date: fmtDate(d), path: p, exists: false });
+    }
+  }
+  out.recentNotes = recent;
+
+  // Counts
+  const yyyy = sessionDate.getFullYear();
+  const yyyyMm = `${yyyy}-${String(sessionDate.getMonth() + 1).padStart(2, "0")}`;
+  const monthDir = path.join(dailiesDir(vault), yyyyMm);
+  // Count only real daily notes — cloud-sync artifacts ("Daily - 2026-07-10
+  // (conflicted copy).md", "Daily - 2026-07-10 2.md") inflated the totals.
+  const isDailyNote = (e) => /^Daily - \d{4}-\d{2}-\d{2}\.md$/.test(e.name);
+  out.totalThisMonth = safeListDir(monthDir, { extension: ".md" }).filter(isDailyNote).length;
+
+  // This year — sum across all month folders
+  const yearDirs = safeListDir(dailiesDir(vault), { dirsOnly: true })
+    .filter(e => e.name.startsWith(`${yyyy}-`));
+  let yearCount = 0;
+  for (const yd of yearDirs) {
+    yearCount += safeListDir(yd.path, { extension: ".md" }).filter(isDailyNote).length;
+  }
+  out.totalThisYear = yearCount;
+
+  // 365-day grid: array of {date, exists}
+  const heatmapDays = [];
+  for (let i = 364; i >= 0; i--) {
+    const d = new Date(sessionDate);
+    d.setDate(d.getDate() - i);
+    const p = dailyNotePath(vault, d);
+    heatmapDays.push({ date: fmtDate(d), exists: exists(p) });
+  }
+  out.heatmap = heatmapDays;
+
+  return out;
+}
+
+// Strip bold FIRST (else the bullet-strip eats one * of a **bold** line),
+// then a leading bullet/checkbox marker. Returns null on empty.
+function cleanLine(s) {
+  if (!s) return null;
+  return s.replace(/\*\*/g, "").replace(/^\s*[-*]\s+(\[.\]\s*)?/, "").trim() || null;
+}
+
+const EMPTY_JOURNAL = { hasEvening: false, hasMorning: false, evening: null, morning: null };
+
+// v6 SURFACE 2 — parse the Daily Note `## Journal` section into its
+// `### Evening · …` / `### Morning · …` sub-anchors (written by the journal
+// close endpoint, W3). Every field is null when absent — a guessed score is
+// never ok (false-zero contract). The section ends at the next H1/H2.
+function parseJournal(text) {
+  if (!text) return EMPTY_JOURNAL;
+  const jm = text.match(/^#{1,6}\s*journal\s*$/im);
+  if (!jm) return EMPTY_JOURNAL;
+  let sect = text.slice(jm.index + jm[0].length);
+  const nextTop = sect.search(/^#{1,2}\s/m);
+  if (nextTop > 0) sect = sect.slice(0, nextTop);
+  const under = (re) => { const m = sect.match(re); return m ? cleanLine(m[1]) : null; };
+  // A score must be ANCHORED, never the leftmost digit in prose — "Day 3 in a
+  // row, honestly a 7/10" read as 3 and corrupted the calibration gap (R5-A).
+  // Accepted shapes, in order: "7/10" anywhere; "Score: 7" / "Energy: 7";
+  // a leading first-token number (the journal endpoint's own format,
+  // "7 — scattered but shipped") unless it's a time/duration ("5 hours…").
+  // Anything else = null (never a guess).
+  const num = (line) => {
+    if (!line) return null;
+    let m = line.match(/\b(10|[1-9])\s*\/\s*10\b/);
+    if (m) return Number(m[1]);
+    m = line.match(/\b(?:score|energy)\s*[:=]?\s*(10|[1-9])\b/i);
+    if (m) return Number(m[1]);
+    m = line.match(/^\s*(10|[1-9])\b(?!\s*(?:am|pm|h\b|hr|hour|min|:|%))/i);
+    return m ? Number(m[1]) : null;
+  };
+
+  const evScoreLine = under(/###[^\n]*evening[^\n]*score[^\n]*\n+([^\n#][^\n]*)/i);
+  const evening = {
+    score: num(evScoreLine),
+    scoreWhy: evScoreLine,
+    winAvoidance: under(/###[^\n]*evening[^\n]*(?:win|avoid)[^\n]*\n+([^\n#][^\n]*)/i),
+    workedDidnt: under(/###[^\n]*evening[^\n]*work[^\n]*\n+([^\n#][^\n]*)/i),
+    doDifferently: under(/###[^\n]*evening[^\n]*differ[^\n]*\n+([^\n#][^\n]*)/i),
+    // Codex W3 round 3: the alibi is an EVENING field — read it ONLY from an
+    // Evening header (matches what the journal endpoint writes: "### Evening ·
+    // alibi"). Requiring "evening" positively — rather than just excluding
+    // morning — means a user's unrelated "### Random prediction note" is NOT
+    // misread as the evening alibi. Consistent with every other evening field,
+    // which already requires "evening" in the header.
+    alibi: under(/###[^\n]*\bevening\b[^\n]*(?:alibi|prediction)[^\n]*\n+([^\n#][^\n]*)/i),
+  };
+  const mEnergyLine = under(/###[^\n]*morning[^\n]*energy[^\n]*\n+([^\n#][^\n]*)/i);
+  const morning = {
+    wantVsShould: under(/###[^\n]*morning[^\n]*(?:want|should)[^\n]*\n+([^\n#][^\n]*)/i),
+    energy: num(mEnergyLine),
+    grateful: under(/###[^\n]*morning[^\n]*grate[^\n]*\n+([^\n#][^\n]*)/i),
+    picture: under(/###[^\n]*morning[^\n]*(?:picture|visuali)[^\n]*\n+([^\n#][^\n]*)/i),
+  };
+  // Codex W3 fix 3: alibi counts toward an evening entry — the journal endpoint
+  // can write an alibi-only evening block, and it must read back (not be dropped).
+  const hasEvening = !!(evening.score || evening.winAvoidance || evening.workedDidnt || evening.doDifferently || evening.alibi);
+  const hasMorning = !!(morning.wantVsShould || morning.energy || morning.grateful || morning.picture);
+  return { hasEvening, hasMorning, evening: hasEvening ? evening : null, morning: hasMorning ? morning : null };
+}
+
+function analyzeNoteText(text) {
+  if (!text) return { tasksTotal: 0, tasksDone: 0, tasks: [], length: 0, focus: null, todaysCall: null, journal: EMPTY_JOURNAL, plan: null, got: null };
+  const lines = text.split("\n");
+  let total = 0, done = 0;
+  // W12: keep each checkbox line's text so the dashboard can write the tick
+  // back (POST /api/checkbox/toggle matches on exact trimmed item text). The
+  // counters above stay authoritative for the aggregate surfaces.
+  const tasks = [];
+  for (const line of lines) {
+    const m = line.match(/^\s*[-*]\s*\[([ xX])\]\s*(.*)$/);
+    if (m) {
+      total++;
+      const checked = m[1].toLowerCase() === "x";
+      if (checked) done++;
+      const t = (m[2] || "").trim();
+      if (t) tasks.push({ text: t, checked });
+    }
+  }
+  // v6 SURFACE 1 — today's stated focus, for the Say-it friction rule
+  // (off-plan new-project intent vs the day's plan). First content line under
+  // a "Focus" heading; null when there's no plan to argue against. Forgiving
+  // heading match because Daily templates vary; a guessed plan is never ok.
+  const fm = text.match(/^#{1,6}\s*[^\n]*focus[^\n]*\n+([^\n#][^\n]*)/im);
+  const focus = cleanLine(fm ? fm[1] : null);
+  // v6 — `## Today's Call` (the v6 hero label); falls back to focus when absent
+  // (the real template uses `## Focus`; Today's Call is the v6 demo label).
+  const tc = text.match(/^#{1,6}\s*[^\n]*today'?s call[^\n]*\n+([^\n#][^\n]*)/im);
+  const todaysCall = cleanLine(tc ? tc[1] : null);
+  // v6 SURFACE 2 — the `## Journal` sub-anchors (evening/morning).
+  const journal = parseJournal(text);
+  // v6 SURFACE 7 (Rewind) — per-date plan/got. plan = today's-call|focus;
+  // got = first line of `## Review`, else the first `## Key Insights` bullet;
+  // null when neither exists (Rewind shows an honest gap, never a guess).
+  let got = null;
+  const rev = text.match(/^#{1,6}\s*review[^\n]*\n+([^\n#][^\n]*)/im);
+  if (rev) got = cleanLine(rev[1]);
+  else {
+    const ki = text.match(/^#{1,6}\s*[^\n]*key insight[^\n]*\n+(?:[^\n]*\n)*?\s*[-*]\s+([^\n]+)/im);
+    if (ki) got = cleanLine(ki[1]);
+  }
+  const plan = todaysCall || focus;
+  return { tasksTotal: total, tasksDone: done, tasks, length: text.length, focus, todaysCall, journal, plan, got };
+}
+
+module.exports = { resolveDailyNotes, fmtDate, analyzeNoteText, parseJournal };

package/src/dashboard/lib/date-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+
+function localDateKey(date = new Date()) {
+  const d = date instanceof Date ? date : new Date(date);
+  if (Number.isNaN(d.getTime())) return "";
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function localMidnight(date = new Date()) {
+  const d = date instanceof Date ? new Date(date.getTime()) : new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+// T245 — Mover OS session-day convention. Workflows (/log, /analyse-day,
+// /plan-tomorrow) treat any session before 05:00 as belonging to YESTERDAY
+// — the user is still on "today's" plan until they wake up tomorrow.
+// Parsers that ask "is there a Daily Note for today?" need the same rule
+// or they report ghost gaps at 3 AM (the user wrote the note for May 24,
+// it's now 03:00 on May 25 — `localDateKey()` returns 2026-05-25 and the
+// May 24 note is invisible to the check).
+function sessionDateKey(date = new Date()) {
+  const d = date instanceof Date ? new Date(date.getTime()) : new Date(date);
+  if (Number.isNaN(d.getTime())) return "";
+  // Roll back to yesterday's date when hour < 5.
+  if (d.getHours() < 5) {
+    d.setDate(d.getDate() - 1);
+  }
+  return localDateKey(d);
+}
+
+// Midnight of the SESSION day (see sessionDateKey) as a Date — for parsers
+// that bucket by day and must agree with the T245 convention.
+function sessionMidnight(date = new Date()) {
+  const d = date instanceof Date ? new Date(date.getTime()) : new Date(date);
+  if (d.getHours() < 5) d.setDate(d.getDate() - 1);
+  return localMidnight(d);
+}
+
+module.exports = { localDateKey, localMidnight, sessionDateKey, sessionMidnight };

package/src/dashboard/lib/distribution-parser.js

@@ -0,0 +1,137 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+const { localDateKey, sessionMidnight } = require("./date-utils");
+
+// distribution-parser.js — F30. Heuristic scan of Daily Notes session logs
+// for distribution-action keywords. Buckets by day. Returns 30-day rolling
+// counts so the StatsStrip can show "DIST 7D · +3 vs prev week".
+
+// HONESTY FIX (owner catch, 2026-07-07): bare verbs (shipped/published/posted/
+// replied/commented) counted DEV work as distribution. Session logs are full of
+// "R-A shipped" and "artifact published", which inflated the Home KPI, the day
+// score's ship component, and Evidence's "distribution shipped" verdicts on days
+// with zero real outreach. Every pattern below is CHANNEL-ANCHORED: the verb must
+// sit near a real audience artifact or outreach act. We accept undercounting over
+// inflating. A distribution count is a claim about reaching people, never about
+// writing code.
+const KEYWORDS = [
+  // publishing verbs anchored to an audience artifact or platform
+  /\b(?:posted|published|launched|shipped)\b[^.\n]{0,60}\b(?:reel|tweet|thread|article|video|newsletter|episode|waitlist|x\.com|twitter|instagram|\big\b|tiktok|linkedin|reddit|youtube|hacker ?news|product ?hunt)\b/i,
+  // reverse order: "reel posted", "article went live"
+  /\b(?:reel|tweet|thread|article|video|newsletter|episode)\b[^.\n]{0,40}\b(?:posted|published|launched|shipped|went live)\b/i,
+  // direct outreach: PERFORMED verbs only. Bare nouns (outreach, DMs) match
+  // planning talk ("cold-outreach template", "DM proof") and inflate.
+  /\bDM'?(?:d|ed)\b/i,
+  /\bsent (?:\d+ )?(?:DMs?|emails?|outreach|messages?|cold)\b/i,
+  /\breached out\b/i,
+  // reply seeding: PERFORMED forms only. The bare "reply-seeding" noun matched
+  // every strategy sentence that discussed the channel ("reply-seeding should
+  // be primary", "70% X reply-seeding") and made an all-planning week read as
+  // 8 receipts (terra Evidence walk, 2026-07-12).
+  /\breply[- ]seeded\b/i,
+  /\b(?:sent|posted|did|dropped)\b[^.\n]{0,40}\breply[- ]seeds?\b/i,
+  /\breply[- ]seeds?\b[^.\n]{0,30}\b(?:sent|posted|done)\b/i,
+  // replies count only when aimed at a person/audience surface, not code review
+  /\breplied?\b[^.\n]{0,50}\b(?:lead|prospect|customer|buyer|DM|thread|tweet|comment)\b/i,
+  /\btweeted\b/i,
+];
+
+// A clause that matches a KEYWORD is still NOT a receipt when it is talk
+// ABOUT distribution rather than a report of doing it. Three failure classes
+// from the 2026-07-12 terra Evidence walk, where ALL 8 of the week's counted
+// "receipts" were prose (two literally said "the reel never shipped"):
+//   negation        — "the reel never shipped", "reply seed not posted"
+//   plan/modal      — "reply-seeding should be primary", "will post", "70% X"
+//   meta-discussion — strategy docs, reviews, corpus analysis mentioning reels
+// Undercount over inflate: a rejected real receipt costs a pip; a counted
+// fake receipt makes the product lie on its own honesty surface.
+const NOT_A_RECEIPT = [
+  // bare "zero" over-blocked ("the false-zero bug"); only "zero <artifact>"
+  // is a negation ("sent zero DMs").
+  /\b(?:never|not|didn'?t|hasn'?t|wasn'?t|won'?t|isn'?t|couldn'?t|unshipped|unfilmed|unsent|unposted)\b/i,
+  /\bzero (?:DMs?|reels?|posts?|replies|tweets?|threads?|outreach)\b/i,
+  /\b(?:should|would|will|must|needs? to|plan(?:s|ned|ning)?|intend|gonna|tomorrow|next (?:week|step)|queued|owed|blocked|pending|drafted|commitment|deadline)\b/i,
+  /\b(?:strategy|doc|playbook|corpus|harvest|review|audit|analys\w*|research|parser?|keyword|counted|counter|allocation|weight|copy|evidence|rework|redesign|mandate)\b/i,
+  // "No reel shipped" / "no thread posted" — capital-No negation the \bnot\b
+  // class misses.
+  /\bno (?:reels?|tweets?|threads?|posts?|DMs?|articles?|outreach)\b/i,
+  /%/,
+  // A question is never a receipt ("| Twitter thread published? |" template
+  // checklist rows counted for weeks in March).
+  /\?/,
+];
+function isReceiptClause(frag) {
+  if (!KEYWORDS.some((re) => re.test(frag))) return false;
+  return !NOT_A_RECEIPT.some((re) => re.test(frag));
+}
+
+function compute({ vault, daysLookback = 30 } = {}) {
+  if (!vault) return { available: false, days: [], todayCount: null, total7d: null, total30d: null, delta7d: null };
+  const dDir = dailiesDir(vault);
+  if (!fs.existsSync(dDir)) return { available: false, days: [], todayCount: null, total7d: null, total30d: null, delta7d: null };
+
+  // Session-day anchor (T245): before 05:00 "today" is still yesterday's
+  // session, same convention daily-note-resolver uses — otherwise the 2am
+  // outreach a user is actively logging shows todayCount 0 (R5-A).
+  const today = sessionMidnight();
+  const days = [];
+  for (let i = 0; i < daysLookback; i++) {
+    // setDate (not ms arithmetic): a fixed 24h step skips one calendar day
+    // across a DST spring-forward and shifts the rest of the window (R5-A).
+    const d = new Date(today.getTime());
+    d.setDate(d.getDate() - i);
+    const key = localDateKey(d);
+    const monthDir = key.slice(0, 7);
+    const fpath = path.join(dDir, monthDir, `Daily - ${key}.md`);
+    let count = 0;
+    // The actual matched clauses, so Evidence can show REAL receipt lines
+    // instead of the fabricated "Distribution shipped" template rows terra
+    // confirmed (v4b syntheticReceipts, 2026-07-12).
+    const matches = [];
+    // R3-E1: a day with no note is NO-RECORD, not "zero receipts" — the UI
+    // needs the difference to clamp all-time views to the first real note.
+    let exists = false;
+    try {
+      const text = fs.readFileSync(fpath, "utf8");
+      exists = true;
+      // Only a recognizable session-log section counts. The old full-file
+      // fallback (header renamed → scan EVERYTHING) counted journal prose
+      // about last month's article as today's outreach — the 29-vs-2 scar's
+      // second face. No section = count 0 (undercount over inflate).
+      // H2 OR H3, suffix allowed: /log itself writes "### Session Log
+      // [ATTENDED] — 10:00 [Claude Code]" (Codex R5-C catch).
+      const slm = text.match(/^#{2,3}\s*(?:session\s*log|log)\b/im);
+      const section = slm ? text.slice(slm.index) : "";
+      // Count at most ONE action per clause: "sent DMs and reached out to 5
+      // leads" is one outreach session described two ways, not two — but
+      // comma-separated real actions ("posted a thread, sent 5 DMs") each
+      // count (Codex R5-C: sentence-level was undercounting those).
+      if (section) {
+        for (const frag of section.split(/[.\n,;]+/)) {
+          if (isReceiptClause(frag)) {
+            count += 1;
+            if (matches.length < 6) matches.push(frag.trim().slice(0, 140));
+          }
+        }
+      }
+    } catch (_) { /* missing daily — count stays 0 */ }
+    days.push({ date: key, count, exists, matches });
+  }
+  const total7d = days.slice(0, 7).reduce((s, d) => s + d.count, 0);
+  const total30d = days.reduce((s, d) => s + d.count, 0);
+  const prior7d = days.slice(7, 14).reduce((s, d) => s + d.count, 0);
+  const todayCount = days[0] ? days[0].count : 0;
+  return {
+    available: true,
+    days: days.reverse(),
+    todayCount,
+    total7d,
+    total30d,
+    delta7d: total7d - prior7d
+  };
+}
+
+module.exports = { compute };