mover-os 4.7.7 → 4.7.9

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 };

package/src/dashboard/lib/drift-history.js

@@ -0,0 +1,88 @@
+"use strict";
+
+// Drift history persistence. drift-score.js is a pure compute function;
+// to render a real time-series sparkline the dashboard needs the daily
+// values stored somewhere. We persist one snapshot per calendar day at
+// ~/.mover/drift-history.json. Same-day requests overwrite the entry,
+// so the latest computed score wins; new days append. Capped at 90 days.
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { localDateKey } = require("./date-utils");
+
+const HISTORY_PATH = path.join(os.homedir(), ".mover", "drift-history.json");
+const MAX_DAYS = 90;
+
+// LOCAL calendar day, not UTC. The bare toISOString().slice(0,10) bucketed
+// by UTC while every other parser (streak, distribution, session-time) keys
+// by local time via date-utils, so near midnight in any non-UTC zone the
+// drift sparkline's day disagreed with the rest of the dashboard by one day.
+function todayKey() {
+  return localDateKey();
+}
+
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+}
+
+function load() {
+  try {
+    if (!fs.existsSync(HISTORY_PATH)) return { version: 1, history: [] };
+    const raw = fs.readFileSync(HISTORY_PATH, "utf8");
+    const data = JSON.parse(raw);
+    if (!data || !Array.isArray(data.history)) return { version: 1, history: [] };
+    return data;
+  } catch {
+    return { version: 1, history: [] };
+  }
+}
+
+function save(data) {
+  try {
+    ensureDir(HISTORY_PATH);
+    // Atomic write (find-bugs #8): write to a tmp file then rename in.
+    // POSIX rename is atomic per inode; modern NTFS is effectively atomic
+    // on same-filesystem rename. A crash mid-write previously truncated
+    // the history file — JSON.parse threw on next load and dropped all
+    // drift history silently to {history: []}.
+    const tmp = `${HISTORY_PATH}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+    fs.renameSync(tmp, HISTORY_PATH);
+  } catch (e) {
+    // Persistence failure is non-fatal — the dashboard still renders
+    // with current snapshot.
+  }
+}
+
+// Record today's value. Overwrites the same-day entry if present so the
+// last computed score wins; appends a new entry for a new day. Trims to
+// MAX_DAYS to keep the file small.
+function recordSnapshot({ value, components }) {
+  if (!Number.isFinite(value)) return load();
+  const data = load();
+  const day = todayKey();
+  const idx = data.history.findIndex(e => e.date === day);
+  const entry = { date: day, value, components: components || {} };
+  if (idx >= 0) {
+    data.history[idx] = entry;
+  } else {
+    data.history.push(entry);
+    data.history.sort((a, b) => a.date.localeCompare(b.date));
+    if (data.history.length > MAX_DAYS) {
+      data.history = data.history.slice(-MAX_DAYS);
+    }
+  }
+  save(data);
+  return data;
+}
+
+// Return the trailing N days as [{date, value}] sorted ASC. Used by the
+// /api/state.json driftScore.history field.
+function getHistory(days = 30) {
+  const data = load();
+  return data.history.slice(-days).map(e => ({ date: e.date, value: e.value }));
+}
+
+module.exports = { recordSnapshot, getHistory, HISTORY_PATH };

package/src/dashboard/lib/drift-score.js

@@ -0,0 +1,119 @@
+"use strict";
+
+// drift-score.js — composite score 0-100 representing distance from stated strategy.
+// Reads from pattern-manifest + active-context + engine-health + daily-note-resolver.
+// Pure function: takes already-parsed inputs, returns DriftScore shape.
+//
+// Score components (each 0-25, sum = 0-100):
+//   1. Zombie load   — manifest.zombie_count (clamped 0-5, weighted x5)
+//   2. Override burden — count of override_history entries last 7 days (x6, clamp 25)
+//   3. Distribution gap — days since last `/log` distribution-tagged entry (x2.5, clamp 25)
+//   4. Stale review age — analyse_day_overdue (x1.5, clamp 25)
+//
+// Band thresholds: 0-29 low, 30-49 med, 50-74 high, 75-100 crit.
+// Delta computed against the value 24h ago if available.
+
+function compute(inputs) {
+  const {
+    manifest = null,
+    activeContext = null,
+    engineHealth = null,
+    todayPlanRanDistribution = false,
+    yesterdayScore = null,
+  } = inputs || {};
+
+  // 1) Zombie load — accept both camelCase (loader normalised) and snake_case (raw manifest)
+  const zombieCount = clampInt(
+    manifest && (manifest.zombieCount ?? manifest.zombie_count),
+    0, 5
+  );
+  const zombieScore = zombieCount * 5;
+
+  // 2) Override burden (7-day window)
+  const overrideEntries = (manifest && (manifest.overrideHistory || manifest.override_history)) || [];
+  const now = Date.now();
+  const weekMs = 7 * 24 * 3600 * 1000;
+  const recentOverrides = overrideEntries.filter((o) => {
+    const t = Date.parse(o.date || o.timestamp || "");
+    return Number.isFinite(t) && now - t <= weekMs;
+  }).length;
+  const overrideScore = Math.min(25, recentOverrides * 6);
+
+  // 3) Distribution gap — days since the last logged distribution action.
+  // Derived from REAL per-day counts (distribution parser) — never a fabricated
+  // default. When we genuinely can't measure (parser unavailable AND the manifest
+  // has no last_distribution_at), the gap is UNKNOWN and contributes 0, rather
+  // than inventing a penalty (the old `distGapDays = 3`). [false-zero, T261]
+  const dist = inputs.distribution;
+  let distGapDays = null; // null = unmeasured
+  if (dist && dist.available !== false && Array.isArray(dist.days) && dist.days.length) {
+    // days[] is chronological (oldest → newest). Gap = days since the most
+    // recent day with count > 0; full window if there has never been one.
+    let gap = dist.days.length;
+    for (let i = dist.days.length - 1; i >= 0; i--) {
+      if (dist.days[i].count > 0) { gap = (dist.days.length - 1) - i; break; }
+    }
+    distGapDays = gap;
+  } else {
+    const lastDistDate = manifest && manifest.last_distribution_at;
+    if (lastDistDate) {
+      const t = Date.parse(lastDistDate);
+      if (Number.isFinite(t)) distGapDays = Math.max(0, Math.floor((now - t) / (24 * 3600 * 1000)));
+    }
+  }
+  const distGapKnown = distGapDays != null;
+  const distScore = distGapKnown ? Math.min(25, distGapDays * 2.5) : 0;
+
+  // 4) Stale review age — unknown (null overdueDays from an unavailable health
+  // scan) contributes 0, not a fabricated "no penalty". [Codex P1, T261]
+  const analyseOverdue = engineHealth && engineHealth.analyseDay && engineHealth.analyseDay.overdueDays != null
+    ? engineHealth.analyseDay.overdueDays
+    : null;
+  const reviewKnown = analyseOverdue != null;
+  const reviewScore = reviewKnown ? Math.min(25, analyseOverdue * 1.5) : 0;
+
+  // 5) Contradictions — phantom-strategy rows where stated != demonstrated.
+  // Codex v3-fidelity report flagged this as the 5th category. Weighted
+  // x5 with clamp 25, so 5+ contradictions = full red on this axis.
+  const phantomCount = clampInt(
+    inputs.phantomCount,
+    0, 5
+  );
+  const contradictionScore = phantomCount * 5;
+
+  // Clamp to 0–100: five 25-pt axes can sum to 125. [Codex IMPORTANT, T261]
+  const value = Math.min(100, Math.round(zombieScore + overrideScore + distScore + reviewScore + contradictionScore));
+
+  const band =
+    value >= 75 ? "crit" :
+    value >= 50 ? "high" :
+    value >= 30 ? "med"  : "low";
+
+  let delta = 0;
+  if (Number.isFinite(yesterdayScore)) {
+    delta = value - yesterdayScore;
+  }
+
+  return {
+    value,
+    delta,
+    band,
+    components: {
+      zombies: zombieScore,
+      overrides: overrideScore,
+      distributionGap: Math.round(distScore),
+      distributionGapKnown: distGapKnown,
+      staleReviewAge: Math.round(reviewScore),
+      staleReviewKnown: reviewKnown,
+      contradictions: contradictionScore,
+    },
+    computedAt: new Date().toISOString(),
+  };
+}
+
+function clampInt(n, lo, hi) {
+  const v = Number.isFinite(n) ? Math.floor(n) : 0;
+  return Math.min(hi, Math.max(lo, v));
+}
+
+module.exports = { compute };

package/src/dashboard/lib/engine-default-fingerprints.json

@@ -0,0 +1,53 @@
+{
+  "_comment": "Known-good hashes of shipped Engine DEFAULTS across versions (CRLF-normalized+trimmed, sha256). engine-writer allows overwriting a non-sentinel file ONLY if its hash matches one of these (a fresh/older install default); a hash NOT here means the user modified it = real data, refuse. Regenerate: node scripts/gen-engine-fingerprints.mjs.",
+  "generated": "git-history",
+  "files": {
+    "Goals.md": [
+      "27abf1d26d51525baa5a3ae9c8cc6f879a723f929334852b7ef9549a5fa11c57",
+      "30f3e24ad7e45bbb2053a0863164357b3e6cf718146540e685462495e38c996c"
+    ],
+    "Mover_Dossier.md": [
+      "c0d6817e390153f834d6a52e8d0e686cb3eb056e6457afecafd5e3abc0c47c49",
+      "21b1ecb65d7c7dbe7be03efa965fefd54f727663e3f0088be66dd453fd244677",
+      "72ca850dfd15972045918fcf0170315da72290a7ca7d034710362ca77e7cd1fa",
+      "e10ace7b0a72d17f342c70d03f015525e7029b13e43eae2c43e8c6ecd14483ee",
+      "bc568ebd12e25377274cf906d0569218c46d1c06e5dc9e857b98e3fdc128b667"
+    ],
+    "Active_Context.md": [
+      "433ef66c852de9a5c37bb65cc40c9d20e577fbcb46ecf91963c8f2d7b23f8a70",
+      "5dec535b04d4c7b11029222812e782a02dcbaea03faaa8979e0adb45bf9698b9",
+      "22b4855fc5f8337b2d1d2f077d12cf709333ea2cc3aa96c7fd1e380ea55ab7fc",
+      "de5b8133f2fd35ad70920bc1c08f2ab75c26edcf58f6b88fccf245a0e729c5aa",
+      "fc6f35e45f7b3934d0ab705b6e259ce195c637019e49381885dab7c963f3ccca",
+      "8eec472e3f451a1d8a121b3a3bd76065137921aa95824666fbb466fec6fb6443",
+      "f0bf0c38418e6c42be46b1546acd676e55aeb64cd1ba31c164dc7047b5ee6807",
+      "25f525f55fb86c638cd67792ef05f46de688e048586a3ccb2d980b8d1a78c7db",
+      "63e7db7db109bdfa78edf5df5d69e0286d614e84aa0165ae372576f6a816602c",
+      "52a8d57d45cafd662e3d106c2acb6fc07116572ca82bc04ff96f7e913ce47395",
+      "d79582e10cb0410554b9a1a669127cc42150805a1207f867edf90ce60f9effa2",
+      "829a755f53600266f60a8daaa9450e8e3516a7b03538eabeed9ff94ef5ec2b1b",
+      "aaa0e5bdac55f53db3bd36db526f841c5e6f62fb7cd8abf7626ff95b68818e14",
+      "4e2b064fe6d2391704a490020be147c507809a1c420da67eac34add5c85b3ebf",
+      "ae47ece41ab9c4dfa12df6e0c9b895de2e44ad1b788bcbc84728f43764a0a90a",
+      "52332d01a067494dc2cd2a5a642d741aa16cf847e49b5e73b744586e167a7faa"
+    ],
+    "Auto_Learnings.md": [
+      "2f02d8724b3283101be1dce7b14e69f478e841d36453ee990ede636cb0daaced",
+      "54fe4b57dd90bed94ef7c5d6af50ef290347afef55081d5c3ec51b4bc3181b60",
+      "a04fe481a5e79eaf0888c0fd71100fbbc709c1d2c8a1145b7d6fa6482d32a144",
+      "0d5bb1ed881384f1559b9fd2702199d28f7e151bd5ec9f9a559b9ece038e88e5",
+      "e1f5361fbd42cbfb655dbe4fd3a8129ec27e5d31c5bbc397615d0eb61c507438",
+      "10d443002d1056d6a939dea23231acaa0a5f01f1b3c6a86b808bb383efd34621",
+      "2ee52d9282a830ef34c52de5d38e78f19710769b1433391dc787fdfed8cf6093"
+    ],
+    "Metrics_Log.md": [
+      "3e3ab4011b65ddf8b435898ee31d136d31fa346cf408a741b6752f6bd9178537",
+      "4f3e7ba572b46cb7cf594640737badb5c2a742e8e2942a53d554ac0e4cddcb69",
+      "a840982311c4ad8300813316926b50a6bc6050b1c45a058ad146b6b695299dbf"
+    ],
+    "Someday_Maybe.md": [
+      "d9d7889a0923059c182d197aa3579a6d4ee78e19d980a7b144652bae7d7715a5",
+      "115ff4539c651ea87184b124a40ea75c874b5122c26d1ecfce3b5657c3d618da"
+    ]
+  }
+}

package/src/dashboard/lib/engine-health.js

@@ -0,0 +1,173 @@
+"use strict";
+
+const {
+  activeContextPath,
+  strategyPath,
+  goalsPath,
+  moverDossierPath,
+  autoLearningsPath,
+  metricsLogPath,
+  voiceDnaPath,
+  identityPrimePath,
+  safeStat,
+  safeRead
+} = require("./paths");
+
+// Compute file staleness traffic lights using thresholds documented in src/hooks/engine-health.sh.
+// Returns array of {file, status: OK|YELLOW|RED, ageDays, label, threshold}.
+// Status uses 'OK' (matches UI types.ts EngineHealthStatus). The shell-side
+// engine-health.sh emits 'GREEN' for terminal output; the JS parser is the
+// source of truth for state.json.
+
+const THRESHOLDS = {
+  Active_Context: { yellow: 3, red: 7 },
+  Strategy: { yellow: 30, red: 60 },
+  Mover_Dossier: { yellow: 60, red: 90 },
+  Auto_Learnings: { yellow: 30, red: 60 },
+  Metrics_Log: { yellow: 14, red: 30 },
+  Voice_DNA: { yellow: 60, red: 90 },
+  Identity_Prime: { yellow: 90, red: 180 },
+  Goals: { yellow: 30, red: 60 }
+};
+
+function ageDays(stat) {
+  if (!stat) return null;
+  const ms = Date.now() - stat.mtime.getTime();
+  return Math.floor(ms / (24 * 60 * 60 * 1000));
+}
+
+function statusFor(age, thresholds) {
+  if (age === null) return { status: "UNKNOWN", label: "missing" };
+  if (age >= thresholds.red) return { status: "RED", label: `${age}d` };
+  if (age >= thresholds.yellow) return { status: "YELLOW", label: `${age}d` };
+  return { status: "OK", label: `${age}d` };
+}
+
+function computeEngineHealth(vault) {
+  const targets = [
+    { key: "Active_Context", path: activeContextPath(vault) },
+    { key: "Strategy", path: strategyPath(vault) },
+    { key: "Identity_Prime", path: identityPrimePath(vault) },
+    { key: "Goals", path: goalsPath(vault) },
+    { key: "Mover_Dossier", path: moverDossierPath(vault) },
+    { key: "Auto_Learnings", path: autoLearningsPath(vault) },
+    { key: "Metrics_Log", path: metricsLogPath(vault) },
+    { key: "Voice_DNA", path: voiceDnaPath(vault) }
+  ];
+
+  const items = targets.map(t => {
+    const stat = safeStat(t.path);
+    const age = ageDays(stat);
+    const thresholds = THRESHOLDS[t.key] || { yellow: 30, red: 90 };
+    const { status, label } = statusFor(age, thresholds);
+    return {
+      file: t.key,
+      path: t.path,
+      exists: !!stat,
+      ageDays: age,
+      status,
+      label,
+      thresholdYellow: thresholds.yellow,
+      thresholdRed: thresholds.red,
+      mtime: stat ? stat.mtime : null
+    };
+  });
+
+  // Workflow-state staleness from Active_Context
+  const acText = safeRead(activeContextPath(vault), "");
+  const wfStaleness = parseWorkflowStateStaleness(acText);
+
+  // Goals expiration check — look for date fields in Goals.md
+  const goalsText = safeRead(goalsPath(vault), "");
+  const expiredGoals = scanForExpiredGoals(goalsText);
+
+  // Summary counts — include workflow staleness in the totals so the Briefing's
+  // Engine Health bar matches Active_Context's stated status. (Codex audit:
+  // "summary red count ignores workflow staleness" — fixed 2026-05-13.)
+  const wfRed = wfStaleness.filter(w => w.status === "RED").length;
+  const wfYellow = wfStaleness.filter(w => w.status === "YELLOW").length;
+  const summary = {
+    red: items.filter(i => i.status === "RED").length + (expiredGoals.length > 0 ? 1 : 0) + wfRed,
+    yellow: items.filter(i => i.status === "YELLOW").length + wfYellow,
+    green: items.filter(i => i.status === "OK").length,
+    unknown: items.filter(i => i.status === "UNKNOWN").length
+  };
+
+  return {
+    available: true,
+    scannedAt: new Date(),
+    items,
+    workflowStaleness: wfStaleness,
+    expiredGoals,
+    summary,
+    overallStatus: summary.red > 0 ? "RED" : summary.yellow > 0 ? "YELLOW" : "OK"
+  };
+}
+
+function parseWorkflowStateStaleness(text) {
+  const out = [];
+  const checks = [
+    { key: "log_last_run", label: "/log", yellow: 2, red: 5 },
+    { key: "analyse_day_last_run", label: "/analyse-day", yellow: 5, red: 10 },
+    { key: "weekly_review_last_run", label: "/review-week", yellow: 14, red: 21 },
+    { key: "monthly_review_last_run", label: "/review-month", yellow: 30, red: 60 },
+    { key: "pivot_strategy_last_run", label: "/pivot-strategy", yellow: 30, red: 60 }
+  ];
+  const now = Date.now();
+  // Prefer the canonical preface field — Active_Context.md uses **key:** YYYY-MM-DD…
+  // in the file preface, with optional plain `key: YYYY-MM-DD` lower in the doc.
+  // The old regex matched the FIRST plain occurrence, which is often a historical
+  // [STALE]/[DRIFT] log line months out of date. Try bold form first, then plain.
+  const firstHeader = text.search(/^## /m);
+  const preface = firstHeader > 0 ? text.slice(0, firstHeader) : text;
+  for (const c of checks) {
+    const boldPreface = preface.match(new RegExp(`\\*\\*${c.key}:?\\*\\*\\s*([\\d\\-T:]+)`, "i"));
+    const plainPreface = preface.match(new RegExp(`(?:^|\\n)${c.key}:\\s*([\\d\\-T:]+)`, "i"));
+    const docBold = text.match(new RegExp(`\\*\\*${c.key}:?\\*\\*\\s*([\\d\\-T:]+)`, "i"));
+    const docPlain = text.match(new RegExp(`(?:^|\\n)${c.key}:\\s*([\\d\\-T:]+)`, "i"));
+    const m = boldPreface || plainPreface || docBold || docPlain;
+    if (!m) {
+      out.push({ ...c, status: "UNKNOWN", ageDays: null });
+      continue;
+    }
+    const dt = new Date(m[1]);
+    if (isNaN(dt.getTime())) {
+      out.push({ ...c, status: "UNKNOWN", ageDays: null });
+      continue;
+    }
+    const age = Math.floor((now - dt.getTime()) / (24 * 60 * 60 * 1000));
+    let status = "OK";
+    if (age >= c.red) status = "RED";
+    else if (age >= c.yellow) status = "YELLOW";
+    out.push({ ...c, status, ageDays: age, lastRun: dt });
+  }
+  return out;
+}
+
+function scanForExpiredGoals(text) {
+  if (!text) return [];
+  const out = [];
+  // T242 bug hunt fix (B#17): old regex `|Date:` alternative matched ANY
+  // line containing `Date:` (Hire Date, Updated Date, etc) anywhere in
+  // Goals.md, including quoted person entries — false-RED expired goals.
+  // Drop the bare `Date:` arm. Require explicit "Target Date" semantics.
+  // Also: require ISO YYYY-MM-DD shape (was `[\d\-]{8,10}` which accepts
+  // `2-3-2026`, `0-0-0`, etc).
+  // Both bold conventions accepted: `**Target Date:** X` AND `**Target
+  // Date**: X` — the colon-outside-bold style made a 6-month-overdue goal
+  // silently invisible to the RED alert (R5-A false-negative twin of B#17).
+  const re = /(?:\*\*Target Date:?\*\*:?|^\s*Target Date:)\s*(\d{4}-\d{2}-\d{2})\b/gim;
+  let m;
+  const now = Date.now();
+  while ((m = re.exec(text)) !== null) {
+    const dt = Date.parse(`${m[1]}T00:00:00Z`);
+    if (!Number.isFinite(dt)) continue;
+    if (dt < now) {
+      const age = Math.floor((now - dt) / (24 * 60 * 60 * 1000));
+      out.push({ targetDate: m[1], expiredDays: age });
+    }
+  }
+  return out;
+}
+
+module.exports = { computeEngineHealth, THRESHOLDS };