mover-os 4.7.6 → 4.7.8

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

@@ -0,0 +1,83 @@
+"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 HISTORY_PATH = path.join(os.homedir(), ".mover", "drift-history.json");
+const MAX_DAYS = 90;
+
+function todayKey() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+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-health.js

@@ -0,0 +1,170 @@
+"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).
+  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 };