mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/memory-text.js

@@ -0,0 +1,136 @@
+"use strict";
+
+// memory-text.js — shared text utilities for the Mover memory engine.
+// Zero-dep (Node stdlib only). Two distinct tokenizers on purpose:
+//   - tokenize(): SEARCH terms — stopworded, len>=3. Feeds the BM25 index + queries.
+//   - words():    LINK matching — raw lowercased word sequence, NO stopword removal,
+//                 so multi-word note names ("Launch Plan", "The Standing") survive as n-grams.
+// Mixing the two would drop stopword-containing note names and pollute the index with "the".
+
+const fs = require("fs");
+const path = require("path");
+
+// Compact English + Mover-chatter stopword set. Kept inline to stay zero-dep.
+const STOPWORDS = new Set((
+  "a an and are as at be been being but by for from had has have he her hers him his i if in into is it its " +
+  "me my no nor not of off on once only or our ours out over own she so some such than that the their theirs them " +
+  "then there these they this those to too under until up very was we were what when where which while who whom why " +
+  "will with you your yours about above after again against all am any because before below between both did do does " +
+  "doing down during each few more most other same should through too will just dont cant wont youre ive im also get " +
+  "got like one two way thing things stuff lot really actually maybe okay yeah yep nope going want need make made " +
+  "now new use used using via per etc ok let lets going gonna wanna"
+).split(/\s+/).filter(Boolean));
+
+// Generic note-name tokens that are too ambiguous to be a useful wikilink target.
+const VOCAB_STOP = new Set([
+  "index", "readme", "schema", "template", "_template", "misc", "notes", "untitled",
+  "home", "moc", "map", "tools", "people", "places", "scripts", "inbox", "archive",
+  "daily", "weekly", "monthly", "project", "projects", "library", "engine"
+]);
+
+// SEARCH tokens: lowercase, alphanumeric cores (keep internal . - _ for things like
+// "v4.5.1", "engine-writer"), drop stopwords + sub-3-char noise + over-long blobs.
+function tokenize(text) {
+  if (!text) return [];
+  const out = [];
+  const re = /[a-z0-9][a-z0-9._-]{1,40}/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    let t = m[0].toLowerCase().replace(/^[._-]+|[._-]+$/g, "");
+    if (t.length < 3 || t.length > 40) continue;
+    if (STOPWORDS.has(t)) continue;
+    out.push(t);
+  }
+  return out;
+}
+
+// LINK words: lowercase word sequence, light cleanup, NO stopword removal.
+function words(text) {
+  if (!text) return [];
+  const out = [];
+  const re = /[a-z0-9][a-z0-9'._-]*/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const w = m[0].toLowerCase().replace(/^['._-]+|['._-]+$/g, "");
+    if (w) out.push(w);
+  }
+  return out;
+}
+
+// Build uni/bi/tri-gram membership sets from a (capped) text blob, for O(vocab) link matching.
+function ngramSets(text) {
+  const w = words(text);
+  const uni = new Set();
+  const bi = new Set();
+  const tri = new Set();
+  for (let i = 0; i < w.length; i++) {
+    uni.add(w[i]);
+    if (i + 1 < w.length) bi.add(w[i] + " " + w[i + 1]);
+    if (i + 2 < w.length) tri.add(w[i] + " " + w[i + 1] + " " + w[i + 2]);
+  }
+  return { 1: uni, 2: bi, 3: tri };
+}
+
+// term -> frequency map from search tokens.
+function termFreq(tokens) {
+  const tf = Object.create(null);
+  for (const t of tokens) tf[t] = (tf[t] || 0) + 1;
+  return tf;
+}
+
+// Recursively collect .md basenames (no extension) under a dir.
+function listMd(dir, acc, depth) {
+  if (depth < 0) return acc;
+  let ents;
+  try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return acc; }
+  for (const e of ents) {
+    if (e.name.startsWith(".") || e.name === "node_modules") continue;
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) listMd(p, acc, depth - 1);
+    else if (e.name.endsWith(".md")) acc.push(e.name.replace(/\.md$/, ""));
+  }
+  return acc;
+}
+
+// Vocab = the set of existing vault notes the gardener/recall can link into.
+// Sourced from 01_Projects folder names + every .md basename under 03_Library + 02_Areas/Engine.
+// Returns { entries:[{canonical,lower,nWords}], byN:{1:Map,2:Map,3:Map} }.
+function buildVocab(vault) {
+  const raw = new Set();
+  try {
+    for (const e of fs.readdirSync(path.join(vault, "01_Projects"), { withFileTypes: true })) {
+      if (e.isDirectory()) raw.add(e.name);
+    }
+  } catch {}
+  listMd(path.join(vault, "03_Library"), [], 4).forEach((n) => raw.add(n));
+  listMd(path.join(vault, "02_Areas", "Engine"), [], 3).forEach((n) => raw.add(n));
+
+  const entries = [];
+  const byN = { 1: new Map(), 2: new Map(), 3: new Map() };
+  for (const name of raw) {
+    const w = words(name);
+    const nWords = w.length;
+    if (nWords < 1 || nWords > 3) continue;
+    const lower = w.join(" ");
+    // Single-word notes must be >=4 chars and not a generic term, or they match everything.
+    if (nWords === 1 && (lower.length < 4 || VOCAB_STOP.has(lower))) continue;
+    // Skip date-stamped dailies/weeklies AND numbered/ordinal note names ("7 Workflow",
+    // "4. Outbound") — a leading digit is never a useful wikilink target, only index noise.
+    if (/^daily|^weekly|^\d/.test(lower)) continue;
+    if (byN[nWords].has(lower)) continue;
+    byN[nWords].set(lower, name);
+    entries.push({ canonical: name, lower, nWords });
+  }
+  return { entries, byN };
+}
+
+// Given precomputed ngramSets for a session and a vocab, return matched canonical note names.
+function matchLinks(sets, vocab) {
+  const hits = [];
+  for (const e of vocab.entries) {
+    if (sets[e.nWords] && sets[e.nWords].has(e.lower)) hits.push(e.canonical);
+  }
+  return hits;
+}
+
+module.exports = { tokenize, words, ngramSets, termFreq, buildVocab, matchLinks, STOPWORDS, VOCAB_STOP };

