mover-os 4.7.7 → 4.7.8

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

@@ -0,0 +1,67 @@
+"use strict";
+
+const { goalsPath, safeRead, safeStat } = require("./paths");
+
+// Parse Goals.md. Extracts 3-month, 1-year, 10-year goals + expiration dates.
+
+function parseGoals(vault) {
+  const filePath = goalsPath(vault);
+  const text = safeRead(filePath);
+  const stat = safeStat(filePath);
+  if (!text) return { available: false, filePath };
+
+  const out = {
+    available: true,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    raw: text,
+    horizons: []
+  };
+
+  // Split on ## headers
+  const lines = text.split("\n");
+  let current = null;
+  let buf = [];
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.+?)\s*$/);
+    if (h) {
+      if (current) {
+        out.horizons.push({ title: current, body: buf.join("\n"), ...analyzeHorizon(buf.join("\n")) });
+      }
+      current = h[1];
+      buf = [];
+    } else if (current) {
+      buf.push(line);
+    }
+  }
+  if (current) {
+    out.horizons.push({ title: current, body: buf.join("\n"), ...analyzeHorizon(buf.join("\n")) });
+  }
+
+  // Identify 3-month, 1-year, 10-year via title heuristic
+  const now = Date.now();
+  out.expired = [];
+  for (const h of out.horizons) {
+    if (h.targetDate) {
+      const dt = new Date(h.targetDate);
+      if (!isNaN(dt.getTime()) && dt.getTime() < now) {
+        out.expired.push({ title: h.title, targetDate: h.targetDate, expiredDays: Math.floor((now - dt.getTime()) / 86400000) });
+      }
+    }
+  }
+
+  return out;
+}
+
+function analyzeHorizon(body) {
+  const dateMatch = body.match(/\*\*(?:Target Date|Date|By):?\*\*\s*([\d\-/]{8,10})/i);
+  const goalsList = body.split("\n")
+    .map(l => l.match(/^\s*[-*\d.]+\s+(.+)$/))
+    .filter(Boolean).map(m => m[1].trim());
+  return {
+    targetDate: dateMatch ? dateMatch[1] : null,
+    goals: goalsList.slice(0, 12)
+  };
+}
+
+module.exports = { parseGoals };

package/src/dashboard/lib/health-protocols-parser.js

