mover-os 4.7.7 → 4.7.8

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