mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/state-core/start-close.js

@@ -0,0 +1,162 @@
+"use strict";
+
+// start-close.js — CORE-LOOP PHASE 2b (SCHEMA-SPEC v0.2 section 3, owner
+// default #4). The two verbs the whole loop collapses into, as LIBRARY
+// functions only: nothing here is wired to a workflow, hook, or server
+// route yet. Wiring comes after the owner inspects the migration manifest.
+//
+//   start(vaultRoot, ...)  = reap orphaned sessions from before, write
+//                            session.started, and (optionally) inventory
+//                            today's plan (plan.observed + plan.ticked from
+//                            the note's checkboxes). No other side effects.
+//   close(vaultRoot, ...)  = write the session's gathered facts +
+//                            session.closed, then rebuild and write the four
+//                            projection files beside the legacy ones.
+//
+// Projections are rebuildable, never hand-edited (spec section 2), so
+// writeProjections overwrites them wholesale on every Close. The file bytes
+// use the SAME assembly as dryrun.js's manifest (projectionFileText), so a
+// Close over an unchanged log at the same clock reading reproduces the
+// migration's bytes exactly — tested in state-core-startclose.test.mjs.
+
+const fs = require("fs");
+const path = require("path");
+const events = require("./events");
+const { appendEvent, readEvents, acquireLock } = require("./event-log");
+
+// A session younger than this is NEVER reaped by another Start's sweep:
+// terra attack 5 reproduced session B (started 1ms after A) reaping live
+// session A. The grace window makes parallel sessions safe without a
+// liveness lease; a genuinely crashed session is reaped by the first Start
+// that runs after the window. Wiring may later pass real liveness (agent
+// pids) to tighten this.
+const DEFAULT_REAP_GRACE_MS = 24 * 3600 * 1000;
+const { rebuildProjections } = require("./projections");
+const { projectionFileText, PROJECTION_NAMES, STATE_DIR, LOG_NAME } = require("./dryrun");
+const { backfillDailyTasks } = require("./backfill");
+
+function logPathFor(vaultRoot) {
+  return path.join(vaultRoot, STATE_DIR, LOG_NAME);
+}
+
+// Rebuilds from the log and overwrites the four projection files. Holds the
+// log's advisory lock across the read-reduce-write so a concurrent append
+// cannot land between the rebuild and the file writes (terra attack 6
+// reproduced a stored projection with a stale watermark that way), and each
+// file goes through a same-dir temp+rename so a crash never leaves a
+// half-written projection. Returns the rebuild result.
+function writeProjections(vaultRoot, { now, lockWaitMs } = {}) {
+  const nowMs = typeof now === "number" ? now : Date.now();
+  const logPath = logPathFor(vaultRoot);
+  const lock = acquireLock(logPath, lockWaitMs != null ? { lockWaitMs } : {});
+  try {
+    const rebuilt = rebuildProjections(logPath, { now: () => nowMs });
+    const watermark = { id: rebuilt.body.throughEventId, ts: rebuilt.body.throughEventTs };
+    for (const [kind, name] of Object.entries(PROJECTION_NAMES)) {
+      const dest = path.join(vaultRoot, STATE_DIR, name);
+      const tmp = `${dest}.tmp-${process.pid}`;
+      fs.writeFileSync(tmp, projectionFileText(kind, rebuilt.body[kind], watermark, rebuilt.body.eventCount, nowMs), "utf8");
+      fs.renameSync(tmp, dest);
+    }
+    return rebuilt;
+  } finally {
+    lock.release();
+  }
+}
+
+// Start = session.started + orphan sweep + (optional) plan inventory.
+// The sweep runs BEFORE this session's own started event is appended, so a
+// session can never reap itself. planNote is today's Daily Note content:
+// its checkboxes become the honest denominator (plan.observed) plus a
+// plan.ticked for boxes already [x] — both dedupe on identical re-runs, so
+// a double Start is harmless.
+// One TOTAL wall-clock budget across a whole start()/close() call (sol #8
+// partial refutation 2: lockWaitMs bounded each acquisition, but a call
+// performs one acquisition per orphan/fact, so a hook child had no single
+// deadline). Returns append options for the NEXT acquisition: the per-append
+// wait shrinks to the remaining budget; when the budget is spent it throws,
+// and the caller's partial work stands (appends are individually atomic and
+// deduped, so the next session's Start/Close catches up losslessly).
+function budgetedOpts(deadlineAt, lockWaitMs) {
+  if (deadlineAt == null) return lockWaitMs != null ? { lockWaitMs } : {};
+  const remaining = deadlineAt - Date.now();
+  if (remaining <= 0) throw new Error("start-close: total budget exhausted (partial work stands; the next session catches up)");
+  return { lockWaitMs: lockWaitMs != null ? Math.min(lockWaitMs, remaining) : remaining };
+}
+
+function start(vaultRoot, { agent, project, focus, sessionId, planNote, now, reapGraceMs, lockWaitMs, totalBudgetMs } = {}) {
+  const nowMs = typeof now === "number" ? now : Date.now();
+  const graceMs = typeof reapGraceMs === "number" ? reapGraceMs : DEFAULT_REAP_GRACE_MS;
+  const logPath = logPathFor(vaultRoot);
+  // lockWaitMs bounds EACH append's wait for a contended lock (terra wiring
+  // finding 5); totalBudgetMs bounds the WHOLE call (sol #8 refutation 2).
+  // The deadline is real wall clock, never the caller's logical `now`.
+  const deadlineAt = typeof totalBudgetMs === "number" ? Date.now() + totalBudgetMs : null;
+
+  const { events: existing } = readEvents(logPath);
+  // Only sessions older than the grace window are treated as crashed; a
+  // parallel session that started recently is LIVE, not an orphan.
+  const orphans = events.findOrphanSessions(existing).filter((o) => nowMs - o.ts > graceMs);
+  let reaped = 0;
+  for (const orphan of orphans) {
+    const r = appendEvent(logPath, events.reapSession(orphan, { ts: nowMs }), budgetedOpts(deadlineAt, lockWaitMs));
+    if (r.appended) reaped += 1;
+  }
+
+  const startedPayload = { agent, project };
+  if (sessionId) startedPayload.sessionId = sessionId;
+  if (focus) startedPayload.focus = focus;
+  const started = events.sessionStarted(startedPayload, { ts: nowMs });
+  appendEvent(logPath, started, budgetedOpts(deadlineAt, lockWaitMs));
+
+  let planEvents = 0;
+  const skipped = [];
+  if (planNote && typeof planNote.text === "string") {
+    const r = backfillDailyTasks(planNote.text, {
+      noteDate: planNote.noteDate,
+      relPath: planNote.relPath || `Dailies/${planNote.noteDate}.md`,
+    });
+    for (const e of r.events) {
+      if (appendEvent(logPath, e, budgetedOpts(deadlineAt, lockWaitMs)).appended) planEvents += 1;
+    }
+    skipped.push(...r.skipped);
+  }
+
+  return { sessionId: started.payload.sessionId, reaped, planEvents, skipped };
+}
+
+// Close = the session's gathered facts + session.closed + projection
+// rebuild. `facts` are prebuilt envelopes (events.js constructors) — Close
+// appends them verbatim; duplicates dedupe by key, so retrying a crashed
+// Close never double-counts.
+function close(vaultRoot, { sessionId, agent, project, summary, mins, dateKey, facts = [], now, lockWaitMs, totalBudgetMs } = {}) {
+  const nowMs = typeof now === "number" ? now : Date.now();
+  const logPath = logPathFor(vaultRoot);
+  const deadlineAt = typeof totalBudgetMs === "number" ? Date.now() + totalBudgetMs : null;
+  const appendOpts = () => budgetedOpts(deadlineAt, lockWaitMs);
+
+  let appended = 0;
+  let duplicates = 0;
+  for (const fact of facts) {
+    const r = appendEvent(logPath, fact, appendOpts());
+    if (r.appended) appended += 1;
+    else if (r.duplicate) duplicates += 1;
+  }
+
+  const closedPayload = { sessionId, agent, project, summary };
+  if (typeof mins === "number") closedPayload.mins = mins;
+  // Vault-zone policy (SCHEMA-SPEC v0.2.7): live wiring passes the
+  // product-local day; events.sessionClosed validates the shape.
+  if (dateKey !== undefined) closedPayload.dateKey = dateKey;
+  const r = appendEvent(logPath, events.sessionClosed(closedPayload, { ts: nowMs }), appendOpts());
+  if (r.appended) appended += 1;
+  else if (r.duplicate) duplicates += 1;
+
+  // The projection rebuild is the one step that must not be skipped mid-call:
+  // it gets whatever budget remains (or the per-lock default when unbudgeted).
+  const rebuildOpts = appendOpts();
+  const rebuilt = writeProjections(vaultRoot, { now: nowMs, lockWaitMs: rebuildOpts.lockWaitMs });
+  return { appended, duplicates, hash: rebuilt.hash, eventCount: rebuilt.body.eventCount };
+}
+
+module.exports = { start, close, writeProjections, logPathFor };

