mover-os 4.7.7 → 4.7.9

package/src/dashboard/build.js

@@ -0,0 +1,1541 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const {
+  dashboardOutDir,
+  dashboardIndexPath,
+  dashboardBuildLogPath
+} = require("./lib/paths");
+
+const { parseActiveContext } = require("./lib/active-context-parser");
+const { parseAutoLearnings } = require("./lib/auto-learnings-parser");
+const { loadPatternManifest } = require("./lib/pattern-manifest-loader");
+const { readStats: readActivationStats } = require("./lib/activation-log");
+const { scanProjects } = require("./lib/project-scanner");
+const { computeEngineHealth } = require("./lib/engine-health");
+const { resolveDailyNotes } = require("./lib/daily-note-resolver");
+const { parseIdentity } = require("./lib/identity-parser");
+const { parseStrategy } = require("./lib/strategy-parser");
+const { parseGoals } = require("./lib/goals-parser");
+const { computeSuggestions } = require("./lib/suggested-now");
+const { indexLibrary } = require("./lib/library-indexer");
+const { parseVoiceDna } = require("./lib/voice-dna-parser");
+const { parseMetricsLog } = require("./lib/metrics-log-parser");
+const { parseHealthProtocols } = require("./lib/health-protocols-parser");
+const { detectAgents } = require("./lib/agent-detector");
+const { readHookActivity } = require("./lib/hook-activity");
+const { parseDossier } = require("./lib/dossier-parser");
+const driftScore = require("./lib/drift-score");
+const driftHistory = require("./lib/drift-history");
+const phantomStrategy = require("./lib/phantom-strategy");
+const promiseWall = require("./lib/promise-wall");
+const forkedFuture = require("./lib/forked-future");
+const workflowLibrary = require("./lib/workflow-library-parser");
+const hourlyActivity = require("./lib/hourly-activity-parser");
+const sessionTime = require("./lib/session-time-parser");
+// Wave 2 — wiring previously-built parsers into StateJson.
+const strategyParser = require("./lib/strategy-parser");
+const identityParser = require("./lib/identity-parser");
+const goalsParser = require("./lib/goals-parser");
+const projectScanner = require("./lib/project-scanner");
+const metricsLog = require("./lib/metrics-log-parser");
+const libraryIndexer = require("./lib/library-indexer");
+// Wave 5 — newest parsers
+const distributionParser = require("./lib/distribution-parser");
+const streakParser = require("./lib/streak-parser");
+const overrideOutcomeParser = require("./lib/override-outcome-parser");
+const refusalParser = require("./lib/refusal-parser");
+const { normalizeOverrides, computeOverrideSummary } = require("./lib/override-summary");
+const { computeGoalForecast, parseDomainProgress } = require("./lib/goal-forecast");
+const { computeExecutionPlan } = require("./lib/execution-plan");
+const antiIdentityDetector = require("./lib/anti-identity-detector");
+const vaultGraphParser = require("./lib/vault-graph-parser");
+
+// v2 dashboard indexers — net additions for the holistic rebuild.
+// Surfaces Skills (60+ AI skill packs), Hooks (~23 scripts), CLI usage,
+// and a richer Library index with file paths + frontmatter + previews.
+const { indexSkills } = require("./lib/skill-indexer");
+const { indexHooks } = require("./lib/hook-indexer");
+const { parseCliUsage } = require("./lib/cli-usage-parser");
+// v6 W1 parsers (Wave 1 foundation)
+const movesUsageParser = require("./lib/moves-usage-parser");
+const feedParser = require("./lib/feed-parser");
+const rewindSnapshots = require("./lib/rewind-snapshots");
+const recordScoreLib = require("./lib/record-score");
+const { indexLibraryV2 } = require("./lib/library-indexer-v2");
+
+// Execution Protocol parser — pulls "Daily floor" / "Daily minimum output"
+// items per domain from Strategy.md (Work / Vitality / Faith). This is the
+// SOURCE OF TRUTH for the Briefing route's Execution Protocol checkboxes.
+const { parseStrategyProtocol } = require("./lib/strategy-protocol-parser");
+
+// Lab parser — walks 02_Areas/Engine/Experiments/*.md and emits the
+// hypothesis register: active experiments, KPI bars, sample progress,
+// friction chips. Drives the /lab route.
+const { buildExperiments } = require("./lib/experiments-parser");
+
+function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }
+
+function readTemplate(filename) {
+  const tplPath = path.join(__dirname, "templates", filename);
+  return fs.readFileSync(tplPath, "utf8");
+}
+
+function copyStatic(outDir) {
+  const cssSrc = path.join(__dirname, "styles.css");
+  const jsSrc = path.join(__dirname, "dashboard.js");
+  if (fs.existsSync(cssSrc)) fs.copyFileSync(cssSrc, path.join(outDir, "styles.css"));
+  if (fs.existsSync(jsSrc)) fs.copyFileSync(jsSrc, path.join(outDir, "dashboard.js"));
+}
+
+function escape(s) {
+  if (s === null || s === undefined || s === "") return "—";
+  return String(s).replace(/[&<>"']/g, (c) => ({ "&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;" }[c]));
+}
+
+function rawHtml(s) { return s == null ? "" : String(s); }
+
+function formatTime(d) { return `${String(d.getHours()).padStart(2,"0")}:${String(d.getMinutes()).padStart(2,"0")}`; }
+function formatDate(d) {
+  const days = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
+  const months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
+  return `${days[d.getDay()]} ${months[d.getMonth()]} ${d.getDate()}`;
+}
+
+function frictionClass(level) {
+  const num = parseInt(String(level || "L0").replace(/[^\d]/g,""), 10) || 0;
+  if (num >= 3) return "l3";
+  if (num >= 2) return "l2";
+  if (num >= 1) return "l1";
+  return "l0";
+}
+
+function frictionPct(level) {
+  const num = parseInt(String(level || "L0").replace(/[^\d]/g,""), 10) || 0;
+  return Math.min(100, num * 33);
+}
+
+async function build({ vault, version }) {
+  const startedAt = Date.now();
+  const errors = [];
+
+  function tryParse(name, fn, fallback = null) {
+    try { return fn(); } catch (e) { errors.push(`[${name}] ${e.message}`); return fallback; }
+  }
+
+  // Parse all data sources
+  const ac = tryParse("active-context", () => parseActiveContext(vault), { available: false });
+  const al = tryParse("auto-learnings", () => parseAutoLearnings(vault), { available: false, entries: [], stats: {}, activePatternsConf3Plus: [], growingPatterns: [], escalatedPatterns: [] });
+  const manifest = tryParse("pattern-manifest", () => loadPatternManifest(), { available: false });
+  const projects = tryParse("projects", () => scanProjects(vault, { limit: 8 }), { available: false, projects: [] });
+  const engineHealth = tryParse("engine-health", () => computeEngineHealth(vault), null);
+  const daily = tryParse("daily-note", () => resolveDailyNotes(vault, { lookback: 30 }), null);
+  const identity = tryParse("identity", () => parseIdentity(vault), { available: false });
+  const strategy = tryParse("strategy", () => parseStrategy(vault), { available: false });
+  const goals = tryParse("goals", () => parseGoals(vault), { available: false });
+  const library = tryParse("library", () => indexLibrary(vault), { available: false });
+  const voiceDna = tryParse("voice-dna", () => parseVoiceDna(vault), { available: false });
+  const metrics = tryParse("metrics", () => parseMetricsLog(vault), { available: false });
+  const healthProtocols = tryParse("health-protocols", () => parseHealthProtocols(vault), { available: false, protocols: [] });
+  const agents = tryParse("agents", () => detectAgents(), { available: false, agents: [] });
+  const hookActivity = tryParse("hook-activity", () => readHookActivity(), { available: false, recentMarkers: [] });
+  const dossier = tryParse("dossier", () => parseDossier(vault), { available: false });
+
+  // V5 wiring (wishlist #49 — Codex viral pick #1). Parser already shipped
+  // but the UI module + state.json field never landed. Walks Daily Notes
+  // for FLAG/VERDICT/ROAST markers + Auto_Learnings escalations.
+  const { compute: computeRoastWall } = require("./lib/roast-wall-parser");
+  const roastWall = tryParse(
+    "roast-wall",
+    () => computeRoastWall({ vault, autoLearnings: al, daysLookback: 60 }),
+    { available: false, count: 0, roasts: [], stats: { high: 0, med: 0, low: 0 } }
+  );
+
+  // Phase 41.7 — Workflow read/write graph. Scans src/workflows/*.md for
+  // reads/writes annotations + engine file references; builds the
+  // directed graph powering Library → Workflow Graph tab.
+  const { scan: scanWorkflowGraph } = require("./lib/workflow-graph-parser");
+  const bundleRoot = path.join(__dirname, "..", "..");
+  const workflowGraph = tryParse(
+    "workflow-graph",
+    () => scanWorkflowGraph({ bundleRoot }),
+    { available: false, workflowCount: 0, workflows: [], edges: [], files: [] }
+  );
+
+  // Black Box Correlations (V5_CLOSED_LOOP wishlist). Pearson r between
+  // Battery signals (sleep/protein/energy) and output signals
+  // (tasksDone/sessionCount/energy). Honest empty states when data sparse.
+  const { compute: computeCorrelations } = require("./lib/correlations-parser");
+  const correlations = tryParse(
+    "correlations",
+    () => computeCorrelations({ vault, windowDays: 30 }),
+    { available: false, reason: "parser_error" }
+  );
+
+  const now = new Date();
+
+  // Audit pass 2 (find-bugs #4): snoozes are loaded later into state.json
+  // but computeSuggestions ran without them, so a snoozed workflow stayed
+  // pinned to suggestedNow[0] until the rebuild after expiry. Load snoozes
+  // here and pass through so live snoozes filter out of recommendations.
+  const snoozeList = (() => {
+    try {
+      const snoozePath = path.join(os.homedir(), ".mover", "dashboard", "snoozes.json");
+      if (!fs.existsSync(snoozePath)) return [];
+      const raw = JSON.parse(fs.readFileSync(snoozePath, "utf8"));
+      return Array.isArray(raw) ? raw : [];
+    } catch (_) { return []; }
+  })();
+  const suggestions = tryParse("suggested-now", () => computeSuggestions({
+    now, ac, manifest, daily, engineHealth, strategy, projects, snoozes: snoozeList
+  }, { limit: 3 }), []);
+
+  // Compute "Today's Call" from energy + Single Test
+  const todayCall = computeTodayCall({ ac, manifest, engineHealth, friction: manifest ? manifest.frictionLevel : "L0" });
+
+  // Days to Single Test target
+  const daysToTest = computeDaysToTarget(strategy, manifest);
+
+  // Compute today's progress percentage
+  const todayProgress = computeTodayProgress(daily);
+  const studioVerdict = computeStudioVerdict({
+    todayCall,
+    manifest,
+    engineHealth,
+    daysToTest,
+    strategy
+  });
+
+  // Render template
+  const template = readTemplate("index.html");
+
+  const tokens = {
+    // Header
+    header_date: formatDate(now),
+    header_time: formatTime(now),
+    header_completion: dailyCompletionString(daily),
+    header_streak: daily ? String(daily.streak || 0) : "—",
+    header_friction: manifest ? (manifest.frictionLevel || "L0") : "—",
+    header_friction_class: frictionClass(manifest ? manifest.frictionLevel : "L0"),
+    header_engine_health: engineHealth ? engineHealth.overallStatus : "—",
+    header_engine_health_class: engineHealth ? engineHealth.overallStatus.toLowerCase() : "unknown",
+    header_days_to_test: daysToTest != null ? String(daysToTest) : "—",
+    studio_verdict_title: escape(studioVerdict.title),
+    studio_verdict_subline: escape(studioVerdict.subline),
+
+    // Hero
+    hero_archetype: identity && identity.archetype ? escape(identity.archetype.split("(")[0].trim()) : "Mover OS Operator",
+    hero_law: identity && identity.theLaw ? escape(identity.theLaw.replace(/^["']|["']$/g, "")) : "your AI knows you",
+    hero_core_drive: identity && identity.coreDrive ? escape(identity.coreDrive.split("(")[0].trim()) : "—",
+    hero_fatal_flaw: identity && identity.fatalFlaw ? escape(identity.fatalFlaw.split("(")[0].trim()) : "—",
+    hero_single_test: manifest && manifest.singleTest ? escape(manifest.singleTest) : (strategy && strategy.singleTest ? escape(strategy.singleTest) : "Define a Single Test in Strategy.md"),
+    hero_sacrifice: manifest && manifest.sacrifice ? escape(shortenForCallout(manifest.sacrifice)) : "—",
+
+    // Today's Call
+    today_call_class: todayCall.class,
+    today_call_status: todayCall.status,
+    today_call_text: escape(todayCall.text),
+    today_progress_pct: todayProgress.pct,
+    ring_offset: String(todayProgress.ringOffset),
+
+    // Strategy header
+    strategy_target_date: strategy && strategy.targetDate ? escape(strategy.targetDate) : "no date",
+
+    // Suggested Now
+    suggested_now_cards: rawHtml(renderSuggestedNow(suggestions, manifest)),
+
+    // Tactical
+    tactical_focus: shortenForMetric(extractFromAC(ac, "primary_metric") || extractFromAC(ac, "today_s_focus")) || "—",
+    tactical_hard_thing: shortenForMetric(extractFromAC(ac, "active_sacrifices") || extractFromAC(ac, "hard_thing"), 100) || "—",
+    tactical_floor: shortenForMetric(extractFromAC(ac, "current_floors") || extractFromAC(ac, "floor"), 100) || "—",
+    tactical_mode: shortenForMetric(extractFromAC(ac, "oscillation_trend") || extractFromAC(ac, "mode")) || "—",
+
+    // Energy
+    energy_battery: shortBattery(ac) || "—",
+    energy_zone: shortZone(ac) || "—",
+    energy_oscillation: shortOscillation(ac) || "—",
+    energy_session_age: ac && ac.workflowState && ac.workflowState.log_last_run ? humanizeTimeAgo(new Date(ac.workflowState.log_last_run), now) : "—",
+
+    // Patterns
+    patterns_list: rawHtml(renderPatterns(al)),
+    patterns_stat_count: al && al.activePatternsConf3Plus ? String(al.activePatternsConf3Plus.length) : "0",
+    patterns_stat_growing: al && al.growingPatterns ? String(al.growingPatterns.length) : "0",
+    patterns_stat_escalated: al && al.escalatedPatterns ? String(al.escalatedPatterns.length) : "0",
+
+    // Friction
+    friction_level: manifest ? (manifest.frictionLevel || "L0") : "L0",
+    friction_class: frictionClass(manifest ? manifest.frictionLevel : "L0"),
+    friction_pct: String(frictionPct(manifest ? manifest.frictionLevel : "L0")),
+    friction_zombie_count: manifest ? String(manifest.zombieCount || 0) : "0",
+    friction_override_count: manifest ? recentOverrideCount(manifest.overrideHistory, 14) : "0",
+    friction_zombies: manifest && manifest.zombieTasks && manifest.zombieTasks.length > 0
+      ? manifest.zombieTasks.slice(0, 3).map(t => escape(t)).join(" · ")
+      : "no zombie tasks",
+
+    // Vitality
+    vitality_hrv: metrics && metrics.hrvLatest ? metrics.hrvLatest + " ms" : (extractFromAC(ac, "hrv") || "—"),
+    vitality_sleep: metrics && metrics.sleepLatest ? metrics.sleepLatest + " h" : "—",
+    vitality_rhr: metrics && metrics.rhrLatest ? metrics.rhrLatest + " bpm" : "—",
+    vitality_weight: metrics && metrics.weightLatest ? metrics.weightLatest + " kg" : "—",
+    health_protocols_block: rawHtml(renderHealthProtocols(healthProtocols) || renderHealthProtocolEmpty()),
+
+    // Engine Health
+    engine_health_items: rawHtml(renderEngineHealth(engineHealth)),
+
+    // Agents
+    agents_grid: rawHtml(renderAgentsGrid(agents)),
+    agents_summary: agents && agents.installedCount ? `${agents.installedCount} installed · ${agents.runnableCount} runnable · ${agents.hookSupportedCount} hook-enabled` : "no agents detected",
+
+    // Streaks
+    streak_current: daily ? String(daily.streak || 0) : "—",
+    streak_month: daily ? String(daily.totalThisMonth || 0) : "—",
+    streak_year: daily ? String(daily.totalThisYear || 0) : "—",
+    heatmap: rawHtml(renderHeatmap(daily)),
+
+    // Projects
+    projects_list: rawHtml(renderProjects(projects)),
+
+    // Strategy
+    strategy_version: strategy && strategy.version ? "V" + escape(strategy.version) : "—",
+    strategy_updated: strategy && strategy.lastUpdatedField ? escape(strategy.lastUpdatedField) : "—",
+    strategy_hypothesis: strategy && strategy.hypothesisBody ? escape(extractFirstSentences(strategy.hypothesisBody, 2)) : "—",
+    strategy_validation: strategy && strategy.validationCriteria ? escape(strategy.validationCriteria) : "—",
+    strategy_fail: strategy && strategy.failCondition ? escape(strategy.failCondition) : "—",
+
+    // Goals
+    goals_list: rawHtml(renderGoals(goals)),
+
+    // Library
+    library_counts: rawHtml(renderLibraryCounts(library)),
+    library_recent: rawHtml(renderLibraryRecent(library)),
+
+    // Entities
+    entities_grid: rawHtml(renderEntities(library)),
+
+    // Voice DNA
+    voice_samples: voiceDna && voiceDna.totalSamples ? String(voiceDna.totalSamples) : "0",
+    voice_banned: voiceDna && voiceDna.bannedPhrases ? String(voiceDna.bannedPhrases.length) : "0",
+    voice_traits: voiceDna && voiceDna.available
+      ? renderVoiceTraits(voiceDna)
+      : "no voice dna file",
+
+    // Identity
+    identity_evolved: identity && identity.evolvedSelf ? escape(extractFirstSentences(identity.evolvedSelf, 2)) : (identity && identity.theLaw ? escape(identity.theLaw) : "—"),
+    identity_anti: identity && identity.antiIdentityBody ? escape(extractFirstSentences(identity.antiIdentityBody, 2)) : "—",
+
+    // Active_Context lists
+    backlog_list: rawHtml(renderBulletList((ac && ac.backlog) || [])),
+    waiting_list: rawHtml(renderBulletList((ac && ac.waitingFor) || [])),
+    commitments_list: rawHtml(renderBulletList((ac && ac.commitments) || [])),
+    override_list: rawHtml(renderOverrides(manifest)),
+
+    // Hook activity
+    hook_stats: rawHtml(renderHookStats(hookActivity)),
+    hook_recent: rawHtml(renderHookRecent(hookActivity)),
+
+    // Dossier
+    dossier_list: rawHtml(renderDossier(dossier)),
+
+    // Footer
+    build_time: formatTime(now),
+    version: version || "unknown",
+    vault_short: vault ? path.basename(vault) : "—"
+  };
+
+  let html = template;
+  for (const [key, val] of Object.entries(tokens)) {
+    // Audit M8 — keys are developer-controlled today, but escaping
+    // regex metacharacters before embedding into `new RegExp(...)`
+    // prevents ReDoS / mis-replacement if any key ever contains a `.`,
+    // `*`, `+`, `(`, etc. (e.g. a parser leaks a user field into the
+    // tokens map).
+    const safeKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    html = html.replace(new RegExp("{{\\s*" + safeKey + "\\s*}}", "g"), val == null ? "—" : String(val));
+  }
+  // Replace any remaining tokens
+  html = html.replace(/{{\s*[a-z_]+\s*}}/g, "—");
+
+  // Write output
+  const outDir = dashboardOutDir();
+  ensureDir(outDir);
+  fs.writeFileSync(dashboardIndexPath(), html, "utf8");
+  copyStatic(outDir);
+
+  if (errors.length > 0) {
+    const log = `[${new Date().toISOString()}] errors=${errors.length}\n` + errors.map(e => "  - " + e).join("\n") + "\n";
+    fs.appendFileSync(dashboardBuildLogPath(), log);
+  }
+
+  const builtAt = new Date();
+
+  // ───────── StateJson — the typed contract the React UI reads ─────────
+  // Matches src/dashboard/ui/src/lib/types.ts. Single source of truth for v3.
+  // Per-section fallbacks keep the API alive even when individual parsers fail.
+
+  // Compute phantom rows up front so drift-score can incorporate them as
+  // its "contradictions" component (Codex v3-fidelity #10 — 5th breakdown axis).
+  const phantomRowsForDrift = phantomRowsForState(strategy, al, manifest);
+  // Look up yesterday's persisted value to compute a real delta (was always 0
+  // because we passed yesterdayScore: null). drift-history.js stores one
+  // snapshot per calendar day in ~/.mover/drift-history.json.
+  const driftHistEntries = tryParse("drift-history-read", () => driftHistory.getHistory(90), []);
+  const yesterdayKey = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
+  const yesterdayEntry = driftHistEntries.find(e => e.date === yesterdayKey);
+  // Distribution computed up-front so drift derives the gap from REAL per-day
+  // counts instead of a fabricated default. [false-zero discipline, T261]
+  const distributionForStateJson = tryParse("distribution", () => distributionParser.compute({ vault, daysLookback: 365 }), { available: false, days: [], todayCount: null, total7d: null, total30d: null, delta7d: null });
+  const drift = tryParse("drift-score", () => driftScore.compute({
+    manifest,
+    activeContext: ac,
+    engineHealth: engineHealthForState(engineHealth),
+    distribution: distributionForStateJson,
+    todayPlanRanDistribution: !!(daily && daily.today && daily.today.exists),
+    yesterdayScore: yesterdayEntry ? yesterdayEntry.value : null,
+    phantomCount: phantomRowsForDrift.length,
+  }), null);
+  // Persist today's value back to history so tomorrow's run has a delta
+  // and the dashboard sparkline gets a real time-series.
+  if (drift && Number.isFinite(drift.value)) {
+    tryParse("drift-history-write", () => driftHistory.recordSnapshot({
+      value: drift.value,
+      components: drift.components,
+    }), null);
+  }
+  // Re-read after the write so the history array we expose includes today.
+  const driftHistoryArr = tryParse("drift-history-final", () => driftHistory.getHistory(30), []);
+  if (drift) drift.history = driftHistoryArr;
+
+  const forked = tryParse("forked-future", () => forkedFuture.compute({
+    driftScore: drift,
+    recent7d: [],
+    activePatterns: (al && al.activePatternsConf3Plus) || [],
+    horizonDays: 14,
+  }), null);
+
+  // distributionForStateJson computed earlier (before drift). [T261]
+  const overrideEntries = normalizeOverrides(manifest);
+  const overrideSummary = computeOverrideSummary(overrideEntries, builtAt);
+  const engineHealthState = engineHealthForState(engineHealth);
+  const goalForecast = tryParse("goal-forecast", () => computeGoalForecast({
+    strategy,
+    activeContext: ac,
+    distribution: distributionForStateJson,
+    engineHealth: engineHealthState,
+    daily,
+    now: builtAt
+  }), { available: false, adjustments: [], workflows: [] });
+  // Per-domain measurement forecast — dispatches each domain on its declared shape
+  // (single | chain | scalar | streak), honest-null until that domain logs data.
+  const domainForecasts = tryParse("domain-forecasts", () => {
+    const decl = (strategy && strategy.measurement) || {};
+    return {
+      work:     parseDomainProgress({ domain: "work",     decl: decl.work,     goalForecast, metricsLog: metrics }),
+      vitality: parseDomainProgress({ domain: "vitality", decl: decl.vitality, goalForecast, metricsLog: metrics }),
+      faith:    parseDomainProgress({ domain: "faith",    decl: decl.faith,    goalForecast, metricsLog: metrics }),
+    };
+  }, { work: { available: false, type: null }, vitality: { available: false, type: null }, faith: { available: false, type: null } });
+  const executionPlan = tryParse("execution-plan", () => computeExecutionPlan({
+    suggestions,
+    goalForecast,
+    healthProtocols,
+    projects,
+    engineHealth: engineHealthState,
+    daily,
+    overrides: overrideSummary,
+  }), { available: false, items: [], capacityScore: 0, checked: 0, total: 0, lanes: [] });
+
+  // What to call the operator: config userName (user-editable in Configure)
+  // wins, then the Identity_Prime H1 name written by onboarding. Never a
+  // folder or account name — an honest null greets namelessly instead.
+  // Plausibility gate: pre-4.7.9 onboarding could store a whole identity
+  // sentence as the name ("I'm a 24-year-old freelance photographer...").
+  // A greeting name reads as a callsign; anything sentence-shaped greets
+  // namelessly instead (wrong name is worse than no name).
+  const plausibleName = (s) =>
+    typeof s === "string" && s.trim() && s.trim().length <= 32 &&
+    !/[.!?\n:;]/.test(s.trim()) && s.trim().split(/\s+/).length <= 3
+      ? s.trim() : null;
+  const cfgForName = tryParse("config", () => require("./lib/config-parser").read(), {});
+  const profileName =
+    plausibleName(cfgForName && cfgForName.userName) ||
+    plausibleName(identity && identity.name) || null;
+
+  const stateJson = {
+    builtAt: builtAt.toISOString(),
+    vaultPath: vault,
+    profileName,
+    version: version || "unknown",
+    engineHealth: engineHealthState,
+    activeContext: (function() {
+      // Inject typed active patterns from Auto_Learnings parser before mapping
+      const typed = ((al && al.activePatternsConf3Plus) || []).map(p => ({
+        id: p.name || p.id || "",
+        description: extractPatternHeadline(p),
+        confidence: typeof p.confidence === "number" ? p.confidence : 0,
+        status: p.status || "",
+        severity: p.severity || "",
+        polarity: p.polarity || "neutral",
+        category: p.category || "watching",
+        firstDetected: p.firstDetected || "",
+        lastUpdated: p.lastUpdated || "",
+        sourcePath: (al && al.filePath) || ""
+      }));
+      const acWithTyped = ac ? { ...ac, __activePatternsTyped: typed } : ac;
+      return activeContextForState(acWithTyped, manifest);
+    })(),
+    driftScore: drift,
+    forkedFuture: forked,
+    phantomRows: phantomRowsForDrift,
+    suggestedNow: (suggestions || []).map(s => ({
+      workflow: s.workflow || s.command || "",
+      reason: s.reason || s.explanation || "",
+      score: typeof s.score === "number" ? s.score : 0,
+      signalKey: s.signal || s.key || ""
+    })),
+    // V5.0 activation stats (Codex #3 wiring fix, 2026-05-24). Reads from
+    // ~/.mover/activation-events.jsonl. Local-only, telemetry-never.
+    // Cheap (~1ms typical) — re-read on every build.
+    activation: tryParse("activation-log", () => readActivationStats(), {
+      available: false,
+      installDays: 0,
+      dashboardOpens: 0,
+      dashboardOpens7d: 0,
+      workflowRuns: 0,
+      workflowRuns7d: 0,
+      logCompletions7d: 0,
+      distinctOpenDays: 0,
+      activated: false,
+      firstEventAt: null,
+    }),
+    agents: (agents && agents.agents ? agents.agents : []).map(a => ({
+      id: a.id || a.name || "",
+      name: a.name || a.id || "",
+      // agent-detector.js now intersects config-dir + binary-on-PATH. Pass through.
+      installed: !!a.installed,
+      runnable: !!a.runnable,
+      hookSupport: !!a.hookSupport,
+      detectedPath: a.configPath || a.path || a.detectedPath || undefined
+    })),
+    workflows: (() => {
+      try {
+        // bundleRoot = src/dashboard/build.js → ../../ = bundle root
+        const wl = workflowLibrary.indexWorkflows(path.resolve(__dirname, "..", ".."));
+        return (wl.workflows || []).map(w => ({
+          name: w.name,
+          description: w.description || "",
+          risk: w.risk || "LOW",
+          target: w.target || "",
+          reads: w.reads || [],
+          writes: w.writes || [],
+          handsOffTo: w.handsOffTo || [],
+          // v6 SURFACE 1 — Say-it card copy + structured io contract
+          does: w.does,
+          long: w.long,
+          needsYou: w.needsYou,
+          io: w.io ?? null
+        }));
+      } catch (e) {
+        errors.push(`[workflow-library] ${e.message}`);
+        return [];
+      }
+    })(),
+    // Wave 2 — newly-wired parsers
+    strategy: (() => {
+      const out = tryParse("strategy", () => strategyParser.parseStrategy(vault), { available: false });
+      if (!out || !out.available) return { available: false };
+      return {
+        available: true,
+        version: out.version || null,
+        primeObjective: out.primeObjective || null,
+        stretchTarget: out.stretchTarget || null,
+        currentState: out.currentState || null,
+        singleTest: out.singleTest || null,
+        targetDate: out.targetDate || null,
+        measurement: out.measurement || null,
+        lastUpdated: out.lastUpdated ? out.lastUpdated.toISOString() : (out.lastUpdatedField || null),
+        hypotheses: (out.hypotheses || []).map(h => ({
+          domain: h.domain,
+          body: (h.body || '').slice(0, 1200) // cap body so StateJson stays lean
+        }))
+      };
+    })(),
+    goalForecast,
+    domainForecasts,
+    executionPlan,
+    identity: (() => {
+      const out = tryParse("identity", () => identityParser.parseIdentity(vault), { available: false });
+      if (!out || !out.available) return { available: false };
+      return {
+        available: true,
+        archetype: out.archetype || null,
+        coreDrive: out.coreDrive || null,
+        fatalFlaw: out.fatalFlaw || null,
+        theLaw: out.theLaw || null,
+        antiIdentity: out.antiIdentity || null,
+        antiIdentityBody: out.antiIdentityBody || null,
+        psychFirewall: out.psychFirewall || null
+      };
+    })(),
+    // F19 — Anti-Identity Detector hits, cross-referencing patterns +
+    // overrides against the user's anti-identity statement.
+    antiIdentityHits: (() => {
+      const identity = tryParse("identity", () => identityParser.parseIdentity(vault), { available: false });
+      // ac is the parsed active-context. Patterns live in its activePatterns array.
+      const patterns = (ac && ac.activePatterns) || [];
+      return tryParse(
+        "anti-identity-detect",
+        () => antiIdentityDetector.detect({ identity, patterns, overrides: overrideEntries }),
+        { available: false }
+      );
+    })(),
+    // F39 — Vault wiki-link graph (distinct from PublicProofGraph which
+    // shows behavioral patterns). Walks every md file in the vault to
+    // build a node-edge map of [[wiki-links]]. Capped at 200 nodes for
+    // payload reasonableness. Connections route renders this.
+    vaultGraph: tryParse(
+      "vault-graph",
+      () => vaultGraphParser.buildVaultGraph(vault, { limit: 200 }),
+      { available: false, nodes: [], edges: [] }
+    ),
+    // Voice DNA — surface the REAL Voice_DNA.md calibration to the dashboard
+    // (the Library's "Your writing voice" panel). The parser already ran above
+    // (voiceDna); it was only feeding flat CLI strings, never the state tree,
+    // so the dashboard showed "harvest your voice" even though the file is
+    // already calibrated. honest-empty when the file is absent. No capped
+    // numbers leak out: sampleCount is the true total; bannedPhrases is capped
+    // in the parser so we don't surface it as a count.
+    voice: (() => {
+      if (!voiceDna || !voiceDna.available) return { available: false };
+      const traits = [];
+      if (voiceDna.lowercaseI) traits.push("lowercase 'i'");
+      if (voiceDna.commaSpliced) traits.push("comma-spliced");
+      if (voiceDna.usesBrother) traits.push('says "brother"');
+      if (voiceDna.urlInline) traits.push("inline urls");
+      if ((voiceDna.totalSamples || 0) > 0 && Number.isFinite(voiceDna.shortestSample)) {
+        traits.push(`${voiceDna.shortestSample}-${voiceDna.longestSample} char range`);
+      }
+      // Count writing rules + banned phrases UNCAPPED from the raw file (the
+      // parser caps bannedPhrases at 12, which would under-report). A voice is
+      // "calibrated" when the file defines rules / banned phrases / traits —
+      // sample passages are a bonus, not the bar (the owner's file has rules
+      // but no fenced samples, and is correctly already calibrated).
+      const raw = voiceDna.raw || "";
+      // Pull the actual bullet TEXT under a heading (until the next h2), so the
+      // Library can SHOW the voice (how it's defined + what it avoids), not just
+      // a status badge. Real lines only; never invented.
+      const sectionBullets = (headingRe) => {
+        const m = raw.match(headingRe);
+        if (!m) return [];
+        const rest = raw.slice(m.index + m[0].length);
+        const end = rest.search(/\n##\s/); // stop at the next h2
+        const section = end >= 0 ? rest.slice(0, end) : rest;
+        return (section.match(/^\s*[-*]\s+.+$/gm) || [])
+          .map((l) => l.replace(/^\s*[-*]\s+/, "").trim())
+          .filter((l) => l && !l.startsWith("#"));
+      };
+      const ruleLines = sectionBullets(/##\s*Writing Rules[^\n]*\n/i);
+      const bannedLines = sectionBullets(/##\s*Banned[^\n]*\n/i);
+      const rulesCount = ruleLines.length;
+      const bannedCount = bannedLines.length;
+      return {
+        available: true,
+        calibrated: rulesCount > 0 || bannedCount > 0 || (voiceDna.totalSamples || 0) > 0 || traits.length > 0,
+        lastUpdated: voiceDna.lastUpdated || null,
+        rulesCount,
+        bannedCount,
+        sampleCount: voiceDna.totalSamples || 0,
+        traits,
+        // a few REAL rules / banned phrases — the voice's actual definition
+        rules: ruleLines.slice(0, 6).map((s) => (s.length > 130 ? s.slice(0, 130).trim() + "…" : s)),
+        banned: bannedLines.slice(0, 10).map((s) => s.replace(/^["'""]|["'""]$/g, "").trim()),
+        // up to 3 real writing samples (trimmed) — literally the user's own voice
+        samples: (voiceDna.samples || [])
+          .filter((s) => s && s.trim().length > 0)
+          .slice(0, 3)
+          .map((s) => (s.length > 220 ? s.slice(0, 220).trim() + "…" : s.trim())),
+        path: voiceDna.filePath || null,
+      };
+    })(),
+    goals: (() => {
+      const out = tryParse("goals", () => goalsParser.parseGoals(vault), { available: false });
+      if (!out || !out.available) return { available: false, horizons: [] };
+      return {
+        available: true,
+        horizons: (out.horizons || []).slice(0, 5).map(h => ({
+          title: h.title || "",
+          body: (h.body || "").slice(0, 600)
+        }))
+      };
+    })(),
+    projects: (() => {
+      // limit 1000 = effectively all. The old 12 silently hid 20 of the
+      // owner's 32 projects from the Library shelf; he ruled: show all,
+      // split active/dormant (2026-07-12). Consumers that want fewer slice.
+      const out = tryParse("projects", () => projectScanner.scanProjects(vault, { limit: 1000 }), { available: false, projects: [] });
+      if (!out || !out.available) return { available: false, projects: [], totalCount: 0 };
+      return {
+        available: true,
+        totalCount: out.totalCount || 0,
+        activeCount: typeof out.activeCount === "number" ? out.activeCount : undefined,
+        projects: (out.projects || []).map(p => ({
+          name: p.name || "",
+          path: p.path || "",
+          planPath: p.planPath || "",
+          totalTasks: p.totalTasks || 0,
+          doneTasks: p.doneTasks || 0,
+          openTasks: p.openTasks || 0,
+          unverifiedTasks: p.unverifiedTasks || 0,
+          zombieTasks: p.zombieTasks || 0,
+          lastModified: p.lastModified ? p.lastModified.toISOString() : null,
+          stateExcerpt: p.stateExcerpt || null,
+          recentExecutionLog: (p.recentExecutionLog || []).slice(0, 3)
+        }))
+      };
+    })(),
+    metrics: (() => {
+      const out = tryParse("metrics-log", () => metricsLog.parseMetricsLog(vault), { available: false });
+      if (!out || !out.available) return { available: false };
+      return {
+        available: true,
+        sleepLatest: out.sleepLatest || null,
+        rhrLatest: out.rhrLatest || null,
+        weightLatest: out.weightLatest || null,
+        rolling30: out.rolling30 || null,
+        days: (out.days || []).slice(-30)
+      };
+    })(),
+    library: (() => {
+      const out = tryParse("library", () => libraryIndexer.indexLibrary(vault), { available: false });
+      if (!out || !out.available) return { available: false };
+      return {
+        available: true,
+        mocs: out.mocs || 0,
+        principles: out.principles || 0,
+        cheatsheets: out.cheatsheets || 0,
+        sops: out.sops || 0,
+        entities: out.entities || 0,
+        inputs: out.inputs || 0,
+        scripts: out.scripts || 0,
+        recentHarvests: (out.recentHarvests || []).slice(0, 5)
+      };
+    })(),
+    // v2 indexers (net additions for the holistic dashboard rebuild)
+    libraryV2: tryParse("library-v2", () => indexLibraryV2(vault), { available: false }),
+    skills: tryParse("skills", () => indexSkills(), { available: false, count: 0, byCategory: { system: [], specialist: [], domain: [] }, all: [] }),
+    hooks: tryParse("hooks", () => indexHooks(), { available: false, count: 0, byEvent: {}, registered: [], unregistered: [] }),
+    cliUsage: tryParse("cli-usage", () => parseCliUsage(), { available: false, commands: [] }),
+    // Briefing route's Execution Protocol — daily floor items per domain
+    // pulled from Strategy.md (not Daily Note tasks, which were the wrong
+    // source in the previous iteration).
+    strategyProtocol: tryParse("strategy-protocol", () => parseStrategyProtocol(vault), { available: false }),
+    experiments: tryParse("experiments", () => buildExperiments(vault), { available: false, all: [], active: [], past: [], byDomain: { work: [], vitality: [], faith: [] }, count: 0, activeCount: 0, pastCount: 0 }),
+    // v6 W1 — live work feed, moves-usage lighting, rewind keyframes, journal calibration gap.
+    // False-zero: every fallback matches the full shape; absent source -> available:false, never a fabricated 0.
+    feed: tryParse("feed", () => feedParser.compute({ vault, limit: 40 }), { available: false, caption: "", events: [], activeSessions: [] }),
+    movesUsage: tryParse("moves-usage", () => movesUsageParser.computeMovesUsage({ vault }), { available: false, source: "", totalRuns: null, byCommand: {} }),
+    rewind: tryParse("rewind", () => rewindSnapshots.buildRewind({ vault }), { available: false, keyframes: [], dailies: {}, gapBefore: "", gapAfter: "" }),
+    journalGap: (() => {
+      const ev = daily && daily.today && daily.today.journal ? daily.today.journal.evening : null;
+      const selfScore = ev && ev.score != null ? ev.score : null;
+      let rec = { score: null, why: null, basis: "not enough logged to score today" };
+      try { rec = recordScoreLib.computeRecordScore({ daily, distribution: distributionForStateJson }) || rec; } catch (_) {}
+      const recordScore = rec && rec.score != null ? rec.score : null;
+      // Trend reads the RAW resolver output (daily.recentNotes carries journal via
+      // analyzeNoteText); honest self-score history, empty on day 1.
+      const trend = (daily && daily.recentNotes ? daily.recentNotes : [])
+        .filter(n => n && n.journal && n.journal.evening && n.journal.evening.score != null)
+        .slice(0, 7)
+        .map(n => ({ date: n.date, score: n.journal.evening.score }));
+      return {
+        available: selfScore != null || recordScore != null,
+        selfScore,
+        recordScore,
+        gap: selfScore != null && recordScore != null ? selfScore - recordScore : null,
+        recordWhy: rec.why || null,
+        trend,
+        basis: rec.basis || null
+      };
+    })(),
+    // Wave 5 parsers
+    distribution: (() => {
+      return distributionForStateJson || { available: false, days: [], todayCount: null, total7d: null, total30d: null, delta7d: null };
+    })(),
+    streak: (() => {
+      // False-zero discipline (T261): the tryParse fallback must match the FULL
+      // StreakData shape — a bare { available:false } leaves days/currentStreak/
+      // coverage undefined and a consumer that reads them before checking
+      // `available` crashes (or worse, treats undefined as a clean streak).
+      const FULL_STREAK_FALLBACK = { available: false, days: [], currentStreak: 0, streakThroughYesterday: 0, todayExists: false, longestStreak: 0, totalDays: 0, coverage: 0 };
+      const out = tryParse("streak", () => streakParser.compute({ vault, daysLookback: 365 }), FULL_STREAK_FALLBACK);
+      return out || FULL_STREAK_FALLBACK;
+    })(),
+    overrideOutcomes: (() => {
+      try {
+        const out = tryParse("override-outcomes", () => overrideOutcomeParser.compute({ vault, overrides: overrideEntries.slice(-100), windowDays: 90 }), { available: false });
+        return out || { available: false, outcomes: [] };
+      } catch (_) { return { available: false, outcomes: [] }; }
+    })(),
+    overrideSummary,
+    // Core-loop TRIAL MODE (SCHEMA-SPEC v0.2 section 2, wired 2026-07-12):
+    // compares the legacy override count against override.logged events and
+    // logs movement to State/trial-deltas.jsonl. The UI keeps rendering the
+    // LEGACY values everywhere; this field only makes the gap observable.
+    // Best-effort: unmigrated vaults report available:false and nothing runs.
+    stateCoreTrial: (() => {
+      try {
+        const { runTrial } = require("./lib/state-core/trial");
+        return runTrial({ vault, manifestOverrideCount: overrideEntries.length });
+      } catch (_) { return { available: false, reason: "trial module unavailable" }; }
+    })(),
+    refusals: (() => {
+      // False-zero discipline (T261): full RefusalsData shape on parse failure
+      // so count/count7d/recent are never undefined under available:false.
+      const FULL_REFUSALS_FALLBACK = { available: false, count: 0, count7d: 0, delta7d: 0, recent: [] };
+      const out = tryParse("refusals", () => refusalParser.compute({ daysLookback: 30 }), FULL_REFUSALS_FALLBACK);
+      return out || FULL_REFUSALS_FALLBACK;
+    })(),
+    hourlyActivity: (() => {
+      // False-zero discipline (T261): full HourlyActivity shape on both parse
+      // failure and the !available guard — previous empty-state was missing
+      // daysScanned + peakCount, so PerformanceCurve read undefined for the
+      // "last N days" label and the peak-band math under available:false.
+      const FULL_HOURLY_FALLBACK = { available: false, daysScanned: 0, hours: [], peakHour: null, peakCount: 0, todayHours: [], events: [] };
+      const out = tryParse("hourly-activity", () => hourlyActivity.compute({ vault, daysLookback: 14 }), FULL_HOURLY_FALLBACK);
+      if (!out || !out.available) return FULL_HOURLY_FALLBACK;
+      return {
+        available: true,
+        daysScanned: out.daysScanned || 0,
+        hours: out.hours || [],
+        peakHour: out.peakHour,
+        peakCount: out.peakCount || 0,
+        todayHours: out.todayHours || [],
+        events: out.events || []
+      };
+    })(),
+    // REAL tracked time from Session Log start-end ranges (the honest core of
+    // "did hours"). NOT a per-domain split — sessions tag a [project], never a
+    // Work/Vitality/Faith domain, so a domain breakdown would be fabricated.
+    sessionTime: (() => {
+      const FULL_SESSIONTIME_FALLBACK = {
+        available: false, daysScanned: 0,
+        today: { minutes: 0, sessions: 0 },
+        last7d: { minutes: 0, sessions: 0, untimed: 0 },
+        last30d: { minutes: 0, sessions: 0, untimed: 0 },
+        byProject7d: [], longest: null,
+        src: "Dailies session-log start-end ranges",
+      };
+      const out = tryParse("session-time", () => sessionTime.compute({ vault, daysLookback: 30 }), FULL_SESSIONTIME_FALLBACK);
+      return out || FULL_SESSIONTIME_FALLBACK;
+    })(),
+    daily: (() => {
+      if (!daily) {
+        return {
+          available: false,
+          today: null,
+          streak: 0,
+          recentNotes: [],
+          totalThisMonth: 0,
+          totalThisYear: 0
+        };
+      }
+      return {
+        available: true,
+        today: daily.today ? {
+          date: daily.today.date || null,
+          path: daily.today.path || null,
+          exists: !!daily.today.exists,
+          tasksTotal: daily.today.tasksTotal || 0,
+          tasksDone: daily.today.tasksDone || 0,
+          // W12: per-task lines (text + checked) so Home checkboxes can write
+          // back through /api/checkbox/toggle. null on older parser output.
+          tasks: daily.today.tasks ?? null,
+          length: daily.today.length || 0,
+          // v6 SURFACE 1 — the real plan focus for the Say-it friction rule.
+          // Was dropped here; the parser computes it (daily-note-resolver).
+          focus: daily.today.focus ?? null,
+          // v6 W1 — today's-call + `## Journal` sub-anchors + plan/got. All
+          // false-zero: null when the section is absent, never a guessed value.
+          todaysCall: daily.today.todaysCall ?? null,
+          journal: daily.today.journal ?? null,
+          plan: daily.today.plan ?? null,
+          got: daily.today.got ?? null
+        } : null,
+        streak: daily.streak || 0,
+        recentNotes: (daily.recentNotes || []).slice(0, 14).map(n => ({
+          date: n.date,
+          exists: !!n.exists,
+          tasksTotal: n.tasksTotal || 0,
+          tasksDone: n.tasksDone || 0,
+          length: n.length || 0,
+          // v6 W1 — per-date journal + plan for the calibration trend + Rewind
+          journal: n.journal ?? null,
+          todaysCall: n.todaysCall ?? null,
+          plan: n.plan ?? null
+        })),
+        totalThisMonth: daily.totalThisMonth || 0,
+        totalThisYear: daily.totalThisYear || 0
+      };
+    })(),
+    healthProtocols: (() => {
+      if (!healthProtocols || !healthProtocols.available) return { available: false, protocols: [] };
+      return {
+        available: true,
+        protocols: healthProtocols.protocols.map(p => ({
+          title: p.title || "",
+          filePath: p.filePath || "",
+          lastUpdated: p.lastUpdated ? p.lastUpdated.toISOString() : null,
+          current: p.current ? {
+            heading: p.current.heading || "",
+            daysIntoPhase: p.daysIntoPhase != null ? p.daysIntoPhase : null,
+            daysRemaining: p.daysRemaining != null ? p.daysRemaining : null,
+            items: (p.current.items || []).map(it => ({ text: it.text, checked: !!it.checked })),
+            done: p.current.done || 0,
+            total: p.current.total || 0
+          } : null
+        }))
+      };
+    })(),
+    snoozes: (() => {
+      try {
+        const snoozePath = path.join(os.homedir(), ".mover", "dashboard", "snoozes.json");
+        if (!fs.existsSync(snoozePath)) return [];
+        const raw = JSON.parse(fs.readFileSync(snoozePath, "utf8"));
+        return Array.isArray(raw) ? raw : [];
+      } catch (_) { return []; }
+    })(),
+    roastWall: roastWall || { available: false, count: 0, roasts: [], stats: { high: 0, med: 0, low: 0 } },
+    workflowGraph: workflowGraph || { available: false, workflowCount: 0, workflows: [], edges: [], files: [] },
+    correlations: correlations || { available: false, reason: "parser_error" },
+    overrides: (() => {
+      try {
+        return overrideEntries.slice(-30);
+      } catch (_) { return []; }
+    })(),
+    // Strip absolute filesystem paths from error messages before they reach
+    // /api/state.json (code-bug-audit H5). Node's ENOENT errors include the
+    // full vault/home path which leaked filesystem layout to any browser tab.
+    errors: errors.map(msg => ({
+      source: msg.match(/^\[([^\]]+)\]/)?.[1] || "unknown",
+      message: msg.replace(/['"]?\/[^\s'":,]+/g, "[path]"),
+    }))
+  };
+
+  return {
+    builtAt,
+    durationMs: Date.now() - startedAt,
+    sectionCount: 6,
+    errors,
+    state: stateJson
+  };
+}
+
+// ───────── StateJson shape mappers ─────────
+
+function engineHealthForState(engineHealth) {
+  if (!engineHealth) {
+    // No-blackbox: the scan couldn't run. Emit nulls + available:false so the UI
+    // shows "health unavailable", NOT a fabricated all-OK / 0-days-stale vault.
+    // [false-zero discipline, T261]
+    return {
+      available: false,
+      unavailableReason: "parser_error",
+      scannedAt: new Date().toISOString(),
+      strategy:     { staleDays: null, status: null, lastUpdated: "" },
+      dossier:      { staleDays: null, status: null, lastUpdated: "" },
+      goals:        { status: null, expired: [] },
+      analyseDay:   { overdueDays: null, status: null, lastRun: null },
+      weeklyReview: { overdueDays: null, status: null, lastRun: null }
+    };
+  }
+  const findItem = (key) => (engineHealth.items || []).find(i => i.file === key) || null;
+  const findWf   = (lbl) => (engineHealth.workflowStaleness || []).find(w => w.label === lbl) || null;
+  // B1 fix: engine-health.js emits `file: "Strategy"` (capital, no .md) — see
+  // engine-health.js:45-53. Look up by THAT key first, then fall back to variants.
+  // A missing item now yields null (honest "no data"), never 0/"OK" — the old
+  // `|| 0` masked the 2026-05-14 "0D STALE on a weeks-old file" key-mismatch bug.
+  const strat = findItem("Strategy") || findItem("strategy") || findItem("Strategy.md") || {};
+  const doss  = findItem("Mover_Dossier") || findItem("dossier") || findItem("Mover_Dossier.md") || findItem("Architect_Dossier.md") || {};
+  const ad    = findWf("/analyse-day") || {};
+  const rw    = findWf("/review-week") || {};
+  return {
+    available: true,
+    unavailableReason: null,
+    scannedAt: (engineHealth.scannedAt instanceof Date) ? engineHealth.scannedAt.toISOString() : String(engineHealth.scannedAt || ""),
+    strategy:     { staleDays: strat.ageDays != null ? strat.ageDays : null, status: strat.status || null, lastUpdated: strat.mtime ? String(strat.mtime) : "" },
+    dossier:      { staleDays: doss.ageDays  != null ? doss.ageDays  : null, status: doss.status  || null, lastUpdated: doss.mtime  ? String(doss.mtime)  : "" },
+    goals:        { status: (engineHealth.expiredGoals || []).length > 0 ? "RED" : "OK", expired: engineHealth.expiredGoals || [] },
+    analyseDay:   { overdueDays: ad.ageDays != null ? ad.ageDays : null, status: ad.status || null, lastRun: ad.lastRun || null },
+    weeklyReview: { overdueDays: rw.ageDays != null ? rw.ageDays : null, status: rw.status || null, lastRun: rw.lastRun || null }
+  };
+}
+
+// Derive a concise headline from an Auto_Learnings pattern entry.
+// Prefers the entry's "name" (header), falling back to first non-empty
+// evidence line, then to a body excerpt.
+function extractPatternHeadline(p) {
+  if (!p) return "";
+  if (p.name) return p.name;
+  if (p.evidence && p.evidence.length) {
+    const first = p.evidence[0];
+    return typeof first === "string" ? first : (first.text || first.summary || "");
+  }
+  return (p.body || "").split("\n").find(l => l.trim().length > 12) || "";
+}
+
+function activeContextForState(ac, manifest) {
+  if (!ac || !ac.available) {
+    return {
+      available: false, lastUpdated: "", singleTest: null, sacrifice: [],
+      frictionLevel: null, zombieCount: null,
+      waitingFor: [], activeSessions: [], backlog: [], commitments: [], activePatterns: [],
+      graveyard: []
+    };
+  }
+  // T225: derive deadline LIVE from the manifest's Single Test prose
+  // instead of hardcoding null. Codex root-cause: TheBet + StudioShell
+  // T-MINUS chip + formatDeadline all key off `deadline`. With deadline
+  // null, the UI falls back to regex parsing the same text again, which
+  // it did correctly — but the deadline ISO was unavailable for any code
+  // path that needed a real Date object (countdown math, sorting,
+  // analytics). The parser already has battle-tested extractDateFromText
+  // that handles "by Month Day, Year" + ISO + month-name variants.
+  const { extractDateFromText } = require("./lib/strategy-parser");
+  const liveDeadline = manifest && manifest.singleTest
+    ? extractDateFromText(manifest.singleTest)
+    : null;
+  // T242 bug hunt fix (C#20): status was hardcoded "unknown" so every UI
+  // surface keyed off `singleTest.status` always showed the gray branch.
+  // Derive from deadline distance to now: failed | at-risk | on-track.
+  // (Matches the types.ts union; goalForecast.status is computed elsewhere
+  // for richer signal but the singleTest carries a self-sufficient one.)
+  let liveStatus = "unknown";
+  if (liveDeadline) {
+    const deadlineMs = Date.parse(liveDeadline + "T23:59:59Z");
+    const nowMs = Date.now();
+    if (Number.isFinite(deadlineMs)) {
+      if (nowMs > deadlineMs) liveStatus = "failed";
+      else if (nowMs > deadlineMs - 14 * 24 * 3600 * 1000) liveStatus = "at-risk";
+      else liveStatus = "on-track";
+    }
+  }
+  const singleTest = manifest && manifest.singleTest
+    ? { text: manifest.singleTest, deadline: liveDeadline || null, status: liveStatus }
+    : null;
+  const sacrifice = manifest && manifest.sacrifice
+    ? (Array.isArray(manifest.sacrifice) ? manifest.sacrifice : [manifest.sacrifice])
+    : [];
+  // false-zero (F5/T261): friction is only known from the manifest, and we read
+  // the RAW field — the loader (pattern-manifest-loader.js) defaults a missing
+  // friction_level to "L0", which would erase the absent-vs-real-0 distinction
+  // before we can act on it. A present friction_level (incl. a real 0) → its
+  // number; an absent field, or no manifest at all → null.
+  const rawManifest = manifest && manifest.manifest ? manifest.manifest : null;
+  const frictionLevel = rawManifest && rawManifest.friction_level != null
+    ? (parseInt(String(rawManifest.friction_level).replace(/[^\d]/g, ""), 10) || 0)
+    : null;
+  return {
+    available: true,
+    // T242 bug hunt fix (C#10): String(Date) emits Date.toString() which
+    // is non-spec for cross-browser Date.parse. Force canonical ISO.
+    lastUpdated: ac.lastUpdated ? new Date(ac.lastUpdated).toISOString() : "",
+    singleTest,
+    sacrifice,
+    frictionLevel,
+    // false-zero (F11/T261): read the RAW zombie_count — the loader defaults a
+    // missing field to 0, erasing absent-vs-real-0. Present 0 → real 0; absent → null.
+    zombieCount: rawManifest && Number.isFinite(rawManifest.zombie_count) ? rawManifest.zombie_count : null,
+    waitingFor: ac.waitingFor || [],
+    activeSessions: ac.activeSessions || [],
+    backlog: ac.backlog || [],
+    commitments: ac.commitments || [],
+    // Workflow State bus timestamps (log_last_run etc). Evidence needs these:
+    // activation-log only sees DASHBOARD-launched runs, so it claimed "0
+    // workflow runs this week" while /log had run three times that day in
+    // the terminal (owner-caught, 2026-07-10). These timestamps are written
+    // by the workflows themselves, so they cover both paths. Whitelisted to
+    // *_last_run keys: the section parser also slurps stray session-log
+    // fields (a "latest_delta_..." key carried a whole session summary blob).
+    workflowState: (() => {
+      const ws = ac.workflowState;
+      if (!ws || typeof ws !== "object") return null;
+      const out = {};
+      for (const [k, v] of Object.entries(ws)) {
+        if (/_last_run$/.test(k) && typeof v === "string" && v.length <= 32) out[k] = v;
+      }
+      return Object.keys(out).length ? out : null;
+    })(),
+    // v6 SURFACE 5 — buried ideas, for the Say-it graveyard echo. Exposed
+    // raw; the client extracts name/reason/date/cost (strict gate: no stanza
+    // unless all parse).
+    graveyard: (ac.graveyard || []).map(g => ({ text: g.text, raw: g.raw, label: g.label })),
+    // Switched from ac.activePatterns (descriptions only, no structured
+    // confidence/status) to al.activePatternsConf3Plus which carries the
+    // typed fields from Auto_Learnings parser. Fixes CONF 0 bug where the
+    // UI confidence badge always showed 0.
+    activePatterns: (function () {
+      const fromAL = (manifest && manifest._auto_learnings) || null; // not set, fall back
+      if (Array.isArray(ac.__activePatternsTyped)) return ac.__activePatternsTyped;
+      return (ac.activePatterns || []).map(p => ({
+        id: p.id || p.name || "",
+        description: p.description || p.text || "",
+        confidence: p.confidence || 0,
+        status: p.status || ""
+      }));
+    })()
+  };
+}
+
+function phantomRowsForState(strategy, autoLearnings, manifest) {
+  // Now delegates to phantom-strategy.js (built Phase 6.2). Pure function.
+  try {
+    return phantomStrategy.compute({ strategy, autoLearnings, manifest });
+  } catch (e) {
+    return [];
+  }
+}
+
+// ─────────── Renderers ───────────
+
+function renderSuggestedNow(suggestions, manifest) {
+  if (!suggestions || suggestions.length === 0) {
+    return `<div class="suggest-card" style="grid-column:span 3;">
+      <div class="suggest-workflow">All clear</div>
+      <div class="suggest-reason">No urgent workflows surface right now. Keep shipping.</div>
+      <div class="suggest-meta"><span class="status-pill status-green">CLEAR</span><span class="suggest-score">—</span></div>
+    </div>`;
+  }
+  return suggestions.map(s => `
+    <div class="suggest-card" data-workflow="${escape(s.workflow)}" data-reason="${escape(s.reason)}">
+      <div class="suggest-workflow">${escape(s.workflow)}</div>
+      <div class="suggest-reason">${escape(s.reason)}</div>
+      <div class="suggest-meta">
+        <span class="status-pill status-${escape((s.urgency||"info").toLowerCase())}">${escape(s.urgency||"info")}</span>
+        <span class="suggest-score">score ${s.score}</span>
+      </div>
+      <div class="suggest-actions">
+        <button class="suggest-action-btn" data-action="run" data-workflow="${escape(s.workflow)}">run</button>
+        <button class="suggest-action-btn" data-action="snooze" data-workflow="${escape(s.workflow)}">snooze 4h</button>
+        <button class="suggest-action-btn" data-action="skip" data-workflow="${escape(s.workflow)}">skip today</button>
+      </div>
+    </div>
+  `).join("");
+}
+
+function renderPatterns(al) {
+  const list = (al && al.activePatternsConf3Plus) || [];
+  if (list.length === 0) {
+    return `<div class="pattern"><div class="pattern-name" style="color:var(--text-dim);">No active patterns at Confidence 3+</div></div>`;
+  }
+  return list.slice(0, 6).map(p => `
+    <div class="pattern">
+      <div class="pattern-head">
+        <span class="pattern-name">${escape(p.name)}</span>
+        <span class="pattern-conf pattern-conf-${p.confidence||0}">Conf ${p.confidence||"?"}</span>
+      </div>
+      <div class="pattern-meta">
+        ${p.status ? `<span>· ${escape(p.status.replace(/_\(.*$/,"").replace(/_/g," "))}</span>` : ""}
+        ${p.severity ? `<span>severity ${escape(p.severity)}</span>` : ""}
+        ${p.domain ? `<span>${escape(p.domain)}</span>` : ""}
+        ${p.evidence && p.evidence.length ? `<span>${p.evidence.length} evidence</span>` : ""}
+      </div>
+    </div>
+  `).join("");
+}
+
+function renderHealthProtocols(hp) {
+  if (!hp || !hp.available || !hp.protocols.length) return "";
+  // For now render the first protocol's current phase as a checklist.
+  // Multi-protocol UI can come later.
+  const p = hp.protocols[0];
+  if (!p.current) return "";
+  const items = p.current.items;
+  const checked = items.filter(i => i.checked).length;
+  const total = items.length;
+  const pct = total > 0 ? Math.round((checked / total) * 100) : 0;
+  const phaseName = p.current.heading.replace(/^PHASE\s+\d+\s*—\s*/i, "").replace(/\s*\(.*\)\s*$/, "");
+  const dayLabel = (p.daysRemaining !== null && p.daysIntoPhase !== null)
+    ? `Day ${p.daysIntoPhase + 1} · ${p.daysRemaining}d left`
+    : "";
+  const listHtml = items.slice(0, 8).map(i => `
+    <div class="health-item ${i.checked ? "checked" : ""}">
+      <span class="health-check">${i.checked ? "✓" : "○"}</span>
+      <span class="health-text">${escape(i.text.replace(/\*\*/g, "").slice(0, 90))}</span>
+    </div>
+  `).join("");
+  return `
+    <div class="health-protocol">
+      <div class="health-header">
+        <span class="health-title">${escape(p.title)}</span>
+        <span class="health-meta">${escape(phaseName)} · ${dayLabel}</span>
+      </div>
+      <div class="health-progress"><span style="width: ${pct}%"></span></div>
+      <div class="health-progress-label">${checked}/${total} done</div>
+      <div class="health-list">${listHtml}</div>
+    </div>
+  `;
+}
+
+function renderHealthProtocolEmpty() {
+  return `
+    <div class="health-protocol empty">
+      <div class="health-header">
+        <span class="health-title">No protocol loaded</span>
+        <span class="health-meta">local markdown</span>
+      </div>
+      <div class="health-progress"><span style="width: 0%"></span></div>
+      <div class="health-progress-label">0/0 done</div>
+      <div class="health-list">
+        <div class="health-item"><span class="health-check">○</span><span class="health-text">Add a protocol in 02_Areas/Health</span></div>
+      </div>
+    </div>
+  `;
+}
+
+function renderEngineHealth(eh) {
+  if (!eh || !eh.items) return `<div class="engine-health-row"><span>—</span></div>`;
+  return eh.items.map(i => `
+    <div class="engine-health-row">
+      <span class="file">${escape(i.file)}</span>
+      <span class="age">${i.exists ? escape(i.label) : "missing"}</span>
+      <span class="status-pill status-${i.status.toLowerCase()}">${escape(i.status)}</span>
+    </div>
+  `).join("");
+}
+
+function renderAgentsGrid(agents) {
+  if (!agents || !agents.agents) return `<div class="agent-card"><span>—</span></div>`;
+  return agents.agents.slice(0, 8).map(a => `
+    <div class="agent-card${a.installed ? ' installed' : ''}">
+      <span class="agent-name">${escape(a.name)}</span>
+      <span class="agent-meta">${a.installed ? `${a.runnable ? "runnable" : "installed"}${a.hookSupport ? " · hooks" : ""}` : "not detected"}</span>
+      <span class="agent-dot${a.installed ? ' installed' : ''}"></span>
+    </div>
+  `).join("");
+}
+
+function renderHeatmap(daily) {
+  if (!daily || !daily.heatmap) return "";
+  return daily.heatmap.map(d => `<div class="heatmap-day${d.exists ? ' filled' : ''}" title="${d.date}${d.exists ? ' · ✓' : ''}"></div>`).join("");
+}
+
+function renderProjects(scan) {
+  if (!scan || !scan.projects || scan.projects.length === 0) return `<div class="project-row"><span class="project-name" style="color:var(--text-dim);">No active projects detected.</span></div>`;
+  return scan.projects.map(p => {
+    const total = p.totalTasks || 0;
+    const done = (p.doneTasks || 0) + (p.unverifiedTasks || 0);
+    const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+    return `<div class="project-row">
+      <span class="project-name">${escape(p.name)}</span>
+      <div class="project-progress"><div class="project-progress-bar" style="width:${pct}%"></div></div>
+      <span class="project-counts">${done}/${total} (${pct}%)</span>
+    </div>`;
+  }).join("");
+}
+
+function renderGoals(g) {
+  if (!g || !g.horizons || g.horizons.length === 0) return `<div class="goal-horizon"><div class="goal-horizon-title" style="color:var(--text-dim);">No goals defined.</div></div>`;
+  return g.horizons.slice(0, 4).map(h => {
+    const isExpired = h.targetDate && new Date(h.targetDate).getTime() < Date.now();
+    return `<div class="goal-horizon">
+      <div class="goal-horizon-title">${escape(h.title)}</div>
+      ${h.targetDate ? `<div class="goal-horizon-date">${escape(h.targetDate)}${isExpired ? ' · <span class="status-pill status-red">EXPIRED</span>' : ''}</div>` : ""}
+      <ul class="goal-list">${h.goals.slice(0, 4).map(x => `<li>${escape(x)}</li>`).join("")}</ul>
+    </div>`;
+  }).join("");
+}
+
+function renderLibraryCounts(lib) {
+  if (!lib || !lib.sections) return `<div class="library-count-item"><span class="library-count-num">—</span><span class="library-count-label">library</span></div>`;
+  return lib.sections.map(s => `
+    <div class="library-count-item">
+      <span class="library-count-num">${s.count}</span>
+      <span class="library-count-label">${escape(s.name)}</span>
+    </div>
+  `).join("");
+}
+
+function renderLibraryRecent(lib) {
+  if (!lib || !lib.sections) return "no recent harvests";
+  const recent = [];
+  for (const s of lib.sections) {
+    for (const r of (s.recent || [])) recent.push({ ...r, section: s.name });
+  }
+  recent.sort((a, b) => b.mtime - a.mtime);
+  if (recent.length === 0) return "no recent harvests";
+  return recent.slice(0, 5).map(r => `
+    <div>· <strong>${escape(r.section)}</strong> · ${escape(r.name)} <span style="color:var(--text-muted);">${r.ageDays}d</span></div>
+  `).join("");
+}
+
+function renderEntities(lib) {
+  if (!lib || !lib.entities) return `<div class="entity-block"><span>—</span></div>`;
+  return lib.entities.map(e => {
+    const recent = (e.recent || []).slice(0, 4).map(r => escape(r.name)).join(", ");
+    return `<div class="entity-block">
+      <div class="kicker-inline">${escape(e.name)} (${e.count})</div>
+      <div class="entity-name-list">${recent || "no entries"}</div>
+    </div>`;
+  }).join("");
+}
+
+function renderVoiceTraits(voiceDna) {
+  const traits = [];
+  if (voiceDna.lowercaseI) traits.push("lowercase 'i'");
+  if (voiceDna.commaSpliced) traits.push("comma-spliced");
+  if (voiceDna.usesBrother) traits.push('"brother"');
+  if (voiceDna.urlInline) traits.push("url inline");
+  if (voiceDna.totalSamples > 0) traits.push(`${voiceDna.shortestSample}-${voiceDna.longestSample} chars`);
+  return traits.length > 0 ? traits.map(t => escape(t)).join(" · ") : "no traits extracted";
+}
+
+function renderBulletList(items) {
+  if (!items || items.length === 0) return `<div class="bullet" style="color:var(--text-muted);">empty</div>`;
+  return items.slice(0, 6).map(i => {
+    const cls = i.checked === true ? "checked" : "open";
+    return `<div class="bullet ${cls}"><span class="text">${escape(i.text)}</span></div>`;
+  }).join("");
+}
+
+function renderOverrides(manifest) {
+  if (!manifest || !manifest.overrideHistory) return `<div style="color:var(--text-muted);font-family:var(--font-mono);font-size:11px;">no recent overrides</div>`;
+  const cutoff = Date.now() - 14 * 86400000;
+  const recent = manifest.overrideHistory.filter(o => {
+    if (!o.date) return false;
+    const d = new Date(o.date);
+    return !isNaN(d.getTime()) && d.getTime() >= cutoff;
+  }).slice(0, 8);
+  if (recent.length === 0) return `<div style="color:var(--text-muted);font-family:var(--font-mono);font-size:11px;">no overrides in last 14 days · L0 friction</div>`;
+  return recent.map(o => `
+    <div class="override-row">
+      <span class="date">${escape(o.date)}</span>
+      <span>${escape((o.what || "").slice(0, 40))}</span>
+      <span>over: ${escape((o.over || "").slice(0, 40))}</span>
+      <span style="color:var(--text-dim);">${escape((o.reason || "").slice(0, 80))}</span>
+    </div>
+  `).join("");
+}
+
+function renderHookStats(hooks) {
+  if (!hooks || !hooks.hookStats) return "—";
+  const s = hooks.hookStats;
+  return `
+    <div class="hook-stat"><div class="hook-stat-name">/log</div><div class="hook-stat-num">${s.log}</div></div>
+    <div class="hook-stat"><div class="hook-stat-name">session start</div><div class="hook-stat-num">${s.sessionStart}</div></div>
+    <div class="hook-stat"><div class="hook-stat-name">engine health</div><div class="hook-stat-num">${s.engineHealth}</div></div>
+    <div class="hook-stat"><div class="hook-stat-name">plan sync</div><div class="hook-stat-num">${s.planSync}</div></div>
+  `;
+}
+
+function renderHookRecent(hooks) {
+  if (!hooks || !hooks.recentMarkers || hooks.recentMarkers.length === 0) return "no hook firings in last 7 days";
+  return hooks.recentMarkers.slice(0, 5).map(m => `
+    <div>· ${escape(m.agent)} · ${escape(m.name.replace(/^mover_/, "").slice(0, 40))} · ${m.ageHours.toFixed(1)}h</div>
+  `).join("");
+}
+
+function renderDossier(d) {
+  if (!d || !d.available) return `<div class="dossier-section">no dossier data</div>`;
+  const sections = [
+    { title: "Skills", items: d.skills },
+    { title: "Capital", items: d.capital },
+    { title: "Audience", items: d.audience },
+    { title: "Network", items: d.network }
+  ].filter(s => s.items && s.items.length > 0);
+  if (sections.length === 0) return `<div class="dossier-section">no dossier sections found</div>`;
+  return sections.map(s => `
+    <div class="dossier-section">
+      <div class="dossier-section-title">${escape(s.title)}</div>
+      ${s.items.slice(0, 3).map(i => `<div>· ${escape(i)}</div>`).join("")}
+    </div>
+  `).join("");
+}
+
+// ─────────── Helpers ───────────
+
+function dailyCompletionString(daily) {
+  if (!daily || !daily.today || !daily.today.exists) return "no daily note";
+  const t = daily.today;
+  if (!t.tasksTotal) return "no tasks";
+  return `${t.tasksDone}/${t.tasksTotal} done`;
+}
+
+function extractFromAC(ac, keyRegex) {
+  if (!ac) return null;
+  const candidates = [];
+  if (ac.sections) for (const sec of Object.values(ac.sections)) if (sec.fields) candidates.push(sec.fields);
+  if (ac.fields) candidates.push(ac.fields);
+  // Audit pass 2 (find-bugs #6): every current caller passes a literal
+  // string, but the param is typed as `keyRegex` and would happily compile
+  // a future user-controlled key. Escape regex metacharacters so a value
+  // like `[*` from a parsed section header can't ReDoS or partial-match
+  // unintended keys. Callers needing real regex behavior can opt-in with
+  // a leading sentinel later if the use case appears.
+  const safeKey = String(keyRegex).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(safeKey, "i");
+  for (const fields of candidates) for (const [k, v] of Object.entries(fields)) if (re.test(k)) return v;
+  return null;
+}
+
+function recentOverrideCount(history, days) {
+  if (!history || history.length === 0) return "0";
+  const cutoff = Date.now() - days * 86400000;
+  const c = history.filter(o => {
+    if (!o.date) return false;
+    const d = new Date(o.date);
+    return !isNaN(d.getTime()) && d.getTime() >= cutoff;
+  }).length;
+  return String(c);
+}
+
+function humanizeTimeAgo(then, now) {
+  if (!then || !now) return "—";
+  const ms = now.getTime() - then.getTime();
+  const min = Math.round(ms / 60000);
+  if (min < 1) return "now";
+  if (min < 60) return `${min}m`;
+  const hr = Math.round(min / 60);
+  if (hr < 24) return `${hr}h`;
+  const day = Math.round(hr / 24);
+  return `${day}d`;
+}
+
+function shortBattery(ac) {
+  const v = extractFromAC(ac, "battery_state") || extractFromAC(ac, "battery");
+  if (!v) return null;
+  return v.split(/[(,]/)[0].trim();
+}
+
+function shortZone(ac) {
+  const v = extractFromAC(ac, "discipline_zone") || extractFromAC(ac, "zone");
+  if (!v) return null;
+  const m = v.match(/^([0-9]+)/);
+  return m ? m[1] : v.split(/[(,]/)[0].trim();
+}
+
+function shortOscillation(ac) {
+  const v = extractFromAC(ac, "oscillation_trend") || extractFromAC(ac, "oscillation");
+  if (!v) return null;
+  return v.split(/[(,—]/)[0].trim().slice(0, 24);
+}
+
+function shortenForMetric(text, maxLen = 60) {
+  if (!text) return null;
+  const cleaned = String(text).replace(/\s+/g, " ").trim();
+  if (cleaned.length <= maxLen) return cleaned;
+  return cleaned.slice(0, maxLen - 1) + "…";
+}
+
+function shortenForCallout(text) {
+  if (!text) return "—";
+  // First sentence
+  const cleaned = String(text).replace(/\s+/g, " ").trim();
+  const firstSentence = cleaned.split(/(?<=\.)\s/)[0];
+  return firstSentence.slice(0, 100);
+}
+
+function extractFirstSentences(text, n) {
+  if (!text) return "";
+  const cleaned = text.replace(/^[#*\-]+\s*/gm, "").replace(/\n+/g, " ").trim();
+  const parts = cleaned.split(/(?<=[.!?])\s+/);
+  return parts.slice(0, n).join(" ").slice(0, 280);
+}
+
+function computeTodayCall({ ac, manifest, engineHealth, friction }) {
+  const fLevel = parseInt(String(friction || "L0").replace(/[^\d]/g, ""), 10) || 0;
+  // null = health scan unavailable — NOT "OK". Don't claim "All clear" from
+  // absence. [false-zero — Codex P1, T261]
+  const ehStatus = engineHealth ? engineHealth.overallStatus : null;
+  if (ehStatus === "RED" || fLevel >= 3) {
+    return {
+      class: "red", status: "RED",
+      text: "Engine drift detected. Address what your AI keeps catching before adding more output."
+    };
+  }
+  if (ehStatus === "YELLOW" || fLevel >= 1) {
+    return {
+      class: "amber", status: "AMBER",
+      text: "Caution. Some signals stale or friction firing. Run a workflow before deeper work."
+    };
+  }
+  if (ehStatus == null) {
+    return {
+      class: "amber", status: "UNKNOWN",
+      text: "Engine health unavailable — can't read your Engine files to confirm the brief is clear."
+    };
+  }
+  return {
+    class: "green", status: "OK",
+    text: "All clear. Push hard on the Single Test."
+  };
+}
+
+function computeStudioVerdict({ todayCall, manifest, engineHealth, daysToTest, strategy }) {
+  const fLevel = parseInt(String((manifest && manifest.frictionLevel) || "L0").replace(/[^\d]/g, ""), 10) || 0;
+  // null = health scan unavailable — NOT "OK". [false-zero — Codex P1, T261]
+  const engineStatus = engineHealth ? engineHealth.overallStatus : null;
+  const zombieCount = manifest ? (manifest.zombieCount || 0) : 0;
+  const test = manifest && manifest.singleTest ? manifest.singleTest : (strategy && strategy.singleTest ? strategy.singleTest : "the current Single Test");
+  const days = daysToTest == null ? "the deadline" : `${daysToTest}d`;
+
+  if (engineStatus === "RED" || fLevel >= 3) {
+    return {
+      title: zombieCount > 0
+        ? `You're drifting. ${zombieCount} zombie ${zombieCount === 1 ? "task is" : "tasks are"} still open.`
+        : "You're drifting. The system is catching repeated avoidance.",
+      subline: `${todayCall.text} ${shortenForMetric(test, 86)} is ${days} away.`
+    };
+  }
+
+  if (engineStatus === "YELLOW" || fLevel >= 1) {
+    return {
+      title: "Caution. The brief found friction before output.",
+      subline: `${todayCall.text} Run the workflow before opening another build surface.`
+    };
+  }
+
+  if (engineStatus == null) {
+    return {
+      title: "Brief incomplete — engine health unavailable.",
+      subline: `${todayCall.text} Can't confirm a clear brief without reading your Engine files.`
+    };
+  }
+
+  return {
+    title: "Clear brief. Push the Single Test.",
+    subline: `${todayCall.text} The next move is distribution, not more system surface.`
+  };
+}
+
+function computeDaysToTarget(strategy, manifest) {
+  // Try strategy.targetDate first
+  let date = null;
+  if (strategy && strategy.targetDate) {
+    const d = new Date(strategy.targetDate);
+    if (!isNaN(d.getTime())) date = d;
+  }
+  // Try to extract date from singleTest text e.g. "by May 15"
+  if (!date && manifest && manifest.singleTest) {
+    const m = manifest.singleTest.match(/by ([A-Za-z]+ \d+)(?:,? (\d{4}))?/);
+    if (m) {
+      const year = m[2] || new Date().getFullYear();
+      const d = new Date(`${m[1]}, ${year}`);
+      if (!isNaN(d.getTime())) date = d;
+    }
+  }
+  if (!date) return null;
+  return Math.max(0, Math.ceil((date.getTime() - Date.now()) / 86400000));
+}
+
+function computeTodayProgress(daily) {
+  if (!daily || !daily.today || !daily.today.exists) return { pct: 0, ringOffset: 0 };
+  const t = daily.today;
+  if (!t.tasksTotal) return { pct: 0, ringOffset: 0 };
+  const pct = Math.round((t.tasksDone / t.tasksTotal) * 100);
+  const circumference = 2 * Math.PI * 70; // matches r=70 in template
+  const offset = Math.round((pct / 100) * circumference);
+  return { pct: String(pct), ringOffset: offset };
+}
+
+module.exports = { build };