mover-os 4.7.6 → 4.7.8

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

@@ -0,0 +1,294 @@
+"use strict";
+
+// feed-parser.js — the live work feed. A plain sentence per real work event.
+//
+// SOURCE (live, local, never telemetry):
+//   1. ~/.claude/history.jsonl  — one line per real prompt the user typed into a
+//      Claude Code session: { display, timestamp(ms), project, sessionId }.
+//      Each line IS a real work event (a thing that actually happened in a real
+//      session under this vault). We tail the last N and turn each into a plain
+//      sentence.
+//   2. ~/.claude/sessions/*.json — live session descriptors:
+//      { pid, sessionId, cwd, startedAt(ms), updatedAt(ms), status, version,
+//        name, ... }. These tell us which sessions are open right now.
+//
+// SCOPING (Codex must-fix / v6 amendment fix 8 nice-to-have): resolve the
+// project slug AND each session cwd to a REALPATH and test containment against
+// THIS vault's realpath — NOT a loose `project` string match. A symlinked or
+// case-differing vault path still scopes correctly; an unrelated project that
+// happens to share a path prefix string does not leak in.
+//
+// HARD HONESTY (v6-PLAN-AMENDMENTS fix 8 + Fable Finding C — binding):
+//   - NO `cost` field. There is no per-step token source. We do not invent one.
+//   - NO `diff` field. There is no per-step diff source. The only file signal we
+//     emit is, at most, a real path that already appears in the user's own text.
+//   Each event is a plain sentence + ids. Nothing more.
+//
+// FALSE-ZERO (T261 discipline): if nothing real is happening under this vault —
+// no in-vault history events AND no in-vault sessions — return
+//   { available:false, events:[], activeSessions:[], caption:'' }.
+// We never fabricate scripted demo steps to fill an empty feed.
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { redactText } = require("./redaction");
+
+const HISTORY_FILE = path.join(os.homedir(), ".claude", "history.jsonl");
+const SESSIONS_DIR = path.join(os.homedir(), ".claude", "sessions");
+
+// A session counts as "active" only if its descriptor was touched recently.
+// Claude writes `updatedAt` on every turn; a stale file is a dead process whose
+// descriptor was never cleaned up. 30 min is generous for "this is live".
+const ACTIVE_WINDOW_MS = 30 * 60 * 1000;
+
+// ---------------------------------------------------------------------------
+// realpath-based vault scoping
+// ---------------------------------------------------------------------------
+
+// Resolve a path to its realpath when it exists on disk; fall back to a
+// lexical normalize (resolves `..`/`.` without touching disk) so a recorded
+// path for a since-deleted dir still scopes sanely. Never throws.
+function resolveReal(p) {
+  if (!p || typeof p !== "string") return null;
+  try {
+    return fs.realpathSync.native(p);
+  } catch (_) {
+    try {
+      return path.resolve(p);
+    } catch (_) {
+      return null;
+    }
+  }
+}
+
+// True when `child` is the same path as, or nested under, `root`. Compares on a
+// path-segment boundary (root + sep) so `/a/Mover OS` does NOT match
+// `/a/Mover OS Bundle 2`. Case-insensitive on darwin/win32 where the FS is.
+function isUnder(child, root) {
+  if (!child || !root) return false;
+  const ci = process.platform === "darwin" || process.platform === "win32";
+  let c = ci ? child.toLowerCase() : child;
+  let r = ci ? root.toLowerCase() : root;
+  if (c === r) return true;
+  const withSep = r.endsWith(path.sep) ? r : r + path.sep;
+  return c.startsWith(withSep);
+}
+
+// ---------------------------------------------------------------------------
+// event classification — plain, honest, source-backed
+// ---------------------------------------------------------------------------
+
+// A leading slash means the user invoked a workflow / command — a deliberate
+// "move". Everything else is a typed prompt to the agent terminal.
+function classify(display) {
+  const text = (display || "").trim();
+  if (text.startsWith("/")) {
+    // /plan-tomorrow, /log, /compact ... → kind is the bare command token.
+    const cmd = text.slice(1).split(/[\s\n]/, 1)[0].toLowerCase();
+    return { lane: "move", kind: cmd ? `/${cmd}` : "command" };
+  }
+  return { lane: "term", kind: "prompt" };
+}
+
+// Turn a raw multi-line prompt into one clean redacted sentence. We keep the
+// user's own words (that's the honest signal) — only collapse whitespace, trim
+// to a readable length, and run the privacy scrubber over the result.
+function toSentence(display) {
+  let t = (display || "").replace(/\s+/g, " ").trim();
+  if (!t) return "";
+  // Trim to a feed-readable length on a word boundary; mark truncation with an
+  // ellipsis so it never reads as a fabricated complete thought.
+  const MAX = 180;
+  if (t.length > MAX) {
+    const cut = t.slice(0, MAX);
+    const lastSpace = cut.lastIndexOf(" ");
+    t = (lastSpace > 80 ? cut.slice(0, lastSpace) : cut).trim() + "…";
+  }
+  return redactText(t).text;
+}
+
+// ---------------------------------------------------------------------------
+// session descriptors
+// ---------------------------------------------------------------------------
+
+function readSessions(vaultReal) {
+  let names;
+  try {
+    names = fs.readdirSync(SESSIONS_DIR);
+  } catch (_) {
+    return [];
+  }
+  const now = Date.now();
+  const sessions = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    let desc;
+    try {
+      desc = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, name), "utf8"));
+    } catch (_) {
+      continue; // skip mid-write / corrupt descriptor
+    }
+    if (!desc || typeof desc !== "object") continue;
+    const cwdReal = resolveReal(desc.cwd);
+    const isThisVault = isUnder(cwdReal, vaultReal);
+    const updatedAt = Number(desc.updatedAt) || Number(desc.startedAt) || 0;
+    // status: trust the descriptor when present; otherwise infer from recency.
+    // A descriptor with no `status`/`updatedAt` that hasn't been touched in the
+    // active window is a leftover from a closed process — mark it "idle".
+    let status = typeof desc.status === "string" && desc.status ? desc.status : null;
+    const fresh = updatedAt > 0 && now - updatedAt <= ACTIVE_WINDOW_MS;
+    if (!status) status = fresh ? "active" : "idle";
+    sessions.push({
+      name: desc.name || "",
+      cwd: desc.cwd || "",
+      status,
+      version: desc.version || "",
+      startedAt: Number(desc.startedAt) ? new Date(Number(desc.startedAt)).toISOString() : null,
+      updatedAt: updatedAt ? new Date(updatedAt).toISOString() : null,
+      isThisVault: Boolean(isThisVault),
+      _fresh: fresh,
+    });
+  }
+  // Most-recently-active first.
+  sessions.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""));
+  return sessions;
+}
+
+// Map a sessionId → a friendly name from the live descriptors, so a feed row
+// can show "landing-polar-overhaul" instead of a bare uuid.
+function buildSessionNameMap() {
+  const map = new Map();
+  let names;
+  try {
+    names = fs.readdirSync(SESSIONS_DIR);
+  } catch (_) {
+    return map;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const desc = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, name), "utf8"));
+      if (desc && desc.sessionId && desc.name) map.set(desc.sessionId, desc.name);
+    } catch (_) {
+      /* skip */
+    }
+  }
+  return map;
+}
+
+// ---------------------------------------------------------------------------
+// history events (tailed, scoped, redacted)
+// ---------------------------------------------------------------------------
+
+function readEvents(vaultReal, limit, sessionNames) {
+  let raw;
+  try {
+    raw = fs.readFileSync(HISTORY_FILE, "utf8");
+  } catch (_) {
+    return [];
+  }
+  const lines = raw.split("\n");
+  // Memoize realpath per distinct `project` string — history has thousands of
+  // lines but only a handful of distinct projects, and realpath hits disk.
+  const projectScopeCache = new Map();
+  const inVault = (project) => {
+    if (projectScopeCache.has(project)) return projectScopeCache.get(project);
+    const real = resolveReal(project);
+    const ok = isUnder(real, vaultReal);
+    projectScopeCache.set(project, ok);
+    return ok;
+  };
+
+  const events = [];
+  // Walk newest → oldest, collect up to `limit` in-vault events, then flip to
+  // chronological. Tailing from the end keeps this cheap on a large history.
+  for (let i = lines.length - 1; i >= 0 && events.length < limit; i--) {
+    const line = lines[i];
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (_) {
+      continue;
+    }
+    const project = obj.project;
+    if (!project || !inVault(project)) continue;
+
+    const display = obj.display;
+    const text = toSentence(display);
+    if (!text) continue; // nothing real to say
+
+    const tsMs = Number(obj.timestamp) || 0;
+    const { lane, kind } = classify(display);
+    const sessionId = obj.sessionId || "";
+    events.push({
+      ts: tsMs ? new Date(tsMs).toISOString() : null,
+      sessionId,
+      sessionName: (sessionId && sessionNames.get(sessionId)) || "",
+      lane, // 'move' | 'term'
+      kind,
+      text,
+      project,
+    });
+  }
+  events.reverse(); // chronological (oldest of the tail → newest)
+  return events;
+}
+
+// ---------------------------------------------------------------------------
+// public API
+// ---------------------------------------------------------------------------
+
+// compute({ vault, limit }) → live work-feed payload.
+//   available       false when nothing real is happening under this vault
+//   caption         one honest line summarizing the feed (or '')
+//   events          [{ ts, sessionId, sessionName, lane, kind, text, project }]
+//   activeSessions  [{ name, cwd, status, version, startedAt, updatedAt, isThisVault }]
+//
+// No `cost`, no `diff` — there is no per-step source for either (binding).
+function compute({ vault, limit = 40 } = {}) {
+  const EMPTY = { available: false, caption: "", events: [], activeSessions: [] };
+  if (!vault || typeof vault !== "string") return EMPTY;
+
+  const vaultReal = resolveReal(vault);
+  if (!vaultReal) return EMPTY;
+
+  const lim = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 40;
+
+  const sessions = readSessions(vaultReal);
+  const sessionNames = buildSessionNameMap();
+  const events = readEvents(vaultReal, lim, sessionNames);
+
+  // Active sessions surfaced to the UI = sessions running under THIS vault.
+  const activeSessions = sessions
+    .filter((s) => s.isThisVault)
+    .map(({ _fresh, ...s }) => s); // drop internal field
+
+  // False-zero discipline: a feed with no in-vault events AND no in-vault
+  // sessions is genuinely "nothing running" → unavailable, never a demo.
+  if (events.length === 0 && activeSessions.length === 0) return EMPTY;
+
+  // Honest caption from real counts only. "live" = a descriptor this vault owns
+  // that is currently active/busy (recently touched).
+  const liveNow = sessions.filter((s) => s.isThisVault && (s.status === "active" || s.status === "busy")).length;
+  let caption;
+  if (events.length === 0) {
+    caption = liveNow > 0 ? `${liveNow} session${liveNow === 1 ? "" : "s"} open — no events yet` : "";
+  } else {
+    const moves = events.filter((e) => e.lane === "move").length;
+    const parts = [`${events.length} recent event${events.length === 1 ? "" : "s"}`];
+    if (moves > 0) parts.push(`${moves} move${moves === 1 ? "" : "s"}`);
+    if (liveNow > 0) parts.push(`${liveNow} live`);
+    caption = parts.join(" · ");
+  }
+
+  return {
+    available: true,
+    caption,
+    events,
+    activeSessions,
+  };
+}
+
+module.exports = { compute };

