mover-os 4.7.7 → 4.7.8

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,211 @@
+"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);
+  out.totalThisMonth = safeListDir(monthDir, { extension: ".md" }).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" }).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; };
+  const num = (line) => { if (!line) return null; const m = line.match(/\b(?:10|[1-9])\b/); return m ? Number(m[0]) : 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,35 @@
+"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);
+}
+
+module.exports = { localDateKey, localMidnight, sessionDateKey };

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

@@ -0,0 +1,78 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+const { localDateKey, localMidnight } = 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,
+  /\breply[- ]seed(?:ing|ed)?\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,
+];
+
+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 };
+
+  const today = localMidnight();
+  const days = [];
+  for (let i = 0; i < daysLookback; i++) {
+    const d = new Date(today.getTime() - i * 24 * 3600 * 1000);
+    const key = localDateKey(d);
+    const monthDir = key.slice(0, 7);
+    const fpath = path.join(dDir, monthDir, `Daily - ${key}.md`);
+    let count = 0;
+    // 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;
+      const slIdx = text.indexOf("## Session Log");
+      const section = slIdx >= 0 ? text.slice(slIdx) : text;
+      for (const re of KEYWORDS) {
+        const matches = section.match(new RegExp(re.source, "g" + (re.flags.includes("i") ? "i" : "")));
+        if (matches) count += matches.length;
+      }
+    } catch (_) { /* missing daily — count stays 0 */ }
+    days.push({ date: key, count, exists });
+  }
+  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 };

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

@@ -0,0 +1,64 @@
+"use strict";
+
+const { moverDossierPath, safeRead, safeStat } = require("./paths");
+
+// Parse Mover_Dossier.md — asset inventory (skills, capital, audience, network).
+
+function parseDossier(vault) {
+  const filePath = moverDossierPath(vault);
+  const text = safeRead(filePath);
+  const stat = safeStat(filePath);
+  if (!text) return { available: false };
+
+  const out = {
+    available: true,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    fields: {},
+    sections: {}
+  };
+
+  // Bold-key fields
+  const re = /\*\*([^*]+):\*\*\s*([^\n]+)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const k = m[1].trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_|_$/g, "");
+    out.fields[k] = m[2].trim();
+  }
+
+  // Section split
+  const lines = text.split("\n");
+  let cur = null, buf = [];
+  for (const line of lines) {
+    const h = line.match(/^##+\s+(.+?)\s*$/);
+    if (h) {
+      if (cur) out.sections[cur.toLowerCase()] = buf.join("\n");
+      cur = h[1];
+      buf = [];
+    } else if (cur) buf.push(line);
+  }
+  if (cur) out.sections[cur.toLowerCase()] = buf.join("\n");
+
+  // Common keys
+  out.skills = extractList(out.sections, "skills");
+  out.capital = extractList(out.sections, "capital");
+  out.audience = extractList(out.sections, "audience");
+  out.network = extractList(out.sections, "network");
+  out.assets = extractList(out.sections, "assets") || extractList(out.sections, "asset inventory");
+
+  return out;
+}
+
+function extractList(sections, needle) {
+  for (const [title, body] of Object.entries(sections)) {
+    if (title.includes(needle)) {
+      return body.split("\n")
+        .map(l => l.match(/^\s*[-*\d.]+\s+(.+)$/))
+        .filter(Boolean).map(m => m[1].trim())
+        .slice(0, 8);
+    }
+  }
+  return null;
+}
+
+module.exports = { parseDossier };