mover-os 4.7.6 → 4.7.8

package/src/dashboard/lib/rewind-snapshots.js

@@ -0,0 +1,689 @@
+"use strict";
+
+// rewind-snapshots.js — re-render the record (bet / strategy / 4-numbers /
+// that-day) as of ANY past date, from DATED FACTS ONLY.
+//
+// "Rewind" answers: "What did my record look like on 2026-05-19?" by
+// collecting every dated fact the Engine actually recorded and emitting one
+// keyframe per date. The UI scrubs a slider; for any chosen date it shows the
+// LAST keyframe at-or-before that date (the state of the world as of then).
+//
+// WHY pure + dated-only: this is a HISTORY view. Interpolating a streak or a
+// post-count for a date that has no measurement would invent a past that never
+// happened — the exact lie T261 (false-zero honesty) hunted down. So:
+//   - nums / calib are null unless a dated row sits AT/NEAR that keyframe.
+//   - We NEVER call drift-history build() or any WRITE path — those mutate
+//     TODAY's record (recordSnapshot writes ~/.mover/drift-history.json). A
+//     history reader that writes is a corruption vector. buildRewind only READS.
+//   - Pre-moverDay1 facts → gapBefore (labelled), never silently dropped.
+//   - Anything unreadable → available:false with a reason. Label every absence.
+//
+// SOURCES (dated facts ONLY):
+//   1. git log of Engine files (commit author-dates) — WHEN AVAILABLE. Many
+//      live vaults keep 02_Areas/Engine/ git-ignored (it's protected user
+//      data); then this source contributes nothing and we say so via
+//      meta.gitAvailable=false. We scope git to the Engine dir and shell out
+//      read-only; any failure is swallowed.
+//   2. Strategy.md `## LAB REPORT` / CHANGELOG datestamps — bet+strategy keyframes.
+//   3. Graveyard kill-dates (Active_Context "THE GRAVEYARD" + Strategy "ARCHIVED
+//      HYPOTHESES") — "Killed 2026-05-19" / "Killed Feb 18".
+//   4. override_history[] from the pattern-manifest (NOT Override_Log.md — that
+//      file is never written; v6-PLAN-AMENDMENTS.md fix 7 makes the manifest
+//      override_history the single source).
+//   5. Metrics_Log.md dated rows.
+//   6. Daily Notes — per-date plan (Focus) / got (tasks done) — `dailies` map.
+
+const { execFileSync } = require("child_process");
+const path = require("path");
+
+const {
+  strategyPath,
+  activeContextPath,
+  metricsLogPath,
+  engineDir,
+  dailiesDir,
+  safeRead,
+  safeReadJson,
+  safeStat,
+  safeListDir,
+  moverPatternManifestPath,
+} = require("./paths");
+const { localDateKey } = require("./date-utils");
+
+// Mover OS "day 1" — the operational floor for the record. Facts before this
+// are real but pre-history; they go in gapBefore, not the scrub timeline.
+const MOVER_DAY1 = "2026-04-30";
+
+// Source rank for the deterministic tiebreak when two keyframes share a date.
+// Lower = earlier in the stable sort. strategy/bet outranks graveyard outranks
+// override outranks metrics outranks git outranks daily, so a date's "headline"
+// fact lands first. Anything unknown sorts last.
+const SOURCE_RANK = {
+  strategy: 0,
+  bet: 0,
+  graveyard: 1,
+  override: 2,
+  metrics: 3,
+  git: 4,
+  daily: 5,
+};
+
+function buildRewind({ vault } = {}) {
+  // Total-failure contract: no vault → unavailable, fully labelled, no throw.
+  if (!vault || typeof vault !== "string") {
+    return unavailable("no vault path provided");
+  }
+
+  const meta = {
+    gitAvailable: false,
+    gitError: null,
+    sourcesRead: {},
+    sourcesMissing: [],
+  };
+
+  let keyframes = [];
+
+  // Each collector is independently wrapped: one unreadable source must not
+  // sink the whole rewind. We only flip available:false when EVERYTHING is
+  // unreadable (checked at the end).
+  collect(meta, "strategy", () => collectStrategy(vault), keyframes);
+  collect(meta, "graveyard", () => collectGraveyard(vault), keyframes);
+  collect(meta, "override", () => collectOverrides(), keyframes);
+  collect(meta, "metrics", () => collectMetrics(vault), keyframes);
+  collect(meta, "git", () => collectGit(vault, meta), keyframes);
+
+  // Daily Notes: per-date plan/got. Returns BOTH a keyframe list (the dated
+  // existence of a note) and the `dailies` lookup map the UI reads for that-day
+  // detail. Wrapped the same way; never throws.
+  let dailies = {};
+  collect(meta, "daily", () => {
+    const r = collectDailies(vault);
+    dailies = r.dailies;
+    return r.keyframes;
+  }, keyframes);
+
+  // Partition pre-moverDay1 facts into gapBefore (labelled), keep the rest.
+  const onTimeline = [];
+  let gapBeforeCount = 0;
+  for (const kf of keyframes) {
+    if (!kf || !kf.date) continue;
+    if (kf.date < MOVER_DAY1) { gapBeforeCount++; continue; }
+    onTimeline.push(kf);
+  }
+
+  // Deterministic ordering: date ASC, then SOURCE_RANK, then a fully stable
+  // tiebreak on a per-keyframe signature so equal (date,source) pairs never
+  // reorder run-to-run. Array.prototype.sort is not guaranteed stable across
+  // engines for large arrays, so we encode the original index into the
+  // comparator — true determinism regardless of engine.
+  const indexed = onTimeline.map((kf, i) => ({ kf, i, sig: keyframeSig(kf) }));
+  indexed.sort((a, b) => {
+    if (a.kf.date !== b.kf.date) return a.kf.date < b.kf.date ? -1 : 1;
+    const ra = SOURCE_RANK[a.kf.source] ?? 99;
+    const rb = SOURCE_RANK[b.kf.source] ?? 99;
+    if (ra !== rb) return ra - rb;
+    if (a.sig !== b.sig) return a.sig < b.sig ? -1 : 1;
+    return a.i - b.i; // last resort: insertion order
+  });
+  const sorted = indexed.map((x) => x.kf);
+
+  // After sorting, enrich each keyframe's `nums`/`calib` from dated rows NEAR
+  // that date — only when a real measurement exists in a tight window. No
+  // window hit → leave null. This is the no-interpolation guard.
+  const numIndex = buildNumIndex(vault, meta);
+  for (const kf of sorted) {
+    if (kf.nums === undefined) kf.nums = numsNear(kf.date, numIndex);
+    if (kf.calib === undefined) kf.calib = calibNear(kf.date, numIndex);
+  }
+
+  // Carry-forward `since` (days since the prior keyframe) — derived purely from
+  // the dated keyframe gaps, not invented.
+  for (let i = 0; i < sorted.length; i++) {
+    if (sorted[i].since === undefined) {
+      sorted[i].since = i === 0 ? null : daysBetween(sorted[i - 1].date, sorted[i].date);
+    }
+  }
+
+  // Availability is gated on VAULT-SCOPED sources only. The override source
+  // reads the GLOBAL pattern-manifest (~/.mover), which exists regardless of
+  // vault — so a bogus/empty vault could otherwise look "available" off
+  // ambient override rows that aren't this vault's record. The record lives in
+  // the vault; if no vault-scoped dated fact is readable, the rewind is
+  // unavailable (labelled), even when global overrides parsed fine.
+  const VAULT_SCOPED = ["strategy", "graveyard", "metrics", "daily", "git"];
+  const anyVaultSourceRead = VAULT_SCOPED.some((s) => meta.sourcesRead[s] === true);
+  const vaultScopedKeyframes = sorted.filter((kf) => kf.source !== "override").length;
+
+  if (!anyVaultSourceRead || (sorted.length === 0) || vaultScopedKeyframes === 0) {
+    const out = unavailable("no readable vault-scoped dated facts");
+    out.meta = meta;
+    out.gapBefore = gapBeforeCount;
+    return out;
+  }
+
+  const start = sorted.length ? sorted[0].date : null;
+  // `end` is the newest dated FACT, capped at today — a rewind never points to
+  // the future even if a fact carries a future-dated deadline string.
+  const todayKey = localDateKey(new Date());
+  let end = sorted.length ? sorted[sorted.length - 1].date : null;
+  if (end && end > todayKey) end = todayKey;
+
+  // gapAfter: days between the last recorded fact and now — the "no fresh
+  // record" tail the UI labels (e.g. "12 days since your last logged fact").
+  const gapAfter = end ? daysBetween(end, todayKey) : null;
+
+  return {
+    available: true,
+    start,
+    end,
+    moverDay1: MOVER_DAY1,
+    keyframes: sorted,
+    dailies,
+    gapBefore: gapBeforeCount,
+    gapAfter,
+    meta,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Collectors — each returns an array of keyframes (or [] ); never throws on its
+// own (the collect() wrapper is the final safety net regardless).
+// ---------------------------------------------------------------------------
+
+// Strategy.md: the LAB REPORT / CHANGELOG bullets carry a `[YYYY-MM-DD]` stamp
+// and a one-line summary. The first line of the summary that starts with a
+// **bold** label is treated as the "bet"/"strategy" headline for that date.
+function collectStrategy(vault) {
+  const text = safeRead(strategyPath(vault));
+  if (!text) return null; // null = source missing (distinct from [] = present-but-empty)
+  const out = [];
+
+  // Reuse the strategy-parser's LAB REPORT shape: lines like
+  // `*   **[2026-05-19]:** **V4.0 — ...** rest`. We match the date + the rest,
+  // then pull the first bold token as the bet label.
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const m = line.match(/^[-*]\s+\*\*\[(\d{4}-\d{2}-\d{2})\]:?\*\*\s*(.+)$/);
+    if (!m) continue;
+    const date = m[1];
+    const rest = m[2].trim();
+    const boldM = rest.match(/\*\*([^*]+?)\*\*/);
+    const headline = boldM ? boldM[1].trim() : firstSentence(rest);
+    out.push({
+      date,
+      source: "strategy",
+      ev: "Strategy logged",
+      bet: stripMd(headline) || null,
+      strategy: stripMd(headline) || null,
+      since: undefined,
+      nums: undefined,
+      calib: undefined,
+      files: [{ f: "Strategy.md", src: "LAB REPORT" }],
+    });
+  }
+  return out;
+}
+
+// Graveyard kill-dates across BOTH Active_Context (THE GRAVEYARD) and
+// Strategy.md (ARCHIVED HYPOTHESES). Date forms seen in the wild:
+//   "Killed 2026-05-19"  |  "(Killed Feb 18)"  |  "killed 2026-05-19"
+function collectGraveyard(vault) {
+  const sources = [
+    { text: safeRead(activeContextPath(vault)), f: "Active_Context.md", src: "THE GRAVEYARD" },
+    { text: safeRead(strategyPath(vault)), f: "Strategy.md", src: "ARCHIVED HYPOTHESES" },
+  ];
+  if (sources.every((s) => !s.text)) return null;
+
+  const out = [];
+  for (const s of sources) {
+    if (!s.text) continue;
+    const lines = s.text.split("\n");
+    for (const line of lines) {
+      if (!/💀|killed/i.test(line)) continue;
+      const date = parseKillDate(line);
+      if (!date) continue; // undated graveyard entry — can't place it, skip (labelled by omission)
+      const label = killLabel(line);
+      out.push({
+        date,
+        source: "graveyard",
+        ev: "Idea killed",
+        bet: label || null,
+        strategy: undefined,
+        since: undefined,
+        nums: undefined,
+        calib: undefined,
+        files: [{ f: s.f, src: s.src }],
+      });
+    }
+  }
+  return out;
+}
+
+// override_history from the pattern-manifest (the ONLY override source —
+// v6-PLAN-AMENDMENTS fix 7). Date may be `2026-05-24` or `2026-05-24T02:00`;
+// some entries use `timestamp`. Level may be "L3" or 3. All forgiving.
+function collectOverrides() {
+  const manifest = safeReadJson(moverPatternManifestPath());
+  if (!manifest) return null;
+  const hist = manifest.override_history || manifest.overrideHistory;
+  if (!Array.isArray(hist)) return []; // manifest present, no overrides logged
+  const out = [];
+  for (const o of hist) {
+    if (!o || typeof o !== "object") continue;
+    const date = isoDay(o.date || o.timestamp);
+    if (!date) continue;
+    const level = normLevel(o.level);
+    const what = stripMd(o.what || o.scope || o.type || "");
+    out.push({
+      date,
+      source: "override",
+      ev: level ? `Override ${level}` : "Override",
+      bet: undefined,
+      strategy: undefined,
+      since: undefined,
+      nums: undefined,
+      calib: undefined,
+      files: [{ f: "pattern-manifest.json", src: "override_history" }],
+      // extra context fields the UI may show; not part of the contract shape
+      level: level || null,
+      what: what || null,
+    });
+  }
+  return out;
+}
+
+// Metrics_Log.md dated rows → light keyframes (a fact existed that day). The
+// numeric enrichment (readiness etc.) happens in numsNear; here we only mark
+// the date so the scrubber has a stop. Dedupe per date.
+function collectMetrics(vault) {
+  const text = safeRead(metricsLogPath(vault));
+  if (!text) return null;
+  const seen = new Set();
+  const out = [];
+  const lines = text.split("\n");
+  for (const line of lines) {
+    // "- 2026-04-09 → score 75" | "| 2026-05-13 | 6 | ..." | "- 2026-04-24: ..."
+    const m = line.match(/(?:^[-*]\s*|^\|\s*)\[?(\d{4}-\d{2}-\d{2})\]?/);
+    if (!m) continue;
+    const date = m[1];
+    if (seen.has(date)) continue;
+    seen.add(date);
+    out.push({
+      date,
+      source: "metrics",
+      ev: "Metrics row",
+      bet: undefined,
+      strategy: undefined,
+      since: undefined,
+      nums: undefined,
+      calib: undefined,
+      files: [{ f: "Metrics_Log.md", src: "dated row" }],
+    });
+  }
+  return out;
+}
+
+// git log of the Engine directory — commit author-dates as keyframes. When the
+// Engine dir isn't under git (common: it's protected/ignored), this returns []
+// and sets meta.gitAvailable=false. Read-only `git log`; never mutates.
+function collectGit(vault, meta) {
+  const dir = engineDir(vault);
+  let stdout;
+  try {
+    stdout = execFileSync(
+      "git",
+      ["-C", dir, "log", "--format=%aI|%s", "--", "."],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 8000 }
+    );
+  } catch (e) {
+    // Not a repo / git absent / path outside repo — all expected. Label it.
+    meta.gitAvailable = false;
+    meta.gitError = (e && e.message ? String(e.message) : "git unavailable").slice(0, 200);
+    return []; // present-as-source but yielded nothing; keeps available:true via other sources
+  }
+  meta.gitAvailable = true;
+  const out = [];
+  const seen = new Set();
+  for (const line of stdout.split("\n")) {
+    const idx = line.indexOf("|");
+    if (idx < 0) continue;
+    const iso = line.slice(0, idx).trim();
+    const subj = line.slice(idx + 1).trim();
+    const date = isoDay(iso);
+    if (!date) continue;
+    // Collapse multiple commits on the same day to one keyframe (the scrubber
+    // wants one stop per day; subject of the first kept).
+    if (seen.has(date)) continue;
+    seen.add(date);
+    out.push({
+      date,
+      source: "git",
+      ev: "Engine commit",
+      bet: undefined,
+      strategy: undefined,
+      since: undefined,
+      nums: undefined,
+      calib: undefined,
+      files: [{ f: "Engine/", src: "git commit" }],
+      subject: subj || null,
+    });
+  }
+  return out;
+}
+
+// Daily Notes → per-date plan/got map + one existence keyframe per note. Walks
+// Dailies/YYYY-MM/Daily - YYYY-MM-DD.md. Plan = Focus line; got = count of
+// done tasks. Both real, both from the note itself — no inference.
+function collectDailies(vault) {
+  const root = dailiesDir(vault);
+  const dailies = {};
+  const keyframes = [];
+  const months = safeListDir(root, { dirsOnly: true });
+  if (!months.length) {
+    // Distinguish missing dir from empty: if the dir itself is unreadable,
+    // signal via throw-equivalent (return null path). Here we treat "no month
+    // folders" as an empty-but-present source.
+    if (!safeStat(root)) return { dailies, keyframes: null }; // null → source missing
+    return { dailies, keyframes: [] };
+  }
+  for (const mo of months) {
+    const files = safeListDir(mo.path, { extension: ".md" });
+    for (const file of files) {
+      const dm = file.name.match(/Daily - (\d{4}-\d{2}-\d{2})\.md$/);
+      if (!dm) continue;
+      const date = dm[1];
+      const text = safeRead(file.path, "");
+      const detail = analyzeDaily(text);
+      dailies[date] = {
+        date,
+        path: file.path,
+        plan: detail.focus, // may be null — labelled absence, never guessed
+        got: detail.tasksDone,
+        tasksTotal: detail.tasksTotal,
+      };
+      keyframes.push({
+        date,
+        source: "daily",
+        ev: "Daily note",
+        bet: undefined,
+        strategy: undefined,
+        since: undefined,
+        nums: undefined,
+        calib: undefined,
+        files: [{ f: `Daily - ${date}.md`, src: "Dailies" }],
+      });
+    }
+  }
+  return { dailies, keyframes };
+}
+
+// ---------------------------------------------------------------------------
+// nums / calib enrichment — dated rows ONLY, tight window, NEVER interpolated.
+// ---------------------------------------------------------------------------
+
+// Build a date→{posts,convs,streak,overrides,calib} index from the Metrics_Log
+// performance table + override_history + daily streak chain. Only EXACT dated
+// rows populate it. numsNear/calibNear then do a SAME-DAY-ONLY lookup (window
+// 0) so we never smear a measurement across days.
+function buildNumIndex(vault, meta) {
+  const idx = {};
+  const ensure = (d) => (idx[d] || (idx[d] = { posts: null, convs: null, streak: null, overrides: null, calib: null }));
+
+  // 1) Metrics_Log performance table rows:
+  //    | 2026-05-13 | 6 | 0 strategic / ~7 off-plan | 0/4 | 0% | 0/10 | 1/10 | ...
+  // Columns vary by version; we pull the two "x/10" cells as DM-convos + reels
+  // ONLY when the row clearly has them. Conservative: if the shape doesn't
+  // match, we leave nums null rather than mis-map a column.
+  const mtext = safeRead(metricsLogPath(vault));
+  if (mtext) {
+    for (const line of mtext.split("\n")) {
+      const m = line.match(/^\|\s*(\d{4}-\d{2}-\d{2})\s*\|(.+)$/);
+      if (!m) continue;
+      const date = m[1];
+      const cells = m[2].split("|").map((c) => c.trim());
+      const e = ensure(date);
+      // Find "N/10" cells — these are the distribution counts in this table.
+      const tens = cells
+        .map((c) => {
+          const t = c.match(/^(\d+)\s*\/\s*10$/);
+          return t ? parseInt(t[1], 10) : null;
+        })
+        .filter((v) => v != null);
+      if (tens.length >= 2) {
+        e.convs = tens[0]; // DMs/convos column
+        e.posts = tens[1]; // reels/posts column
+      } else if (tens.length === 1) {
+        e.posts = tens[0];
+      }
+    }
+  }
+
+  // 2) override counts per day from the manifest.
+  const manifest = safeReadJson(moverPatternManifestPath());
+  const hist = manifest && (manifest.override_history || manifest.overrideHistory);
+  if (Array.isArray(hist)) {
+    for (const o of hist) {
+      const d = isoDay(o && (o.date || o.timestamp));
+      if (!d) continue;
+      const e = ensure(d);
+      e.overrides = (e.overrides || 0) + 1;
+    }
+  }
+
+  // 3) streak — consecutive Daily Notes ending on each note's date. Computed
+  // from the REAL set of note dates (existence), not invented. We build the
+  // date set first, then for each note date count the back-run.
+  const noteDates = collectDailyDateSet(vault);
+  for (const d of noteDates) {
+    const e = ensure(d);
+    e.streak = backRun(d, noteDates);
+  }
+
+  return idx;
+}
+
+// SAME-DAY ONLY (window 0). Returns the {posts,convs,streak,overrides} object
+// ONLY when the date carries a real per-day MEASUREMENT — a distribution count
+// (posts/convs from the Metrics table) or a logged override that day. A bare
+// `streak` does NOT qualify: streak is a continuity value computable for every
+// note-day, so triggering on it would make nums non-null on ~every keyframe and
+// dissolve the "this day has a real record" signal (false-zero discipline,
+// T261). Streak rides along as context only when a measurement already exists.
+// No measurement → null. This is the hard no-interpolation boundary.
+function numsNear(date, numIndex) {
+  const e = numIndex[date];
+  if (!e) return null;
+  const measured = e.posts != null || e.convs != null || e.overrides != null;
+  if (!measured) return null;
+  return {
+    posts: e.posts,
+    convs: e.convs,
+    streak: e.streak, // context, present only because a measurement qualified the day
+    overrides: e.overrides,
+  };
+}
+
+function calibNear(date, numIndex) {
+  const e = numIndex[date];
+  if (!e || e.calib == null) return null;
+  return e.calib;
+}
+
+// ---------------------------------------------------------------------------
+// Small parsing / date helpers
+// ---------------------------------------------------------------------------
+
+// Run a collector under a label, recording read/missing status into meta and
+// appending its keyframes. null return = source file missing; [] = present but
+// empty; thrown = unreadable (recorded as read:false). Never propagates.
+function collect(meta, label, fn, acc) {
+  try {
+    const res = fn();
+    if (res === null) {
+      meta.sourcesRead[label] = false;
+      meta.sourcesMissing.push(label);
+      return;
+    }
+    meta.sourcesRead[label] = true;
+    if (Array.isArray(res)) {
+      for (const kf of res) if (kf && kf.date) acc.push(kf);
+    }
+  } catch (e) {
+    meta.sourcesRead[label] = false;
+    meta.sourcesMissing.push(label);
+  }
+}
+
+function unavailable(reason) {
+  return {
+    available: false,
+    reason,
+    start: null,
+    end: null,
+    moverDay1: MOVER_DAY1,
+    keyframes: [],
+    dailies: {},
+    gapBefore: 0,
+    gapAfter: null,
+  };
+}
+
+// Coerce an ISO-ish timestamp ("2026-05-24T02:00", "2026-05-24") to YYYY-MM-DD,
+// or null. Pure string slice when already date-prefixed (avoids TZ shifts that
+// `new Date(...)` would introduce on a date-only string).
+function isoDay(v) {
+  if (!v || typeof v !== "string") return null;
+  const m = v.match(/^(\d{4})-(\d{2})-(\d{2})/);
+  return m ? `${m[1]}-${m[2]}-${m[3]}` : null;
+}
+
+// Kill-date out of a graveyard line. ISO first ("Killed 2026-05-19"); then a
+// "Killed Mon DD(, YYYY)?" form ("(Killed Feb 18)") via the month map. Year
+// defaults to the current year when absent — but only for placing a same-year
+// kill; cross-year ambiguity stays as-is (these are recent records).
+function parseKillDate(line) {
+  const iso = line.match(/\b(?:killed|died)\b[^0-9]*\b(\d{4}-\d{2}-\d{2})\b/i);
+  if (iso) return iso[1];
+  const mo = line.match(/\b(?:killed|died)\b[^A-Za-z]*\b([A-Za-z]{3,9})\s+(\d{1,2})(?:,?\s*(\d{4}))?/i);
+  if (mo) {
+    const mi = monthIndex(mo[1]);
+    if (mi < 0) return null;
+    const day = parseInt(mo[2], 10);
+    if (!(day >= 1 && day <= 31)) return null;
+    const year = mo[3] ? parseInt(mo[3], 10) : new Date().getFullYear();
+    return `${year}-${String(mi + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+  }
+  return null;
+}
+
+// The bold label of a graveyard bullet → the killed thing's name.
+function killLabel(line) {
+  const b = line.match(/\*\*([^*]+?)\*\*/);
+  if (b) return stripMd(b[1].trim());
+  // No bold — take prose up to the first "Killed"/colon.
+  const t = line.replace(/^[\s*\-💀]+/, "").split(/Killed|:/i)[0];
+  return stripMd(t.trim()) || null;
+}
+
+function monthIndex(name) {
+  const n = String(name).toLowerCase().slice(0, 3);
+  const map = { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 };
+  return map[n] != null ? map[n] : -1;
+}
+
+// "L3" | 3 | "RETROSPECTIVE-L3" → "L3"; unknown → null.
+function normLevel(level) {
+  if (level == null) return null;
+  if (typeof level === "number") return Number.isFinite(level) ? `L${level}` : null;
+  const m = String(level).match(/L?(\d)/i);
+  return m ? `L${m[1]}` : null;
+}
+
+// Strip light markdown so labels render as plain text in the timeline.
+function stripMd(s) {
+  if (!s || typeof s !== "string") return null;
+  return s
+    .replace(/\*\*/g, "")
+    .replace(/[`*_]/g, "")
+    .replace(/^\s*[-*]\s+/, "")
+    .replace(/\s+/g, " ")
+    .replace(/[:\s]+$/, "") // trailing colon/space from "**Label:**" bullets
+    .trim() || null;
+}
+
+function firstSentence(s) {
+  if (!s) return null;
+  const m = s.match(/^(.+?[.!?])(\s|$)/);
+  return (m ? m[1] : s).slice(0, 120);
+}
+
+// Inclusive day delta between two YYYY-MM-DD keys (b - a) in whole days. Built
+// on UTC midnight so DST never shifts the count.
+function daysBetween(a, b) {
+  const ta = Date.parse(`${a}T00:00:00Z`);
+  const tb = Date.parse(`${b}T00:00:00Z`);
+  if (!Number.isFinite(ta) || !Number.isFinite(tb)) return null;
+  return Math.round((tb - ta) / 86400000);
+}
+
+// Deterministic signature for tiebreaking equal (date, source) keyframes.
+function keyframeSig(kf) {
+  return [kf.source, kf.ev || "", kf.bet || "", kf.what || "", kf.subject || "",
+    (kf.files && kf.files[0] && kf.files[0].f) || ""].join("
");
+}
+
+// Daily-note plan/got from note text. Focus line (first content line under a
+// "Focus" heading) → plan; done-task count → got. Null focus when no Focus
+// section exists (labelled absence — a guessed plan is never acceptable).
+function analyzeDaily(text) {
+  if (!text) return { focus: null, tasksDone: 0, tasksTotal: 0 };
+  let total = 0, done = 0;
+  for (const line of text.split("\n")) {
+    const m = line.match(/^\s*[-*]\s*\[([ xX~])\]/);
+    if (m) {
+      total++;
+      if (m[1].toLowerCase() === "x") done++;
+    }
+  }
+  const fm = text.match(/^#{1,6}\s*[^\n]*focus[^\n]*\n+([^\n#][^\n]*)/im);
+  const focus = fm
+    ? (fm[1].replace(/\*\*/g, "").replace(/^\s*[-*]\s+(\[.\]\s*)?/, "").trim() || null)
+    : null;
+  return { focus, tasksDone: done, tasksTotal: total };
+}
+
+// Set of all Daily-Note dates (YYYY-MM-DD) present on disk.
+function collectDailyDateSet(vault) {
+  const set = new Set();
+  const months = safeListDir(dailiesDir(vault), { dirsOnly: true });
+  for (const mo of months) {
+    for (const f of safeListDir(mo.path, { extension: ".md" })) {
+      const dm = f.name.match(/Daily - (\d{4}-\d{2}-\d{2})\.md$/);
+      if (dm) set.add(dm[1]);
+    }
+  }
+  return set;
+}
+
+// Consecutive-day back-run ending on `date`, counting only dates in `set`.
+function backRun(date, set) {
+  let n = 0;
+  let cur = date;
+  // Walk backwards day-by-day while the note exists.
+  for (let i = 0; i < 400; i++) {
+    if (!set.has(cur)) break;
+    n++;
+    cur = addDays(cur, -1);
+    if (!cur) break;
+  }
+  return n;
+}
+
+function addDays(dateKey, delta) {
+  const t = Date.parse(`${dateKey}T00:00:00Z`);
+  if (!Number.isFinite(t)) return null;
+  const d = new Date(t + delta * 86400000);
+  return localDateKey(new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+}
+
+module.exports = { buildRewind };