mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/goal-forecast.js

@@ -0,0 +1,427 @@
+"use strict";
+
+const { localDateKey } = require("./date-utils");
+
+function computeGoalForecast({ strategy, activeContext, distribution, engineHealth, daily, now = new Date() } = {}) {
+  const sourceText = [
+    activeContext && activeContext.raw,
+    strategy && strategy.singleTest,
+  ].filter(Boolean).join("\n");
+
+  const parsed = parseGoalProgress({
+    singleTest: strategy && strategy.singleTest,
+    sourceText,
+    targetDate: strategy && strategy.targetDate,
+    now,
+  });
+
+  const current = parsed.current;                 // null when progress is unmeasured
+  const target = parsed.target;
+  const hasProgress = current != null;
+  const needed = (target && hasProgress) ? Math.max(0, target - current) : null;
+  const deadline = parsed.deadline;
+  const daysRemaining = deadline ? daysBetween(localDateKey(now), deadline) : null;
+  const daysSafe = daysRemaining == null ? null : Math.max(0, daysRemaining);
+  const requiredPerDay = (needed == null || daysSafe == null)
+    ? null
+    : daysSafe === 0 ? needed : round(needed / daysSafe, 2);
+  // progressPct is null (UNMEASURED), never a false 0, when no scoped progress exists.
+  const progressPct = (target > 0 && hasProgress) ? Math.min(100, Math.round((current / target) * 100)) : null;
+
+  // Status is scoped to the OUTCOME. A real dated target with no scoped progress
+  // reads "unknown" (-> "Not measured" in the UI), never a fabricated on-track. A
+  // scoped zero reads on-track (0 of 2, deadline ahead). [sol #11 cross-scope]
+  let status = "unknown";
+  if (!target) status = "unknown";
+  else if (hasProgress && current >= target) status = "complete";
+  else if (daysRemaining != null && daysRemaining < 0) status = "failed";
+  else if (!hasProgress) status = "unknown";
+  else if (daysRemaining != null && daysRemaining <= 1 && needed > 2) status = "unlikely";
+  else if (requiredPerDay != null && requiredPerDay > 1) status = "at-risk";
+  else status = "on-track";
+
+  // Only act on distribution we actually measured. Unavailable (null) distribution
+  // must NOT trigger a "0 actions logged" experiment. [false-zero — Codex, T261]
+  const total7dKnown = !!(distribution && distribution.available !== false && Number.isFinite(distribution.total7d));
+  const total7d = total7dKnown ? distribution.total7d : 0;
+  const adjustments = [];
+  const workflows = [];
+
+  if (engineHealth && engineHealth.analyseDay && engineHealth.analyseDay.status === "RED") {
+    pushAction(adjustments, workflows, {
+      workflow: "/analyse-day",
+      title: "Run a day review before more strategy edits",
+      detail: `You haven't reviewed a day in ${engineHealth.analyseDay.overdueDays} days. Run /analyse-day to get the dashboard current.`,
+      priority: "critical",
+    });
+  }
+  // Only treat strategy health as "trouble" when the scan actually ran and
+  // returned a concrete RED/YELLOW. A null status from an unavailable scan must
+  // NOT trigger /pivot-strategy. [false-zero regression fix — Codex P1, T261]
+  const strategyTrouble = engineHealth && engineHealth.available !== false
+    && engineHealth.strategy && (engineHealth.strategy.status === "RED" || engineHealth.strategy.status === "YELLOW");
+  if (status === "failed" || status === "unlikely" || strategyTrouble) {
+    pushAction(adjustments, workflows, {
+      workflow: "/pivot-strategy",
+      title: status === "failed" ? "Close the failed Single Test" : "Recalibrate the current strategy",
+      detail: `${current ?? "—"}/${target} against the active target. Keep the test, kill it, or replace it with a dated operating gate.`,
+      priority: status === "failed" ? "critical" : "high",
+    });
+  }
+  if (needed > 0 && total7dKnown && total7d < 10) {
+    pushAction(adjustments, workflows, {
+      workflow: "/experiment",
+      title: "Open a distribution experiment",
+      detail: `Only ${total7d} distribution actions logged in 7 days. Test one channel loop with a falsifiable metric instead of adding more dashboard surface.`,
+      priority: "high",
+    });
+  }
+  if (daily && daily.today && !daily.today.exists) {
+    pushAction(adjustments, workflows, {
+      workflow: "/plan-tomorrow",
+      title: "Set today's execution list",
+      detail: "No Daily Note found for today, so the dashboard is missing the live plan it should enforce.",
+      priority: "medium",
+    });
+  }
+
+  // available:false when no real target parsed → null out the numerals so the UI
+  // shows its honest "no measurable test" / "calibrating" state, never a
+  // fabricated "0/10". [false-zero discipline, T261]
+  const available = !!target;
+  return {
+    available,
+    singleTest: parsed.singleTest || null,
+    // current stays null when the target is parseable but progress is unmeasured
+    // (a clean bet with no scoped record) — the UI shows "Progress not measured".
+    current: available ? current : null,
+    target: available ? target : null,
+    unit: parsed.unit,
+    // kind rides with the parsed counter when one exists (the verdict must
+    // cite what the numbers actually count); keyword classification only
+    // labels the no-counter cases (revenue/vitality wording, available:false).
+    kind: parsed.counterKind || classifyGoalKind(strategy && strategy.singleTest),
+    // shape: "clean" (one metric + date), "compound" (a multi-signal gate), or
+    // "unparseable" (no target the dashboard can score). The hero renders each
+    // differently; a compound/legacy bet gets a "rewrite for clarity" affordance.
+    gate: parsed.gate === true,
+    shape: parsed.shape || (parsed.gate ? "compound" : (available ? "clean" : "unparseable")),
+    // whether `current` came from a real test-scoped record vs is just unmeasured.
+    progressMeasured: parsed.progressMeasured === true,
+    // the input commitment (daily quota) + the channel it names, both SEPARATE
+    // from the bet — Today renders these, never the hero.
+    commitment: (strategy && strategy.commitment) || null,
+    channel: parseChannel(strategy && strategy.commitment),
+    deadline,
+    daysRemaining,
+    // Derived pace numerals are honest-null when there is no measurable target
+    // (a gate/unparseable test) OR when the target is real but progress is
+    // unmeasured. Secondary readers that copy them raw must not report a false 0%.
+    needed: available ? needed : null,
+    requiredPerDay: available ? requiredPerDay : null,
+    progressPct: available ? progressPct : null,
+    status,
+    source: parsed.source,
+    distribution7d: total7dKnown ? total7d : null,
+    adjustments,
+    workflows,
+  };
+}
+
+function pushAction(adjustments, workflows, action) {
+  adjustments.push(action);
+  if (action.workflow && !workflows.includes(action.workflow)) workflows.push(action.workflow);
+}
+
+// The channel named in the Commitment ("...via X replies and DMs; ...") — the
+// hero's support line uses it ("From X replies and DMs, by Jul 26"). Null-safe.
+function parseChannel(commitment) {
+  if (!commitment) return null;
+  const m = String(commitment).match(/\b(?:via|through|on|using)\s+([^;.,]+?)(?=\s*[;.,]|$)/i);
+  return m ? m[1].trim() : null;
+}
+
+// A scoped progress record's unit must be the SAME kind of thing as the target.
+// The HEAD noun (last word) must match, so "0/2 paying customers" counts toward a
+// "customers" target, but "2/2 customer support calls" (head = calls) and
+// "1/2 customer interviews" (head = interviews) do NOT — a shared adjective is not
+// a unit match, or a same-denominator side metric fabricates "Complete". [sol #12]
+function unitFamilyMatch(scopedUnit, targetUnit) {
+  const norm = (s) => String(s || "").toLowerCase().replace(/[^a-z ]+/g, " ").trim().replace(/s\b/g, "");
+  const t = norm(targetUnit).split(/\s+/).filter(Boolean);
+  const s = norm(scopedUnit).split(/\s+/).filter(Boolean);
+  if (!t.length || !s.length) return false;
+  return t[t.length - 1] === s[s.length - 1];  // head nouns must be identical
+}
+
+// What currency is the goal stated in, and does anything on file measure it?
+// Drives the goal-anchored verdict on Evidence: an installs goal is pushed by
+// distribution receipts; a distribution goal IS the receipts; a revenue or
+// vitality goal has no parser yet, so the card must say "unmeasured" instead
+// of pretending workflow counts answer it. Order matters: adoption phrasing
+// ("15 activated installs") usually also names the channel, so adoption wins
+// when both appear. Returns null when nothing matches (generic verdict).
+function classifyGoalKind(singleTest) {
+  const t = String(singleTest || "").toLowerCase();
+  if (!t) return null;
+  if (/\b(installs?|activat|referrals?|sign-?ups?|customers?|users?|sales?|purchases?|buyers?|strangers?)/.test(t)) return "adoption";
+  if (/\b(dms?|outreach|repl(y|ies)|posts?|publish\w*|distribut\w*|articles?|reels?|videos?|content|newsletters?|followers?|subscribers?|views?|audience|impressions?)\b/.test(t)) return "distribution";
+  if (/(revenue|mrr\b|income|profit|£|\$|€)/.test(t)) return "revenue";
+  if (/\b(sleep|gym|weight|prayers?|fajr|salah|steps|health|energy|fasting)\b/.test(t)) return "vitality";
+  return null;
+}
+
+function parseGoalProgress({ singleTest, sourceText, targetDate, now }) {
+  const out = {
+    singleTest: singleTest || null,
+    current: null,          // measured ONLY from a test-scoped record; null = unmeasured
+    target: 0,
+    unit: "customers",
+    counterKind: null,
+    shape: "unparseable",
+    progressMeasured: false,
+    deadline: null,
+    source: "strategy",
+  };
+
+  if (singleTest) {
+    // A multi-signal GATE ("Hit 2 of 3": 10 conversations / 5 install starts /
+    // 2 paid) is not one countable number. The single-counter regex below would
+    // grab "5 install starts" as target=5 and pair it with an unrelated sales
+    // count elsewhere on file, fabricating "4 of 5 installs". Detect the gate,
+    // refuse to collapse it, keep the deadline so the card can still pace to the
+    // date, and let the UI render the honest "scored by hand" state.
+    //
+    // The marker must be a gate VERDICT, not a bare "N of M": require a scoring
+    // verb (hit/pass/meet/clear, "of" or "out of") OR an "N of M =" verdict
+    // clause. A bare "N of M" would false-trigger on "Day 2 of 14: send 50 DMs"
+    // (a real distribution counter) and hide it; the verb/"=" gate keeps those
+    // parsing normally. A "+" rider ("15 installs + 1 referral") has no "of" at
+    // all and still parses its primary counter. [gate honesty, sol #10 hardening]
+    if (/\b(?:hit|hitting|pass(?:ed)?|meet|met|clear(?:ed)?)\s+\d+\s+(?:out\s+of|of)\s+\d+\b|\b\d+\s+(?:out\s+of|of)\s+\d+\s*=/i.test(singleTest)) {
+      out.gate = true;
+      out.counterKind = "gate";
+      out.shape = "compound";
+      out.deadline = extractDate(singleTest, now) || targetDate || null;
+      return out; // target stays 0 -> available:false -> honest-null, no fabricated counter
+    }
+    // Regex captures count-based phrasing (e.g. "10 paying customers/sales")
+    // AND activation phrasing ("N activated installs / referrals"). The
+    // extended unit list keeps backwards-compat and makes an activation-style
+    // mid-term metric ("N activated installs + M referrals by <date>") parse correctly.
+    // The negative lookahead stops an adoption noun acting as a MODIFIER of a
+    // distribution noun from being read as the counter: "10 sales posts" is a
+    // publishing target, never a sales counter. [terra F3, 2026-07-10]
+    const DIST_NOUN = "posts?|dms?|reels?|articles?|videos?|emails?|threads?|newsletters?";
+    const targetMatch = singleTest.match(new RegExp("\\b(\\d+)\\s+(?:paying\\s+|activated\\s+)?(?:strangers?|customers?|sales|users?|installs?|referrals?|activations?)\\b(?!\\s+(?:" + DIST_NOUN + ")\\b)", "i"));
+    if (targetMatch) {
+      out.target = Number(targetMatch[1]);
+      // Set unit from the matched phrase so the hero strip says
+      // "activated installs" instead of the default "customers" on V4.
+      const phrase = targetMatch[0].toLowerCase();
+      if (/install/.test(phrase)) out.unit = "activated installs";
+      else if (/referral/.test(phrase)) out.unit = "referrals";
+      else if (/user/.test(phrase)) out.unit = "users";
+      else out.unit = "customers";
+      out.counterKind = "adoption";
+      out.shape = "clean";
+    } else {
+      // Distribution counter ("publish 10 posts", "send 50 DMs", "10 sales
+      // posts"): the kind rides with the SAME match that set the number, so
+      // the verdict can never cite a counter the parse didn't produce.
+      const distMatch = singleTest.match(new RegExp("\\b(\\d+)\\s+(?:[a-z-]+\\s+)?(" + DIST_NOUN + ")\\b", "i"));
+      if (distMatch) {
+        out.target = Number(distMatch[1]);
+        out.unit = distMatch[2].toLowerCase();
+        out.counterKind = "distribution";
+        out.shape = "clean";
+      }
+    }
+    const deadline = extractDate(singleTest, now) || targetDate;
+    if (deadline) out.deadline = deadline;
+  }
+
+  const text = sourceText || "";
+
+  // Progress is TEST-SCOPED, and ONLY test-scoped. A generic lifetime line
+  // ("LIVE, 4 SALES" — all from April) or a historical ratio ("4/10 sales" from
+  // a dead strategy) must NOT count as progress toward THIS bet; doing so
+  // fabricated "4 of 2 · complete" the moment the target became a clean 2. The
+  // ONLY thing that counts as current is an explicit scoped record whose
+  // denominator and unit family match the active target:
+  //   "Current bet progress: 0/2 paying customers". [sol #11 cross-scope bug]
+  if (out.target) {
+    const scoped = text.match(/current\s+bet\s+progress:\s*(\d+)\s*\/\s*(\d+)\s*([a-z][a-z ]*)?/i);
+    if (scoped) {
+      const cur = Number(scoped[1]);
+      const den = Number(scoped[2]);
+      const scopedUnit = (scoped[3] || "").trim();
+      const unitOk = !scopedUnit || unitFamilyMatch(scopedUnit, out.unit);
+      if (Number.isFinite(cur) && den === out.target && unitOk) {
+        out.current = cur;               // a scoped ZERO is honest progress, not "unmeasured"
+        out.progressMeasured = true;
+        out.source = "scoped_progress";
+      }
+    }
+  }
+
+  // No fabricated target: if the Single Test carries no parseable number,
+  // target stays 0 → computeGoalForecast reports available:false (honest "no
+  // measurable test") instead of a made-up "0/10". [false-zero discipline, T261]
+  if (!out.deadline) out.deadline = targetDate || extractDate(text, now);
+  return out;
+}
+
+function extractDate(text, now) {
+  if (!text) return null;
+  const iso = text.match(/\b(20\d{2})-([01]\d)-([0-3]\d)\b/);
+  if (iso) {
+    // Impossible dates (2026-02-30) must yield NO deadline, not a silent
+    // JS rollover to March 2 rendered as a real target. [terra F4, 2026-07-10]
+    return validCalendarDay(Number(iso[1]), Number(iso[2]) - 1, Number(iso[3])) ? iso[0] : null;
+  }
+  const months = ["jan","feb","mar","apr","may","jun","jul","aug","sep","sept","oct","nov","dec","january","february","march","april","june","july","august","september","october","november","december"];
+  const m = text.match(new RegExp(`\\b(?:by\\s+)?(${months.join("|")})\\s+(\\d{1,2})(?:,?\\s*(20\\d{2}))?`, "i"));
+  if (!m) return null;
+  const month = monthIndex(m[1]);
+  const day = Number(m[2]);
+  const year = m[3] ? Number(m[3]) : now.getFullYear();
+  if (month < 0 || !Number.isFinite(day)) return null;
+  if (!validCalendarDay(year, month, day)) return null; // "Feb 30" rolls over too
+  return localDateKey(new Date(year, month, day));
+}
+
+// True only when (year, month0, day) names a day that exists: round-trip
+// through UTC and require every component to survive unchanged.
+function validCalendarDay(year, month0, day) {
+  const d = new Date(Date.UTC(year, month0, day));
+  return d.getUTCFullYear() === year && d.getUTCMonth() === month0 && d.getUTCDate() === day;
+}
+
+function monthIndex(name) {
+  const n = String(name || "").toLowerCase().slice(0, 3);
+  return { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 }[n] ?? -1;
+}
+
+// T242 bug hunt fix (B#16): previously `new Date(`${iso}T00:00:00`)` parsed
+// as LOCAL time. Across DST transitions (Mar/Nov in US, Mar/Oct in EU)
+// two consecutive days are 23 or 25 hours apart, so the ceil-divide by a
+// fixed 86400000ms returned 0 or 2 for what should be 1. Goal countdown
+// chips flickered around DST. Use UTC midnight + calendar-day math.
+function daysBetween(fromIso, toIso) {
+  const fromUtc = Date.parse(`${fromIso}T00:00:00Z`);
+  const toUtc = Date.parse(`${toIso}T00:00:00Z`);
+  if (!Number.isFinite(fromUtc) || !Number.isFinite(toUtc)) return null;
+  return Math.round((toUtc - fromUtc) / (24 * 3600 * 1000));
+}
+
+function round(n, d) {
+  const p = Math.pow(10, d);
+  return Math.round(n * p) / p;
+}
+
+// ── Per-domain measurement dispatcher ─────────────────────────────────────────
+// Each domain declares a measurement SHAPE in Strategy.md (single | chain | scalar
+// | streak). This routes the declaration + whatever live source exists into a
+// render-ready progress object, honest-null wherever a domain has not logged data
+// yet. The dashboard renders the shape; the fuel arrives once the user logs it.
+function parseDomainProgress({ domain, decl, goalForecast, streak, metricsLog } = {}) {
+  if (!decl || !decl.type) return { available: false, type: null };
+  const type = decl.type;
+
+  if (type === "single") {
+    // Work's single test is already computed by computeGoalForecast. Other domains
+    // declaring single have no per-domain count source yet -> honest-null.
+    if (domain === "work" && goalForecast && goalForecast.available) {
+      return {
+        available: true, type: "single",
+        current: goalForecast.current, target: goalForecast.target,
+        unit: goalForecast.unit || null, progressPct: goalForecast.progressPct ?? null,
+        status: goalForecast.status || null,
+      };
+    }
+    return { available: false, type: "single", current: null, target: numFrom(decl.target), unit: null };
+  }
+
+  if (type === "scalar") {
+    const baseline = numFrom(decl.baseline);
+    const target = numFrom(decl.target);
+    const current = scalarCurrent(decl, metricsLog); // best-effort; null until logged
+    const progressPct =
+      baseline != null && target != null && current != null && target !== baseline
+        ? clampPct(Math.round(((current - baseline) / (target - baseline)) * 100))
+        : null;
+    return {
+      available: current != null, type: "scalar",
+      baseline, target, current,
+      baselineText: decl.baseline || null, targetText: decl.target || null,
+      progressPct,
+    };
+  }
+
+  if (type === "streak") {
+    // streak-parser tracks day-PRESENCE (a daily note exists), NOT whether the
+    // declared practice was actually done. Presenting that as the practice streak
+    // would be a false signal, so the count stays honest-null until a per-practice
+    // source exists; the ring renders its ready/empty state.
+    return {
+      available: false, type: "streak",
+      currentStreak: null, longestStreak: null, todayDone: null,
+      note: "activates once the practice is logged",
+    };
+  }
+
+  if (type === "chain") {
+    const stages = parseChainStages(decl.chain); // [] when no chain math declared
+    return {
+      available: false, type: "chain",
+      stages, bottleneck: null,
+      note: stages.length ? "awaiting per-stage numbers" : "declare the chain (revenue -> ... -> daily action)",
+    };
+  }
+
+  return { available: false, type };
+}
+
+// Pull a leading number out of a prose value ("7.5h sleep" -> 7.5, "78 kg" -> 78).
+function numFrom(text) {
+  if (text == null) return null;
+  const m = String(text).match(/-?\d+(?:\.\d+)?/);
+  return m ? Number(m[0]) : null;
+}
+
+function clampPct(n) {
+  if (!Number.isFinite(n)) return null;
+  return Math.max(0, Math.min(100, n));
+}
+
+// Best-effort current value for a scalar domain from the metrics log's latest
+// readings, matched by keyword. Null (honest) when nothing matches.
+function scalarCurrent(decl, metricsLog) {
+  if (!metricsLog || metricsLog.available === false) return null;
+  const hay = ((decl.target || "") + " " + (decl.baseline || "")).toLowerCase();
+  const pick = /sleep/.test(hay) ? metricsLog.sleepLatest
+    : /weight|kg|\blb/.test(hay) ? metricsLog.weightLatest
+    : /hrv/.test(hay) ? metricsLog.hrvLatest
+    : /rhr|resting|heart/.test(hay) ? metricsLog.rhrLatest
+    : null;
+  return numFrom(pick);
+}
+
+// Split a declared chain ("$10k = 100 sales = 1k calls at 10% = 50 DMs/day") into
+// ordered stages. Each stage is a label only; the live per-stage numbers arrive
+// from the logged funnel, so `current` is honest-null here.
+function parseChainStages(chain) {
+  if (!chain) return [];
+  return String(chain)
+    .split(/\s*(?:=|->|→|>)\s*/)
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .slice(0, 6)
+    .map((label) => ({ label, current: null }));
+}
+
+// parseGoalProgress exported for the menu-bar CLI (cmdPulseBar): the bar's
+// mission number must come from the SAME parse the dashboard shows, never a
+// second implementation that can drift. [owner: glance-number = the bet]
+module.exports = { computeGoalForecast, parseGoalProgress, parseDomainProgress, classifyGoalKind };

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

