mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/paths.js

@@ -0,0 +1,192 @@
+"use strict";
+
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+
+function moverDir() {
+  return path.join(os.homedir(), ".mover");
+}
+
+function moverConfigPath() {
+  return path.join(moverDir(), "config.json");
+}
+
+function moverPatternManifestPath() {
+  return path.join(moverDir(), "pattern-manifest.json");
+}
+
+function dashboardOutDir() {
+  return path.join(moverDir(), "dashboard");
+}
+
+function dashboardIndexPath() {
+  return path.join(dashboardOutDir(), "index.html");
+}
+
+function dashboardBuildLogPath() {
+  return path.join(dashboardOutDir(), "build.log");
+}
+
+function dashboardSnoozesPath() {
+  return path.join(dashboardOutDir(), "snoozes.json");
+}
+
+// Vault-relative paths (caller passes vault root)
+function engineDir(vault) { return path.join(vault, "02_Areas", "Engine"); }
+
+function engineFile(vault, name) { return path.join(engineDir(vault), name); }
+
+function dailiesDir(vault) { return path.join(engineDir(vault), "Dailies"); }
+
+function weeklyReviewsDir(vault) { return path.join(engineDir(vault), "Weekly Reviews"); }
+
+function projectsDir(vault) { return path.join(vault, "01_Projects"); }
+
+function libraryDir(vault) { return path.join(vault, "03_Library"); }
+
+function inboxDir(vault) { return path.join(vault, "00_Inbox"); }
+
+function archivesDir(vault) { return path.join(vault, "04_Archives"); }
+
+// Engine file shortcuts
+function activeContextPath(vault) { return engineFile(vault, "Active_Context.md"); }
+function strategyPath(vault) { return engineFile(vault, "Strategy.md"); }
+function identityPrimePath(vault) { return engineFile(vault, "Identity_Prime.md"); }
+function goalsPath(vault) { return engineFile(vault, "Goals.md"); }
+function autoLearningsPath(vault) { return engineFile(vault, "Auto_Learnings.md"); }
+// Dossier filename varies by user: Mover_Dossier.md (default), Architect_Dossier.md, Red_Team_Dossier.md.
+// Returns the first existing file from candidate list, or default if none exist.
+function moverDossierPath(vault) {
+  const candidates = ["Mover_Dossier.md", "Architect_Dossier.md", "Red_Team_Dossier.md"];
+  for (const name of candidates) {
+    const p = engineFile(vault, name);
+    try { if (fs.existsSync(p)) return p; } catch (_) {}
+  }
+  return engineFile(vault, candidates[0]);
+}
+function voiceDnaPath(vault) { return engineFile(vault, "Voice_DNA.md"); }
+function metricsLogPath(vault) { return engineFile(vault, "Metrics_Log.md"); }
+function healthAnalysisPath(vault) { return engineFile(vault, "Health_Analysis_Full.md"); }
+
+// Daily note resolver — supports YYYY-MM/Daily - YYYY-MM-DD.md format
+function dailyNotePath(vault, date) {
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  return path.join(dailiesDir(vault), `${yyyy}-${mm}`, `Daily - ${yyyy}-${mm}-${dd}.md`);
+}
+
+// Library subdirs
+function libraryCheatsheetsDir(vault) { return path.join(libraryDir(vault), "Cheatsheets"); }
+function libraryPrinciplesDir(vault) { return path.join(libraryDir(vault), "Principles"); }
+function librarySopsDir(vault) { return path.join(libraryDir(vault), "SOPs"); }
+function libraryEntitiesDir(vault) { return path.join(libraryDir(vault), "Entities"); }
+function libraryEntitiesPeopleDir(vault) { return path.join(libraryEntitiesDir(vault), "People"); }
+function libraryEntitiesOrgsDir(vault) { return path.join(libraryEntitiesDir(vault), "Organizations"); }
+function libraryEntitiesPlacesDir(vault) { return path.join(libraryEntitiesDir(vault), "Places"); }
+function libraryEntitiesDecisionsDir(vault) { return path.join(libraryEntitiesDir(vault), "Decisions"); }
+function libraryInputsDir(vault) { return path.join(libraryDir(vault), "Inputs"); }
+function libraryScriptsDir(vault) { return path.join(libraryDir(vault), "Scripts"); }
+function libraryMocsDir(vault) { return path.join(libraryDir(vault), "MOCs"); }
+
+function exists(p) {
+  try { fs.accessSync(p); return true; } catch { return false; }
+}
+
+// Resolve the vault root with NO hardcoded/PII path (so lib CLI entrypoints never ship a machine
+// path): env MOVER_VAULT → ~/.mover/config.json vaultPath → walk up from cwd for 02_Areas/Engine → cwd.
+function resolveVault() {
+  const hasEngine = (v) => { try { return !!v && fs.existsSync(path.join(v, "02_Areas", "Engine")); } catch { return false; } };
+  if (hasEngine(process.env.MOVER_VAULT)) return process.env.MOVER_VAULT;
+  let cfg = {}; try { cfg = JSON.parse(fs.readFileSync(moverConfigPath(), "utf8")) || {}; } catch {}
+  if (hasEngine(cfg.vaultPath)) return cfg.vaultPath;
+  let dir = process.cwd();
+  for (let i = 0; i < 8; i++) {
+    if (hasEngine(dir)) return dir;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return process.env.MOVER_VAULT || cfg.vaultPath || process.cwd();
+}
+
+function safeRead(p, fallback = null) {
+  try { return fs.readFileSync(p, "utf8"); } catch { return fallback; }
+}
+
+function safeReadJson(p, fallback = null) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return fallback; }
+}
+
+function safeStat(p) {
+  try { return fs.statSync(p); } catch { return null; }
+}
+
+function safeListDir(p, options = {}) {
+  try {
+    let entries = fs.readdirSync(p, { withFileTypes: true });
+    if (options.dirsOnly) entries = entries.filter(e => e.isDirectory());
+    if (options.filesOnly) entries = entries.filter(e => e.isFile());
+    if (options.extension) entries = entries.filter(e => e.isFile() && e.name.endsWith(options.extension));
+    if (options.skipUnderscore) entries = entries.filter(e => !e.name.startsWith("_") && !e.name.startsWith("."));
+    return entries.map(e => ({
+      name: e.name,
+      path: path.join(p, e.name),
+      isDir: e.isDirectory(),
+      isFile: e.isFile()
+    }));
+  } catch {
+    return [];
+  }
+}
+
+module.exports = {
+  // Mover dirs
+  moverDir,
+  moverConfigPath,
+  moverPatternManifestPath,
+  dashboardOutDir,
+  dashboardIndexPath,
+  dashboardBuildLogPath,
+  dashboardSnoozesPath,
+  // Vault dirs
+  engineDir,
+  engineFile,
+  dailiesDir,
+  weeklyReviewsDir,
+  projectsDir,
+  libraryDir,
+  inboxDir,
+  archivesDir,
+  // Engine files
+  activeContextPath,
+  strategyPath,
+  identityPrimePath,
+  goalsPath,
+  autoLearningsPath,
+  moverDossierPath,
+  voiceDnaPath,
+  metricsLogPath,
+  healthAnalysisPath,
+  dailyNotePath,
+  // Library
+  libraryCheatsheetsDir,
+  libraryPrinciplesDir,
+  librarySopsDir,
+  libraryEntitiesDir,
+  libraryEntitiesPeopleDir,
+  libraryEntitiesOrgsDir,
+  libraryEntitiesPlacesDir,
+  libraryEntitiesDecisionsDir,
+  libraryInputsDir,
+  libraryScriptsDir,
+  libraryMocsDir,
+  // Helpers
+  resolveVault,
+  exists,
+  safeRead,
+  safeReadJson,
+  safeStat,
+  safeListDir
+};

