mover-os 4.7.7 → 4.7.8

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

@@ -0,0 +1,245 @@
+"use strict";
+
+const { strategyPath, safeRead, safeStat } = require("./paths");
+const { localDateKey } = require("./date-utils");
+
+// Parse Strategy.md. Extracts hypothesis, single test, sacrifice, validation criteria, fail condition,
+// LAB REPORT changelog, current phase + version.
+
+function parseStrategy(vault) {
+  const filePath = strategyPath(vault);
+  const text = safeRead(filePath);
+  const stat = safeStat(filePath);
+  if (!text) return { available: false, filePath };
+
+  const out = {
+    available: true,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    raw: text,
+    fields: {}
+  };
+
+  const re = /\*\*([^*]+):\*\*\s*([^\n]+)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const k = m[1].trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_|_$/g, "");
+    out.fields[k] = m[2].trim();
+  }
+
+  // Header-level fields
+  out.version = out.fields.version || null;
+  out.lastUpdatedField = out.fields.updated || out.fields.last_updated || null;
+  // Target Date — normalize to ISO YYYY-MM-DD so downstream T-MINUS math works.
+  // Field can be "June 30th, 2026" / "2026-05-15" / "by May 15" — all coerced.
+  const rawTarget = out.fields.target_date || null;
+  out.targetDate = rawTarget ? (extractDateFromText(rawTarget) || rawTarget) : null;
+  out.primeObjective = out.fields.prime_objective || null;
+  out.stretchTarget = out.fields.stretch_target || null;
+  out.currentState = out.fields.current_state || null;
+
+  // Single Test extraction — V4 uses **Mid-term Milestone:**, older versions
+  // used **Single Test:** / **The Bet:**. Try V4 first, fall back to legacy
+  // so the live dashboard parser keeps working across Strategy.md versions.
+  const milestoneMatch = text.match(/\*\*Mid-term Milestone:\*\*\s+(.+?)(?=\n\*\*|\n##|$)/is);
+  if (milestoneMatch) {
+    out.singleTest = milestoneMatch[1].trim().replace(/\s+/g, " ");
+  } else {
+    const stMatch = text.match(/\*\*(?:Single Test|The Bet):?\*\*\s*"?([^"\n]+)"?/i);
+    out.singleTest = stMatch ? stMatch[1].trim().replace(/^"|"$/g, "") : null;
+  }
+
+  // Pull deadline date out of the Single Test prose if Target Date is absent.
+  // V4 text says "by June 30, 2026" → ISO 2026-06-30. Older V3 said "by May 15".
+  if (!out.targetDate && out.singleTest) {
+    out.targetDate = extractDateFromText(out.singleTest);
+  }
+
+  // Sacrifice extraction — V4 uses "**The Sacrifice (V4 — hardened past V3.0):**"
+  // followed by a bulleted list. Old format was inline text after "**Sacrifice:**".
+  const sacrV4 = text.match(/\*\*The Sacrifice[^*]*\*\*\s*\n([\s\S]+?)(?=\n\*\*\w[^*]*\*\*|\n##\s|$)/i);
+  if (sacrV4) {
+    out.sacrificeBlock = sacrV4[1].trim();
+    out.sacrificeItems = sacrV4[1].split("\n")
+      .map(l => l.replace(/^\s*[*-]\s+/, "").trim())
+      .filter(l => l && !l.startsWith("**"))
+      .slice(0, 4);
+  } else {
+    const sacMatch = text.match(/\*\*The Sacrifice:?\*\*([\s\S]*?)(?=\n##|\n###|\n\*\*|$)/i);
+    out.sacrificeBlock = sacMatch ? sacMatch[1].trim() : null;
+    out.sacrificeItems = out.sacrificeBlock
+      ? out.sacrificeBlock.split("\n")
+        .map(l => l.match(/^\s*[-*]\s+(.+)$/))
+        .filter(Boolean).map(m => m[1].trim())
+      : [];
+  }
+
+  // Validation + Fail
+  const valMatch = text.match(/\*\*✅ Validation Criteria:?\*\*\s*([^\n]+)/i);
+  out.validationCriteria = valMatch ? valMatch[1].trim() : null;
+  const failMatch = text.match(/\*\*❌ Fail Condition:?\*\*\s*([^\n]+)/i);
+  out.failCondition = failMatch ? failMatch[1].trim() : null;
+
+  // Hypothesis section body. NOTE the `m` flag — without it `^` matches
+  // start of STRING not start of LINE, so the section headers below the
+  // first line never match. Found via dashboard CURRENT STRATEGIES empty.
+  // T222: Strategy V4+ leads Section 1 with a `**Context:**` block
+  // summarizing why the PRIOR version failed (literally "V3.0 Single Test
+  // FAILED (4/10 by May 15)..."). The dashboard was rendering this as if
+  // it were the current hypothesis, leaking the V3 May 15 date into the UI.
+  // Skip past the retrospective preamble — start from **Status:**, or
+  // **The Positioning** if Status is absent, falling back to the full
+  // section for older Strategy.md files that don't follow V4 layout.
+  let body = extractSection(text, /^##\s+1\.\s+BUSINESS HYPOTHESIS/im);
+  if (body) {
+    const statusIdx = body.search(/^\*\*Status:\*\*/m);
+    const positioningIdx = body.search(/^\*\*The Positioning/m);
+    const skipTo = statusIdx >= 0 ? statusIdx
+                 : positioningIdx >= 0 ? positioningIdx
+                 : -1;
+    if (skipTo > 0) {
+      body = body.slice(skipTo).trim();
+    }
+  }
+  out.hypothesisBody = body;
+
+  // Pivot Itch Defense
+  out.pivotItchDefense = extractSection(text, /\bPivot Itch\b/im);
+
+  // LAB REPORT changelog entries
+  out.labReport = extractLabReport(text);
+
+  // Bio-algorithm + Mindset hypotheses (for vitality/mindset domains)
+  out.bioAlgorithmBody = extractSection(text, /^##\s+2\.\s+THE BIO-ALGORITHM/im);
+  out.mindsetBody = extractSection(text, /^##\s+3\.\s+MINDSET HYPOTHESIS/im);
+
+  // Combined: per-domain strategies. Used by Briefing CURRENT STRATEGIES
+  // cards instead of Goals.md horizons (user feedback: should come from
+  // Strategy.md, not Goals.md).
+  out.hypotheses = [
+    { domain: 'WORK',    body: out.hypothesisBody || '' },
+    { domain: 'VITALITY', body: out.bioAlgorithmBody || '' },
+    { domain: 'FAITH / PURPOSE', body: out.mindsetBody || '' },
+  ].filter(h => h.body && h.body.trim().length > 20);
+
+  // Per-domain MEASUREMENT declaration (single | chain | scalar | streak), written
+  // by the onboarding Scribe inside each domain section so the dashboard dispatches
+  // on the shape. Header NAMES differ between the hand-authored V4 file (BUSINESS
+  // HYPOTHESIS / THE BIO-ALGORITHM) and the fresh Scribe file (WORK / VITALITY
+  // HYPOTHESIS), so match on the section NUMBER, not the name.
+  out.measurement = {
+    work:     readMeasurementDecl(extractSection(text, /^##\s+1\.\s+/im)),
+    vitality: readMeasurementDecl(extractSection(text, /^##\s+2\.\s+/im)),
+    faith:    readMeasurementDecl(extractSection(text, /^##\s+3\.\s+/im)),
+  };
+
+  // Archived hypotheses (graveyard)
+  out.archived = extractGraveyardEntries(text);
+
+  return out;
+}
+
+// Read a "**Measurement:** <type>" declaration (plus a scalar baseline/target or a
+// chain's reverse-engineering math) from a domain section body. Returns
+// { type, baseline?, target?, chain? } or null. The honest placeholder
+// "_(single | chain | scalar | streak, set once ...)_" contains all four words, so
+// it is rejected: only a real, LEADING bare type counts as a declaration.
+function readMeasurementDecl(body) {
+  if (!body) return null;
+  const mm = body.match(/\*\*Measurement:\*\*\s*([^\n]+)/i);
+  if (!mm) return null;
+  const tm = mm[1].trim().match(/^(single|chain|scalar|streak)\b/i); // anchored: the value IS the type
+  if (!tm) return null; // a "_(...)_" placeholder or no real declaration
+  const decl = { type: tm[1].toLowerCase() };
+  const real = (s) => (s && !/^_?\(/.test(s.trim()) ? s.trim() : null); // skip "_(...)_" placeholders
+  const base = body.match(/\*\*Baseline:\*\*\s*([^\n]+)/i);
+  const targ = body.match(/\*\*Target:\*\*\s*([^\n]+)/i);
+  const chain = body.match(/\*\*Chain:\*\*\s*([^\n]+)/i);
+  if (base && real(base[1])) decl.baseline = real(base[1]);
+  if (targ && real(targ[1])) decl.target = real(targ[1]);
+  if (chain && real(chain[1])) decl.chain = real(chain[1]);
+  return decl;
+}
+
+// Extract a date from arbitrary prose. Handles ISO YYYY-MM-DD, "by Month Day",
+// "Month Day", "Month Day, YYYY". Returns ISO string or null. Assumes the
+// current year if not specified.
+function extractDateFromText(text) {
+  if (!text) return null;
+  // ISO date first — most specific
+  const iso = text.match(/\b(20\d{2}-[01]\d-[0-3]\d)\b/);
+  if (iso) return iso[1];
+
+  // "by Month Day(,? Year)?"
+  //
+  // T242 bug hunt fix (B#7): regex alternation is left-to-right. Previous
+  // order put short prefixes first ("jan", "feb", ...) so "january 5" only
+  // captured "jan" — then the day-capture group started at "uary 5", which
+  // luckily still found "5" via the lazy `\d{1,2}` advance. The bug surfaces
+  // when the input is "sept 5": short "sep" matched, capture continues at
+  // "t 5" — `\d` finds nothing, then engine backtracks. Fragile. Reorder
+  // to longest-first so "september", "sept" match before "sep".
+  const MONTHS = [
+    "january","february","march","april","may","june","july","august","september","october","november","december",
+    "sept","jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec"
+  ];
+  const monthRe = MONTHS.join("|");
+  const m = text.match(new RegExp(`\\b(?:by\\s+)?(${monthRe})\\s+(\\d{1,2})(?:,?\\s*(20\\d{2}))?`, "i"));
+  if (m) {
+    const mIdx = monthIndex(m[1]);
+    if (mIdx < 0) return null;
+    const day = parseInt(m[2], 10);
+    if (!Number.isFinite(day) || day < 1 || day > 31) return null;
+    const year = m[3] ? parseInt(m[3], 10) : new Date().getFullYear();
+    const d = new Date(year, mIdx, day);
+    if (isNaN(d.getTime())) return null;
+    return localDateKey(d);
+  }
+  return null;
+}
+
+function monthIndex(name) {
+  const n = name.toLowerCase().slice(0, 3);
+  const map = { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 };
+  return map[n] != null ? map[n] : -1;
+}
+
+function extractSection(text, headerRe) {
+  const m = text.match(headerRe);
+  if (!m) return null;
+  const startIdx = m.index;
+  const startLineEnd = text.indexOf("\n", startIdx);
+  const after = text.slice(startLineEnd + 1);
+  const nextHeader = after.search(/^##\s+/m);
+  return nextHeader === -1 ? after.trim() : after.slice(0, nextHeader).trim();
+}
+
+function extractLabReport(text) {
+  const idx = text.search(/^##\s*🔄?\s*LAB REPORT/im);
+  if (idx === -1) return [];
+  const after = text.slice(idx);
+  const next = after.slice(after.indexOf("\n") + 1).search(/^##\s+/m);
+  const block = next === -1 ? after : after.slice(0, after.indexOf("\n") + 1 + next);
+  const lines = block.split("\n");
+  const entries = [];
+  for (const line of lines) {
+    const m = line.match(/^[-*]\s+\*\*\[([\d\-]+)\]:?\*\*\s*(.+)$/);
+    if (m) entries.push({ date: m[1], summary: m[2].trim() });
+  }
+  return entries;
+}
+
+function extractGraveyardEntries(text) {
+  const idx = text.search(/^##\s*⚰️?\s*ARCHIVED HYPOTHESES|^##\s*The Graveyard/im);
+  if (idx === -1) return [];
+  const after = text.slice(idx);
+  const lines = after.split("\n");
+  const out = [];
+  for (const line of lines) {
+    const m = line.match(/^###\s+(.+?)\s*$/);
+    if (m) out.push({ name: m[1].trim() });
+  }
+  return out;
+}
+
+module.exports = { parseStrategy, extractDateFromText };

package/src/dashboard/lib/strategy-protocol-parser.js

@@ -0,0 +1,135 @@
+"use strict";
+
+const { strategyPath, safeRead } = require("./paths");
+
+// strategy-protocol-parser — extracts the "Daily floor" / "Daily minimum
+// output" items per domain from Strategy.md. This is the SOURCE OF TRUTH
+// for the Execution Protocol module on the Briefing route.
+//
+// Strategy.md is organized in sections:
+//   ## 1. BUSINESS HYPOTHESIS (V3.x) → Work domain
+//   ## 2. THE BIO-ALGORITHM (Vitality) → Vitality domain
+//   ## 3. MINDSET HYPOTHESIS (V2.x — The Anchor Reset) → Faith domain
+//
+// Per section, we extract:
+//   - Daily minimum output (if present) — bullet of required actions
+//   - Daily floor (bad days) — single-line bullet of bare minimum
+// Both lines are split into individual checkboxes (sentences / commas).
+
+function parseStrategyProtocol(vault) {
+  const text = safeRead(strategyPath(vault));
+  if (!text) return { available: false };
+
+  const sections = splitByDomain(text);
+
+  return {
+    available: true,
+    work: extractDomainItems(sections.work, "Work"),
+    vitality: extractDomainItems(sections.vitality, "Vitality"),
+    faith: extractDomainItems(sections.faith, "Faith"),
+  };
+}
+
+// Slice Strategy.md into 3 buckets by the major section headings.
+// Uses string indexOf instead of regex with emoji classes (which are
+// fragile across multi-codepoint glyphs like ⚰️).
+function splitByDomain(text) {
+  const out = { work: "", vitality: "", faith: "" };
+
+  const businessIdx = text.search(/##\s*1\.\s*BUSINESS HYPOTHESIS/i);
+  const bioIdx = text.search(/##\s*2\.\s*THE BIO-ALGORITHM/i);
+  const mindsetIdx = text.search(/##\s*3\.\s*MINDSET HYPOTHESIS/i);
+
+  // Next-section heuristic: any `\n##` after the mindset start, excluding
+  // the mindset header itself. We split on `\n##` and pick the slice
+  // starting with "MINDSET HYPOTHESIS" then stop at the next `\n##`.
+  let mindsetEnd = text.length;
+  if (mindsetIdx >= 0) {
+    const tail = text.slice(mindsetIdx + 5); // skip "## 3."
+    const next = tail.search(/\n##\s/);
+    if (next > 0) mindsetEnd = mindsetIdx + 5 + next;
+  }
+
+  if (businessIdx >= 0 && bioIdx > businessIdx) {
+    out.work = text.slice(businessIdx, bioIdx);
+  }
+  if (bioIdx >= 0 && mindsetIdx > bioIdx) {
+    out.vitality = text.slice(bioIdx, mindsetIdx);
+  }
+  if (mindsetIdx >= 0) {
+    out.faith = text.slice(mindsetIdx, mindsetEnd);
+  }
+
+  return out;
+}
+
+// Within a domain section, find "Daily floor" and "Daily minimum output" lines
+// and produce checklist items.
+function extractDomainItems(section, domainLabel) {
+  if (!section) return { available: false, items: [] };
+  const items = [];
+
+  // Daily minimum output — multi-item, often a few comma- or slash-separated.
+  const minMatch = section.match(/\*\*Daily minimum output:\*\*\s*([^\n]+)/i);
+  if (minMatch) {
+    splitIntoBullets(minMatch[1]).forEach(text => {
+      items.push({ text, source: "Daily minimum output", emphasis: "primary" });
+    });
+  }
+
+  // Daily floor (bad days) — single floor item, sometimes multi-clause.
+  const floorMatch = section.match(/\*\*Daily floor[^:]*:\*\*\s*([^\n]+)/i);
+  if (floorMatch) {
+    splitIntoBullets(floorMatch[1]).forEach(text => {
+      items.push({ text, source: "Daily floor", emphasis: "floor" });
+    });
+  }
+
+  return {
+    available: items.length > 0,
+    domain: domainLabel,
+    items,
+  };
+}
+
+// Split a content line like "3 tweets/day + 1 thread/week" or
+// "Mg glycinate + Vit D3 taken. 3L water. No melatonin." into separate
+// human-readable bullet items.
+const QUALIFIER_BLACKLIST = new Set([
+  "non-negotiable", "non negotiable",
+  "no excuses", "always", "never",
+  "tbd", "etc", "etc.",
+]);
+
+function splitIntoBullets(line) {
+  const cleaned = line
+    .replace(/\.$/, "")
+    .trim()
+    .replace(/\*\*/g, "");
+
+  // Split on:
+  //   - periods between sentences (not inside numbers)
+  //   - " + " when followed by an uppercase letter (separator vs equation)
+  //   - " · " bullets
+  //   - " | " pipes
+  const parts = cleaned
+    .split(/(?:\s*\.(?=\s+[A-Z0-9])|\s*[·|]\s*|\s+\+\s+(?=[A-Z]))/)
+    .map(p => p.trim().replace(/\.$/, ""))
+    .filter(p => p.length >= 3 && p.length <= 140)
+    // Reject pure qualifier strings — these aren't actionable items
+    .filter(p => !QUALIFIER_BLACKLIST.has(p.toLowerCase()));
+
+  // De-dupe and cap at 5 per domain
+  const seen = new Set();
+  const out = [];
+  for (const p of parts) {
+    const k = p.toLowerCase();
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(p);
+    if (out.length >= 5) break;
+  }
+  return out;
+}
+
+module.exports = { parseStrategyProtocol };

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

@@ -0,0 +1,95 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+const { localDateKey, localMidnight } = require("./date-utils");
+
+// streak-parser.js — F34. 365-day Daily Note presence map. Each day is one
+// cell. Used by StreakHeatmap.tsx for GitHub-style grid visualization.
+
+function compute({ vault, daysLookback = 365 } = {}) {
+  if (!vault) return { available: false, days: [], currentStreak: 0, longestStreak: 0 };
+  const dDir = dailiesDir(vault);
+  if (!fs.existsSync(dDir)) return { available: false, days: [], currentStreak: 0, longestStreak: 0 };
+
+  const today = localMidnight();
+  const days = [];
+  let currentStreak = 0;
+  let streakThroughYesterday = 0;
+  let longestStreak = 0;
+  let runningStreak = 0;
+  let counted = 0;
+
+  for (let i = 0; i < daysLookback; i++) {
+    const d = new Date(today.getTime() - i * 24 * 3600 * 1000);
+    const key = localDateKey(d);
+    const monthDir = key.slice(0, 7);
+    const fpath = path.join(dDir, monthDir, `Daily - ${key}.md`);
+    let exists = false;
+    let size = 0;
+    try {
+      const stat = fs.statSync(fpath);
+      exists = true;
+      size = stat.size;
+      counted++;
+    } catch (_) { /* missing */ }
+
+    days.push({ date: key, exists, size });
+
+    // longestStreak is any run's max; runningStreak resets on each gap.
+    if (exists) {
+      runningStreak++;
+      if (runningStreak > longestStreak) longestStreak = runningStreak;
+    } else {
+      runningStreak = 0;
+    }
+  }
+
+  // currentStreak is the consecutive run ENDING TODAY, so it is computed in one
+  // dedicated forward pass that stops at the first gap — never mutated inside
+  // the scan above. The old interleaved update overwrote it with a LATER (older)
+  // run's length: a map like [T,T,T, gap, T,T,T,T,T,T] reported 6 instead of 3,
+  // because once the scan re-entered a run after a gap it re-assigned
+  // currentStreak while its `> 0` guard still held from the today-run.
+  if (days[0] && days[0].exists) {
+    for (let i = 0; i < days.length; i++) {
+      if (!days[i].exists) break;
+      currentStreak++;
+    }
+  }
+
+  // If today's Daily Note is missing, keep the preserved streak separately.
+  // `currentStreak` remains strict (today must exist); `streakThroughYesterday`
+  // lets the UI say "21-day streak waiting on today's note" instead of
+  // implying the history vanished at 00:01.
+  if (days[0] && !days[0].exists) {
+    for (let i = 1; i < days.length; i++) {
+      if (!days[i].exists) break;
+      streakThroughYesterday++;
+    }
+  } else {
+    streakThroughYesterday = currentStreak;
+  }
+
+  // T242 bug hunt fix (C#17): capture todayExists BEFORE reversing. JS
+  // object literal property evaluation is left-to-right, so `days: days.reverse()`
+  // mutates the array in place before `todayExists: days[0]` reads it —
+  // `days[0]` post-reverse is the OLDEST day, not today. Previous code
+  // reported `todayExists: false` (oldest day's existence) regardless
+  // of today's actual state — disagreeing with daily.today.exists for
+  // months.
+  const todayExists = !!(days[0] && days[0].exists);
+  return {
+    available: true,
+    days: days.reverse(),
+    currentStreak,
+    streakThroughYesterday,
+    todayExists,
+    longestStreak,
+    totalDays: counted,
+    coverage: counted / daysLookback
+  };
+}
+
+module.exports = { compute };