@@ -0,0 +1,67 @@
+"use strict";
+
+const { goalsPath, safeRead, safeStat } = require("./paths");
+
+// Parse Goals.md. Extracts 3-month, 1-year, 10-year goals + expiration dates.
+
+function parseGoals(vault) {
+  const filePath = goalsPath(vault);
+  const text = safeRead(filePath);
+  const stat = safeStat(filePath);
+  if (!text) return { available: false, filePath };
+
+  const out = {
+    available: true,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    raw: text,
+    horizons: []
+  };
+
+  // Split on ## headers
+  const lines = text.split("\n");
+  let current = null;
+  let buf = [];
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.+?)\s*$/);
+    if (h) {
+      if (current) {
+        out.horizons.push({ title: current, body: buf.join("\n"), ...analyzeHorizon(buf.join("\n")) });
+      }
+      current = h[1];
+      buf = [];
+    } else if (current) {
+      buf.push(line);
+    }
+  }
+  if (current) {
+    out.horizons.push({ title: current, body: buf.join("\n"), ...analyzeHorizon(buf.join("\n")) });
+  }
+
+  // Identify 3-month, 1-year, 10-year via title heuristic
+  const now = Date.now();
+  out.expired = [];
+  for (const h of out.horizons) {
+    if (h.targetDate) {
+      const dt = new Date(h.targetDate);
+      if (!isNaN(dt.getTime()) && dt.getTime() < now) {
+        out.expired.push({ title: h.title, targetDate: h.targetDate, expiredDays: Math.floor((now - dt.getTime()) / 86400000) });
+      }
+    }
+  }
+
+  return out;
+}
+
+function analyzeHorizon(body) {
+  const dateMatch = body.match(/\*\*(?:Target Date|Date|By):?\*\*\s*([\d\-/]{8,10})/i);
+  const goalsList = body.split("\n")
+    .map(l => l.match(/^\s*[-*\d.]+\s+(.+)$/))
+    .filter(Boolean).map(m => m[1].trim());
+  return {
+    targetDate: dateMatch ? dateMatch[1] : null,
+    goals: goalsList.slice(0, 12)
+  };
+}
+
+module.exports = { parseGoals };

