mover-os 4.7.7 → 4.7.8

package/src/dashboard/lib/execution-plan.js

@@ -0,0 +1,125 @@
+"use strict";
+
+function computeExecutionPlan({
+  suggestions = [],
+  goalForecast = null,
+  healthProtocols = null,
+  projects = null,
+  engineHealth = null,
+  daily = null,
+  overrides = null,
+} = {}) {
+  const items = [];
+  const seen = new Set();
+  const add = (item) => {
+    if (!item || !item.title) return;
+    const key = item.workflow ? `workflow:${item.workflow}` : (item.id || `${item.lane}:${item.title}`);
+    if (seen.has(key)) return;
+    seen.add(key);
+    items.push({
+      id: key,
+      lane: item.lane || "work",
+      title: item.title,
+      detail: item.detail || "",
+      workflow: item.workflow || null,
+      filePath: item.filePath || null,
+      priority: item.priority || "medium",
+      source: item.source || "",
+      checked: !!item.checked,
+    });
+  };
+
+  if (engineHealth && engineHealth.analyseDay && engineHealth.analyseDay.status === "RED") {
+    add({
+      lane: "engine",
+      title: "Audit today before the system keeps compounding",
+      detail: `/analyse-day is ${engineHealth.analyseDay.overdueDays} days overdue.`,
+      workflow: "/analyse-day",
+      priority: "critical",
+      source: "engine-health",
+    });
+  }
+
+  if (goalForecast && goalForecast.available) {
+    for (const a of goalForecast.adjustments || []) {
+      add({
+        lane: a.workflow === "/experiment" ? "experiment" : "strategy",
+        title: a.title,
+        detail: a.detail,
+        workflow: a.workflow,
+        priority: a.priority,
+        source: "goal-forecast",
+      });
+    }
+  }
+
+  for (const s of suggestions || []) {
+    add({
+      lane: "workflow",
+      title: s.reason || `Run ${s.workflow}`,
+      detail: `${s.workflow}${s.signal ? ` · ${s.signal}` : ""}`,
+      workflow: s.workflow || s.command || null,
+      priority: (s.urgency || "").toUpperCase() === "RED" ? "critical" : "high",
+      source: "suggested-now",
+    });
+  }
+
+  const primaryProject = projects && Array.isArray(projects.projects) ? projects.projects[0] : null;
+  if (primaryProject && primaryProject.openTasks > 0) {
+    add({
+      lane: "work",
+      title: `Move ${primaryProject.name}`,
+      detail: `${primaryProject.openTasks} open tasks · ${primaryProject.zombieTasks || 0} zombie · ${primaryProject.unverifiedTasks || 0} unverified.`,
+      filePath: primaryProject.planPath,
+      priority: primaryProject.zombieTasks > 0 ? "high" : "medium",
+      source: "project-plan",
+    });
+  }
+
+  const protocol = healthProtocols && healthProtocols.protocols && healthProtocols.protocols.find(p => p.current);
+  if (protocol && protocol.current) {
+    const nextHealth = (protocol.current.items || []).find(i => !i.checked);
+    if (nextHealth) {
+      add({
+        lane: "health",
+        title: clean(nextHealth.text).slice(0, 120),
+        detail: `${protocol.title} · ${protocol.current.done}/${protocol.current.total} complete.`,
+        filePath: protocol.filePath,
+        priority: "medium",
+        source: "health-protocol",
+      });
+    }
+  }
+
+  const todayMissing = daily && daily.today && !daily.today.exists;
+  if (todayMissing) {
+    add({
+      lane: "engine",
+      title: "Create today's Daily Note",
+      detail: "Most live dashboard stats depend on the current Daily Note.",
+      workflow: "/plan-tomorrow",
+      priority: "high",
+      source: "daily",
+    });
+  }
+
+  const checked = items.filter(i => i.checked).length;
+  const total = Math.max(1, items.length);
+  const overrideRecent = overrides && Number.isFinite(overrides.last7d) ? overrides.last7d : 0;
+  const capacityScore = Math.max(0, Math.min(100, 100 - items.filter(i => i.priority === "critical").length * 20 - items.filter(i => i.priority === "high").length * 9 - overrideRecent * 4));
+
+  return {
+    available: true,
+    capacityScore,
+    checked,
+    total: items.length,
+    items: items.slice(0, 12),
+    lanes: ["strategy", "experiment", "work", "health", "engine", "workflow"],
+  };
+}
+
+function clean(text) {
+  return String(text || "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\s+/g, " ").trim();
+}
+
+module.exports = { computeExecutionPlan };

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

@@ -0,0 +1,429 @@
+"use strict";
+
+// Lab Parser — reads `02_Areas/Engine/Experiments/*.md` and returns the
+// hypothesis register the dashboard renders. Each file is one experiment.
+// Schema: YAML frontmatter (hypothesis, domain, status, sample_target,
+// sample_current, variables.primary, variables.controls, kpis[], started,
+// deadline, parent_strategy) + markdown body with `## Daily log` and
+// `## Result` sections.
+//
+// Experiment-discipline principles enforced via FRICTION objects emitted
+// per experiment — the UI surfaces these as warning chips so users see
+// what makes a real experiment vs a wish.
+
+const fs = require("fs");
+const path = require("path");
+
+const DOMAINS = new Set(["work", "vitality", "faith"]);
+const VALID_STATUS = new Set(["active", "pass", "fail", "paused", "inconclusive"]);
+const MAX_CONCURRENT_PER_DOMAIN = 3;
+
+// Detects whether a string contains a numeric target. Hypothesis without
+// a number is unverifiable — the rule: "if you can't write a number,
+// you don't have an experiment yet."
+const NUMERIC_RE = /(?:\d+(?:\.\d+)?%|\d+\s*\/\s*\d+|>=?\s*\d|<=?\s*\d|\d+\s*(?:min|hr|hour|day|week|kg|lbs|reps|sessions|sales|customers|calls|replies|posts|visits|clicks))/i;
+
+function parseFrontmatter(text) {
+  // Audit pass 2 (find-bugs #13): normalize CRLF so Windows-edited files
+  // match the same regex as Unix. Previously CRLF files returned empty
+  // frontmatter and all hypothesis/status/domain fields were blank.
+  text = String(text).replace(/\r\n/g, "\n");
+  const m = text.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!m) return { frontmatter: {}, body: text };
+  const fmText = m[1];
+  const body = text.slice(m[0].length);
+  const fm = {};
+
+  // Minimal YAML — flat keys, nested map for variables, list for kpis +
+  // variables.controls. Built for our schema, not general YAML.
+  const lines = fmText.split("\n");
+  let currentKey = null;
+  let listBuffer = null;
+  let mapBuffer = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (!raw.trim() || raw.trim().startsWith("#")) continue;
+
+    // Top-level key: value
+    const topMatch = raw.match(/^([a-z_][a-z0-9_]*)\s*:\s*(.*)$/i);
+    const indented = /^\s+/.test(raw);
+
+    if (!indented && topMatch) {
+      // Flush prior buffers
+      if (currentKey && listBuffer) fm[currentKey] = listBuffer;
+      if (currentKey && mapBuffer) fm[currentKey] = mapBuffer;
+      listBuffer = null; mapBuffer = null;
+
+      const [, key, valRaw] = topMatch;
+      const val = stripQuotes((valRaw || "").trim());
+      currentKey = key;
+      if (val === "") {
+        // Block-style start
+        // Lookahead to determine list-of-maps or map
+        const next = lines[i + 1] || "";
+        if (next.match(/^\s+-\s/)) listBuffer = [];
+        else if (next.match(/^\s+[a-z_]+\s*:/i)) mapBuffer = {};
+        else listBuffer = []; // safest default
+      } else {
+        fm[key] = val;
+        currentKey = null;
+      }
+      continue;
+    }
+
+    // List item under current key
+    const listItem = raw.match(/^\s+-\s*(.*)$/);
+    if (listItem && listBuffer != null) {
+      const itemRaw = listItem[1];
+      if (itemRaw.match(/^[a-z_]+\s*:/i)) {
+        // List of maps — collect this object
+        const obj = {};
+        const firstKv = itemRaw.match(/^([a-z_][a-z0-9_]*)\s*:\s*(.*)$/i);
+        if (firstKv) obj[firstKv[1]] = stripQuotes(firstKv[2].trim());
+        // Lookahead for more keys at deeper indent
+        while (i + 1 < lines.length) {
+          const next = lines[i + 1];
+          if (!/^\s{4,}[a-z_]+\s*:/i.test(next)) break;
+          i++;
+          const kv = next.match(/^\s+([a-z_][a-z0-9_]*)\s*:\s*(.*)$/i);
+          if (kv) obj[kv[1]] = stripQuotes(kv[2].trim());
+        }
+        listBuffer.push(obj);
+      } else {
+        listBuffer.push(stripQuotes(itemRaw));
+      }
+      continue;
+    }
+
+    // Map key under current key
+    if (indented && mapBuffer != null) {
+      const kv = raw.match(/^\s+([a-z_][a-z0-9_]*)\s*:\s*(.*)$/i);
+      if (kv) {
+        const [, k, v] = kv;
+        const vt = stripQuotes((v || "").trim());
+        if (vt === "") {
+          // Nested list (e.g. controls under variables)
+          const nestedList = [];
+          while (i + 1 < lines.length) {
+            const next = lines[i + 1];
+            if (!/^\s{4,}-\s/.test(next)) break;
+            i++;
+            const m2 = next.match(/^\s+-\s*(.*)$/);
+            if (m2) nestedList.push(stripQuotes(m2[1]));
+          }
+          mapBuffer[k] = nestedList;
+        } else {
+          mapBuffer[k] = vt;
+        }
+      }
+      continue;
+    }
+  }
+  // Final flush
+  if (currentKey && listBuffer) fm[currentKey] = listBuffer;
+  if (currentKey && mapBuffer) fm[currentKey] = mapBuffer;
+
+  return { frontmatter: fm, body };
+}
+
+function stripQuotes(s) {
+  if (!s) return s;
+  const t = s.trim();
+  if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+
+function parseDailyLog(body) {
+  // Extract entries like:
+  //   - 2026-05-14 — 12 visitors, 0 buys.
+  //   - 2026-05-14 - 12 visitors
+  // Returns [{ date, text }] sorted ASC.
+  const out = [];
+  const re = /^\s*-\s*(\d{4}-\d{2}-\d{2})\s*[—\-:]\s*(.+)$/gm;
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    out.push({ date: m[1], text: m[2].trim() });
+  }
+  out.sort((a, b) => a.date.localeCompare(b.date));
+  return out;
+}
+
+function detectFrictions(fm, body, allByDomain) {
+  // Experiment-discipline checks — surfaced as user-visible warning chips.
+  const frictions = [];
+
+  if (!fm.hypothesis || fm.hypothesis.length < 12) {
+    frictions.push({
+      level: "crit",
+      label: "no hypothesis",
+      detail: "Write a measurable claim. If you can't, you don't have an experiment.",
+    });
+  } else if (!NUMERIC_RE.test(fm.hypothesis)) {
+    frictions.push({
+      level: "warn",
+      label: "no number in hypothesis",
+      detail: "Add a numeric target (%, count, time). Unfalsifiable hypotheses can't fail.",
+    });
+  }
+
+  if (!fm.sample_target || Number(fm.sample_target) <= 0) {
+    frictions.push({
+      level: "warn",
+      label: "no sample target",
+      detail: "Define how many measurements before you judge. No floor = endless pivoting.",
+    });
+  }
+
+  if (!fm.variables || !fm.variables.primary) {
+    frictions.push({
+      level: "warn",
+      label: "no primary variable",
+      detail: "Name the ONE thing changing. Ceteris paribus.",
+    });
+  } else if (Array.isArray(fm.variables.primary) && fm.variables.primary.length > 1) {
+    frictions.push({
+      level: "warn",
+      label: "multiple primary variables",
+      detail: "Pick one. Two variables changing = correlation, not experiment.",
+    });
+  }
+
+  // Section presence
+  if (!/##\s+Daily log/i.test(body)) {
+    frictions.push({
+      level: "info",
+      label: "no daily log section",
+      detail: "Add `## Daily log` for time-series tracking.",
+    });
+  }
+
+  // Per-domain concurrent cap
+  const activeCount = (allByDomain[fm.domain] || []).filter(e => e.status === "active").length;
+  if (activeCount > MAX_CONCURRENT_PER_DOMAIN) {
+    frictions.push({
+      level: "warn",
+      label: `${activeCount} concurrent in ${fm.domain}`,
+      detail: `Cap is ${MAX_CONCURRENT_PER_DOMAIN}. Close one before starting another.`,
+    });
+  }
+
+  // Status sanity
+  if (fm.status && !VALID_STATUS.has(fm.status)) {
+    frictions.push({
+      level: "info",
+      label: `unknown status: ${fm.status}`,
+      detail: `Valid: ${[...VALID_STATUS].join(", ")}`,
+    });
+  }
+
+  return frictions;
+}
+
+function dateDays(iso) {
+  if (!iso) return null;
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return null;
+  const diff = Math.floor((Date.now() - t) / 86400000);
+  return diff;
+}
+
+function buildExperiments(vault) {
+  const expDir = path.join(vault, "02_Areas", "Engine", "Experiments");
+  if (!fs.existsSync(expDir)) {
+    return { available: false, byDomain: { work: [], vitality: [], faith: [] }, all: [], active: [], past: [], count: 0 };
+  }
+
+  let entries;
+  try { entries = fs.readdirSync(expDir, { withFileTypes: true }); } catch {
+    return { available: false, byDomain: { work: [], vitality: [], faith: [] }, all: [], active: [], past: [], count: 0 };
+  }
+
+  const all = [];
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith(".md")) continue;
+    if (e.name.startsWith("_TEMPLATE")) continue; // skip template
+    const filePath = path.join(expDir, e.name);
+    let text;
+    try { text = fs.readFileSync(filePath, "utf8"); } catch { continue; }
+
+    const { frontmatter: fm, body } = parseFrontmatter(text);
+
+    const status = (fm.status || "active").toLowerCase();
+    const domain = (fm.domain || "work").toLowerCase();
+    const sampleTarget = Number(fm.sample_target) || 0;
+    const sampleCurrent = Number(fm.sample_current) || 0;
+    const kpis = Array.isArray(fm.kpis) ? fm.kpis.map(k => ({
+      name: k.name || "—",
+      target: k.target || "—",
+      current: k.current || "—",
+      met: kpiMet(k.target, k.current),
+    })) : [];
+
+    const dailyLog = parseDailyLog(body);
+    const lastObservation = dailyLog.length ? dailyLog[dailyLog.length - 1] : null;
+
+    // Result + transition copy
+    const resultMatch = body.match(/##\s+Result\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+    const ifPassMatch = body.match(/##\s+If PASS\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+    const ifFailMatch = body.match(/##\s+If FAIL\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+    const whyMatch = body.match(/##\s+Why this test\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+
+    const startDays = dateDays(fm.started);
+    const deadlineDate = fm.deadline ? Date.parse(fm.deadline) : null;
+    const deadlineDaysLeft = deadlineDate
+      ? Math.ceil((deadlineDate - Date.now()) / 86400000)
+      : null;
+
+    const slug = e.name.replace(/\.md$/, "");
+
+    all.push({
+      slug,
+      path: filePath,
+      title: extractTitle(body) || slug,
+      hypothesis: fm.hypothesis || "(no hypothesis)",
+      domain,
+      status,
+      started: fm.started || null,
+      deadline: fm.deadline || null,
+      startedDaysAgo: startDays,
+      deadlineDaysLeft,
+      sampleTarget,
+      sampleCurrent,
+      samplePct: sampleTarget > 0 ? Math.min(100, (sampleCurrent / sampleTarget) * 100) : 0,
+      kpis,
+      primaryVariable: fm.variables?.primary || null,
+      controls: Array.isArray(fm.variables?.controls) ? fm.variables.controls : [],
+      parentStrategy: fm.parent_strategy || null,
+      // T210: structural Single Test linkage. Prefer the new dedicated field,
+      // fall back to parent_strategy so old experiment files still parse.
+      // Cross-reference against the current Strategy.md singleTest happens
+      // after the main loop (need the live single-test text available).
+      linkedSingleTest: fm.linked_single_test || fm.parent_strategy || null,
+      linkedToCurrentTest: false,
+      why: whyMatch ? whyMatch[1].trim().slice(0, 400) : null,
+      result: resultMatch ? resultMatch[1].trim().slice(0, 600) : null,
+      ifPass: ifPassMatch ? ifPassMatch[1].trim().slice(0, 300) : null,
+      ifFail: ifFailMatch ? ifFailMatch[1].trim().slice(0, 300) : null,
+      dailyLog,
+      lastObservation,
+      frictions: [], // populated after grouping (concurrent-cap needs the full set)
+      // Preserve raw body so detectFrictions can check section presence.
+      // Audit pass 2 (find-bugs #9): previously body was dropped, so
+      // detectFrictions received the hardcoded string "## Daily log"
+      // which always matches the test — the missing-section friction
+      // never surfaced for experiments that genuinely lacked the section.
+      _body: body,
+    });
+  }
+
+  // Group by domain for concurrent-cap detection
+  const byDomain = { work: [], vitality: [], faith: [] };
+  for (const exp of all) {
+    if (DOMAINS.has(exp.domain)) byDomain[exp.domain].push(exp);
+  }
+
+  // Now compute frictions with awareness of grouped state
+  for (const exp of all) {
+    exp.frictions = detectFrictions(
+      {
+        hypothesis: exp.hypothesis,
+        sample_target: exp.sampleTarget,
+        variables: { primary: exp.primaryVariable, controls: exp.controls },
+        status: exp.status,
+        domain: exp.domain,
+      },
+      // Pass the real body so section-presence checks fire (find-bugs #9).
+      exp._body || "",
+      byDomain
+    );
+    // Drop the internal field — UI doesn't need raw body in the payload.
+    delete exp._body;
+  }
+
+  // T210: cross-reference experiments against the vault's CURRENT Single
+  // Test. An experiment is "linked to current test" when its declared
+  // linked_single_test (or parent_strategy fallback) overlaps materially
+  // with the live Strategy.md singleTest text. Loose match by keyword
+  // intersection — full string equality is brittle when users paraphrase.
+  let currentTestKeywords = null;
+  try {
+    const stratFs = require("fs");
+    const stratPath = require("path").join(vault, "02_Areas", "Engine", "Strategy.md");
+    const stratText = stratFs.existsSync(stratPath) ? stratFs.readFileSync(stratPath, "utf8") : "";
+    const milestoneMatch = stratText.match(/\*\*Mid-term Milestone:\*\*\s+(.+?)(?=\n\*\*|\n##|$)/is);
+    const legacyMatch = stratText.match(/\*\*(?:Single Test|The Bet):\*\*\s+(.+?)(?=\n\*\*|\n##|$)/is);
+    const current = (milestoneMatch && milestoneMatch[1]) || (legacyMatch && legacyMatch[1]) || "";
+    if (current) {
+      currentTestKeywords = current.toLowerCase().match(/\b[a-z][a-z0-9-]{4,}\b/g) || [];
+    }
+  } catch (_) { /* tolerate missing Strategy.md */ }
+
+  if (currentTestKeywords && currentTestKeywords.length) {
+    const sigSet = new Set(currentTestKeywords.filter(w =>
+      !/^(the|and|for|with|that|this|from|into|over|about|test|active|installs|referral|deadline|operational|gate)$/.test(w)
+    ));
+    for (const exp of all) {
+      if (!exp.linkedSingleTest) continue;
+      const expWords = String(exp.linkedSingleTest).toLowerCase().match(/\b[a-z][a-z0-9-]{4,}\b/g) || [];
+      const overlap = expWords.filter(w => sigSet.has(w)).length;
+      // 2+ significant keyword overlap = same Single Test
+      exp.linkedToCurrentTest = overlap >= 2;
+    }
+  }
+
+  const active = all.filter(e => e.status === "active");
+  const past = all.filter(e => e.status !== "active");
+  const linkedActive = active.filter(e => e.linkedToCurrentTest);
+  const orphanedActive = active.filter(e => !e.linkedToCurrentTest);
+
+  return {
+    available: true,
+    all,
+    active,
+    past,
+    byDomain,
+    linkedActive,
+    orphanedActive,
+    count: all.length,
+    activeCount: active.length,
+    pastCount: past.length,
+    linkedActiveCount: linkedActive.length,
+    orphanedActiveCount: orphanedActive.length,
+  };
+}
+
+function extractTitle(body) {
+  const m = body.match(/^#\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+function kpiMet(target, current) {
+  // Parse simple targets: ">= 2%", "< 30", "= 100", ">= 5/day"
+  if (!target || !current || current === "—") return null;
+  const tNum = parseFirstNumber(target);
+  const cNum = parseFirstNumber(current);
+  if (tNum == null || cNum == null) return null;
+  const op = /<=/.test(target) ? "lte"
+           : /<\s/.test(target) ? "lt"
+           : />=/.test(target) ? "gte"
+           : />\s/.test(target) ? "gt"
+           : "eq";
+  switch (op) {
+    case "lte": return cNum <= tNum;
+    case "lt":  return cNum <  tNum;
+    case "gte": return cNum >= tNum;
+    case "gt":  return cNum >  tNum;
+    case "eq":  return cNum === tNum;
+  }
+  return null;
+}
+
+function parseFirstNumber(s) {
+  const m = String(s).match(/-?\d+(?:\.\d+)?/);
+  return m ? Number(m[0]) : null;
+}
+
+module.exports = { buildExperiments, parseFrontmatter, parseDailyLog, kpiMet };