package/src/dashboard/lib/forked-future.js

@@ -0,0 +1,60 @@
+"use strict";
+
+// forked-future.js — Two-path drift projection for the Briefing module.
+// Each scenario is a confidence-coned sparkline:
+//   path A: "if you hold the pattern" — extrapolates current drift trajectory
+//   path B: "if you break the pattern" — drift falls toward baseline (15-20)
+//
+// Pure function: takes current drift score + recent trajectory + active
+// patterns, returns two arrays of {value, lo, hi} points across N days.
+
+function compute({ driftScore = null, recent7d = [], activePatterns = [], horizonDays = 14 } = {}) {
+  if (!driftScore) return null;
+
+  const current = driftScore.value;
+  const baseline = 15;            // healthy floor target
+  const ceiling = 100;
+  const trendDelta = computeTrend(recent7d);
+  const patternWeight = Math.min(1, (activePatterns || []).filter(p => p.confidence >= 3).length * 0.15);
+
+  // Path A: hold the pattern. Trajectory continues at observed slope, with
+  // pattern weight pulling toward ceiling (active Conf 3+ patterns add drift).
+  const slopeA = trendDelta + 0.6 + patternWeight * 0.8;
+  const holdPath = [];
+  for (let i = 0; i <= horizonDays; i++) {
+    const v = Math.min(ceiling, Math.max(0, current + slopeA * i));
+    const spread = 3 + i * 0.8; // widening confidence cone
+    holdPath.push({ day: i, value: round(v), lo: round(v - spread), hi: round(Math.min(ceiling, v + spread)) });
+  }
+
+  // Path B: break the pattern. Drift decays toward baseline at -2/day (faster
+  // initially), with smaller confidence cone (the action is causal).
+  const breakPath = [];
+  for (let i = 0; i <= horizonDays; i++) {
+    const v = baseline + (current - baseline) * Math.pow(0.85, i);
+    const spread = 2 + i * 0.4;
+    breakPath.push({ day: i, value: round(v), lo: round(Math.max(0, v - spread)), hi: round(v + spread) });
+  }
+
+  return {
+    horizonDays,
+    current,
+    baseline,
+    holdPath,
+    breakPath,
+    interpretation: {
+      hold: `${slopeA >= 0.6 ? 'Drift climbs' : 'Drift drifts'} toward ${holdPath[holdPath.length - 1].value}/100 in ${horizonDays} days if pattern continues.`,
+      break: `Drift falls toward ${breakPath[breakPath.length - 1].value}/100 if the next 3 sessions break the pattern.`
+    }
+  };
+}
+
+function computeTrend(values) {
+  if (!values || values.length < 2) return 0;
+  // Simple slope: last - first / count
+  return (values[values.length - 1] - values[0]) / Math.max(1, values.length - 1);
+}
+
+function round(v) { return Math.round(v * 10) / 10; }
+
+module.exports = { compute };

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