package/src/dashboard/lib/health-protocols-parser.js

@@ -0,0 +1,133 @@
+"use strict";
+
+const path = require("path");
+const fs = require("fs");
+const { safeListDir, safeRead, safeStat } = require("./paths");
+
+// Parse 02_Areas/Health/*.md as actionable recovery/maintenance protocols.
+// A "protocol" file looks like:
+//   # <Title>
+//   ## PHASE 1 — <name> (Days 1-7: <date range>)
+//   ### Every day (10 min total)
+//   - [ ] action one
+//   - [ ] action two
+//   ## PHASE 2 — ...
+//
+// Output for the dashboard:
+//   - title
+//   - currentPhase (detected by date range vs today, or first uncompleted)
+//   - today's checklist (unchecked items in current phase)
+//   - completedToday (checked items in current phase — for progress)
+//   - daysIntoPhase / daysRemaining (if dates present)
+//
+// Forgiving: never throws. Empty/missing → { available: false }.
+
+function healthDir(vault) {
+  return path.join(vault, "02_Areas", "Health");
+}
+
+function parseDateRange(line) {
+  // Match "(May 12-19)" or "(Days 1-7: May 12-19)" or "(May 20 → Jun 30)"
+  // Returns { startISO, endISO } or null
+  const m = line.match(/\((?:[^:)]*?:)?\s*([A-Z][a-z]{2})\s+(\d{1,2})(?:\s*[-–→]\s*(?:([A-Z][a-z]{2})\s+)?(\d{1,2}))?\)/);
+  if (!m) return null;
+  const monthMap = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
+  const year = new Date().getFullYear();
+  const sm = monthMap[m[1]];
+  const sd = parseInt(m[2], 10);
+  const em = m[3] ? monthMap[m[3]] : sm;
+  const ed = m[4] ? parseInt(m[4], 10) : sd;
+  if (sm === undefined || em === undefined) return null;
+  return {
+    start: new Date(year, sm, sd),
+    end: new Date(year, em, ed)
+  };
+}
+
+function parseProtocolFile(filePath) {
+  const text = safeRead(filePath);
+  if (!text) return null;
+  const stat = safeStat(filePath);
+
+  // Title from first H1, fallback to filename
+  const titleMatch = text.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : path.basename(filePath, ".md");
+
+  // Find all PHASE blocks. Phases are H2 headings that contain "PHASE" or similar.
+  const lines = text.split("\n");
+  const phases = [];
+  let currentPhase = null;
+
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    const phaseMatch = line.match(/^##\s+(.*PHASE.*)$/i);
+    if (phaseMatch) {
+      if (currentPhase) phases.push(currentPhase);
+      currentPhase = {
+        heading: phaseMatch[1].trim(),
+        dates: parseDateRange(phaseMatch[1]),
+        items: [],
+        done: 0,
+        total: 0
+      };
+      continue;
+    }
+    if (!currentPhase) continue;
+    // Skip subheadings — items only
+    if (line.startsWith("##")) continue;
+    // Checkbox lines
+    const cb = line.match(/^[-*]\s+\[([ xX])\]\s+(.+)$/);
+    if (cb) {
+      const checked = cb[1].toLowerCase() === "x";
+      currentPhase.items.push({ text: cb[2].trim(), checked });
+      currentPhase.total++;
+      if (checked) currentPhase.done++;
+    }
+  }
+  if (currentPhase) phases.push(currentPhase);
+
+  // Determine the current phase: one whose date range contains today,
+  // OR the first phase with any unchecked items if no date hits.
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  let current = phases.find(p => p.dates && p.dates.start <= today && today <= p.dates.end);
+  if (!current) current = phases.find(p => p.done < p.total);
+  if (!current && phases.length) current = phases[phases.length - 1];
+
+  // Days remaining in current phase
+  let daysRemaining = null;
+  let daysIntoPhase = null;
+  if (current && current.dates) {
+    daysRemaining = Math.max(0, Math.ceil((current.dates.end - today) / (1000 * 60 * 60 * 24)));
+    daysIntoPhase = Math.max(0, Math.ceil((today - current.dates.start) / (1000 * 60 * 60 * 24)));
+  }
+
+  return {
+    available: true,
+    title,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    phases,
+    current,
+    daysRemaining,
+    daysIntoPhase
+  };
+}
+
+function parseHealthProtocols(vault) {
+  const dir = healthDir(vault);
+  const entries = safeListDir(dir, { filesOnly: true, extension: ".md", skipUnderscore: true });
+  const protocols = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    const p = parseProtocolFile(full);
+    if (p && p.available) protocols.push(p);
+  }
+  return {
+    available: protocols.length > 0,
+    dir,
+    protocols
+  };
+}
+
+module.exports = { parseHealthProtocols };