@@ -0,0 +1,133 @@
+"use strict";
+
+const path = require("path");
+const fs = require("fs");
+const { safeListDir, safeRead, safeStat } = require("./paths");
+
+// Parse 02_Areas/Health/*.md as actionable recovery/maintenance protocols.
+// A "protocol" file looks like:
+//   # <Title>
+//   ## PHASE 1 — <name> (Days 1-7: <date range>)
+//   ### Every day (10 min total)
+//   - [ ] action one
+//   - [ ] action two
+//   ## PHASE 2 — ...
+//
+// Output for the dashboard:
+//   - title
+//   - currentPhase (detected by date range vs today, or first uncompleted)
+//   - today's checklist (unchecked items in current phase)
+//   - completedToday (checked items in current phase — for progress)
+//   - daysIntoPhase / daysRemaining (if dates present)
+//
+// Forgiving: never throws. Empty/missing → { available: false }.
+
+function healthDir(vault) {
+  return path.join(vault, "02_Areas", "Health");
+}
+
+function parseDateRange(line) {
+  // Match "(May 12-19)" or "(Days 1-7: May 12-19)" or "(May 20 → Jun 30)"
+  // Returns { startISO, endISO } or null
+  const m = line.match(/\((?:[^:)]*?:)?\s*([A-Z][a-z]{2})\s+(\d{1,2})(?:\s*[-–→]\s*(?:([A-Z][a-z]{2})\s+)?(\d{1,2}))?\)/);
+  if (!m) return null;
+  const monthMap = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
+  const year = new Date().getFullYear();
+  const sm = monthMap[m[1]];
+  const sd = parseInt(m[2], 10);
+  const em = m[3] ? monthMap[m[3]] : sm;
+  const ed = m[4] ? parseInt(m[4], 10) : sd;
+  if (sm === undefined || em === undefined) return null;
+  return {
+    start: new Date(year, sm, sd),
+    end: new Date(year, em, ed)
+  };
+}
+
+function parseProtocolFile(filePath) {
+  const text = safeRead(filePath);
+  if (!text) return null;
+  const stat = safeStat(filePath);
+
+  // Title from first H1, fallback to filename
+  const titleMatch = text.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : path.basename(filePath, ".md");
+
+  // Find all PHASE blocks. Phases are H2 headings that contain "PHASE" or similar.
+  const lines = text.split("\n");
+  const phases = [];
+  let currentPhase = null;
+
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    const phaseMatch = line.match(/^##\s+(.*PHASE.*)$/i);
+    if (phaseMatch) {
+      if (currentPhase) phases.push(currentPhase);
+      currentPhase = {
+        heading: phaseMatch[1].trim(),
+        dates: parseDateRange(phaseMatch[1]),
+        items: [],
+        done: 0,
+        total: 0
+      };
+      continue;
+    }
+    if (!currentPhase) continue;
+    // Skip subheadings — items only
+    if (line.startsWith("##")) continue;
+    // Checkbox lines
+    const cb = line.match(/^[-*]\s+\[([ xX])\]\s+(.+)$/);
+    if (cb) {
+      const checked = cb[1].toLowerCase() === "x";
+      currentPhase.items.push({ text: cb[2].trim(), checked });
+      currentPhase.total++;
+      if (checked) currentPhase.done++;
+    }
+  }
+  if (currentPhase) phases.push(currentPhase);
+
+  // Determine the current phase: one whose date range contains today,
+  // OR the first phase with any unchecked items if no date hits.
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  let current = phases.find(p => p.dates && p.dates.start <= today && today <= p.dates.end);
+  if (!current) current = phases.find(p => p.done < p.total);
+  if (!current && phases.length) current = phases[phases.length - 1];
+
+  // Days remaining in current phase
+  let daysRemaining = null;
+  let daysIntoPhase = null;
+  if (current && current.dates) {
+    daysRemaining = Math.max(0, Math.ceil((current.dates.end - today) / (1000 * 60 * 60 * 24)));
+    daysIntoPhase = Math.max(0, Math.ceil((today - current.dates.start) / (1000 * 60 * 60 * 24)));
+  }
+
+  return {
+    available: true,
+    title,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    phases,
+    current,
+    daysRemaining,
+    daysIntoPhase
+  };
+}
+
+function parseHealthProtocols(vault) {
+  const dir = healthDir(vault);
+  const entries = safeListDir(dir, { filesOnly: true, extension: ".md", skipUnderscore: true });
+  const protocols = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    const p = parseProtocolFile(full);
+    if (p && p.available) protocols.push(p);
+  }
+  return {
+    available: protocols.length > 0,
+    dir,
+    protocols
+  };
+}
+
+module.exports = { parseHealthProtocols };

package/src/dashboard/lib/hook-activity.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+const { exists, safeListDir, safeStat } = require("./paths");
+
+// Read recent hook activity from ~/.claude/tmp/mover_* markers + session-history if available.
+
+function readHookActivity() {
+  const home = os.homedir();
+  const claudeTmp = path.join(home, ".claude", "tmp");
+  const codexTmp = path.join(home, ".codex", "tmp");
+  const geminiTmp = path.join(home, ".gemini", "tmp");
+
+  const out = { available: true, recentMarkers: [], hookStats: { sessionStart: 0, log: 0, engineHealth: 0, planSync: 0 }, lastFire: null };
+
+  for (const dir of [claudeTmp, codexTmp, geminiTmp]) {
+    if (!exists(dir)) continue;
+    const entries = safeListDir(dir, { filesOnly: true });
+    for (const e of entries) {
+      if (!e.name.startsWith("mover_")) continue;
+      const stat = safeStat(e.path);
+      if (!stat) continue;
+      const ageDays = (Date.now() - stat.mtime.getTime()) / 86400000;
+      if (ageDays > 7) continue;
+      out.recentMarkers.push({
+        name: e.name,
+        agent: dir.includes(".claude") ? "Claude" : dir.includes(".codex") ? "Codex" : "Gemini",
+        mtime: stat.mtime,
+        ageDays: Math.floor(ageDays * 24 * 60) / (24 * 60),
+        ageHours: Math.floor(ageDays * 24 * 10) / 10
+      });
+      // Categorize
+      if (e.name.includes("logprompt") || e.name.includes("logdone")) out.hookStats.log++;
+      else if (e.name.includes("session-start") || e.name.includes("sessionstart")) out.hookStats.sessionStart++;
+      else if (e.name.includes("engine") || e.name.includes("health")) out.hookStats.engineHealth++;
+      else if (e.name.includes("plan-sync")) out.hookStats.planSync++;
+      if (!out.lastFire || stat.mtime > out.lastFire) out.lastFire = stat.mtime;
+    }
+  }
+  out.recentMarkers.sort((a, b) => b.mtime - a.mtime);
+  out.recentMarkers = out.recentMarkers.slice(0, 10);
+
+  return out;
+}
+
+module.exports = { readHookActivity };

