mover-os 4.7.7 → 4.7.8

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

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

@@ -0,0 +1,173 @@
+"use strict";
+
+// record-score.js — the journal-calibration gap. What the RECORD says your
+// day was (derived purely from logged signal), vs the self-score you'd give
+// it. The dashboard surfaces the delta so a "felt like a 7" can meet a
+// "logged like a 3" — or the reverse.
+//
+// computeRecordScore({ daily, distribution, strategyProtocol }) reads two
+// honest signals and nothing else:
+//   1. plan-done ratio — daily.today.tasksDone / daily.today.tasksTotal
+//   2. ship/distribution today — distribution.todayCount
+//
+// FALSE-ZERO (binding, T261 discipline): "no tasks logged AND no
+// distribution today" is INSUFFICIENT DATA, not a bad day. It returns
+// { score: null, why: null } — never a fabricated 4. A real 0/N plan with
+// 0 ships is a measured low day and DOES score (low), because the tasks
+// were logged. The distinction is absence-of-record vs record-of-nothing.
+//
+// strategyProtocol is accepted for signature parity with the other parsers
+// build.js wires (and to let the basis string note whether a protocol
+// exists), but it is NOT load-bearing for the number — the score must stay
+// defensible from the two hard signals above.
+
+// ── The 1-10 mapping ──────────────────────────────────────────────────────
+//
+// Two components, then a blend that lets either one carry a day.
+//
+// PLAN component (0..10), only when tasksTotal > 0:
+//   ratio = tasksDone / tasksTotal, clamped to [0,1].
+//   plan = round(ratio * 9) + 1   → 0% maps to 1 (a logged dead day is a 1,
+//                                    not a 0; 0 is reserved for "no record"),
+//                                    100% maps to 10. Linear between.
+//
+// SHIP component (0..10), from distribution.todayCount (a ship/outreach
+//   count — see distribution-parser.js KEYWORDS):
+//   0 ships → 0  (no lift; it cannot, alone, drag a completed plan down —
+//                 see blend)
+//   1 ship  → 6  (you put something into the world; floor of a "real" day)
+//   2 ships → 8
+//   3+ ships→ 10 (capped)
+//   This is deliberately generous: distribution is the scarce, high-leverage
+//   act in this system, so each unit of it is worth a lot.
+//
+// BLEND:
+//   - Both signals present → max(plan, ship). The day is as good as its best
+//     real axis; shipping rescues a thin plan, a full plan rescues a quiet
+//     ship-day. Taking the max (not the mean) avoids punishing a 10/10 plan
+//     for a no-outreach day, and avoids punishing a 3-ship day for a sparse
+//     task list.
+//   - Plan only (ships unknown/absent) → plan.
+//   - Ships only (no tasks logged, but ships happened) → ship, floored at 1
+//     so a logged ship is never a "1-or-below" by rounding.
+//   - Neither → null (false-zero).
+//
+// Final score is clamped to [1,10] and rounded to a whole number — a journal
+// score is a gut integer, not 6.4.
+
+function computeRecordScore({ daily, distribution, strategyProtocol } = {}) {
+  // ── Read the two hard signals, distinguishing absent from zero ──────────
+
+  // Plan: only "logged" when today's note exists AND has a task list.
+  // daily / daily.today may be null (build.js daily mapper, lines ~681-704).
+  const today = daily && daily.today ? daily.today : null;
+  const tasksTotal = today && Number.isFinite(today.tasksTotal) ? today.tasksTotal : 0;
+  const tasksDone = today && Number.isFinite(today.tasksDone) ? today.tasksDone : 0;
+  // A plan only counts as "logged" when there are tasks to grade against.
+  // 0/0 is an empty note — no record — not a 0% day.
+  const planLogged = tasksTotal > 0;
+
+  // Ships: distribution.todayCount is number|null. null = parser couldn't
+  // measure (no Dailies dir / unavailable), which is NOT zero. Only a real
+  // finite number is a measurement. [false-zero — mirrors goal-forecast.js:38]
+  const distAvailable = !!(distribution && distribution.available !== false);
+  const shipsToday = distAvailable && Number.isFinite(distribution.todayCount)
+    ? distribution.todayCount
+    : null;
+  const shipsKnown = shipsToday != null;
+
+  // ── FALSE-ZERO GATE (binding) ───────────────────────────────────────────
+  // No tasks logged AND no distribution measured today → not enough to score.
+  // Never a fabricated middle-of-the-road 4.
+  if (!planLogged && (!shipsKnown || shipsToday === 0)) {
+    // One more split: if ships were *measured* as 0 we still bail (no plan +
+    // 0 ships = nothing recorded happened). If ships are simply unknown, same
+    // outcome. Both are "nothing to grade."
+    return {
+      score: null,
+      why: null,
+      basis: "not enough logged to score today",
+    };
+  }
+
+  // ── Component scores ────────────────────────────────────────────────────
+  let planScore = null;
+  if (planLogged) {
+    const ratio = clamp(tasksDone / tasksTotal, 0, 1);
+    planScore = Math.round(ratio * 9) + 1; // 0%→1, 100%→10
+  }
+
+  let shipScore = null;
+  if (shipsKnown) {
+    shipScore = shipsToday <= 0 ? 0
+      : shipsToday === 1 ? 6
+      : shipsToday === 2 ? 8
+      : 10; // 3+
+  }
+
+  // ── Blend ───────────────────────────────────────────────────────────────
+  let raw;
+  if (planScore != null && shipScore != null) {
+    raw = Math.max(planScore, shipScore);
+  } else if (planScore != null) {
+    raw = planScore;
+  } else {
+    // ships-only path: a logged ship with no task list. Floor at 1 so a
+    // single ship can't round below the "1 = a real but minimal day" baseline
+    // (shipScore for 1 ship is already 6, so this floor only matters
+    // defensively).
+    raw = Math.max(1, shipScore);
+  }
+
+  const score = clamp(Math.round(raw), 1, 10);
+
+  // ── Explain the number in plain language ────────────────────────────────
+  const why = buildWhy({ planLogged, tasksDone, tasksTotal, shipsKnown, shipsToday, planScore, shipScore, score });
+
+  // basis = the provenance string, names which signals were actually used
+  // (and whether a protocol was available for context — not used in math).
+  const parts = [];
+  if (planLogged) parts.push("plan-done ratio");
+  if (shipsKnown) parts.push("distribution today");
+  const protoNote = strategyProtocol && strategyProtocol.available ? " (protocol present)" : "";
+  const basis = parts.length
+    ? `derived from ${parts.join(" + ")}${protoNote}`
+    : "derived from logged signal";
+
+  return { score, why, basis };
+}
+
+// ── helpers ─────────────────────────────────────────────────────────────────
+
+function clamp(n, min, max) {
+  if (!Number.isFinite(n)) return min;
+  return Math.min(max, Math.max(min, n));
+}
+
+function buildWhy({ planLogged, tasksDone, tasksTotal, shipsKnown, shipsToday, planScore, shipScore, score }) {
+  const bits = [];
+  if (planLogged) {
+    const pct = Math.round((clamp(tasksDone / tasksTotal, 0, 1)) * 100);
+    bits.push(`${tasksDone}/${tasksTotal} plan tasks done (${pct}%)`);
+  }
+  if (shipsKnown) {
+    const n = shipsToday;
+    bits.push(n === 0 ? "no distribution logged today" : `${n} ship${n === 1 ? "" : "s"} logged today`);
+  }
+
+  // Name the carrier when blending, so the user sees WHY it landed where it did.
+  // Only claim something "carried" the day when it actually beat the other axis
+  // by enough to matter; ties (incl. a low/low dead day) just say they agree.
+  let carrier = "";
+  if (planScore != null && shipScore != null) {
+    if (shipScore > planScore) carrier = ". Shipping carried the day over a thin plan";
+    else if (planScore > shipScore) carrier = ". Plan completion carried it over a quiet ship-day";
+    else carrier = ". Plan and shipping agree";
+  }
+
+  // "an 8/10" — article matches the score's spoken vowel sound (8/11/18), else "a".
+  const art = /^(8|11|18)/.test(String(score)) ? "an" : "a";
+  return `Record scores today ${art} ${score}/10: ${bits.join(", ")}${carrier}. Compare against how the day felt.`;
+}
+
+module.exports = { computeRecordScore };