package/src/dashboard/lib/hook-activity.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+const { exists, safeListDir, safeStat } = require("./paths");
+
+// Read recent hook activity from ~/.claude/tmp/mover_* markers + session-history if available.
+
+function readHookActivity() {
+  const home = os.homedir();
+  const claudeTmp = path.join(home, ".claude", "tmp");
+  const codexTmp = path.join(home, ".codex", "tmp");
+  const geminiTmp = path.join(home, ".gemini", "tmp");
+
+  const out = { available: true, recentMarkers: [], hookStats: { sessionStart: 0, log: 0, engineHealth: 0, planSync: 0 }, lastFire: null };
+
+  for (const dir of [claudeTmp, codexTmp, geminiTmp]) {
+    if (!exists(dir)) continue;
+    const entries = safeListDir(dir, { filesOnly: true });
+    for (const e of entries) {
+      if (!e.name.startsWith("mover_")) continue;
+      const stat = safeStat(e.path);
+      if (!stat) continue;
+      const ageDays = (Date.now() - stat.mtime.getTime()) / 86400000;
+      if (ageDays > 7) continue;
+      out.recentMarkers.push({
+        name: e.name,
+        agent: dir.includes(".claude") ? "Claude" : dir.includes(".codex") ? "Codex" : "Gemini",
+        mtime: stat.mtime,
+        ageDays: Math.floor(ageDays * 24 * 60) / (24 * 60),
+        ageHours: Math.floor(ageDays * 24 * 10) / 10
+      });
+      // Categorize
+      if (e.name.includes("logprompt") || e.name.includes("logdone")) out.hookStats.log++;
+      else if (e.name.includes("session-start") || e.name.includes("sessionstart")) out.hookStats.sessionStart++;
+      else if (e.name.includes("engine") || e.name.includes("health")) out.hookStats.engineHealth++;
+      else if (e.name.includes("plan-sync")) out.hookStats.planSync++;
+      if (!out.lastFire || stat.mtime > out.lastFire) out.lastFire = stat.mtime;
+    }
+  }
+  out.recentMarkers.sort((a, b) => b.mtime - a.mtime);
+  out.recentMarkers = out.recentMarkers.slice(0, 10);
+
+  return out;
+}
+
+module.exports = { readHookActivity };