mover-os 4.7.7 → 4.7.9

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

package/src/dashboard/lib/refusal-parser.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+// refusal-parser.js — F38. Reads ~/.mover/refusals.jsonl appended by the
+// friction-enforcer skill. Each line: { ts, message, level, accepted }.
+// Used for the "AI refused me N times this week" share artifact + StatsStrip tile.
+
+function compute({ daysLookback = 30 } = {}) {
+  const p = path.join(os.homedir(), ".mover", "refusals.jsonl");
+  if (!fs.existsSync(p)) return { available: false, count: 0, count7d: 0, recent: [] };
+  let lines;
+  try {
+    lines = fs.readFileSync(p, "utf8").split("\n").filter(Boolean);
+  } catch (_) {
+    return { available: false, count: 0, count7d: 0, recent: [] };
+  }
+  const now = Date.now();
+  const dayMs = 24 * 3600 * 1000;
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const j = JSON.parse(line);
+      const ts = j.ts ? Date.parse(j.ts) : null;
+      if (ts && Number.isFinite(ts)) {
+        const ageDays = (now - ts) / dayMs;
+        if (ageDays <= daysLookback) entries.push({ ts: j.ts, level: j.level || 1, message: j.message || '', accepted: !!j.accepted, ageDays });
+      }
+    } catch (_) { /* skip malformed lines */ }
+  }
+  const count7d = entries.filter(e => e.ageDays <= 7).length;
+  const count30d = entries.length;
+  return {
+    available: true,
+    count: count30d,
+    count7d,
+    delta7d: count7d - entries.filter(e => e.ageDays > 7 && e.ageDays <= 14).length,
+    recent: entries.slice(-10).reverse()
+  };
+}
+
+module.exports = { compute };