package/src/dashboard/lib/hook-indexer.js

@@ -0,0 +1,169 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { safeListDir, safeRead, safeStat, safeReadJson, exists } = require("./paths");
+
+// Index Mover OS hook scripts and their registration state.
+//
+// Scripts live in <bundle>/src/hooks/. We try to locate the bundle:
+//   1. Walking up from this file (lib/ → dashboard/ → src/ → bundle root)
+//   2. Default vault layout <vault>/01_Projects/Mover OS Bundle/src/hooks/
+//
+// Registration state is read from ~/.claude/settings.json hooks block.
+//
+// Last-fired timestamps come from ~/.claude/tmp/mover_<hook>_<id>.* markers.
+
+const HOOK_EVENTS = [
+  "SessionStart",
+  "Stop",
+  "PreToolUse",
+  "PostToolUse",
+  "PreCompact",
+  "UserPromptSubmit",
+  "SubagentStop",
+];
+
+function bundleHooksDir() {
+  // From src/dashboard/lib/hook-indexer.js, walk up to bundle root then into src/hooks
+  // lib/hook-indexer.js → lib → dashboard → src → bundle root
+  const candidate = path.resolve(__dirname, "..", "..", "hooks");
+  if (exists(candidate)) return candidate;
+  // Fallback: ~/.claude/hooks (if installed there)
+  const alt = path.join(os.homedir(), ".claude", "hooks");
+  if (exists(alt)) return alt;
+  return null;
+}
+
+function claudeSettingsPath() {
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+
+function claudeTmpDir() {
+  return path.join(os.homedir(), ".claude", "tmp");
+}
+
+// Extract a one-line description from the first commented lines of a script.
+function extractDescription(content) {
+  if (!content) return "";
+  const lines = content.split(/\r?\n/);
+  // For .sh: lines start with #
+  // For .js: lines start with // or /* */
+  for (let i = 0; i < Math.min(20, lines.length); i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    if (line.startsWith("#!")) continue;
+    if (line.startsWith("'use strict")) continue;
+    // Shell comment
+    const sh = line.match(/^#\s*(.+)$/);
+    if (sh && sh[1].length > 5) return sh[1].trim().slice(0, 140);
+    // JS line comment
+    const js = line.match(/^\/\/\s*(.+)$/);
+    if (js && js[1].length > 5) return js[1].trim().slice(0, 140);
+    // JS block comment start
+    const block = line.match(/^\/\*\s*(.+?)\s*\*?\/?$/);
+    if (block && block[1].length > 5) return block[1].trim().slice(0, 140);
+  }
+  return "";
+}
+
+function readRegisteredHooks() {
+  const settings = safeReadJson(claudeSettingsPath());
+  if (!settings || !settings.hooks) return { byEvent: {}, allPaths: new Set() };
+
+  const byEvent = {};
+  const allPaths = new Set();
+
+  for (const event of Object.keys(settings.hooks)) {
+    const entries = settings.hooks[event];
+    if (!Array.isArray(entries)) continue;
+    byEvent[event] = [];
+    for (const entry of entries) {
+      // shape: { matcher?: string, hooks: [{ type, command }] }
+      const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+      for (const h of hooks) {
+        if (typeof h.command === "string") {
+          // Extract script filename from command
+          const scriptMatch = h.command.match(/([^\s"'\/]+\.(sh|js))/i);
+          if (scriptMatch) {
+            const filename = scriptMatch[1];
+            byEvent[event].push({ filename, command: h.command, matcher: entry.matcher || null });
+            allPaths.add(filename);
+          }
+        }
+      }
+    }
+  }
+
+  return { byEvent, allPaths };
+}
+
+function readLastFired() {
+  const tmp = claudeTmpDir();
+  if (!safeStat(tmp)) return {};
+  const markers = safeListDir(tmp, { filesOnly: true });
+  const lastFired = {};
+  for (const m of markers) {
+    if (!m.name.startsWith("mover_")) continue;
+    const stat = safeStat(m.path);
+    if (!stat) continue;
+    // Marker filename heuristic: mover_<hookname>_<id>.<ext>
+    const m2 = m.name.match(/^mover_([a-z0-9-]+)_/i);
+    if (m2) {
+      const hookKey = m2[1];
+      const t = stat.mtime.getTime();
+      if (!lastFired[hookKey] || lastFired[hookKey] < t) {
+        lastFired[hookKey] = t;
+      }
+    }
+  }
+  return lastFired;
+}
+
+function indexHooks() {
+  const hooksDir = bundleHooksDir();
+  if (!hooksDir) {
+    return { available: false, count: 0, byEvent: {}, registered: [], unregistered: [] };
+  }
+
+  const entries = safeListDir(hooksDir, { filesOnly: true });
+  const scripts = entries.filter(e => e.name.endsWith(".sh") || e.name.endsWith(".js"));
+
+  const { byEvent: regByEvent, allPaths: registeredPaths } = readRegisteredHooks();
+  const lastFired = readLastFired();
+
+  const all = scripts.map(s => {
+    const content = safeRead(s.path);
+    const description = extractDescription(content);
+    const stat = safeStat(s.path);
+    const isRegistered = registeredPaths.has(s.name);
+    // Derive a "key" matching the marker convention (script stem)
+    const stem = s.name.replace(/\.(sh|js)$/, "");
+    const lastFiredAt = lastFired[stem] || null;
+
+    return {
+      filename: s.name,
+      path: s.path,
+      type: s.name.endsWith(".js") ? "js" : "sh",
+      description,
+      registered: isRegistered,
+      lastFiredAt,
+      lastModified: stat ? stat.mtime.getTime() : null,
+    };
+  });
+
+  all.sort((a, b) => a.filename.localeCompare(b.filename));
+
+  return {
+    available: true,
+    count: all.length,
+    byEvent: regByEvent,
+    registered: all.filter(h => h.registered),
+    unregistered: all.filter(h => !h.registered),
+    all,
+    events: HOOK_EVENTS,
+  };
+}
+
+module.exports = { indexHooks };

package/src/dashboard/lib/hourly-activity-parser.js

@@ -0,0 +1,143 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { dailiesDir } = require("./paths");
+const { localDateKey } = require("./date-utils");
+
+// hourly-activity-parser.js — a 24-hour readiness-curve UI pattern applied
+// to behavioral data.
+//
+// The reference pattern plots biometric readiness on a 24-hour curve. We
+// don't have biometrics in the vault — we have BEHAVIORAL ACTIVITY: how
+// often the user actually
+// works (sessions, log entries) at each hour. That density curve answers the
+// same question ("when am I sharpest?") from a different angle: when do you
+// actually get things done historically.
+//
+// Returns: { available, hours: [{ hour: 0..23, count, isPeak }], peakHour,
+//           todayHours: [{ hour, count }], events: [{ hour, text, date }] }
+//
+// Sources:
+//  - Daily Notes ### HH:MM entries inside ## Session Log sections
+//  - Last 14 days (2 full weeks for a stable curve)
+
+function compute({ vault, daysLookback = 14 } = {}) {
+  if (!vault) return { available: false, hours: [], peakHour: null, todayHours: [], events: [] };
+
+  const dDir = dailiesDir(vault);
+  if (!fs.existsSync(dDir)) return { available: false, hours: [], peakHour: null, todayHours: [], events: [] };
+
+  // Per-hour aggregated counts across the lookback window
+  const hourCounts = new Array(24).fill(0);
+  // Today's specific hour counts (for the bright overlay line)
+  const todayCounts = new Array(24).fill(0);
+  // Notable session-log events to plot as markers
+  const events = [];
+
+  const cutoff = Date.now() - daysLookback * 24 * 3600 * 1000;
+  const todayKey = localDateKey();
+
+  let monthDirs;
+  try {
+    monthDirs = fs.readdirSync(dDir).filter(d => /^\d{4}-\d{2}$/.test(d)).sort().reverse();
+  } catch (_) {
+    return { available: false, hours: [], peakHour: null, todayHours: [], events: [] };
+  }
+
+  let scanned = 0;
+  outer: for (const mDir of monthDirs) {
+    if (scanned >= daysLookback) break;
+    const monthPath = path.join(dDir, mDir);
+    let files;
+    try {
+      files = fs.readdirSync(monthPath).filter(f => /^Daily - \d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+    } catch (_) { continue; }
+    for (const f of files) {
+      if (scanned >= daysLookback) break outer;
+      const m = f.match(/(\d{4})-(\d{2})-(\d{2})/);
+      if (!m) continue;
+      const dayKey = `${m[1]}-${m[2]}-${m[3]}`;
+      const dayTs = Date.parse(dayKey);
+      if (!Number.isFinite(dayTs) || dayTs < cutoff) continue;
+      const isToday = dayKey === todayKey;
+      scanned++;
+
+      let text;
+      try { text = fs.readFileSync(path.join(monthPath, f), "utf8"); }
+      catch (_) { continue; }
+
+      // Find the Session Log section. Mover OS uses 3 formats:
+      //   ### Session Log [ATTENDED] — ~02:03-14:37 [May 13] [Claude Code] [Mover OS Bundle] [COMPACTED]
+      //   ### Session Log [AUTO-STUB] — ~22:21 [Claude Code] [Mover OS Bundle] [hash]
+      //   ### ~14:32 - Event Title  (legacy / nested events)
+      // T242 bug hunt fix (B#11): `text.indexOf("## Session Log")` was a
+      // substring search — `### Session Log` (level 3, also valid) contains
+      // the literal `## Session Log` as a substring. Conversely, level-2
+      // `## Session Log` headers with no nested `###` sub-entries were
+      // matched by the section locator but the entries regex below
+      // returned nothing. Anchor to level-2 explicitly. Fallback: if no
+      // level-2 found, try level-3 (some daily notes use only ### form).
+      let slMatch = text.match(/^##\s+Session Log/m);
+      if (!slMatch) slMatch = text.match(/^###\s+Session Log/m);
+      if (!slMatch || typeof slMatch.index !== "number") continue;
+      const section = text.slice(slMatch.index);
+
+      // Format A: Session Log header with time range — count the START hour
+      const reSession = /^###\s+Session Log\s+\[[^\]]+\]\s+—\s+~?(\d{1,2}):(\d{2})(?:[-–]\s*(\d{1,2}):(\d{2}))?\s*(?:\[[^\]]+\])?\s*(?:\[([^\]]+)\])?/gm;
+      let mm;
+      while ((mm = reSession.exec(section)) !== null) {
+        const startHour = parseInt(mm[1], 10);
+        if (!Number.isFinite(startHour) || startHour < 0 || startHour > 23) continue;
+        hourCounts[startHour]++;
+        if (isToday) todayCounts[startHour]++;
+        const tag = mm[5] ? `[${mm[5]}]` : "";
+        const range = mm[3] ? ` ${mm[1]}:${mm[2]}-${mm[3]}:${mm[4]}` : ` ${mm[1]}:${mm[2]}`;
+        events.push({ hour: startHour, date: dayKey, text: `Session${range}${tag ? " " + tag : ""}`.trim(), isToday });
+      }
+
+      // Format B: Legacy nested event headers — `### HH:MM - Title`
+      const reLegacy = /^###\s+~?(\d{1,2}):(\d{2})\s+-\s+(.+)$/gm;
+      while ((mm = reLegacy.exec(section)) !== null) {
+        const hour = parseInt(mm[1], 10);
+        if (!Number.isFinite(hour) || hour < 0 || hour > 23) continue;
+        const title = (mm[3] || "").trim();
+        // Skip Session Log headers re-matched (they contain " — ")
+        if (title.startsWith("Session Log")) continue;
+        hourCounts[hour]++;
+        if (isToday) todayCounts[hour]++;
+        if (title.length < 80) {
+          events.push({ hour, date: dayKey, text: title, isToday });
+        }
+      }
+    }
+  }
+
+  // Compute peak hour
+  let peakHour = null;
+  let peakCount = 0;
+  for (let h = 0; h < 24; h++) {
+    if (hourCounts[h] > peakCount) {
+      peakCount = hourCounts[h];
+      peakHour = h;
+    }
+  }
+
+  const hours = hourCounts.map((c, h) => ({ hour: h, count: c, isPeak: h === peakHour && peakCount > 0 }));
+  const todayHours = todayCounts.map((c, h) => ({ hour: h, count: c }));
+
+  // Keep last 12 today-events for marker overlay
+  const todayEvents = events.filter(e => e.isToday).slice(0, 12);
+
+  return {
+    available: scanned > 0,
+    daysScanned: scanned,
+    hours,
+    peakHour,
+    peakCount,
+    todayHours,
+    events: todayEvents
+  };
+}
+
+module.exports = { compute };

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

@@ -0,0 +1,85 @@
+"use strict";
+
+const { identityPrimePath, safeRead, safeStat } = require("./paths");
+
+// Parse Identity_Prime.md. Extracts archetype, core drive, fatal flaw, the law, anti-identity, code lines.
+
+function parseIdentity(vault) {
+  const filePath = identityPrimePath(vault);
+  const text = safeRead(filePath);
+  const stat = safeStat(filePath);
+  if (!text) return { available: false, filePath };
+
+  const out = { available: true, filePath, lastUpdated: stat ? stat.mtime : null, raw: text, fields: {} };
+
+  // Bold field extraction
+  const re = /\*\*([^*]+):\*\*\s*([^\n]+)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const k = m[1].trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_|_$/g, "");
+    out.fields[k] = m[2].trim();
+  }
+
+  // Personal name from the H1 ("# IDENTITY PRIME: <name>") — the onboarding
+  // engine-writer writes the user's own answer there. Persona titles
+  // ("THE MOVER") and the unanswered placeholder ("You") are not names.
+  const h1 = text.match(/^#[^\n]*IDENTITY PRIME:\s*(.+?)\s*$/mi);
+  const h1name = h1 ? h1[1].trim() : "";
+  out.name = h1name && !/^the\s/i.test(h1name) && h1name.toLowerCase() !== "you" ? h1name : null;
+
+  // Common keys
+  out.archetype = out.fields.archetype || null;
+  out.coreDrive = out.fields.core_drive || null;
+  out.fatalFlaw = out.fields.fatal_flaw || null;
+  out.theLaw = out.fields.the_law || null;
+  out.antiIdentity = out.fields.anti_identity || null;
+  out.psychFirewall = out.fields.psychological_firewall || null;
+
+  // Sections
+  const sections = splitSections(text);
+  out.sections = sections;
+  out.code = extractListUnder(sections, "the code");
+  out.evolvedSelf = sectionBody(sections, "evolved self");
+  out.antiIdentityBody = sectionBody(sections, "anti-identity") || sectionBody(sections, "the mediocre");
+  out.primaryResistanceForms = extractListUnder(sections, "primary resistance forms");
+
+  return out;
+}
+
+function splitSections(text) {
+  const sections = {};
+  const lines = text.split("\n");
+  let currentTitle = null;
+  let buf = [];
+  for (const line of lines) {
+    const h = line.match(/^##+\s+(.+?)\s*$/);
+    if (h) {
+      if (currentTitle) sections[currentTitle.toLowerCase()] = buf.join("\n");
+      currentTitle = h[1];
+      buf = [];
+    } else if (currentTitle) {
+      buf.push(line);
+    }
+  }
+  if (currentTitle) sections[currentTitle.toLowerCase()] = buf.join("\n");
+  return sections;
+}
+
+function sectionBody(sections, needle) {
+  for (const [title, body] of Object.entries(sections)) {
+    if (title.includes(needle.toLowerCase())) return body;
+  }
+  return null;
+}
+
+function extractListUnder(sections, needle) {
+  const body = sectionBody(sections, needle);
+  if (!body) return [];
+  return body.split("\n")
+    .map(l => l.match(/^\s*[-*\d.]+\s+(.+)$/))
+    .filter(Boolean)
+    .map(m => m[1].trim())
+    .slice(0, 12);
+}
+
+module.exports = { parseIdentity };