package/src/dashboard/lib/metrics-log-parser.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const { metricsLogPath, healthAnalysisPath, safeRead, safeStat } = require("./paths");
+
+// Parse Metrics_Log.md + Health_Analysis_Full.md for vitality dashboard data.
+
+function parseMetricsLog(vault) {
+  const mPath = metricsLogPath(vault);
+  const hPath = healthAnalysisPath(vault);
+  const mText = safeRead(mPath);
+  const hText = safeRead(hPath);
+  const mStat = safeStat(mPath);
+
+  const out = {
+    available: !!(mText || hText),
+    metricsLogPath: mPath,
+    healthAnalysisPath: hPath,
+    lastUpdated: mStat ? mStat.mtime : null,
+    latestMetrics: {},
+    recentEntries: []
+  };
+
+  if (mText) {
+    // Extract bold-key fields (most recent ones first)
+    const fieldRe = /\*\*([^*]+):\*\*\s*([^\n]+)/g;
+    let m;
+    while ((m = fieldRe.exec(mText)) !== null) {
+      const k = m[1].trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_|_$/g, "");
+      if (!out.latestMetrics[k]) out.latestMetrics[k] = m[2].trim();
+    }
+
+    // Extract date-prefixed log entries
+    const lines = mText.split("\n");
+    for (const line of lines) {
+      const dateMatch = line.match(/^[-*]?\s*\[?(\d{4}-\d{2}-\d{2})\]?\s+(.+)$/);
+      if (dateMatch) {
+        out.recentEntries.push({ date: dateMatch[1], text: dateMatch[2].trim() });
+      }
+    }
+    out.recentEntries = out.recentEntries.slice(-10).reverse();
+  }
+
+  // Health Analysis: extract HRV, sleep, RHR, weight summary.
+  //
+  // T242 bug hunt fix (C#7): keep the relaxed key-then-anything-then-value
+  // greedy regex (it was finding correct values like sleep=6.73h, hrv=8.9ms
+  // in prose), but add a sanity-range filter. Previous bug: `Weight gain
+  // (+3-4 kg since baseline)` captured "4" as weight. The lazy `[^|]*?`
+  // matched " gain (+3-", then `\d+` grabbed "4", then `\s*kg` matched
+  // " kg". The 4 was a delta, not the weight. Range 30-300 rejects it.
+  // Same fix kills RHR=0.43 (some Fitbit entropy decimal) — out of 30-200.
+  if (hText) {
+    out.hrvLatest = extractMetricInRange(hText, /HRV[^|]*?(\d+(?:\.\d+)?)\s*(?:ms|rmssd)/i, 5, 200);
+    out.sleepLatest = extractMetricInRange(hText, /Sleep[^|]*?(\d+(?:\.\d+)?)\s*(?:h|hours?)/i, 0, 16);
+    out.rhrLatest = extractMetricInRange(hText, /(?:RHR|Resting HR)[^|]*?(\d+(?:\.\d+)?)\s*(?:bpm)?/i, 30, 200);
+    out.weightLatest = extractMetricInRange(hText, /Weight[^|]*?(\d+(?:\.\d+)?)\s*(?:kg|lb)/i, 30, 300);
+  }
+
+  return out;
+}
+
+function extractMetricInRange(text, re, min, max) {
+  const m = text.match(re);
+  if (!m) return null;
+  const v = parseFloat(m[1]);
+  if (!Number.isFinite(v)) return null;
+  if (v < min || v > max) return null;
+  return m[1];
+}
+
+function extractMetricFromText(text, re) {
+  const m = text.match(re);
+  return m ? m[1] : null;
+}
+
+module.exports = { parseMetricsLog };

