mover-os 4.7.8 → 4.7.9

package/src/dashboard/lib/drift-history.js

@@ -9,12 +9,17 @@
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const { localDateKey } = require("./date-utils");
 
 const HISTORY_PATH = path.join(os.homedir(), ".mover", "drift-history.json");
 const MAX_DAYS = 90;
 
+// LOCAL calendar day, not UTC. The bare toISOString().slice(0,10) bucketed
+// by UTC while every other parser (streak, distribution, session-time) keys
+// by local time via date-utils, so near midnight in any non-UTC zone the
+// drift sparkline's day disagreed with the rest of the dashboard by one day.
 function todayKey() {
-  return new Date().toISOString().slice(0, 10);
+  return localDateKey();
 }
 
 function ensureDir(filePath) {

package/src/dashboard/lib/engine-default-fingerprints.json

@@ -0,0 +1,53 @@
+{
+  "_comment": "Known-good hashes of shipped Engine DEFAULTS across versions (CRLF-normalized+trimmed, sha256). engine-writer allows overwriting a non-sentinel file ONLY if its hash matches one of these (a fresh/older install default); a hash NOT here means the user modified it = real data, refuse. Regenerate: node scripts/gen-engine-fingerprints.mjs.",
+  "generated": "git-history",
+  "files": {
+    "Goals.md": [
+      "27abf1d26d51525baa5a3ae9c8cc6f879a723f929334852b7ef9549a5fa11c57",
+      "30f3e24ad7e45bbb2053a0863164357b3e6cf718146540e685462495e38c996c"
+    ],
+    "Mover_Dossier.md": [
+      "c0d6817e390153f834d6a52e8d0e686cb3eb056e6457afecafd5e3abc0c47c49",
+      "21b1ecb65d7c7dbe7be03efa965fefd54f727663e3f0088be66dd453fd244677",
+      "72ca850dfd15972045918fcf0170315da72290a7ca7d034710362ca77e7cd1fa",
+      "e10ace7b0a72d17f342c70d03f015525e7029b13e43eae2c43e8c6ecd14483ee",
+      "bc568ebd12e25377274cf906d0569218c46d1c06e5dc9e857b98e3fdc128b667"
+    ],
+    "Active_Context.md": [
+      "433ef66c852de9a5c37bb65cc40c9d20e577fbcb46ecf91963c8f2d7b23f8a70",
+      "5dec535b04d4c7b11029222812e782a02dcbaea03faaa8979e0adb45bf9698b9",
+      "22b4855fc5f8337b2d1d2f077d12cf709333ea2cc3aa96c7fd1e380ea55ab7fc",
+      "de5b8133f2fd35ad70920bc1c08f2ab75c26edcf58f6b88fccf245a0e729c5aa",
+      "fc6f35e45f7b3934d0ab705b6e259ce195c637019e49381885dab7c963f3ccca",
+      "8eec472e3f451a1d8a121b3a3bd76065137921aa95824666fbb466fec6fb6443",
+      "f0bf0c38418e6c42be46b1546acd676e55aeb64cd1ba31c164dc7047b5ee6807",
+      "25f525f55fb86c638cd67792ef05f46de688e048586a3ccb2d980b8d1a78c7db",
+      "63e7db7db109bdfa78edf5df5d69e0286d614e84aa0165ae372576f6a816602c",
+      "52a8d57d45cafd662e3d106c2acb6fc07116572ca82bc04ff96f7e913ce47395",
+      "d79582e10cb0410554b9a1a669127cc42150805a1207f867edf90ce60f9effa2",
+      "829a755f53600266f60a8daaa9450e8e3516a7b03538eabeed9ff94ef5ec2b1b",
+      "aaa0e5bdac55f53db3bd36db526f841c5e6f62fb7cd8abf7626ff95b68818e14",
+      "4e2b064fe6d2391704a490020be147c507809a1c420da67eac34add5c85b3ebf",
+      "ae47ece41ab9c4dfa12df6e0c9b895de2e44ad1b788bcbc84728f43764a0a90a",
+      "52332d01a067494dc2cd2a5a642d741aa16cf847e49b5e73b744586e167a7faa"
+    ],
+    "Auto_Learnings.md": [
+      "2f02d8724b3283101be1dce7b14e69f478e841d36453ee990ede636cb0daaced",
+      "54fe4b57dd90bed94ef7c5d6af50ef290347afef55081d5c3ec51b4bc3181b60",
+      "a04fe481a5e79eaf0888c0fd71100fbbc709c1d2c8a1145b7d6fa6482d32a144",
+      "0d5bb1ed881384f1559b9fd2702199d28f7e151bd5ec9f9a559b9ece038e88e5",
+      "e1f5361fbd42cbfb655dbe4fd3a8129ec27e5d31c5bbc397615d0eb61c507438",
+      "10d443002d1056d6a939dea23231acaa0a5f01f1b3c6a86b808bb383efd34621",
+      "2ee52d9282a830ef34c52de5d38e78f19710769b1433391dc787fdfed8cf6093"
+    ],
+    "Metrics_Log.md": [
+      "3e3ab4011b65ddf8b435898ee31d136d31fa346cf408a741b6752f6bd9178537",
+      "4f3e7ba572b46cb7cf594640737badb5c2a742e8e2942a53d554ac0e4cddcb69",
+      "a840982311c4ad8300813316926b50a6bc6050b1c45a058ad146b6b695299dbf"
+    ],
+    "Someday_Maybe.md": [
+      "d9d7889a0923059c182d197aa3579a6d4ee78e19d980a7b144652bae7d7715a5",
+      "115ff4539c651ea87184b124a40ea75c874b5122c26d1ecfce3b5657c3d618da"
+    ]
+  }
+}

package/src/dashboard/lib/engine-health.js

@@ -153,7 +153,10 @@ function scanForExpiredGoals(text) {
   // Drop the bare `Date:` arm. Require explicit "Target Date" semantics.
   // Also: require ISO YYYY-MM-DD shape (was `[\d\-]{8,10}` which accepts
   // `2-3-2026`, `0-0-0`, etc).
-  const re = /(?:\*\*Target Date:?\*\*|^\s*Target Date:)\s*(\d{4}-\d{2}-\d{2})\b/gim;
+  // Both bold conventions accepted: `**Target Date:** X` AND `**Target
+  // Date**: X` — the colon-outside-bold style made a 6-month-overdue goal
+  // silently invisible to the RED alert (R5-A false-negative twin of B#17).
+  const re = /(?:\*\*Target Date:?\*\*:?|^\s*Target Date:)\s*(\d{4}-\d{2}-\d{2})\b/gim;
   let m;
   const now = Date.now();
   while ((m = re.exec(text)) !== null) {

package/src/dashboard/lib/engine-writer.js

@@ -49,7 +49,24 @@ const os   = require("os");
 const ENGINE_DIR_REL = path.join("02_Areas", "Engine");
 
 function assertSafeTarget(targetDir, allowEngineWrite = false) {
-  const resolved = path.resolve(targetDir);
+  const lexical = path.resolve(targetDir);
+  // terra F2 (2026-07-11): path.resolve is purely LEXICAL — if 02_Areas/Engine (or
+  // a parent) is a SYMLINK, the endsWith check still matched "02_Areas/Engine" while
+  // the real writes escaped through the link to an external dir. Resolve the REAL
+  // path so the checks below see where writes actually land. realpath fails for a
+  // not-yet-created target (fresh vault) — that has no symlink to follow, so the
+  // lexical path is authoritative there.
+  let resolved = lexical;
+  try { resolved = fs.realpathSync(lexical); }
+  catch {
+    // Target doesn't exist yet; resolve the deepest existing ancestor so a
+    // symlinked PARENT is still caught, then re-append the remainder.
+    try {
+      let cur = lexical, tail = [];
+      while (cur && cur !== path.dirname(cur) && !fs.existsSync(cur)) { tail.unshift(path.basename(cur)); cur = path.dirname(cur); }
+      resolved = path.join(fs.realpathSync(cur), ...tail);
+    } catch { resolved = lexical; }
+  }
   // Compare case-INSENSITIVELY (Bug6): macOS/APFS is case-insensitive, so a lowercase
   // ".../02_areas/engine" points at the real Engine but a case-sensitive endsWith would miss it and
   // let the write through. Keep `resolved` (original case) for the error messages.
@@ -250,7 +267,19 @@ function parseProjectLine(line) {
   }
   const name = cleanProjectName(parts.shift() || "");
   const rest = sanitizeValue(parts.join(": "), 300);
-  return { name, outcome: rest, state: "" };
+  // People answer in prose ("6 bookings, P1, next action portfolio site, blocker underpricing"),
+  // so lift the fields out of the text instead of leaving the brief full of [TBD].
+  const prio = rest.match(/\b(P[0-9])\b/i);
+  const blocker = rest.match(/\bblockers?\s*[:\-]?\s+([^,.;]+)/i);
+  const next = rest.match(/\bnext(?:\s+(?:action|step|move))?\s*[:\-]?\s+([^,.;]+)/i);
+  return {
+    name,
+    outcome: rest,
+    state: "",
+    priority: prio ? prio[1].toUpperCase() : "",
+    blocker: blocker ? blocker[1].trim() : "",
+    nextAction: next ? next[1].trim() : "",
+  };
 }
 
 function cleanProjectSources(raw) {
@@ -297,9 +326,17 @@ function cleanProjects(raw) {
   if (Array.isArray(raw)) {
     raw.forEach(push);
   } else if (typeof raw === "string") {
+    // Prose answers separate projects with sentences, not semicolons:
+    // "…blocker underpricing. Fitness comeback: gym 3x a week, P2." Split on a
+    // period only when the next sentence opens like a new project head
+    // ("Name: details"), so decimals and ordinary sentences stay intact.
+    // Field-label words never open a new project: "…root cause found. Next:
+    // ship the fix." is a continuation parseProjectLine LIFTS as nextAction —
+    // splitting there minted junk "Next"/"Priority" projects (R5-A).
     raw
       .split(/\n+|;+/)
-      .map((x) => x.trim())
+      .flatMap((chunk) => chunk.split(/(?<=\.)\s+(?=(?!(?:Next(?:\s+(?:[Aa]ction|[Ss]tep|[Mm]ove))?|Blockers?|Priority|Action|Step|Status|State|Metric|Goal)\s*:)[A-Z][^.:;]{1,60}:\s)/))
+      .map((x) => x.trim().replace(/\.$/, ""))
       .filter(Boolean)
       .forEach(push);
   }
@@ -1416,14 +1453,82 @@ function writeEngine({ transcript, digest = "", targetDir, dryRun = true, force
         if (e.code !== "ENOENT") throw e; // ENOENT = fresh; anything else re-throws
       }
     }
+    // terra F1 (2026-07-11): the sentinel check misses a PARTIAL Engine whose user
+    // data lives only in non-sentinel files (a legacy or interrupted setup). Also
+    // refuse when the Engine already holds USAGE artifacts that are never shipped
+    // as install defaults — real Daily notes or Weekly/Monthly/Quarterly Reviews.
+    // The installer ships those folders EMPTY (.gitkeep only), so this can never
+    // false-refuse a fresh install (which is exactly why the sentinel-only guard
+    // existed). Voice_DNA.md is NOT used here — it IS shipped as a default.
+    const usageDirs = ["Dailies", "Weekly Reviews", "Monthly Reviews", "Quarterly Reviews"];
+    const hasRealNote = (root) => {
+      let found = false;
+      const walk = (d) => {
+        let entries;
+        try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+        for (const e of entries) {
+          if (found) return;
+          const full = path.join(d, e.name);
+          if (e.isDirectory()) walk(full);
+          else if (e.name.toLowerCase().endsWith(".md")) found = true;
+        }
+      };
+      walk(path.join(targetDir, root));
+      return found;
+    };
+    const usage = usageDirs.filter(hasRealNote);
+    if (usage.length > 0) {
+      throw new Error(
+        `[engine-writer] SAFETY BLOCK: the Engine already contains usage history (${usage.join(", ")}). ` +
+        `Refusing to overwrite a real prior Engine (a fresh install ships these folders empty).`
+      );
+    }
+    // sol flaw #3 COMPLETION (2026-07-11): a partial Engine whose user data lives
+    // ONLY in a non-sentinel file (Goals / Dossier / Active_Context /
+    // Auto_Learnings / Metrics_Log) with no dailies. Fingerprint each existing
+    // target against the KNOWN shipped defaults across versions
+    // (engine-default-fingerprints.json, generated from git history). A file that
+    // matches ANY known default is a fresh OR older-version install default ->
+    // allow (this is what fixed the cross-version false-refuse that made the
+    // current-only fingerprint unsafe). A non-empty file matching NONE was
+    // modified by the user = real data -> refuse. If the manifest is missing, the
+    // sentinel + usage-artifact checks above still stand.
+    let fingerprints = null;
+    try { fingerprints = require("./engine-default-fingerprints.json").files; } catch {}
+    if (fingerprints) {
+      const crypto = require("crypto");
+      const dnHash = (s) => crypto.createHash("sha256").update(String(s).replace(/\r\n/g, "\n").trim()).digest("hex");
+      for (const { path: filePath } of files) {
+        const base = path.basename(filePath);
+        if (SENTINEL_FILES.has(base)) continue;
+        const known = fingerprints[base];
+        if (!Array.isArray(known) || known.length === 0) continue; // no default tracked (e.g. a Daily)
+        let onDisk;
+        try { onDisk = fs.readFileSync(filePath, "utf8"); } catch { continue; } // absent = fresh
+        if (String(onDisk).replace(/\r\n/g, "\n").trim().length === 0) continue; // empty = nothing to lose
+        if (!known.includes(dnHash(onDisk))) {
+          throw new Error(
+            `[engine-writer] SAFETY BLOCK: ${base} differs from every shipped default and holds real user data. ` +
+            `Refusing to overwrite an existing Engine.`
+          );
+        }
+      }
+    }
   }
 
-  // ── Atomic-ish multi-file commit (Bug1+2) ──────────────────────────────────
-  // Write EVERY file to its tmp first; only once all 8 succeed do we rename them in. A failure during
-  // the write phase (disk full, ENOTDIR, perms) unlinks every staged tmp and commits NOTHING — so a
-  // retry is never locked out by a half-seeded sentinel (Identity_Prime/Strategy), and no orphaned
-  // .engine-writer.tmp is left behind. (Per-file rename is itself atomic; once the bytes are on disk a
-  // same-dir rename effectively never fails, so the residual rename-phase window is negligible.)
+  // ── Atomic-ish multi-file commit (Bug1+2, hardened R5-A) ────────────────────
+  // Write EVERY file to its tmp first; only once all succeed do we rename them
+  // in. A failure during the write phase (disk full, ENOTDIR, perms) unlinks
+  // every staged tmp and commits NOTHING — so a retry is never locked out by a
+  // half-seeded sentinel (Identity_Prime/Strategy), and no orphaned
+  // .engine-writer.tmp is left behind.
+  //
+  // The rename phase is NOT assumed infallible: the target is an Obsidian
+  // vault, and synced vaults (iCloud/OneDrive/Dropbox) intermittently lock
+  // files mid-rename. Two defenses: (1) the SENTINEL files rename LAST, so a
+  // failure on any other file can never seed the guard that locks retries out;
+  // (2) on a rename failure every already-renamed file is rolled back to its
+  // tmp, restoring the pre-write state exactly, before rethrowing.
   const staged = [];
   try {
     for (const { path: filePath, content } of files) {
@@ -1436,9 +1541,50 @@ function writeEngine({ transcript, digest = "", targetDir, dryRun = true, force
     for (const { tmp } of staged) { try { fs.unlinkSync(tmp); } catch (_) {} }
     throw e; // nothing renamed → no partial Engine, no force=false lockout, no dangling tmp
   }
-  for (const { tmp, filePath } of staged) {
-    fs.renameSync(tmp, filePath); // atomic: readers never see a partial file
+  const SENTINELS = new Set(["Identity_Prime.md", "Strategy.md"]);
+  const renameOrder = [
+    ...staged.filter((s) => !SENTINELS.has(path.basename(s.filePath))),
+    ...staged.filter((s) => SENTINELS.has(path.basename(s.filePath))),
+  ];
+  const renamed = [];
+  try {
+    for (const entry of renameOrder) {
+      // A forward rename REPLACES any existing file (the structure installer
+      // ships non-empty defaults for the non-sentinel targets) — park the
+      // original first so a rollback can restore it, not just delete the new
+      // bytes (Codex R5-C catch: the first rollback lost the pre-existing
+      // Dossier default on a mid-commit rename failure).
+      entry.bak = null;
+      if (fs.existsSync(entry.filePath)) {
+        // sol flaw #4 (2026-07-11): the old code SWALLOWED a park failure and then
+        // overwrote the original anyway — so if the .bak rename failed, the
+        // original bytes were replaced with no backup, and a later rollback had
+        // nothing to restore (reproduced: Goals.md vanished after a later
+        // Metrics_Log rename failure). Fail CLOSED instead: if we cannot back up
+        // an existing file, do NOT overwrite it. The throw lands in the rollback
+        // below with this file's original still in place, untouched.
+        entry.bak = entry.filePath + ".engine-writer.bak";
+        fs.renameSync(entry.filePath, entry.bak);
+      }
+      fs.renameSync(entry.tmp, entry.filePath); // atomic: readers never see a partial file
+      renamed.push(entry);
+    }
+  } catch (e) {
+    // Roll back. Order matters: move the new bytes out of the way, then
+    // every parked original goes BACK to its path — including the entry
+    // whose rename failed AFTER parking (its original sits at .bak with
+    // nothing at filePath; deleting that bak would lose it).
+    for (const { tmp, filePath } of renamed) {
+      try { fs.renameSync(filePath, tmp); } catch (_) {}
+    }
+    for (const { filePath, bak } of staged) {
+      if (bak && fs.existsSync(bak)) { try { fs.renameSync(bak, filePath); } catch (_) {} }
+    }
+    for (const { tmp } of staged) { try { fs.unlinkSync(tmp); } catch (_) {} }
+    throw e;
   }
+  // Success: clear the parked originals.
+  for (const { bak } of renamed) { if (bak) { try { fs.unlinkSync(bak); } catch (_) {} } }
 
   return { files, written: true };
 }

package/src/dashboard/lib/goal-forecast.js

@@ -15,23 +15,30 @@ function computeGoalForecast({ strategy, activeContext, distribution, engineHeal
     now,
   });
 
-  const current = parsed.current;
+  const current = parsed.current;                 // null when progress is unmeasured
   const target = parsed.target;
-  const needed = Math.max(0, target - current);
+  const hasProgress = current != null;
+  const needed = (target && hasProgress) ? Math.max(0, target - current) : null;
   const deadline = parsed.deadline;
   const daysRemaining = deadline ? daysBetween(localDateKey(now), deadline) : null;
   const daysSafe = daysRemaining == null ? null : Math.max(0, daysRemaining);
-  const requiredPerDay = daysSafe == null
+  const requiredPerDay = (needed == null || daysSafe == null)
     ? null
     : daysSafe === 0 ? needed : round(needed / daysSafe, 2);
-  const progressPct = target > 0 ? Math.min(100, Math.round((current / target) * 100)) : 0;
+  // progressPct is null (UNMEASURED), never a false 0, when no scoped progress exists.
+  const progressPct = (target > 0 && hasProgress) ? Math.min(100, Math.round((current / target) * 100)) : null;
 
+  // Status is scoped to the OUTCOME. A real dated target with no scoped progress
+  // reads "unknown" (-> "Not measured" in the UI), never a fabricated on-track. A
+  // scoped zero reads on-track (0 of 2, deadline ahead). [sol #11 cross-scope]
   let status = "unknown";
-  if (target && current >= target) status = "complete";
+  if (!target) status = "unknown";
+  else if (hasProgress && current >= target) status = "complete";
   else if (daysRemaining != null && daysRemaining < 0) status = "failed";
+  else if (!hasProgress) status = "unknown";
   else if (daysRemaining != null && daysRemaining <= 1 && needed > 2) status = "unlikely";
   else if (requiredPerDay != null && requiredPerDay > 1) status = "at-risk";
-  else if (target) status = "on-track";
+  else status = "on-track";
 
   // Only act on distribution we actually measured. Unavailable (null) distribution
   // must NOT trigger a "0 actions logged" experiment. [false-zero — Codex, T261]
@@ -57,7 +64,7 @@ function computeGoalForecast({ strategy, activeContext, distribution, engineHeal
     pushAction(adjustments, workflows, {
       workflow: "/pivot-strategy",
       title: status === "failed" ? "Close the failed Single Test" : "Recalibrate the current strategy",
-      detail: `${current}/${target} against the active target. Keep the test, kill it, or replace it with a dated operating gate.`,
+      detail: `${current ?? "—"}/${target} against the active target. Keep the test, kill it, or replace it with a dated operating gate.`,
       priority: status === "failed" ? "critical" : "high",
     });
   }
@@ -85,14 +92,34 @@ function computeGoalForecast({ strategy, activeContext, distribution, engineHeal
   return {
     available,
     singleTest: parsed.singleTest || null,
+    // current stays null when the target is parseable but progress is unmeasured
+    // (a clean bet with no scoped record) — the UI shows "Progress not measured".
     current: available ? current : null,
     target: available ? target : null,
     unit: parsed.unit,
+    // kind rides with the parsed counter when one exists (the verdict must
+    // cite what the numbers actually count); keyword classification only
+    // labels the no-counter cases (revenue/vitality wording, available:false).
+    kind: parsed.counterKind || classifyGoalKind(strategy && strategy.singleTest),
+    // shape: "clean" (one metric + date), "compound" (a multi-signal gate), or
+    // "unparseable" (no target the dashboard can score). The hero renders each
+    // differently; a compound/legacy bet gets a "rewrite for clarity" affordance.
+    gate: parsed.gate === true,
+    shape: parsed.shape || (parsed.gate ? "compound" : (available ? "clean" : "unparseable")),
+    // whether `current` came from a real test-scoped record vs is just unmeasured.
+    progressMeasured: parsed.progressMeasured === true,
+    // the input commitment (daily quota) + the channel it names, both SEPARATE
+    // from the bet — Today renders these, never the hero.
+    commitment: (strategy && strategy.commitment) || null,
+    channel: parseChannel(strategy && strategy.commitment),
     deadline,
     daysRemaining,
-    needed,
-    requiredPerDay,
-    progressPct,
+    // Derived pace numerals are honest-null when there is no measurable target
+    // (a gate/unparseable test) OR when the target is real but progress is
+    // unmeasured. Secondary readers that copy them raw must not report a false 0%.
+    needed: available ? needed : null,
+    requiredPerDay: available ? requiredPerDay : null,
+    progressPct: available ? progressPct : null,
     status,
     source: parsed.source,
     distribution7d: total7dKnown ? total7d : null,
@@ -106,22 +133,87 @@ function pushAction(adjustments, workflows, action) {
   if (action.workflow && !workflows.includes(action.workflow)) workflows.push(action.workflow);
 }
 
+// The channel named in the Commitment ("...via X replies and DMs; ...") — the
+// hero's support line uses it ("From X replies and DMs, by Jul 26"). Null-safe.
+function parseChannel(commitment) {
+  if (!commitment) return null;
+  const m = String(commitment).match(/\b(?:via|through|on|using)\s+([^;.,]+?)(?=\s*[;.,]|$)/i);
+  return m ? m[1].trim() : null;
+}
+
+// A scoped progress record's unit must be the SAME kind of thing as the target.
+// The HEAD noun (last word) must match, so "0/2 paying customers" counts toward a
+// "customers" target, but "2/2 customer support calls" (head = calls) and
+// "1/2 customer interviews" (head = interviews) do NOT — a shared adjective is not
+// a unit match, or a same-denominator side metric fabricates "Complete". [sol #12]
+function unitFamilyMatch(scopedUnit, targetUnit) {
+  const norm = (s) => String(s || "").toLowerCase().replace(/[^a-z ]+/g, " ").trim().replace(/s\b/g, "");
+  const t = norm(targetUnit).split(/\s+/).filter(Boolean);
+  const s = norm(scopedUnit).split(/\s+/).filter(Boolean);
+  if (!t.length || !s.length) return false;
+  return t[t.length - 1] === s[s.length - 1];  // head nouns must be identical
+}
+
+// What currency is the goal stated in, and does anything on file measure it?
+// Drives the goal-anchored verdict on Evidence: an installs goal is pushed by
+// distribution receipts; a distribution goal IS the receipts; a revenue or
+// vitality goal has no parser yet, so the card must say "unmeasured" instead
+// of pretending workflow counts answer it. Order matters: adoption phrasing
+// ("15 activated installs") usually also names the channel, so adoption wins
+// when both appear. Returns null when nothing matches (generic verdict).
+function classifyGoalKind(singleTest) {
+  const t = String(singleTest || "").toLowerCase();
+  if (!t) return null;
+  if (/\b(installs?|activat|referrals?|sign-?ups?|customers?|users?|sales?|purchases?|buyers?|strangers?)/.test(t)) return "adoption";
+  if (/\b(dms?|outreach|repl(y|ies)|posts?|publish\w*|distribut\w*|articles?|reels?|videos?|content|newsletters?|followers?|subscribers?|views?|audience|impressions?)\b/.test(t)) return "distribution";
+  if (/(revenue|mrr\b|income|profit|£|\$|€)/.test(t)) return "revenue";
+  if (/\b(sleep|gym|weight|prayers?|fajr|salah|steps|health|energy|fasting)\b/.test(t)) return "vitality";
+  return null;
+}
+
 function parseGoalProgress({ singleTest, sourceText, targetDate, now }) {
   const out = {
     singleTest: singleTest || null,
-    current: 0,
+    current: null,          // measured ONLY from a test-scoped record; null = unmeasured
     target: 0,
     unit: "customers",
+    counterKind: null,
+    shape: "unparseable",
+    progressMeasured: false,
     deadline: null,
     source: "strategy",
   };
 
   if (singleTest) {
+    // A multi-signal GATE ("Hit 2 of 3": 10 conversations / 5 install starts /
+    // 2 paid) is not one countable number. The single-counter regex below would
+    // grab "5 install starts" as target=5 and pair it with an unrelated sales
+    // count elsewhere on file, fabricating "4 of 5 installs". Detect the gate,
+    // refuse to collapse it, keep the deadline so the card can still pace to the
+    // date, and let the UI render the honest "scored by hand" state.
+    //
+    // The marker must be a gate VERDICT, not a bare "N of M": require a scoring
+    // verb (hit/pass/meet/clear, "of" or "out of") OR an "N of M =" verdict
+    // clause. A bare "N of M" would false-trigger on "Day 2 of 14: send 50 DMs"
+    // (a real distribution counter) and hide it; the verb/"=" gate keeps those
+    // parsing normally. A "+" rider ("15 installs + 1 referral") has no "of" at
+    // all and still parses its primary counter. [gate honesty, sol #10 hardening]
+    if (/\b(?:hit|hitting|pass(?:ed)?|meet|met|clear(?:ed)?)\s+\d+\s+(?:out\s+of|of)\s+\d+\b|\b\d+\s+(?:out\s+of|of)\s+\d+\s*=/i.test(singleTest)) {
+      out.gate = true;
+      out.counterKind = "gate";
+      out.shape = "compound";
+      out.deadline = extractDate(singleTest, now) || targetDate || null;
+      return out; // target stays 0 -> available:false -> honest-null, no fabricated counter
+    }
     // Regex captures count-based phrasing (e.g. "10 paying customers/sales")
     // AND activation phrasing ("N activated installs / referrals"). The
     // extended unit list keeps backwards-compat and makes an activation-style
     // mid-term metric ("N activated installs + M referrals by <date>") parse correctly.
-    const targetMatch = singleTest.match(/\b(\d+)\s+(?:paying\s+|activated\s+)?(?:strangers?|customers?|sales|users?|installs?|referrals?|activations?)\b/i);
+    // The negative lookahead stops an adoption noun acting as a MODIFIER of a
+    // distribution noun from being read as the counter: "10 sales posts" is a
+    // publishing target, never a sales counter. [terra F3, 2026-07-10]
+    const DIST_NOUN = "posts?|dms?|reels?|articles?|videos?|emails?|threads?|newsletters?";
+    const targetMatch = singleTest.match(new RegExp("\\b(\\d+)\\s+(?:paying\\s+|activated\\s+)?(?:strangers?|customers?|sales|users?|installs?|referrals?|activations?)\\b(?!\\s+(?:" + DIST_NOUN + ")\\b)", "i"));
     if (targetMatch) {
       out.target = Number(targetMatch[1]);
       // Set unit from the matched phrase so the hero strip says
@@ -131,29 +223,45 @@ function parseGoalProgress({ singleTest, sourceText, targetDate, now }) {
       else if (/referral/.test(phrase)) out.unit = "referrals";
       else if (/user/.test(phrase)) out.unit = "users";
       else out.unit = "customers";
+      out.counterKind = "adoption";
+      out.shape = "clean";
+    } else {
+      // Distribution counter ("publish 10 posts", "send 50 DMs", "10 sales
+      // posts"): the kind rides with the SAME match that set the number, so
+      // the verdict can never cite a counter the parse didn't produce.
+      const distMatch = singleTest.match(new RegExp("\\b(\\d+)\\s+(?:[a-z-]+\\s+)?(" + DIST_NOUN + ")\\b", "i"));
+      if (distMatch) {
+        out.target = Number(distMatch[1]);
+        out.unit = distMatch[2].toLowerCase();
+        out.counterKind = "distribution";
+        out.shape = "clean";
+      }
     }
     const deadline = extractDate(singleTest, now) || targetDate;
     if (deadline) out.deadline = deadline;
   }
 
   const text = sourceText || "";
-  const ratios = Array.from(text.matchAll(/\b(\d+)\s*\/\s*(\d+)\s*(?:sales|paying|customers?|strangers?|users?)\b/gi));
-  if (ratios.length) {
-    const latest = ratios[ratios.length - 1];
-    out.current = Number(latest[1]);
-    if (!out.target) out.target = Number(latest[2]);
-    out.source = "active_context_ratio";
-  }
 
-  const sales = [
-    ...Array.from(text.matchAll(/\b(?:LIVE,\s*|Status:\s*[^\n]{0,60}?|confirmed\s+|current:\s*)(\d+)\s+(?:SALES|sales|purchases)\b/g)),
-    ...Array.from(text.matchAll(/\b(\d+)\s+sales\s+confirmed\b/gi)),
-  ];
-  if (sales.length) {
-    const max = Math.max(...sales.map(m => Number(m[1])).filter(Number.isFinite));
-    if (Number.isFinite(max) && max > out.current) {
-      out.current = max;
-      out.source = "active_context_sales";
+  // Progress is TEST-SCOPED, and ONLY test-scoped. A generic lifetime line
+  // ("LIVE, 4 SALES" — all from April) or a historical ratio ("4/10 sales" from
+  // a dead strategy) must NOT count as progress toward THIS bet; doing so
+  // fabricated "4 of 2 · complete" the moment the target became a clean 2. The
+  // ONLY thing that counts as current is an explicit scoped record whose
+  // denominator and unit family match the active target:
+  //   "Current bet progress: 0/2 paying customers". [sol #11 cross-scope bug]
+  if (out.target) {
+    const scoped = text.match(/current\s+bet\s+progress:\s*(\d+)\s*\/\s*(\d+)\s*([a-z][a-z ]*)?/i);
+    if (scoped) {
+      const cur = Number(scoped[1]);
+      const den = Number(scoped[2]);
+      const scopedUnit = (scoped[3] || "").trim();
+      const unitOk = !scopedUnit || unitFamilyMatch(scopedUnit, out.unit);
+      if (Number.isFinite(cur) && den === out.target && unitOk) {
+        out.current = cur;               // a scoped ZERO is honest progress, not "unmeasured"
+        out.progressMeasured = true;
+        out.source = "scoped_progress";
+      }
     }
   }
 
@@ -166,8 +274,12 @@ function parseGoalProgress({ singleTest, sourceText, targetDate, now }) {
 
 function extractDate(text, now) {
   if (!text) return null;
-  const iso = text.match(/\b(20\d{2}-[01]\d-[0-3]\d)\b/);
-  if (iso) return iso[1];
+  const iso = text.match(/\b(20\d{2})-([01]\d)-([0-3]\d)\b/);
+  if (iso) {
+    // Impossible dates (2026-02-30) must yield NO deadline, not a silent
+    // JS rollover to March 2 rendered as a real target. [terra F4, 2026-07-10]
+    return validCalendarDay(Number(iso[1]), Number(iso[2]) - 1, Number(iso[3])) ? iso[0] : null;
+  }
   const months = ["jan","feb","mar","apr","may","jun","jul","aug","sep","sept","oct","nov","dec","january","february","march","april","june","july","august","september","october","november","december"];
   const m = text.match(new RegExp(`\\b(?:by\\s+)?(${months.join("|")})\\s+(\\d{1,2})(?:,?\\s*(20\\d{2}))?`, "i"));
   if (!m) return null;
@@ -175,9 +287,17 @@ function extractDate(text, now) {
   const day = Number(m[2]);
   const year = m[3] ? Number(m[3]) : now.getFullYear();
   if (month < 0 || !Number.isFinite(day)) return null;
+  if (!validCalendarDay(year, month, day)) return null; // "Feb 30" rolls over too
   return localDateKey(new Date(year, month, day));
 }
 
+// True only when (year, month0, day) names a day that exists: round-trip
+// through UTC and require every component to survive unchanged.
+function validCalendarDay(year, month0, day) {
+  const d = new Date(Date.UTC(year, month0, day));
+  return d.getUTCFullYear() === year && d.getUTCMonth() === month0 && d.getUTCDate() === day;
+}
+
 function monthIndex(name) {
   const n = String(name || "").toLowerCase().slice(0, 3);
   return { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 }[n] ?? -1;
@@ -301,4 +421,7 @@ function parseChainStages(chain) {
     .map((label) => ({ label, current: null }));
 }
 
-module.exports = { computeGoalForecast, parseDomainProgress };
+// parseGoalProgress exported for the menu-bar CLI (cmdPulseBar): the bar's
+// mission number must come from the SAME parse the dashboard shows, never a
+// second implementation that can drift. [owner: glance-number = the bet]
+module.exports = { computeGoalForecast, parseGoalProgress, parseDomainProgress, classifyGoalKind };

package/src/dashboard/lib/library-indexer-v2.js

@@ -3,6 +3,7 @@
 const path = require("path");
 const {
   archivesDir,
+  engineDir,
   libraryDir,
   libraryCheatsheetsDir,
   libraryPrinciplesDir,
@@ -189,6 +190,18 @@ function indexLibraryV2(vault) {
       .filter((e) => !e.name.startsWith(".") && !e.name.startsWith("_")).length;
   }
 
+  // Engine: count-only, top-level FILES of 02_Areas/Engine (subdirs like
+  // Dailies/ and State/ are their own worlds; the Library shelf browse lists
+  // exactly these files). Replaces a hardcoded 12 in the UI mapper — terra
+  // confirmed it fabricated (real vault held 15) and it contaminated the
+  // "indexed" headline sum (2026-07-12). Not added to totalCount, same
+  // reasoning as archives.
+  const engine = { count: 0 };
+  if (exists(engineDir(vault))) {
+    engine.count = safeListDir(engineDir(vault))
+      .filter((e) => e.isFile && !e.name.startsWith(".")).length;
+  }
+
   const totalCount =
     mocs.count + principles.count + cheatsheets.count + sops.count +
     scripts.count + inputs.count + entities.count;
@@ -205,6 +218,7 @@ function indexLibraryV2(vault) {
       inputs,
       entities,
       archives,
+      engine,
     },
   };
 }