package/src/dashboard/lib/state-core/trial.js

@@ -0,0 +1,96 @@
+"use strict";
+
+// trial.js — CORE-LOOP TRIAL MODE (SCHEMA-SPEC v0.2 section 2): "If a
+// projection disagrees with its legacy sibling during the trial, the
+// DASHBOARD shows the legacy value and logs the delta — discrepancies
+// surface, never silently switch."
+//
+// Scope discipline: only pairs with IDENTICAL semantics are compared.
+// Overrides qualify (pattern-manifest override_history and override.logged
+// events share one source since the migration). Streak deliberately does
+// NOT: the legacy streak counts Daily-Note-existence days, the projection
+// counts session.closed days — different definitions, and logging their
+// disagreement would be false-equivalence noise, not signal. When more
+// event writers land (override capture at Close), this file grows pairs.
+//
+// The delta log is the honest gap meter: today nothing writes
+// override.logged forward, so `legacy - events` is exactly the wiring
+// backlog. Watching it shrink to zero across releases IS the trial.
+
+const fs = require("fs");
+const path = require("path");
+
+const STATE_DIR = path.join("02_Areas", "Engine", "State");
+const LOG_NAME = "events.jsonl";
+const DELTA_NAME = "trial-deltas.jsonl";
+const MAX_DELTA_BYTES = 512 * 1024; // rotate once, keep the tail honest
+
+// Compares override counts. Returns null when the vault is unmigrated
+// (beside-mode: no State dir means no trial), else a comparison record.
+function checkOverrides({ vault, manifestOverrideCount }) {
+  const logPath = path.join(vault, STATE_DIR, LOG_NAME);
+  if (!fs.existsSync(logPath)) return null;
+  const { readEvents } = require("./event-log");
+  const { events } = readEvents(logPath);
+  const eventCount = events.filter((e) => e.type === "override.logged").length;
+  const legacy = Number.isFinite(manifestOverrideCount) ? manifestOverrideCount : 0;
+  return {
+    kind: "overrides",
+    legacy,
+    events: eventCount,
+    agrees: legacy === eventCount,
+  };
+}
+
+// Appends a record when the state MOVES: a new disagreement, a change in a
+// standing disagreement, or a disagreement RESOLVING back to agreement (sol
+// #7 partial refutation: returning on agrees left the last durable record
+// claiming an open gap forever — the resolution is exactly the event the
+// 14-day zero-delta switch criterion needs on the record). Standing states,
+// agreeing or not, never re-log: the dashboard rebuilds often and spam
+// would bury real movement.
+function recordDelta(vault, record, { now } = {}) {
+  if (!record) return { logged: false, reason: "unmigrated" };
+  const deltaPath = path.join(vault, STATE_DIR, DELTA_NAME);
+  try {
+    let last = null;
+    if (fs.existsSync(deltaPath)) {
+      const stat = fs.statSync(deltaPath);
+      if (stat.size > MAX_DELTA_BYTES) {
+        fs.renameSync(deltaPath, deltaPath + ".1"); // one rotation, oldest history discarded
+      }
+      const lines = fs.readFileSync(deltaPath, "utf8").trim().split("\n").filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const parsed = JSON.parse(lines[i]);
+          if (parsed.kind === record.kind) { last = parsed; break; }
+        } catch { continue; }
+      }
+    }
+    if (record.agrees) {
+      // Agreement is durable news only when it RESOLVES a recorded gap.
+      if (!last || last.agrees) return { logged: false, reason: "agrees (no open gap on record)" };
+    } else if (last && !last.agrees && last.legacy === record.legacy && last.events === record.events) {
+      return { logged: false, reason: "unchanged since last record" };
+    }
+    const entry = { ts: typeof now === "number" ? now : Date.now(), ...record };
+    fs.appendFileSync(deltaPath, JSON.stringify(entry) + "\n", "utf8");
+    return { logged: true };
+  } catch (e) {
+    return { logged: false, reason: `delta log write failed: ${e.message}` };
+  }
+}
+
+// One-call convenience for the build path: best-effort, never throws.
+function runTrial({ vault, manifestOverrideCount }) {
+  try {
+    const overrides = checkOverrides({ vault, manifestOverrideCount });
+    if (!overrides) return { available: false, reason: "vault not migrated" };
+    const logged = recordDelta(vault, overrides);
+    return { available: true, pairs: [overrides], logged: logged.logged };
+  } catch (e) {
+    return { available: false, reason: e.message };
+  }
+}
+
+module.exports = { checkOverrides, recordDelta, runTrial, DELTA_NAME };

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

@@ -0,0 +1,248 @@
+"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;
+  // The input commitment (daily quota) is SEPARATE from the Single Test (the
+  // outcome bet). The hero renders the bet; Today renders the commitment.
+  out.commitment = out.fields.commitment || 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 };