package/src/dashboard/lib/moves-usage-parser.js

@@ -0,0 +1,184 @@
+"use strict";
+
+// Moves usage parser — lights the Moves map (~25 Mover moves) by how often
+// each move has ACTUALLY run, read from Claude Code's real append-only
+// command history at ~/.claude/history.jsonl.
+//
+// Per the dashboard's "TELEMETRY NEVER" promise: this reads a local file
+// Claude Code already writes. Nothing is sent anywhere.
+//
+// Source line shape (one JSON object per line, append-only):
+//   { "display": "/log ", "pastedContents": {}, "timestamp": 1771088938619,
+//     "project": "<vault>/01_Projects/Mover OS Bundle",
+//     "sessionId": "50ba...-2562" }
+//
+//   - `display`   : the raw prompt text the user submitted. Slash commands
+//                   and `moveros <sub>` invocations start here.
+//   - `timestamp` : epoch ms of the invocation.
+//   - `project`   : the LITERAL cwd string at invocation time. NOT a slug.
+//                   On a machine that migrated platforms, this field can carry
+//                   both old and current absolute paths for the same vault.
+//
+// SCOPING (the crux): we count only invocations made inside THIS vault.
+//   - The dashboard server's canonical vault identity is
+//     `fs.realpathSync(path.resolve(vault))` (server.js:63). We mirror that
+//     so a symlinked vault resolves to the same identity here.
+//   - We then keep a history row only if its `project`, normalized to a
+//     boundary-aligned path-segment array, CONTAINS the vault realpath's
+//     distinctive tail segments as a contiguous run. This is a path-BOUNDARY
+//     match, NOT a substring `includes` — so a sibling like
+//     `Architect_OS_backup/` is correctly excluded (its segment is
+//     `Architect_OS_backup`, which never equals `Architect_OS`).
+//   - Old Windows-era rows can't be realpath-resolved on this machine, but
+//     they ARE this vault's history. The segment-anchor match recovers them
+//     (separators normalized `\` → `/`) without loosening the boundary.
+//
+// FALSE-ZERO DISCIPLINE (T261): history.jsonl absent or unreadable returns
+//   { available:false, source:'', totalRuns:null, byCommand:{} }
+// so the UI shows "calibrating", never a fabricated all-zero map. We NEVER
+// invent counts. A move the user simply hasn't run is ABSENT from byCommand
+// — the UI treats absent as a REAL zero ("never").
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function historyPath() {
+  return path.join(os.homedir(), ".claude", "history.jsonl");
+}
+
+// Normalize any path string (Windows or POSIX) to a clean, trailing-slash-
+// stripped, forward-slash form, then split into non-empty segments.
+function pathSegments(p) {
+  return String(p)
+    .replace(/\\/g, "/")   // Windows separators → POSIX
+    .replace(/\/+$/, "")   // drop trailing slash(es)
+    .split("/")
+    .filter(Boolean);
+}
+
+// Build the vault's distinctive tail anchor: the last up-to-3 segments of the
+// vault realpath (e.g. ["Documents","Obsidian","Architect_OS"]). Three
+// segments is distinctive enough to avoid collisions while still matching the
+// cross-platform paths, which share the `Documents/Obsidian/Architect_OS`
+// tail. Falls back to whatever segments exist for shallow vault paths.
+function vaultAnchorSegments(vault) {
+  let vaultReal;
+  try {
+    vaultReal = fs.realpathSync(path.resolve(vault));
+  } catch (_) {
+    // Vault path doesn't resolve (missing / not yet created). Fall back to the
+    // literal resolved string so scoping still has an anchor to match against.
+    vaultReal = path.resolve(vault);
+  }
+  const segs = pathSegments(vaultReal);
+  return segs.slice(Math.max(0, segs.length - 3));
+}
+
+// True if `projectRaw` (a literal cwd from history) sits inside the vault.
+// Boundary-aligned: the anchor must appear as a contiguous run of WHOLE
+// segments. `Architect_OS_backup` never matches an `Architect_OS` anchor
+// segment, so sibling dirs are excluded.
+function projectMatchesVault(projectRaw, anchor) {
+  if (!projectRaw || anchor.length === 0) return false;
+  const segs = pathSegments(projectRaw);
+  for (let i = 0; i + anchor.length <= segs.length; i++) {
+    let hit = true;
+    for (let j = 0; j < anchor.length; j++) {
+      if (segs[i + j] !== anchor[j]) { hit = false; break; }
+    }
+    if (hit) return true; // everything after the anchor is a descendant → in
+  }
+  return false;
+}
+
+// Extract a Mover-move identity from a raw `display` string.
+// Returns { cmd, label } or null.
+//   - /slash-command   → cmd "log",          label "/log"
+//   - moveros <subcmd> → cmd "pulse",         label "moveros pulse"
+// Per the contract: command names are lowercase, may contain hyphens, and the
+// first letter is a-z (so we don't match `/1`, `/-x`, paths, etc.).
+function extractMove(display) {
+  const text = String(display || "");
+  const slash = text.match(/^\s*(\/[a-z][a-z-]+)/);
+  if (slash) {
+    const label = slash[1];
+    return { cmd: label.slice(1), label };
+  }
+  const cli = text.match(/^\s*moveros\s+([a-z-]+)/);
+  if (cli) {
+    return { cmd: cli[1], label: `moveros ${cli[1]}` };
+  }
+  return null;
+}
+
+// computeMovesUsage({ vault }) -> {
+//   available:  boolean,                 // false only when source is unreadable
+//   source:     string,                  // absolute history.jsonl path, or '' when absent
+//   totalRuns:  number | null,           // total in-scope move invocations; null when unavailable
+//   byCommand:  { [cmd]: { count, lastIso, lastLabel } }   // absent cmd === real zero
+// }
+function computeMovesUsage(opts = {}) {
+  const { vault } = opts;
+  const src = historyPath();
+
+  // False-zero gate: no readable history → unavailable, never a fake map.
+  let raw;
+  try {
+    raw = fs.readFileSync(src, "utf8");
+  } catch (_) {
+    return { available: false, source: "", totalRuns: null, byCommand: {} };
+  }
+
+  const anchor = vaultAnchorSegments(vault);
+  const byCommand = {};
+  // Track newest timestamp per command separately so the public shape only
+  // carries { count, lastIso, lastLabel } (no internal bookkeeping leaks out).
+  const lastTsByCmd = Object.create(null);
+  let totalRuns = 0;
+
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch (_) {
+      // Forward-compat: a malformed line never aborts the scan. Skip it.
+      continue;
+    }
+    if (!projectMatchesVault(row.project, anchor)) continue;
+
+    const move = extractMove(row.display);
+    if (!move) continue;
+
+    const ts = Number(row.timestamp);
+    const hasTs = Number.isFinite(ts);
+    const iso = hasTs ? new Date(ts).toISOString() : null;
+
+    totalRuns += 1;
+    let entry = byCommand[move.cmd];
+    if (!entry) {
+      entry = byCommand[move.cmd] = { count: 0, lastIso: null, lastLabel: null };
+      lastTsByCmd[move.cmd] = -Infinity;
+    }
+    entry.count += 1;
+    // Keep the most-recent invocation's iso + label. Rows without a usable
+    // timestamp never overwrite a dated "last" (they stay as a fallback only
+    // if nothing dated was ever seen).
+    if (hasTs && ts > lastTsByCmd[move.cmd]) {
+      lastTsByCmd[move.cmd] = ts;
+      entry.lastIso = iso;
+      entry.lastLabel = move.label;
+    } else if (entry.lastLabel == null) {
+      // First sighting was undated — record at least the label so the UI has
+      // a name to show. lastIso stays null (honest: timestamp unknown).
+      entry.lastLabel = move.label;
+    }
+  }
+
+  return { available: true, source: src, totalRuns, byCommand };
+}
+
+module.exports = { computeMovesUsage };