package/src/dashboard/lib/pattern-manifest-loader.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const { moverPatternManifestPath, safeReadJson, safeStat } = require("./paths");
+
+// Fast-path read of ~/.mover/pattern-manifest.json. Returns {available, manifest, lastUpdated}.
+
+function loadPatternManifest() {
+  const filePath = moverPatternManifestPath();
+  const stat = safeStat(filePath);
+  const data = safeReadJson(filePath);
+  if (!data) return { available: false, filePath, error: "pattern-manifest.json not found" };
+
+  return {
+    available: true,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    manifest: data,
+    singleTest: data.single_test || null,
+    sacrifice: data.sacrifice || null,
+    frictionLevel: data.friction_level || "L0",
+    zombieCount: data.zombie_count || 0,
+    zombieTasks: Array.isArray(data.zombie_tasks) ? data.zombie_tasks : [],
+    activePatterns: Array.isArray(data.active_patterns) ? data.active_patterns : [],
+    banKeywords: Array.isArray(data.ban_keywords) ? data.ban_keywords : [],
+    overrideHistory: Array.isArray(data.override_history) ? data.override_history : []
+  };
+}
+
+module.exports = { loadPatternManifest };

package/src/dashboard/lib/phantom-strategy.js

@@ -0,0 +1,129 @@
+"use strict";
+
+// phantom-strategy.js — Comparator between STATED strategy (Strategy.md
+// sacrifice + Single Test) and DEMONSTRATED behavior (manifest overrides
+// + Auto_Learnings patterns + recent session deviations).
+//
+// Returns ranked PhantomRow[] with severity-encoded mismatches and source
+// citations. Pure function: takes parsed inputs, returns array.
+
+function compute({ strategy = null, autoLearnings = null, manifest = null, dailyHistory = null } = {}) {
+  const rows = [];
+  const now = Date.now();
+  const weekMs = 7 * 24 * 3600 * 1000;
+  const monthMs = 30 * 24 * 3600 * 1000;
+
+  // Helper: count recent override entries that touch a particular text fragment.
+  const overrides = (manifest && (manifest.overrideHistory || manifest.override_history)) || [];
+  function recentOverridesMatching(stated, sinceMs) {
+    const fragment = stated.slice(0, 24).toLowerCase();
+    return overrides.filter((o) => {
+      const t = Date.parse(o.date || o.timestamp || "");
+      if (!Number.isFinite(t) || now - t > sinceMs) return false;
+      const haystack = ((o.reason || "") + " " + (o.what || "") + " " + (o.plan_item || "")).toLowerCase();
+      return haystack.includes(fragment);
+    });
+  }
+
+  function getAutoLearningPattern(...keywords) {
+    if (!autoLearnings || !autoLearnings.activePatternsConf3Plus) return null;
+    const lower = keywords.map((k) => k.toLowerCase());
+    return autoLearnings.activePatternsConf3Plus.find((p) => {
+      const desc = ((p.description || p.text || "") + " " + (p.id || "")).toLowerCase();
+      return lower.some((k) => desc.includes(k));
+    });
+  }
+
+  function pushRow(id, stated, demonstrated, severity, sources, evidence = {}) {
+    rows.push({
+      id,
+      stated: String(stated).slice(0, 200),
+      demonstrated: String(demonstrated).slice(0, 200),
+      severity,
+      evidence: {
+        sessions: evidence.sessions || 0,
+        distGap: evidence.distGap || 0,
+        sources: sources || []
+      }
+    });
+  }
+
+  // 1) Single Test mismatch
+  const singleTest = (manifest && manifest.singleTest) || (strategy && strategy.singleTest);
+  if (singleTest) {
+    const distPattern = getAutoLearningPattern("distribution", "polish", "system architecture", "spree");
+    const matches = recentOverridesMatching(singleTest, monthMs);
+    const severity = distPattern ? "high" : matches.length > 0 ? "med" : "low";
+    pushRow(
+      "single-test",
+      singleTest,
+      distPattern
+        ? `Pattern detected: ${distPattern.description || distPattern.text || "behavioral drift"}`
+        : matches.length > 0
+        ? `Overridden ${matches.length}× in last 30 days`
+        : "Holding (no logged override).",
+      severity,
+      [
+        ...(distPattern
+          ? [{ file: "Auto_Learnings.md", line: "active_patterns", quote: distPattern.description || "", age: "live" }]
+          : []),
+        ...matches.slice(0, 3).map((m) => ({
+          file: "pattern-manifest.json",
+          line: "override_history",
+          quote: m.reason || m.what || "—",
+          age: m.date || "recent"
+        }))
+      ],
+      { sessions: matches.length }
+    );
+  }
+
+  // 2) Sacrifice rules
+  const sacrifices = manifest && manifest.sacrifice
+    ? (Array.isArray(manifest.sacrifice) ? manifest.sacrifice : [manifest.sacrifice])
+    : strategy && strategy.sacrifice
+    ? (Array.isArray(strategy.sacrifice) ? strategy.sacrifice : [strategy.sacrifice])
+    : [];
+
+  sacrifices.slice(0, 3).forEach((s, i) => {
+    const matches = recentOverridesMatching(s, weekMs);
+    const severity = matches.length >= 2 ? "high" : matches.length === 1 ? "med" : "low";
+    pushRow(
+      `sacrifice-${i}`,
+      s,
+      matches.length > 0
+        ? `Broken ${matches.length}× in last 7 days`
+        : "Holding (no override this week).",
+      severity,
+      matches.slice(0, 2).map((m) => ({
+        file: "pattern-manifest.json",
+        line: "override_history",
+        quote: m.reason || m.what || "—",
+        age: m.date || "recent"
+      })),
+      { sessions: matches.length }
+    );
+  });
+
+  // 3) Weekly Review hygiene (if Strategy says weekly but it's been >7d)
+  if (strategy && strategy.fields && /weekly|friday|review/i.test(JSON.stringify(strategy.fields))) {
+    // If we had analyseDay overdue in inputs, we'd surface that too. For now,
+    // skip unless we can wire engineHealth in.
+  }
+
+  // 4) Distribution-related patterns from Auto_Learnings (catch what Strategy doesn't name)
+  const distPattern = getAutoLearningPattern("system architecture spree");
+  if (distPattern && !rows.some((r) => r.id === "single-test" && r.severity === "high")) {
+    pushRow(
+      "system-spree",
+      "Distribution work over system polish.",
+      distPattern.description || distPattern.text || "System Architecture Spree pattern active.",
+      distPattern.confidence >= 4 ? "high" : "med",
+      [{ file: "Auto_Learnings.md", line: `pattern:${distPattern.id || "spree"}`, quote: distPattern.description || "", age: `conf ${distPattern.confidence || "?"}` }]
+    );
+  }
+
+  return rows.slice(0, 6); // cap at 6 for UI density
+}
+
+module.exports = { compute };

