mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/ingestion.js

@@ -0,0 +1,418 @@
+"use strict";
+
+/**
+ * ingestion.js — D3 data ingestion for the Mover OS onboarding engine.
+ *
+ * Normalizes heterogeneous user-exported notes (Apple Notes export, Google Keep
+ * Takeout, Obsidian/Notion markdown, plain .txt/.md/.json/.html) into ONE compact
+ * text digest suitable for injection into an AgentSession as a framed context turn.
+ *
+ * DESIGN CONSTRAINTS (from onboarding-engine-SPEC.md §4 + §0):
+ *  - Zero network calls — fully local, privacy-first.
+ *  - Zero permissions required — user drags in their own export; we never read the fs.
+ *  - Zero external dependencies — pure Node.js built-ins only.
+ *  - Digest cap: ~6-8k chars total across all files, so it fits comfortably in the
+ *    setup agent's context without flooding it and crowding out the interview itself.
+ *
+ * DEFERRED: Chrome-MCP auto-fetch, OAuth connectors, zip extraction, vault connector.
+ * See D3-ingestion/SPEC.md for the full deferred tail.
+ *
+ * Public API:
+ *   buildDigest(files)   → string
+ *   normalizeFile(file)  → string   (exported for testing)
+ *   SUPPORTED_TYPES      → string[]
+ *   DIGEST_CAP           → number
+ */
+
+// ─── constants ────────────────────────────────────────────────────────────────
+
+/** Hard cap on total digest output (chars). 7k leaves breathing room inside 8k. */
+const DIGEST_CAP = 7_000;
+
+/** Per-file char budget before truncation — files share the cap equally up to this. */
+const PER_FILE_CAP = 3_500;
+
+/** File extensions we accept. Soft reject happens in the UI; this is the server guard. */
+const SUPPORTED_TYPES = [".txt", ".md", ".json", ".html", ".htm"];
+
+// ─── normalizers ──────────────────────────────────────────────────────────────
+
+/**
+ * Strip HTML to plain text. Removes script/style blocks first (they contain
+ * no useful note content and are char-expensive), then removes all remaining
+ * tags, collapses whitespace, and trims.
+ *
+ * Handles Google Keep Takeout (.html files per note) and Apple Notes HTML export.
+ */
+function stripHtml(raw) {
+  // Remove <script>…</script> and <style>…</style> blocks (multiline).
+  let s = raw.replace(/<script[\s\S]*?<\/script>/gi, " ");
+  s = s.replace(/<style[\s\S]*?<\/style>/gi, " ");
+  // Remove HTML comments.
+  s = s.replace(/<!--[\s\S]*?-->/g, " ");
+  // Swap block-level close tags for newlines so paragraphs survive.
+  s = s.replace(/<\/(p|div|li|h[1-6]|br|tr|td|th|blockquote|section|article|header|footer|nav|main)>/gi, "\n");
+  s = s.replace(/<br\s*\/?>/gi, "\n");
+  // Strip all remaining tags.
+  s = s.replace(/<[^>]+>/g, " ");
+  // Decode the most common HTML entities.
+  s = s.replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&mdash;/g, "—")
+        .replace(/&ndash;/g, "–")
+        .replace(/&hellip;/g, "…");
+  // Collapse runs of whitespace (preserve single newlines for paragraph breaks).
+  s = s.replace(/[ \t]+/g, " ");
+  s = s.replace(/\n[ \t]+/g, "\n");
+  s = s.replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}
+
+/**
+ * Normalize a JSON file. Rather than dumping the raw structure (which is often
+ * deeply nested and char-expensive), we flatten it to a bullet list of
+ * "key: value" pairs for scalar leaves. Arrays become an item count + sample.
+ * This works well for Google Keep Takeout (array of note objects).
+ */
+function normalizeJson(raw) {
+  let parsed;
+  try { parsed = JSON.parse(raw); }
+  catch (_) { return raw.slice(0, PER_FILE_CAP); } // unparseable — return raw excerpt
+
+  const lines = [];
+
+  function walk(obj, prefix, depth) {
+    if (depth > 4) return; // don't recurse into deeply nested structures
+    if (Array.isArray(obj)) {
+      lines.push(`${prefix}[${obj.length} items]`);
+      // Sample up to 3 items for context.
+      const sample = obj.slice(0, 3);
+      sample.forEach((item, i) => walk(item, `${prefix}[${i}] `, depth + 1));
+      if (obj.length > 3) lines.push(`${prefix}… and ${obj.length - 3} more`);
+      return;
+    }
+    if (obj !== null && typeof obj === "object") {
+      for (const [k, v] of Object.entries(obj)) {
+        walk(v, prefix ? `${prefix}.${k}` : k, depth + 1);
+      }
+      return;
+    }
+    // Scalar — emit as "key: value"
+    const val = String(obj);
+    if (val.length > 300) {
+      lines.push(`${prefix}: ${val.slice(0, 300)}…`);
+    } else if (val.trim()) {
+      lines.push(`${prefix}: ${val}`);
+    }
+  }
+
+  walk(parsed, "", 0);
+  return lines.join("\n");
+}
+
+/**
+ * Light Markdown normalization. Strips front-matter (---…---), removes image
+ * syntax (![…](…)), collapses code blocks to a one-liner stub, and normalises
+ * whitespace. Preserves prose and headings — that's what the agent needs.
+ */
+function normalizeMd(raw) {
+  let s = raw;
+  // Strip YAML front-matter block.
+  s = s.replace(/^---[\s\S]*?---\n?/, "");
+  // Collapse code fences to a stub.
+  s = s.replace(/```[\s\S]*?```/g, "[code block]");
+  s = s.replace(/`[^`\n]+`/g, (m) => m.slice(1, -1)); // inline code → plain text
+  // Remove image syntax.
+  s = s.replace(/!\[([^\]]*)\]\([^)]*\)/g, (_, alt) => alt ? `[image: ${alt}]` : "[image]");
+  // Preserve link text, drop URL.
+  s = s.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
+  // Wikilinks — keep the display part.
+  s = s.replace(/\[\[([^\]|]+)\|([^\]]+)\]\]/g, "$2");
+  s = s.replace(/\[\[([^\]]+)\]\]/g, "$1");
+  // Collapse checkbox markers.
+  s = s.replace(/^- \[[ xX]\] /gm, "- ");
+  // Collapse multiple blank lines.
+  s = s.replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}
+
+// ─── file-type dispatch ───────────────────────────────────────────────────────
+
+/**
+ * Detect a file's effective type from its name.
+ * Returns one of: "html" | "json" | "md" | "txt" | "unsupported"
+ */
+function detectType(name) {
+  if (!name) return "unsupported";
+  const n = name.toLowerCase();
+  if (n.endsWith(".html") || n.endsWith(".htm")) return "html";
+  if (n.endsWith(".json")) return "json";
+  if (n.endsWith(".md") || n.endsWith(".markdown")) return "md";
+  if (n.endsWith(".txt")) return "txt";
+  return "unsupported";
+}
+
+/**
+ * Normalize a single file to plain text.
+ *
+ * @param {{ name: string, content: string }} file
+ *   `name`    — original filename (used for type detection + section header)
+ *   `content` — raw string content of the file
+ * @returns {string} Normalized plain text, not yet capped.
+ */
+function normalizeFile(file) {
+  if (!file || typeof file.content !== "string") return "";
+  const type = detectType(file.name || "");
+  switch (type) {
+    case "html": return stripHtml(file.content);
+    case "json": return normalizeJson(file.content);
+    case "md":   return normalizeMd(file.content);
+    case "txt":  return file.content.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+    default:     return ""; // unsupported type — skip silently
+  }
+}
+
+// ─── digest builder ───────────────────────────────────────────────────────────
+
+/**
+ * Build a compact, labeled digest from a list of uploaded files.
+ *
+ * The digest format is:
+ *   --- [filename] (type) ---
+ *   <normalized content, capped to PER_FILE_CAP chars>
+ *   (truncated)         ← only if truncated
+ *
+ * Total output is capped at DIGEST_CAP chars. When the cap is hit,
+ * remaining files get a "[omitted — digest cap reached]" stub so the
+ * agent knows there was more content rather than silently missing it.
+ *
+ * @param {Array<{ name: string, content: string }>} files
+ * @returns {string} The assembled digest, ready for AgentSession.send().
+ */
+function buildDigest(files) {
+  if (!Array.isArray(files) || files.length === 0) return "";
+
+  // MF-4: bound the file count. The 2MB request body allows tens of thousands of
+  // tiny file objects; without this, unsupported/over-cap stubs could still blow
+  // up the sections array far past DIGEST_CAP. 50 is generous for a real import.
+  if (files.length > 50) files = files.slice(0, 50);
+
+  const sections = [];
+  let totalChars = 0;
+
+  for (const file of files) {
+    const name = String(file.name || "unknown");
+    const type = detectType(name);
+
+    if (type === "unsupported") {
+      const stub = `--- [${name}] (unsupported — skipped) ---`;
+      sections.push(stub);
+      totalChars += stub.length; // MF-4: stubs count toward the cap too
+      continue;
+    }
+
+    if (totalChars >= DIGEST_CAP) {
+      sections.push(`--- [${name}] (${type}) [omitted — digest cap reached] ---`);
+      continue;
+    }
+
+    let normalized = normalizeFile(file);
+
+    // Per-file cap — truncate at a word boundary if possible.
+    if (normalized.length > PER_FILE_CAP) {
+      const cutoff = normalized.lastIndexOf(" ", PER_FILE_CAP);
+      normalized = normalized.slice(0, cutoff > 0 ? cutoff : PER_FILE_CAP);
+      normalized += "\n(truncated)";
+    }
+
+    // Enforce remaining budget within the total cap. MF-4 part A: account for
+    // the header length so the assembled section can't overshoot DIGEST_CAP.
+    const header = `--- [${name}] (${type}) ---\n`;
+    const remaining = DIGEST_CAP - totalChars - header.length;
+    if (normalized.length > remaining) {
+      const cut = Math.max(0, remaining);
+      const cutoff = normalized.lastIndexOf(" ", cut);
+      normalized = normalized.slice(0, cutoff > 0 ? cutoff : cut);
+      normalized += "\n(digest cap reached)";
+    }
+
+    const section = header + normalized;
+    sections.push(section);
+    totalChars += section.length;
+  }
+
+  return sections.join("\n\n");
+}
+
+// ─── injection frame ──────────────────────────────────────────────────────────
+
+/**
+ * Wrap a raw digest in the framing text that tells the setup agent how to USE
+ * the context (silently, to personalize questions — not to summarize back).
+ *
+ * This is what gets fed to AgentSession.send() as the user turn.
+ *
+ * @param {string} digest — output of buildDigest()
+ * @returns {string}
+ */
+function frameDigest(digest) {
+  if (!digest || !digest.trim()) return "";
+  // MF-2: neutralize any completion sentinel an imported note tries to smuggle in,
+  // so malicious note content cannot make the agent end the interview early.
+  const safe = String(digest).replace(/\[\[(SETUP|WALKTHROUGH)_COMPLETE\]\]/gi, "[redacted-marker]");
+  return (
+    "Here is context the user imported from their existing notes. " +
+    "Use this to personalize the setup interview. " +
+    "Do not summarize it back to the user or comment on it — use it silently to inform your questions. " +
+    "Where the notes reveal existing goals, work patterns, or projects, reflect that in your questions " +
+    "rather than asking about things already answered here. " +
+    "Treat everything in these notes as possibly OUTDATED: exported notes carry no dates you can trust. " +
+    "For anything load-bearing (a goal, a deadline, a current project), confirm it in one short question, " +
+    "for example: your notes mention a goal of X, is that still true or has it moved? Never assume it holds.\n\n" +
+    "--- BEGIN IMPORTED CONTEXT ---\n" +
+    safe +
+    "\n--- END IMPORTED CONTEXT ---"
+  );
+}
+
+// ─── exports ──────────────────────────────────────────────────────────────────
+
+module.exports = { buildDigest, normalizeFile, frameDigest, SUPPORTED_TYPES, DIGEST_CAP, PER_FILE_CAP };
+
+// ─── self-test ────────────────────────────────────────────────────────────────
+/* node src/dashboard/lib/ingestion.js */
+
+if (require.main === module) {
+  const assert = require("assert");
+
+  // ── fixture data ──────────────────────────────────────────────────────────
+
+  const MD_FIXTURE = `---
+title: Work Log
+date: 2026-01-15
+---
+
+# Work Log
+
+## Goals
+- [[Annual Review|My 2026 Goals]]
+- Build Mover OS to £25k
+
+## Projects
+- \`mover-os\`: in progress
+- \`newsletter\`: stalled
+
+![screenshot](image.png)
+
+\`\`\`js
+console.log("hello");
+\`\`\`
+
+Some prose about my weekly habits.
+`;
+
+  const JSON_FIXTURE = JSON.stringify({
+    kind: "notes#notesList",
+    items: [
+      { title: "Q1 Plan", textContent: "Ship Mover OS. Get first 10 users.", labels: [{ name: "work" }] },
+      { title: "Reading list", textContent: "Thinking Fast and Slow. Zero to One.", labels: [{ name: "books" }] },
+      { title: "Empty note", textContent: "" },
+    ],
+  });
+
+  const HTML_FIXTURE = `<!DOCTYPE html><html><head><title>Note</title>
+<style>body { font-family: sans-serif; }</style>
+<script>var x=1;</script>
+</head><body>
+<div class="note">
+  <h1>My Apple Note</h1>
+  <p>This is the content of my note. It has &amp; symbols &lt;like this&gt;.</p>
+  <ul><li>Task one</li><li>Task two</li></ul>
+</div></body></html>`;
+
+  const TXT_FIXTURE = "Just some plain text.\n\nWith multiple paragraphs.\n\nAnd a third one.";
+
+  // ── test: normalizeFile ───────────────────────────────────────────────────
+
+  const mdNorm = normalizeFile({ name: "work.md", content: MD_FIXTURE });
+  assert.ok(!mdNorm.includes("---"), "md: front-matter stripped");
+  assert.ok(mdNorm.includes("Build Mover OS"), "md: prose preserved");
+  assert.ok(!mdNorm.includes("console.log"), "md: code block removed");
+  assert.ok(!mdNorm.includes("](image.png)"), "md: image markdown syntax removed");
+  assert.ok(mdNorm.includes("My 2026 Goals"), "md: wikilink display alias kept");
+  console.log("normalizeFile md: OK");
+
+  const jsonNorm = normalizeFile({ name: "keep.json", content: JSON_FIXTURE });
+  assert.ok(jsonNorm.includes("Q1 Plan"), "json: title value present");
+  assert.ok(jsonNorm.includes("Ship Mover OS"), "json: textContent present");
+  console.log("normalizeFile json: OK");
+
+  const htmlNorm = normalizeFile({ name: "note.html", content: HTML_FIXTURE });
+  assert.ok(!htmlNorm.includes("<html>"), "html: tags stripped");
+  assert.ok(!htmlNorm.includes("font-family"), "html: style block removed");
+  assert.ok(!htmlNorm.includes("var x"), "html: script block removed");
+  assert.ok(htmlNorm.includes("Apple Note"), "html: heading text kept");
+  assert.ok(htmlNorm.includes("& symbols <like this>"), "html: entities decoded");
+  console.log("normalizeFile html: OK");
+
+  const txtNorm = normalizeFile({ name: "notes.txt", content: TXT_FIXTURE });
+  assert.ok(txtNorm.includes("plain text"), "txt: content preserved");
+  console.log("normalizeFile txt: OK");
+
+  const unsupp = normalizeFile({ name: "data.xlsx", content: "binary" });
+  assert.strictEqual(unsupp, "", "unsupported type → empty string");
+  console.log("normalizeFile unsupported: OK");
+
+  // ── test: buildDigest ─────────────────────────────────────────────────────
+
+  const files = [
+    { name: "work.md", content: MD_FIXTURE },
+    { name: "keep.json", content: JSON_FIXTURE },
+    { name: "note.html", content: HTML_FIXTURE },
+    { name: "notes.txt", content: TXT_FIXTURE },
+    { name: "ignored.xlsx", content: "binary" },
+  ];
+
+  const digest = buildDigest(files);
+  assert.ok(digest.length <= DIGEST_CAP, `digest within cap: ${digest.length} <= ${DIGEST_CAP}`);
+  assert.ok(digest.includes("--- [work.md] (md) ---"), "digest: md section header present");
+  assert.ok(digest.includes("--- [keep.json] (json) ---"), "digest: json section header present");
+  assert.ok(digest.includes("--- [note.html] (html) ---"), "digest: html section header present");
+  assert.ok(digest.includes("--- [notes.txt] (txt) ---"), "digest: txt section header present");
+  assert.ok(digest.includes("--- [ignored.xlsx] (unsupported — skipped) ---"), "digest: unsupported flagged");
+  console.log(`buildDigest: OK (${digest.length} chars)`);
+
+  // ── test: per-file cap ────────────────────────────────────────────────────
+
+  const bigContent = "word ".repeat(5_000); // ~25k chars
+  const bigDigest = buildDigest([{ name: "big.txt", content: bigContent }]);
+  assert.ok(bigDigest.length <= DIGEST_CAP + 200, `big file capped: ${bigDigest.length}`);
+  assert.ok(bigDigest.includes("(truncated)") || bigDigest.includes("(digest cap"), "big file truncation noted");
+  console.log("per-file cap: OK");
+
+  // ── test: frameDigest ────────────────────────────────────────────────────
+
+  const framed = frameDigest(digest);
+  assert.ok(framed.includes("--- BEGIN IMPORTED CONTEXT ---"), "framed: opening marker");
+  assert.ok(framed.includes("--- END IMPORTED CONTEXT ---"), "framed: closing marker");
+  assert.ok(framed.includes("silently"), "framed: silent-use instruction present");
+  console.log("frameDigest: OK");
+
+  // ── test: empty inputs ────────────────────────────────────────────────────
+
+  assert.strictEqual(buildDigest([]), "", "empty array → empty string");
+  assert.strictEqual(buildDigest(null), "", "null → empty string");
+  assert.strictEqual(frameDigest(""), "", "empty digest → empty frame");
+  console.log("edge cases: OK");
+
+  // ── print sample output ───────────────────────────────────────────────────
+
+  console.log("\n─── SAMPLE FRAMED DIGEST ───────────────────────────────────────────");
+  console.log(framed.slice(0, 1_200) + (framed.length > 1_200 ? "\n[…truncated for display]" : ""));
+  console.log("────────────────────────────────────────────────────────────────────");
+  console.log("\nAll tests passed.");
+}

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