package/src/dashboard/lib/onboarding-forge.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/**
+ * onboarding-forge.js — turn the REAL list of Engine files being written into an
+ * ordered, human "forge" sequence for the onboarding synthesis beat (the moment the
+ * system composes your operating record from your answers).
+ *
+ * HONESTY CONTRACT: every beat after the lead-in corresponds 1:1 to a file the writer
+ * actually produces — never an invented step, never padding. Unknown-but-real files are
+ * appended (still honest) rather than dropped. Deterministic + zero-dep (mirrors the
+ * connect-recommender / skill-recommender pattern: pure logic here, rendered by the jsx).
+ *
+ * @param {Array<string>} files  file paths or basenames the finalize step will write
+ * @param {{cap?:number}} [opts]
+ * @returns {Array<{ key:string, label:string, file:string|null }>}  lead beat first
+ */
+
+// canonical compose order — the record is built identity-first, then the bet, then leverage
+const ORDER = [
+  "Identity_Prime", "Strategy", "Goals", "Mover_Dossier",
+  "Active_Context", "Auto_Learnings", "Metrics_Log", "Voice_DNA",
+];
+
+// each label is a present-tense act of composition, warm + specific (never "Writing file 3/5")
+const LABELS = {
+  Identity_Prime: "Shaping who you are",
+  Strategy:       "Setting your strategy",
+  Goals:          "Naming the bet",
+  Mover_Dossier:  "Taking stock of your leverage",
+  Active_Context: "Opening your working memory",
+  Auto_Learnings: "Preparing to learn your patterns",
+  Metrics_Log:    "Laying out your scoreboard",
+  Voice_DNA:      "Tuning to your voice",
+};
+
+function basename(name) {
+  return String(name || "").split(/[\\/]/).pop().replace(/\.md$/i, "").trim();
+}
+
+function forgeBeats(files, opts) {
+  const cap = (opts && Number.isFinite(opts.cap)) ? opts.cap : 6;
+  const list = Array.isArray(files) ? files : [];
+  const seen = new Set();
+  const ordered = [];
+
+  // 1. canonical order first (Identity → Strategy → Goals → Dossier → …)
+  for (const key of ORDER) {
+    if (!seen.has(key) && list.some((f) => basename(f) === key)) {
+      seen.add(key);
+      ordered.push(key);
+    }
+  }
+  // 2. any real file we don't have a canonical slot for — appended, never dropped (honest)
+  for (const f of list) {
+    const k = basename(f);
+    if (k && !seen.has(k)) { seen.add(k); ordered.push(k); }
+  }
+
+  const beats = ordered.slice(0, cap).map((k) => ({
+    key: k,
+    label: LABELS[k] || ("Writing " + k.replace(/_/g, " ")),
+    file: k + ".md",
+  }));
+
+  // lead beat — the real first act: parsing the transcript into a profile. file:null because
+  // it isn't a file being written, it's the read that precedes the writes.
+  return [{ key: "_read", label: "Reading your answers", file: null }, ...beats];
+}
+
+module.exports = { forgeBeats, LABELS, ORDER };