package/src/dashboard/lib/pid-markers.js

@@ -0,0 +1,80 @@
+"use strict";
+
+/**
+ * pid-markers.js — crash-orphan bookkeeping shared by AgentSessionManager
+ * (Chat/onboarding) and RunRegistry (Run tab).
+ *
+ * Every dashboard-spawned agent child is detached into its own process group
+ * and recorded here as one marker file per pid, tagged with the owning
+ * dashboard's pid. On startup each manager reaps any group whose OWNER is
+ * gone — children escaped by a crashed dashboard (kill -9, OOM, update crash)
+ * that no graceful shutdown path could ever reach.
+ *
+ * Extracted verbatim from agent-session.js (MF2, Codex r2 hardening) so the
+ * Run tab gets the same guarantee. One file per pid: no shared-file
+ * read-modify-write race across concurrent dashboards; a corrupt write only
+ * loses its own marker. Writes are atomic (tmp + rename). Both managers share
+ * ONE directory on purpose: whichever starts first reaps the other's orphans.
+ */
+
+const os = require("os");
+const path = require("path");
+const fs = require("fs");
+
+const MARKERS_DIR = path.join(os.homedir(), ".mover", "dashboard", "agent-pids");
+
+function markerPath(pid) { return path.join(MARKERS_DIR, String(pid) + ".json"); }
+
+function writeMarker(pid, data) {
+  try {
+    fs.mkdirSync(MARKERS_DIR, { recursive: true });
+    const f = markerPath(pid), tmp = f + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(data));
+    fs.renameSync(tmp, f); // atomic: a reader never sees a half-written marker
+  } catch (_) {}
+}
+
+function removeMarker(pid) { try { fs.unlinkSync(markerPath(pid)); } catch (_) {} }
+
+function readMarkers() {
+  let files; try { files = fs.readdirSync(MARKERS_DIR); } catch (_) { return []; }
+  const out = [];
+  for (const fn of files) {
+    if (!fn.endsWith(".json")) continue;
+    try { out.push(JSON.parse(fs.readFileSync(path.join(MARKERS_DIR, fn), "utf8"))); } catch (_) {}
+  }
+  return out;
+}
+
+function isAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch (e) { return e && e.code === "EPERM"; }
+}
+
+// True if ANY member of the process group still exists (not just the leader) —
+// process.kill(-pid, 0) throws ESRCH only when the whole group is gone.
+function groupAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(-pid, 0); return true; } catch (e) { return e && e.code === "EPERM"; }
+}
+
+function killGroup(pid, sig) {
+  if (!pid) return false;
+  try { process.kill(-pid, sig); return true; }
+  catch (_) { try { process.kill(pid, sig); return true; } catch (__) { return false; } }
+}
+
+// Reap any recorded group whose owning dashboard is gone. Idempotent; safe to
+// call from every manager's constructor (they share the directory).
+function reapOrphans() {
+  for (const m of readMarkers()) {
+    if (!m || !m.pid) continue;
+    // Keep markers whose owning dashboard is still alive (this process OR a
+    // concurrent one). Only a marker whose owner is GONE is a real orphan.
+    if (m.ownerPid && isAlive(m.ownerPid)) continue;
+    if (groupAlive(m.pid)) killGroup(m.pid, "SIGKILL"); // owner gone → orphaned group
+    removeMarker(m.pid);
+  }
+}
+
+module.exports = { MARKERS_DIR, writeMarker, removeMarker, readMarkers, isAlive, groupAlive, killGroup, reapOrphans };