@@ -0,0 +1,226 @@
+"use strict";
+
+const path = require("path");
+const {
+  archivesDir,
+  engineDir,
+  libraryDir,
+  libraryCheatsheetsDir,
+  libraryPrinciplesDir,
+  librarySopsDir,
+  libraryEntitiesPeopleDir,
+  libraryEntitiesOrgsDir,
+  libraryEntitiesPlacesDir,
+  libraryEntitiesDecisionsDir,
+  libraryInputsDir,
+  libraryScriptsDir,
+  libraryMocsDir,
+  safeListDir,
+  safeRead,
+  safeStat,
+  exists,
+} = require("./paths");
+
+// library-indexer-v2 — full file inventory of 03_Library/* with metadata.
+//
+// Replaces library-indexer.js for the v2 dashboard:
+//   - Includes file PATHS so clicking can openFile() in Obsidian.
+//   - Parses YAML frontmatter (title, tags, type, status).
+//   - Extracts first paragraph (200 chars) as a list preview.
+//   - Pulls wiki-links to surface backlinks.
+//
+// Output shape:
+//   {
+//     available: true,
+//     totalCount,
+//     sections: {
+//       mocs: { count, items: [LibraryItem] },
+//       principles: ...,
+//       cheatsheets: ...,
+//       sops: ...,
+//       scripts: ...,
+//       inputs: { count, byType: { Articles: [], Books: [], Videos: [] } },
+//       entities: { count, people: [], orgs: [], places: [], decisions: [] }
+//     }
+//   }
+
+function parseFrontmatter(content) {
+  if (!content) return {};
+  const m = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!m) return {};
+  const body = m[1];
+  const out = {};
+  body.split(/\r?\n/).forEach(line => {
+    const km = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (km) {
+      const key = km[1].trim();
+      let val = km[2].trim();
+      if ((val.startsWith('"') && val.endsWith('"')) ||
+          (val.startsWith("'") && val.endsWith("'"))) {
+        val = val.slice(1, -1);
+      }
+      out[key] = val;
+    }
+  });
+  return out;
+}
+
+function stripFrontmatter(content) {
+  if (!content) return "";
+  return content.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "");
+}
+
+function firstParagraph(content) {
+  const body = stripFrontmatter(content);
+  // Skip headings and quote blocks; find first prose paragraph.
+  const paragraphs = body.split(/\n\s*\n/);
+  for (const para of paragraphs) {
+    const trimmed = para.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith(">")) continue;
+    if (trimmed.startsWith("|")) continue;
+    if (trimmed.startsWith("-") || trimmed.startsWith("*")) continue;
+    // Strip markdown bold/italic/links for a cleaner preview
+    const clean = trimmed
+      .replace(/\[\[([^\|\]]+)(?:\|[^\]]+)?\]\]/g, "$1")
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+      .replace(/[*_`]/g, "")
+      .replace(/\s+/g, " ")
+      .trim();
+    return clean.slice(0, 200);
+  }
+  return "";
+}
+
+function extractWikilinks(content) {
+  if (!content) return [];
+  const links = [];
+  const re = /\[\[([^\|\]]+)(?:\|[^\]]+)?\]\]/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    links.push(m[1].trim());
+  }
+  return Array.from(new Set(links)).slice(0, 20);
+}
+
+function readItem(filePath, name) {
+  const stat = safeStat(filePath);
+  if (!stat) return null;
+  const content = safeRead(filePath);
+  const fm = parseFrontmatter(content);
+  return {
+    name: name.replace(/\.md$/, ""),
+    path: filePath,
+    mtime: stat.mtime.getTime(),
+    ageDays: Math.floor((Date.now() - stat.mtime.getTime()) / 86400000),
+    frontmatter: fm,
+    firstParagraph: firstParagraph(content),
+    wikilinks: extractWikilinks(content),
+    size: stat.size,
+  };
+}
+
+function walkAndIndex(dir, depth = 0) {
+  if (depth > 3) return [];
+  const out = [];
+  const entries = safeListDir(dir);
+  for (const e of entries) {
+    if (e.isFile && e.name.endsWith(".md") && !e.name.startsWith("_")) {
+      const item = readItem(e.path, e.name);
+      if (item) out.push(item);
+    } else if (e.isDir && !e.name.startsWith("_") && !e.name.startsWith(".")) {
+      out.push(...walkAndIndex(e.path, depth + 1));
+    }
+  }
+  return out;
+}
+
+function sortByMtimeDesc(items) {
+  return [...items].sort((a, b) => b.mtime - a.mtime);
+}
+
+function indexSection(dir) {
+  if (!exists(dir)) return { count: 0, items: [] };
+  const items = sortByMtimeDesc(walkAndIndex(dir));
+  return { count: items.length, items };
+}
+
+function indexLibraryV2(vault) {
+  if (!exists(libraryDir(vault))) return { available: false };
+
+  const mocs = indexSection(libraryMocsDir(vault));
+  const principles = indexSection(libraryPrinciplesDir(vault));
+  const cheatsheets = indexSection(libraryCheatsheetsDir(vault));
+  const sops = indexSection(librarySopsDir(vault));
+  const scripts = indexSection(libraryScriptsDir(vault));
+
+  // Inputs split by sub-type
+  const inputs = { count: 0, byType: {} };
+  if (exists(libraryInputsDir(vault))) {
+    const inputSubs = safeListDir(libraryInputsDir(vault), { dirsOnly: true });
+    for (const sub of inputSubs) {
+      if (sub.name.startsWith("_") || sub.name.startsWith(".")) continue;
+      const items = sortByMtimeDesc(walkAndIndex(sub.path));
+      inputs.byType[sub.name] = items;
+      inputs.count += items.length;
+    }
+  }
+
+  // Entities split by sub-type
+  const people = indexSection(libraryEntitiesPeopleDir(vault));
+  const orgs = indexSection(libraryEntitiesOrgsDir(vault));
+  const places = indexSection(libraryEntitiesPlacesDir(vault));
+  const decisions = indexSection(libraryEntitiesDecisionsDir(vault));
+  const entities = {
+    count: people.count + orgs.count + places.count + decisions.count,
+    people: people.items,
+    orgs: orgs.items,
+    places: places.items,
+    decisions: decisions.items,
+  };
+
+  // Archives: count-only, top-level entries of 04_Archives (dirs + files).
+  // Deliberately NOT walked: backup trees in there would pollute search and
+  // cost a deep walk. The count is all the Library shelf needs. Not added to
+  // totalCount (that stays "indexed" files; archives are counted, not indexed).
+  const archives = { count: 0 };
+  if (exists(archivesDir(vault))) {
+    archives.count = safeListDir(archivesDir(vault))
+      .filter((e) => !e.name.startsWith(".") && !e.name.startsWith("_")).length;
+  }
+
+  // Engine: count-only, top-level FILES of 02_Areas/Engine (subdirs like
+  // Dailies/ and State/ are their own worlds; the Library shelf browse lists
+  // exactly these files). Replaces a hardcoded 12 in the UI mapper — terra
+  // confirmed it fabricated (real vault held 15) and it contaminated the
+  // "indexed" headline sum (2026-07-12). Not added to totalCount, same
+  // reasoning as archives.
+  const engine = { count: 0 };
+  if (exists(engineDir(vault))) {
+    engine.count = safeListDir(engineDir(vault))
+      .filter((e) => e.isFile && !e.name.startsWith(".")).length;
+  }
+
+  const totalCount =
+    mocs.count + principles.count + cheatsheets.count + sops.count +
+    scripts.count + inputs.count + entities.count;
+
+  return {
+    available: true,
+    totalCount,
+    sections: {
+      mocs,
+      principles,
+      cheatsheets,
+      sops,
+      scripts,
+      inputs,
+      entities,
+      archives,
+      engine,
+    },
+  };
+}
+
+module.exports = { indexLibraryV2 };