package/src/dashboard/lib/override-outcome-parser.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+const { localDateKey } = require("./date-utils");
+
+// override-outcome-parser.js — F18 / Codex viral #3. Cross-references each
+// override entry against subsequent Daily Notes to detect:
+//   - Did the deferred workflow actually run later? (resolution outcome)
+//   - Was the chosen alternative followed through? (justification outcome)
+//
+// Returns: array of { override, resolution: 'kept'|'reverted'|'unknown', daysToResolve, evidenceFiles }
+
+function compute({ vault, overrides = [], windowDays = 90 } = {}) {
+  if (!vault || !Array.isArray(overrides) || overrides.length === 0) {
+    return { available: false, outcomes: [] };
+  }
+  const dDir = dailiesDir(vault);
+  if (!fs.existsSync(dDir)) return { available: false, outcomes: [] };
+
+  const outcomes = overrides.slice(-20).map((o) => {
+    const overrideDate = o.at ? new Date(o.at) : null;
+    if (!overrideDate || isNaN(overrideDate.getTime())) {
+      return { override: o, resolution: 'unknown', daysToResolve: null, evidenceFiles: [], outcome7d: null, outcome30d: null };
+    }
+    const deferredWorkflow = (o.over || '').toLowerCase();
+    const startTs = overrideDate.getTime();
+    const evidenceFiles = [];
+    let firstSubsequentRun = null;
+
+    // Walk daily notes within windowDays after the override
+    for (let i = 0; i <= windowDays; i++) {
+      const d = new Date(startTs + i * 24 * 3600 * 1000);
+      const key = localDateKey(d);
+      const monthDir = key.slice(0, 7);
+      const fpath = path.join(dDir, monthDir, `Daily - ${key}.md`);
+      try {
+        const text = fs.readFileSync(fpath, "utf8");
+        // Look for the deferred workflow keyword in this daily note
+        if (deferredWorkflow && text.toLowerCase().includes(deferredWorkflow)) {
+          if (!firstSubsequentRun) firstSubsequentRun = { date: key, daysAfter: i };
+          evidenceFiles.push({ date: key, file: `Daily - ${key}.md` });
+          if (evidenceFiles.length >= 3) break;
+        }
+      } catch (_) { /* skip */ }
+    }
+
+    const resolution = firstSubsequentRun ? 'kept' : 'unknown';
+    return {
+      override: o,
+      resolution,
+      daysToResolve: firstSubsequentRun ? firstSubsequentRun.daysAfter : null,
+      evidenceFiles,
+      outcome7d: firstSubsequentRun && firstSubsequentRun.daysAfter <= 7 ? 'kept' : 'pending',
+      outcome30d: firstSubsequentRun && firstSubsequentRun.daysAfter <= 30 ? 'kept' : 'pending',
+    };
+  });
+
+  return {
+    available: true,
+    outcomes,
+    kept: outcomes.filter(x => x.resolution === 'kept').length,
+    unresolved: outcomes.filter(x => x.resolution === 'unknown').length,
+  };
+}
+
+module.exports = { compute };