@@ -0,0 +1,304 @@
+"use strict";
+
+const { localDateKey } = require("./date-utils");
+
+function computeGoalForecast({ strategy, activeContext, distribution, engineHealth, daily, now = new Date() } = {}) {
+  const sourceText = [
+    activeContext && activeContext.raw,
+    strategy && strategy.singleTest,
+  ].filter(Boolean).join("\n");
+
+  const parsed = parseGoalProgress({
+    singleTest: strategy && strategy.singleTest,
+    sourceText,
+    targetDate: strategy && strategy.targetDate,
+    now,
+  });
+
+  const current = parsed.current;
+  const target = parsed.target;
+  const needed = Math.max(0, target - current);
+  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
+    ? null
+    : daysSafe === 0 ? needed : round(needed / daysSafe, 2);
+  const progressPct = target > 0 ? Math.min(100, Math.round((current / target) * 100)) : 0;
+
+  let status = "unknown";
+  if (target && current >= target) status = "complete";
+  else if (daysRemaining != null && daysRemaining < 0) status = "failed";
+  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";
+
+  // Only act on distribution we actually measured. Unavailable (null) distribution
+  // must NOT trigger a "0 actions logged" experiment. [false-zero — Codex, T261]
+  const total7dKnown = !!(distribution && distribution.available !== false && Number.isFinite(distribution.total7d));
+  const total7d = total7dKnown ? distribution.total7d : 0;
+  const adjustments = [];
+  const workflows = [];
+
+  if (engineHealth && engineHealth.analyseDay && engineHealth.analyseDay.status === "RED") {
+    pushAction(adjustments, workflows, {
+      workflow: "/analyse-day",
+      title: "Run a day review before more strategy edits",
+      detail: `You haven't reviewed a day in ${engineHealth.analyseDay.overdueDays} days. Run /analyse-day to get the dashboard current.`,
+      priority: "critical",
+    });
+  }
+  // Only treat strategy health as "trouble" when the scan actually ran and
+  // returned a concrete RED/YELLOW. A null status from an unavailable scan must
+  // NOT trigger /pivot-strategy. [false-zero regression fix — Codex P1, T261]
+  const strategyTrouble = engineHealth && engineHealth.available !== false
+    && engineHealth.strategy && (engineHealth.strategy.status === "RED" || engineHealth.strategy.status === "YELLOW");
+  if (status === "failed" || status === "unlikely" || strategyTrouble) {
+    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.`,
+      priority: status === "failed" ? "critical" : "high",
+    });
+  }
+  if (needed > 0 && total7dKnown && total7d < 10) {
+    pushAction(adjustments, workflows, {
+      workflow: "/experiment",
+      title: "Open a distribution experiment",
+      detail: `Only ${total7d} distribution actions logged in 7 days. Test one channel loop with a falsifiable metric instead of adding more dashboard surface.`,
+      priority: "high",
+    });
+  }
+  if (daily && daily.today && !daily.today.exists) {
+    pushAction(adjustments, workflows, {
+      workflow: "/plan-tomorrow",
+      title: "Set today's execution list",
+      detail: "No Daily Note found for today, so the dashboard is missing the live plan it should enforce.",
+      priority: "medium",
+    });
+  }
+
+  // available:false when no real target parsed → null out the numerals so the UI
+  // shows its honest "no measurable test" / "calibrating" state, never a
+  // fabricated "0/10". [false-zero discipline, T261]
+  const available = !!target;
+  return {
+    available,
+    singleTest: parsed.singleTest || null,
+    current: available ? current : null,
+    target: available ? target : null,
+    unit: parsed.unit,
+    deadline,
+    daysRemaining,
+    needed,
+    requiredPerDay,
+    progressPct,
+    status,
+    source: parsed.source,
+    distribution7d: total7dKnown ? total7d : null,
+    adjustments,
+    workflows,
+  };
+}
+
+function pushAction(adjustments, workflows, action) {
+  adjustments.push(action);
+  if (action.workflow && !workflows.includes(action.workflow)) workflows.push(action.workflow);
+}
+
+function parseGoalProgress({ singleTest, sourceText, targetDate, now }) {
+  const out = {
+    singleTest: singleTest || null,
+    current: 0,
+    target: 0,
+    unit: "customers",
+    deadline: null,
+    source: "strategy",
+  };
+
+  if (singleTest) {
+    // 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);
+    if (targetMatch) {
+      out.target = Number(targetMatch[1]);
+      // Set unit from the matched phrase so the hero strip says
+      // "activated installs" instead of the default "customers" on V4.
+      const phrase = targetMatch[0].toLowerCase();
+      if (/install/.test(phrase)) out.unit = "activated installs";
+      else if (/referral/.test(phrase)) out.unit = "referrals";
+      else if (/user/.test(phrase)) out.unit = "users";
+      else out.unit = "customers";
+    }
+    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";
+    }
+  }
+
+  // No fabricated target: if the Single Test carries no parseable number,
+  // target stays 0 → computeGoalForecast reports available:false (honest "no
+  // measurable test") instead of a made-up "0/10". [false-zero discipline, T261]
+  if (!out.deadline) out.deadline = targetDate || extractDate(text, now);
+  return out;
+}
+
+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 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;
+  const month = monthIndex(m[1]);
+  const day = Number(m[2]);
+  const year = m[3] ? Number(m[3]) : now.getFullYear();
+  if (month < 0 || !Number.isFinite(day)) return null;
+  return localDateKey(new Date(year, month, 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;
+}
+
+// T242 bug hunt fix (B#16): previously `new Date(`${iso}T00:00:00`)` parsed
+// as LOCAL time. Across DST transitions (Mar/Nov in US, Mar/Oct in EU)
+// two consecutive days are 23 or 25 hours apart, so the ceil-divide by a
+// fixed 86400000ms returned 0 or 2 for what should be 1. Goal countdown
+// chips flickered around DST. Use UTC midnight + calendar-day math.
+function daysBetween(fromIso, toIso) {
+  const fromUtc = Date.parse(`${fromIso}T00:00:00Z`);
+  const toUtc = Date.parse(`${toIso}T00:00:00Z`);
+  if (!Number.isFinite(fromUtc) || !Number.isFinite(toUtc)) return null;
+  return Math.round((toUtc - fromUtc) / (24 * 3600 * 1000));
+}
+
+function round(n, d) {
+  const p = Math.pow(10, d);
+  return Math.round(n * p) / p;
+}
+
+// ── Per-domain measurement dispatcher ─────────────────────────────────────────
+// Each domain declares a measurement SHAPE in Strategy.md (single | chain | scalar
+// | streak). This routes the declaration + whatever live source exists into a
+// render-ready progress object, honest-null wherever a domain has not logged data
+// yet. The dashboard renders the shape; the fuel arrives once the user logs it.
+function parseDomainProgress({ domain, decl, goalForecast, streak, metricsLog } = {}) {
+  if (!decl || !decl.type) return { available: false, type: null };
+  const type = decl.type;
+
+  if (type === "single") {
+    // Work's single test is already computed by computeGoalForecast. Other domains
+    // declaring single have no per-domain count source yet -> honest-null.
+    if (domain === "work" && goalForecast && goalForecast.available) {
+      return {
+        available: true, type: "single",
+        current: goalForecast.current, target: goalForecast.target,
+        unit: goalForecast.unit || null, progressPct: goalForecast.progressPct ?? null,
+        status: goalForecast.status || null,
+      };
+    }
+    return { available: false, type: "single", current: null, target: numFrom(decl.target), unit: null };
+  }
+
+  if (type === "scalar") {
+    const baseline = numFrom(decl.baseline);
+    const target = numFrom(decl.target);
+    const current = scalarCurrent(decl, metricsLog); // best-effort; null until logged
+    const progressPct =
+      baseline != null && target != null && current != null && target !== baseline
+        ? clampPct(Math.round(((current - baseline) / (target - baseline)) * 100))
+        : null;
+    return {
+      available: current != null, type: "scalar",
+      baseline, target, current,
+      baselineText: decl.baseline || null, targetText: decl.target || null,
+      progressPct,
+    };
+  }
+
+  if (type === "streak") {
+    // streak-parser tracks day-PRESENCE (a daily note exists), NOT whether the
+    // declared practice was actually done. Presenting that as the practice streak
+    // would be a false signal, so the count stays honest-null until a per-practice
+    // source exists; the ring renders its ready/empty state.
+    return {
+      available: false, type: "streak",
+      currentStreak: null, longestStreak: null, todayDone: null,
+      note: "activates once the practice is logged",
+    };
+  }
+
+  if (type === "chain") {
+    const stages = parseChainStages(decl.chain); // [] when no chain math declared
+    return {
+      available: false, type: "chain",
+      stages, bottleneck: null,
+      note: stages.length ? "awaiting per-stage numbers" : "declare the chain (revenue -> ... -> daily action)",
+    };
+  }
+
+  return { available: false, type };
+}
+
+// Pull a leading number out of a prose value ("7.5h sleep" -> 7.5, "78 kg" -> 78).
+function numFrom(text) {
+  if (text == null) return null;
+  const m = String(text).match(/-?\d+(?:\.\d+)?/);
+  return m ? Number(m[0]) : null;
+}
+
+function clampPct(n) {
+  if (!Number.isFinite(n)) return null;
+  return Math.max(0, Math.min(100, n));
+}
+
+// Best-effort current value for a scalar domain from the metrics log's latest
+// readings, matched by keyword. Null (honest) when nothing matches.
+function scalarCurrent(decl, metricsLog) {
+  if (!metricsLog || metricsLog.available === false) return null;
+  const hay = ((decl.target || "") + " " + (decl.baseline || "")).toLowerCase();
+  const pick = /sleep/.test(hay) ? metricsLog.sleepLatest
+    : /weight|kg|\blb/.test(hay) ? metricsLog.weightLatest
+    : /hrv/.test(hay) ? metricsLog.hrvLatest
+    : /rhr|resting|heart/.test(hay) ? metricsLog.rhrLatest
+    : null;
+  return numFrom(pick);
+}
+
+// Split a declared chain ("$10k = 100 sales = 1k calls at 10% = 50 DMs/day") into
+// ordered stages. Each stage is a label only; the live per-stage numbers arrive
+// from the logged funnel, so `current` is honest-null here.
+function parseChainStages(chain) {
+  if (!chain) return [];
+  return String(chain)
+    .split(/\s*(?:=|->|→|>)\s*/)
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .slice(0, 6)
+    .map((label) => ({ label, current: null }));
+}
+
+module.exports = { computeGoalForecast, parseDomainProgress };