package/src/dashboard/lib/project-scanner.js

@@ -0,0 +1,121 @@
+"use strict";
+
+const path = require("path");
+const { projectsDir, safeListDir, safeRead, safeStat, exists } = require("./paths");
+
+// Scan 01_Projects/* for active projects. Returns {available, projects: [...]}.
+// Each project has plan task counts, recent project_state.md excerpt, lastModified.
+
+function scanProjects(vault, options = {}) {
+  const dir = projectsDir(vault);
+  const entries = safeListDir(dir, { dirsOnly: true, skipUnderscore: true });
+  const limit = options.limit || 12;
+
+  const projects = [];
+  for (const entry of entries) {
+    const projectPath = entry.path;
+    const planMd = exists(path.join(projectPath, "dev", "plan.md"))
+      ? path.join(projectPath, "dev", "plan.md")
+      : (exists(path.join(projectPath, "plan.md")) ? path.join(projectPath, "plan.md") : null);
+    const stateMd = exists(path.join(projectPath, "dev", "project_state.md"))
+      ? path.join(projectPath, "dev", "project_state.md")
+      : (exists(path.join(projectPath, "project_state.md")) ? path.join(projectPath, "project_state.md") : null);
+    const briefMd = exists(path.join(projectPath, "dev", "project_brief.md"))
+      ? path.join(projectPath, "dev", "project_brief.md")
+      : (exists(path.join(projectPath, "project_brief.md")) ? path.join(projectPath, "project_brief.md") : null);
+
+    const project = {
+      name: entry.name,
+      path: projectPath,
+      planPath: planMd,
+      statePath: stateMd,
+      briefPath: briefMd,
+      hasPlanMd: !!planMd,
+      hasStateMd: !!stateMd
+    };
+
+    const stat = safeStat(projectPath);
+    project.lastModified = stat ? stat.mtime : null;
+
+    if (planMd) {
+      const planText = safeRead(planMd, "");
+      const tasks = parseTasks(planText);
+      project.totalTasks = tasks.total;
+      project.doneTasks = tasks.done;
+      project.unverifiedTasks = tasks.unverified;
+      project.openTasks = tasks.open;
+      project.zombieTasks = tasks.zombieCount;
+      project.recentExecutionLog = extractRecentExecutionLog(planText, 3);
+    }
+
+    if (stateMd) {
+      const stateText = safeRead(stateMd, "");
+      project.stateExcerpt = extractFirstParagraph(stateText);
+    }
+
+    projects.push(project);
+  }
+
+  projects.sort((a, b) => {
+    const aT = a.lastModified ? a.lastModified.getTime() : 0;
+    const bT = b.lastModified ? b.lastModified.getTime() : 0;
+    return bT - aT;
+  });
+
+  // activeCount = folders touched inside the dashboard's 30-day evidence
+  // window. totalCount counts every folder ever (incl. one-off errands), which
+  // reads as a lie next to "tests that earned real time".
+  const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+  const activeCount = projects.filter((p) => p.lastModified && p.lastModified.getTime() >= cutoff).length;
+  return { available: true, projects: projects.slice(0, limit), totalCount: projects.length, activeCount };
+}
+
+function parseTasks(text) {
+  const lines = text.split("\n");
+  let total = 0, done = 0, unverified = 0, open = 0, zombieCount = 0;
+  for (const line of lines) {
+    const m = line.match(/^\s*[-*]\s*\[([ xX~])\]/);
+    if (!m) continue;
+    total++;
+    if (m[1] === "x" || m[1] === "X") done++;
+    else if (m[1] === "~") unverified++;
+    else open++;
+    if (/\[ZOMBIE\]/i.test(line)) zombieCount++;
+  }
+  return { total, done, unverified, open, zombieCount };
+}
+
+function extractFirstParagraph(text) {
+  if (!text) return null;
+  const lines = text.split("\n");
+  let collecting = false;
+  let buf = [];
+  for (const line of lines) {
+    if (/^#\s+/.test(line)) continue;
+    if (line.trim() === "") {
+      if (collecting) break;
+      continue;
+    }
+    if (/^[-*]\s+/.test(line)) continue;
+    collecting = true;
+    buf.push(line.trim());
+    if (buf.join(" ").length > 280) break;
+  }
+  return buf.join(" ").slice(0, 280);
+}
+
+function extractRecentExecutionLog(text, count) {
+  const lines = text.split("\n");
+  const idx = lines.findIndex(l => /^##\s*EXECUTION LOG/i.test(l));
+  if (idx === -1) return [];
+  const after = lines.slice(idx + 1);
+  const items = [];
+  for (const line of after) {
+    if (/^##\s+/.test(line)) break;
+    const m = line.match(/^[-*]\s+\[?(\d{4}-\d{2}-\d{2})\]?\s*(.+)$/);
+    if (m) items.push({ date: m[1], text: m[2].trim() });
+  }
+  return items.slice(-count).reverse();
+}
+
+module.exports = { scanProjects };

package/src/dashboard/lib/promise-wall.js

@@ -0,0 +1,88 @@
+"use strict";
+
+// promise-wall.js — Aggregator for Promise Wall module.
+// Pulls from Active_Context COMMITMENTS (S8.5) + WAITING FOR (S3.5) +
+// Daily Notes commitments. Classifies by recipient + age. Pure function:
+// takes already-parsed inputs and returns structured promise data.
+
+function compute({ activeContext = null, dailyNoteHistory = [] }) {
+  const out = {
+    commitments: [],
+    waitingFor: [],
+    byRecipient: {},
+    overdue: [],
+    upcoming: [],
+    fulfilled: [],
+    stats: { total: 0, overdue: 0, dueSoon: 0, openWeekPlus: 0 }
+  };
+
+  if (!activeContext || !activeContext.available) return out;
+
+  const now = Date.now();
+  const dayMs = 24 * 3600 * 1000;
+
+  // Outbound commitments (things YOU promised to others)
+  (activeContext.commitments || []).forEach((c) => {
+    const entry = {
+      kind: "commitment",
+      text: c.text || c.what || "",
+      to: c.to || c.recipient || "—",
+      due: c.due || c.dueBy || null,
+      added: c.added || c.created || null,
+      ageDays: c.added ? Math.max(0, Math.floor((now - Date.parse(c.added)) / dayMs)) : 0,
+    };
+    entry.status = classifyStatus(entry, now);
+    out.commitments.push(entry);
+    bucketByRecipient(out.byRecipient, entry);
+    if (entry.status === "overdue") out.overdue.push(entry);
+    if (entry.status === "due-soon") out.upcoming.push(entry);
+  });
+
+  // Inbound waiting-for (things you're owed)
+  (activeContext.waitingFor || []).forEach((w) => {
+    const entry = {
+      kind: "waiting-for",
+      text: w.text || w.what || "",
+      from: w.from || w.who || "—",
+      expected: w.expected || w.expectedBy || null,
+      added: w.added || w.created || null,
+      ageDays: w.added ? Math.max(0, Math.floor((now - Date.parse(w.added)) / dayMs)) : 0,
+    };
+    entry.status = classifyStatus(entry, now);
+    out.waitingFor.push(entry);
+    bucketByRecipient(out.byRecipient, entry);
+    if (entry.status === "overdue") out.overdue.push(entry);
+    if (entry.status === "due-soon") out.upcoming.push(entry);
+  });
+
+  out.stats.total = out.commitments.length + out.waitingFor.length;
+  out.stats.overdue = out.overdue.length;
+  out.stats.dueSoon = out.upcoming.length;
+  out.stats.openWeekPlus = [...out.commitments, ...out.waitingFor].filter(e => e.ageDays >= 7).length;
+
+  return out;
+}
+
+function classifyStatus(entry, now) {
+  const dueRef = entry.due || entry.expected;
+  if (!dueRef) {
+    // Untimed — judge by age only.
+    if (entry.ageDays >= 14) return "overdue";
+    if (entry.ageDays >= 7) return "due-soon";
+    return "open";
+  }
+  const dueT = Date.parse(dueRef);
+  if (!Number.isFinite(dueT)) return "open";
+  const daysOut = Math.floor((dueT - now) / (24 * 3600 * 1000));
+  if (daysOut < 0) return "overdue";
+  if (daysOut <= 2) return "due-soon";
+  return "open";
+}
+
+function bucketByRecipient(bucket, entry) {
+  const key = entry.to || entry.from || "—";
+  if (!bucket[key]) bucket[key] = [];
+  bucket[key].push(entry);
+}
+
+module.exports = { compute };