package/src/dashboard/lib/override-summary.js

@@ -0,0 +1,73 @@
+"use strict";
+
+// Normalize override entries from pattern-manifest.json.
+//
+// T242 bug hunt fix (C#5): manifest sometimes carries `at` as the short
+// "2026-04-20T11:11" form (no seconds). Per ECMAScript spec, that string
+// is non-standard — Safari parses it as NaN. Force full ISO-8601 with
+// seconds + UTC marker so Date.parse() is consistent across V8/Safari/
+// Firefox. If the input is already valid, normalize to a canonical form.
+function toFullIso(raw) {
+  if (!raw) return "";
+  const s = String(raw).trim();
+  // Already a full ISO with seconds + zone? Keep.
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/.test(s)) return s;
+  // Short form: pad to seconds and treat as UTC. Date constructor accepts
+  // this form universally.
+  const m = s.match(/^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/);
+  if (m) {
+    const ss = m[4] || "00";
+    return `${m[1]}T${m[2]}:${m[3]}:${ss}.000Z`;
+  }
+  // Date-only? Anchor to midnight UTC.
+  if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return `${s}T00:00:00.000Z`;
+  // Anything else — let Date.parse have a try. If valid, re-emit ISO.
+  const t = Date.parse(s);
+  return Number.isFinite(t) ? new Date(t).toISOString() : s;
+}
+
+function normalizeOverrides(manifest) {
+  const raw = (manifest && (manifest.overrideHistory || manifest.override_history)) || [];
+  if (!Array.isArray(raw)) return [];
+  return raw.map((o, i) => ({
+    id: o.id || `${o.timestamp || o.date || "x"}-${i}`,
+    at: toFullIso(o.timestamp || o.date),
+    project: o.project || "",
+    level: o.level || "",
+    what: o.what || o.action || o.task || "",
+    over: o.over || o.plan_item || o.conflicted_with || "",
+    reason: o.reason || o.justification || o.user_override || "",
+    outcome: o.outcome || "",
+  })).filter(o => o.at || o.what || o.reason);
+}
+
+function computeOverrideSummary(overrides, now = new Date()) {
+  const entries = Array.isArray(overrides) ? overrides : [];
+  const nowMs = now.getTime();
+  const day = 24 * 3600 * 1000;
+  const countWithin = (days) => entries.filter(o => {
+    const t = Date.parse(o.at || "");
+    return Number.isFinite(t) && nowMs - t <= days * day;
+  }).length;
+  const byLevel = entries.reduce((acc, o) => {
+    const level = String(o.level || "UNKNOWN").toUpperCase() || "UNKNOWN";
+    acc[level] = (acc[level] || 0) + 1;
+    return acc;
+  }, {});
+  const last = entries
+    .slice()
+    .sort((a, b) => (Date.parse(b.at || "") || 0) - (Date.parse(a.at || "") || 0))
+    .slice(0, 30);
+
+  return {
+    total: entries.length,
+    last7d: countWithin(7),
+    last14d: countWithin(14),
+    last30d: countWithin(30),
+    last90d: countWithin(90),
+    byLevel,
+    recent: last,
+  };
+}
+
+module.exports = { normalizeOverrides, computeOverrideSummary };