package/src/dashboard/lib/redaction.js

@@ -0,0 +1,140 @@
+"use strict";
+
+// redaction.js — Privacy-first scrubber for Public Proof share cards.
+// Allowlist-based: anything NOT explicitly allowed is redacted.
+// Default redaction set covers personal goals, faith, weight, money,
+// named people, project names, dates. Per ui-ux-audit: "redaction must
+// feel trustworthy, not paranoid." Pure function — takes content +
+// settings, returns redacted content + per-field provenance.
+
+const DEFAULT_REDACTIONS = {
+  names: true,
+  faith: true,
+  weight: true,
+  money: true,
+  projectNames: true,
+  exactDates: false,
+  fileNames: true,
+};
+
+// Patterns that match commonly sensitive content. Each one returns a
+// redacted replacement keeping the structure of the original visible.
+const PATTERNS = {
+  // Personal names — capitalized two-word sequences. Best-effort heuristic.
+  names: {
+    re: /\b([A-Z][a-z]+) ([A-Z][a-z]+)\b/g,
+    replace: () => "[NAME]",
+  },
+  // Common faith markers
+  faith: {
+    re: /\b(Fajr|Dhuhr|Asr|Maghrib|Isha|Tahajjud|Quran|Hadith|Allah|Iman|Salah|Wudu)\b/gi,
+    replace: () => "[FAITH]",
+  },
+  // Weight references (kg/lb with numbers)
+  weight: {
+    re: /\b(\d{2,3})\s*(kg|kilos?|lbs?|pounds?)\b/gi,
+    replace: () => "[WEIGHT]",
+  },
+  // Money — $, £, €, ¥ with numbers, or "X dollars/pounds"
+  money: {
+    re: /(?:[$£€¥]\s?\d[\d,.]*\b|\b\d[\d,.]*\s*(?:dollars?|pounds?|euros?|GBP|USD|EUR)\b)/gi,
+    replace: () => "[MONEY]",
+  },
+  // Project names — anything in `01_Projects/Foo/`
+  projectNames: {
+    re: /01_Projects\/([^/\s)]+)/g,
+    replace: () => "01_Projects/[PROJECT]",
+  },
+  // Exact dates YYYY-MM-DD
+  exactDates: {
+    re: /\b20\d{2}-[01]\d-[0-3]\d\b/g,
+    replace: () => "[DATE]",
+  },
+  // File names with extensions
+  fileNames: {
+    re: /\b([A-Za-z0-9_-]{2,40})\.(md|txt|js|ts|tsx|jsx|json|yaml|toml|sh)\b/g,
+    replace: (_m, base) => `[FILE].${_m.split('.').pop()}`,
+  },
+};
+
+// Apply redactions to a string. Returns { text, replacements: { kind: count } }.
+function redactText(text, settings = {}) {
+  const cfg = Object.assign({}, DEFAULT_REDACTIONS, settings);
+  if (!text || typeof text !== "string") return { text: text || "", replacements: {} };
+  let out = text;
+  const replacements = {};
+  for (const [key, pat] of Object.entries(PATTERNS)) {
+    if (!cfg[key]) continue;
+    let count = 0;
+    out = out.replace(pat.re, (...args) => {
+      count++;
+      return pat.replace(...args);
+    });
+    if (count > 0) replacements[key] = count;
+  }
+  return { text: out, replacements };
+}
+
+// Redact a Phantom share card payload — strips names from stated/demonstrated
+// while preserving severity + source counts.
+function redactPhantomCard(card, settings = {}) {
+  const stated = redactText(card.stated || "", settings);
+  const demonstrated = redactText(card.demonstrated || "", settings);
+  return {
+    ...card,
+    stated: stated.text,
+    demonstrated: demonstrated.text,
+    evidence: card.evidence
+      ? {
+          ...card.evidence,
+          sources: (card.evidence.sources || []).map((s) => ({
+            ...s,
+            file: redactText(s.file || "", settings).text,
+            quote: redactText(s.quote || "", settings).text,
+          })),
+        }
+      : undefined,
+    redactionReplacements: {
+      stated: stated.replacements,
+      demonstrated: demonstrated.replacements,
+    },
+  };
+}
+
+// Redact a full Wrapped/share data payload for export.
+function redactWrappedPayload(payload, settings = {}) {
+  if (!payload || typeof payload !== "object") return payload;
+  const out = JSON.parse(JSON.stringify(payload));
+  walk(out, settings);
+  return out;
+}
+
+function walk(node, settings) {
+  if (!node) return;
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      if (typeof node[i] === "string") {
+        node[i] = redactText(node[i], settings).text;
+      } else {
+        walk(node[i], settings);
+      }
+    }
+    return;
+  }
+  if (typeof node === "object") {
+    for (const k of Object.keys(node)) {
+      if (typeof node[k] === "string") {
+        node[k] = redactText(node[k], settings).text;
+      } else {
+        walk(node[k], settings);
+      }
+    }
+  }
+}
+
+module.exports = {
+  DEFAULT_REDACTIONS,
+  redactText,
+  redactPhantomCard,
+  redactWrappedPayload,
+};