package/src/dashboard/lib/regenerate-manifest.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+"use strict";
+
+// regenerate-manifest.js — V5 Phase 41.0.8.
+//
+// Auto-regenerates ~/.mover/pattern-manifest.json after /pivot-strategy
+// writes a new Strategy.md. Without this step, the session-start hook
+// + dashboard hero continue to inject the V3 cached strings until the
+// next manual `moveros doctor --rebuild-manifest` (which doesn't exist).
+//
+// Usage:
+//   node regenerate-manifest.js [vaultPath]
+//
+// Vault path defaults to:
+//   - first argv
+//   - ~/.mover/config.json vaultPath
+//   - walks up from cwd looking for 02_Areas/Engine/
+//
+// Preserves these fields from the existing manifest (append-only):
+//   override_history, recent_wins, active_patterns (if newer than file mtime),
+//   zombie_tasks (the workflow updates these via a different path)
+//
+// Re-derived from Strategy.md:
+//   single_test, single_test_status, single_test_deadline, sacrifice,
+//   sacrifice_status, friction_level, friction_level_reason
+//
+// Safe to call from /pivot-strategy workflow Bash step. Best-effort —
+// failures print to stderr but exit 1 only on truly fatal errors
+// (no Strategy.md found, no vault path resolvable).
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function resolveVaultPath(argv) {
+  if (argv && argv.length > 2) {
+    const p = argv[2];
+    if (fs.existsSync(path.join(p, "02_Areas", "Engine"))) return p;
+  }
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+  if (fs.existsSync(cfgPath)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+      if (cfg.vaultPath && fs.existsSync(path.join(cfg.vaultPath, "02_Areas", "Engine"))) {
+        return cfg.vaultPath;
+      }
+    } catch (_) { /* fall through */ }
+  }
+  let cur = process.cwd();
+  for (let i = 0; i < 6; i++) {
+    if (fs.existsSync(path.join(cur, "02_Areas", "Engine"))) return cur;
+    const next = path.dirname(cur);
+    if (next === cur) break;
+    cur = next;
+  }
+  return null;
+}
+
+function readSection(text, sectionRegex) {
+  // Extract from "## N. <heading>" until next "## " or end of file.
+  const startMatch = text.match(sectionRegex);
+  if (!startMatch) return null;
+  const startIdx = startMatch.index + startMatch[0].length;
+  const tail = text.slice(startIdx);
+  const endMatch = tail.match(/\n##\s/);
+  return endMatch ? tail.slice(0, endMatch.index) : tail;
+}
+
+function extractField(section, labelRegex) {
+  if (!section) return null;
+  // Match "**Label:** value" lines OR "* **Label:** value" bullets.
+  const m = section.match(new RegExp(`\\*?\\*?${labelRegex}:?\\*?\\*?\\s+(.+?)(?=\\n\\*?\\*?\\w+:|\\n\\n|$)`, "is"));
+  if (m) return m[1].trim().replace(/\s+/g, " ");
+  return null;
+}
+
+function extractSingleTest(strategy) {
+  // Pass 4 BLOCKER fix: parser was looking for "**The Bet:**" / "**Single Test:**"
+  // headers that V4 Strategy.md doesn't use. Actual V4 format:
+  //   **Mid-term Milestone:** <N activated installs + M referrals by date>...
+  //   **The Positioning (V4):**
+  //   - **Hero:** "..."
+  // Prefer Mid-term Milestone (machine-stable measurable target), fall back
+  // to legacy headers if found.
+  const milestoneMatch = strategy.match(/\*\*Mid-term Milestone:\*\*\s+(.+?)(?=\n\*\*|\n##|$)/is);
+  if (milestoneMatch) return milestoneMatch[1].trim().replace(/\s+/g, " ");
+
+  // Legacy header support (older Strategy.md versions still parse).
+  const sec = readSection(strategy, /##\s*1\.\s*(BUSINESS\s+)?HYPOTHESIS/i) ||
+              readSection(strategy, /##\s*1\./);
+  if (sec) {
+    const betMatch = sec.match(/\*\*(?:The Bet|Single Test):\*\*\s+(.+?)(?=\n\*\*\w|\n\n##|\n>\s|$)/is);
+    if (betMatch) return betMatch[1].trim().replace(/\s+/g, " ");
+    const hypoMatch = sec.match(/\*\*Hypothesis:\*\*\s+(.+?)(?=\n\*\*\w|\n\n##|$)/is);
+    if (hypoMatch) return hypoMatch[1].trim().replace(/\s+/g, " ");
+  }
+  return null;
+}
+
+function extractSacrifice(strategy) {
+  // Pass 4 BLOCKER fix: V4 uses "**The Sacrifice (V4 — hardened past V3.0):**"
+  // which has a parenthetical that the old regex didn't match. The header
+  // can also be followed by a bulleted list rather than inline text.
+  // Strategy: find the header anywhere (Section 1 or 2), then capture the
+  // first bullet point OR inline text until the next bold header / next section.
+  //
+  // First try: full bullet list under the header (V4 actual structure).
+  const sacrHeaderMatch = strategy.match(/\*\*The Sacrifice[^*]*\*\*\s*\n([\s\S]+?)(?=\n\*\*\w[^*]*\*\*|\n##\s|$)/i);
+  if (sacrHeaderMatch) {
+    // Collapse the bullet list into a single human-readable string.
+    // Take first 2-3 bullets, strip markdown bullet markers.
+    const bullets = sacrHeaderMatch[1]
+      .split(/\n/)
+      .map(l => l.replace(/^\s*[*-]\s+/, "").trim())
+      .filter(l => l && !l.startsWith("**"))
+      .slice(0, 4);
+    if (bullets.length) return bullets.join(" · ").replace(/\s+/g, " ").slice(0, 400);
+  }
+
+  // Fall back: legacy inline format.
+  const sec = readSection(strategy, /##\s*2\./);
+  if (sec) {
+    return extractField(sec, "(?:The Sacrifice|Sacrifice)") ||
+           extractField(sec, "What I am NOT doing");
+  }
+  return null;
+}
+
+function extractFrictionLevel(strategy) {
+  // Pass 4 BLOCKER fix: V4 uses prose like "L3 friction floor active from Day 1"
+  // — not a labeled "Friction Level: L3" line. Accept both formats.
+  // First try labeled form, then prose "L<N> friction" / "friction L<N>".
+  const labeled = strategy.match(/Friction\s+Level\s*[:=]\s*L?(\d)/i);
+  if (labeled) return parseInt(labeled[1], 10);
+  const proseFloor = strategy.match(/\bL([0-5])\s+friction\s+(?:floor|level|active)/i);
+  if (proseFloor) return parseInt(proseFloor[1], 10);
+  const proseLevel = strategy.match(/\bfriction\s+(?:level|floor)\s+L?([0-5])/i);
+  if (proseLevel) return parseInt(proseLevel[1], 10);
+  return null;
+}
+
+function extractStrategyVersion(strategy) {
+  const m = strategy.match(/^\*\*Version:\*\*\s*(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+function regenerate(vaultPath) {
+  const strategyPath = path.join(vaultPath, "02_Areas", "Engine", "Strategy.md");
+  if (!fs.existsSync(strategyPath)) {
+    console.error(`[regenerate-manifest] Strategy.md not found at ${strategyPath}`);
+    process.exit(1);
+  }
+  const strategy = fs.readFileSync(strategyPath, "utf8");
+  const manifestPath = path.join(os.homedir(), ".mover", "pattern-manifest.json");
+
+  let existing = {};
+  if (fs.existsSync(manifestPath)) {
+    try { existing = JSON.parse(fs.readFileSync(manifestPath, "utf8")); }
+    catch (_) { existing = {}; }
+  }
+
+  const singleTest = extractSingleTest(strategy);
+  const sacrifice = extractSacrifice(strategy);
+  const frictionLevel = extractFrictionLevel(strategy);
+  const strategyVersion = extractStrategyVersion(strategy);
+
+  if (!singleTest && !sacrifice) {
+    console.error(`[regenerate-manifest] could not extract Single Test or Sacrifice from Strategy.md — manifest unchanged`);
+    process.exit(1);
+  }
+
+  const next = {
+    ...existing,
+    version: 1,
+    last_updated: new Date().toISOString().slice(0, 16),
+    updated_by: "regenerate-manifest.js",
+    strategy_version: strategyVersion || existing.strategy_version || null,
+    // Re-derived fields
+    ...(singleTest ? { single_test: singleTest } : {}),
+    ...(sacrifice ? { sacrifice: sacrifice } : {}),
+    ...(frictionLevel != null ? { friction_level: frictionLevel } : {}),
+    // Preserved fields (append-only)
+    override_history: Array.isArray(existing.override_history) ? existing.override_history : [],
+    recent_wins: Array.isArray(existing.recent_wins) ? existing.recent_wins : [],
+    active_patterns: Array.isArray(existing.active_patterns) ? existing.active_patterns : [],
+    zombie_tasks: Array.isArray(existing.zombie_tasks) ? existing.zombie_tasks : [],
+  };
+
+  // Atomic tmp+rename
+  const tmp = `${manifestPath}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, JSON.stringify(next, null, 2), "utf8");
+  fs.renameSync(tmp, manifestPath);
+
+  console.log(`Pattern manifest regenerated: single_test="${(next.single_test || "—").slice(0, 60)}…", sacrifice="${(next.sacrifice || "—").slice(0, 60)}…", friction_level=L${next.friction_level || 0}`);
+}
+
+if (require.main === module) {
+  const vault = resolveVaultPath(process.argv);
+  if (!vault) {
+    console.error(`[regenerate-manifest] could not resolve vault path. Pass as first arg or set vaultPath in ~/.mover/config.json`);
+    process.exit(1);
+  }
+  regenerate(vault);
+}
+
+module.exports = { regenerate, extractSingleTest, extractSacrifice, extractFrictionLevel };