context-vault 2.0.1

package/src/capture/file-ops.js

@@ -0,0 +1,75 @@
+/**
+ * file-ops.js — Capture-specific file operations
+ *
+ * Writes markdown entry files with frontmatter to the vault directory.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve, relative } from "node:path";
+import { formatFrontmatter } from "../core/frontmatter.js";
+import { slugify, kindToPath } from "../core/files.js";
+import { formatBody } from "./formatters.js";
+
+function safeFolderPath(vaultDir, kind, folder) {
+  const base = resolve(vaultDir, kindToPath(kind));
+  if (!folder) return base;
+  const resolved = resolve(base, folder);
+  const rel = relative(base, resolved);
+  if (rel.startsWith("..") || resolve(base, rel) !== resolved) {
+    throw new Error(`Folder path escapes vault: "${folder}"`);
+  }
+  return resolved;
+}
+
+export function writeEntryFile(vaultDir, kind, { id, title, body, meta, tags, source, createdAt, folder, category, identity_key, expires_at }) {
+  // P5: folder is now a top-level param; also accept from meta for backward compat
+  const resolvedFolder = folder || meta?.folder || "";
+  const dir = safeFolderPath(vaultDir, kind, resolvedFolder);
+
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch (e) {
+    throw new Error(`Failed to create directory "${dir}": ${e.message}`);
+  }
+
+  const created = createdAt || new Date().toISOString();
+  const fmFields = { id };
+
+  // Add kind-specific meta fields to frontmatter (flattened, not nested)
+  if (meta) {
+    for (const [k, v] of Object.entries(meta)) {
+      if (k === "folder") continue;
+      if (v !== null && v !== undefined) fmFields[k] = v;
+    }
+  }
+
+  if (identity_key) fmFields.identity_key = identity_key;
+  if (expires_at) fmFields.expires_at = expires_at;
+  fmFields.tags = tags || [];
+  fmFields.source = source || "claude-code";
+  fmFields.created = created;
+
+  const mdBody = formatBody(kind, { title, body, meta });
+
+  // Entity kinds: deterministic filename from identity_key (no ULID suffix)
+  let filename;
+  if (category === "entity" && identity_key) {
+    const identitySlug = slugify(identity_key);
+    filename = identitySlug ? `${identitySlug}.md` : `${id.slice(-8).toLowerCase()}.md`;
+  } else {
+    const slug = slugify((title || body).slice(0, 40));
+    const shortId = id.slice(-8).toLowerCase();
+    filename = slug ? `${slug}-${shortId}.md` : `${shortId}.md`;
+  }
+
+  const filePath = resolve(dir, filename);
+  const md = formatFrontmatter(fmFields) + mdBody;
+
+  try {
+    writeFileSync(filePath, md);
+  } catch (e) {
+    throw new Error(`Failed to write entry file "${filePath}": ${e.message}`);
+  }
+
+  return filePath;
+}

package/src/capture/formatters.js

@@ -0,0 +1,29 @@
+/**
+ * formatters.js — Kind-specific markdown body templates
+ *
+ * Maps entry kinds to their markdown body format.
+ * Default formatter used for unknown kinds.
+ */
+
+const FORMATTERS = {
+  insight: ({ body }) => "\n" + body + "\n",
+
+  decision: ({ title, body }) => {
+    const t = title || body.slice(0, 80);
+    return "\n## Decision\n\n" + t + "\n\n## Rationale\n\n" + body + "\n";
+  },
+
+  pattern: ({ title, body, meta }) => {
+    const t = title || body.slice(0, 80);
+    const lang = meta?.language || "";
+    return "\n# " + t + "\n\n```" + lang + "\n" + body + "\n```\n";
+  },
+};
+
+const DEFAULT_FORMATTER = ({ title, body }) =>
+  title ? "\n# " + title + "\n\n" + body + "\n" : "\n" + body + "\n";
+
+export function formatBody(kind, { title, body, meta }) {
+  const fn = FORMATTERS[kind] || DEFAULT_FORMATTER;
+  return fn({ title, body, meta });
+}

package/src/capture/index.js

@@ -0,0 +1,91 @@
+/**
+ * Capture Layer — Public API
+ *
+ * Writes knowledge entries to vault as .md files.
+ * That is its entire job. It does not index, embed, or query.
+ *
+ * Agent Constraint: Only imports from ../core. Never imports ../index or ../retrieve.
+ */
+
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { ulid, slugify, kindToPath } from "../core/files.js";
+import { categoryFor } from "../core/categories.js";
+import { parseFrontmatter } from "../core/frontmatter.js";
+import { writeEntryFile } from "./file-ops.js";
+
+export function writeEntry(ctx, { kind, title, body, meta, tags, source, folder, identity_key, expires_at }) {
+  if (!kind || typeof kind !== "string") {
+    throw new Error("writeEntry: kind is required (non-empty string)");
+  }
+  if (!body || typeof body !== "string" || !body.trim()) {
+    throw new Error("writeEntry: body is required (non-empty string)");
+  }
+  if (tags != null && !Array.isArray(tags)) {
+    throw new Error("writeEntry: tags must be an array if provided");
+  }
+  if (meta != null && typeof meta !== "object") {
+    throw new Error("writeEntry: meta must be an object if provided");
+  }
+
+  const category = categoryFor(kind);
+
+  // Entity upsert: check for existing file at deterministic path
+  let id;
+  let createdAt;
+  if (category === "entity" && identity_key) {
+    const identitySlug = slugify(identity_key);
+    const dir = resolve(ctx.config.vaultDir, kindToPath(kind));
+    const existingPath = resolve(dir, `${identitySlug}.md`);
+
+    if (existsSync(existingPath)) {
+      // Preserve original ID and created timestamp from existing file
+      const raw = readFileSync(existingPath, "utf-8");
+      const { meta: fmMeta } = parseFrontmatter(raw);
+      id = fmMeta.id || ulid();
+      createdAt = fmMeta.created || new Date().toISOString();
+    } else {
+      id = ulid();
+      createdAt = new Date().toISOString();
+    }
+  } else {
+    id = ulid();
+    createdAt = new Date().toISOString();
+  }
+
+  const filePath = writeEntryFile(ctx.config.vaultDir, kind, {
+    id, title, body, meta, tags, source, createdAt, folder,
+    category, identity_key, expires_at,
+  });
+
+  return { id, filePath, kind, category, title, body, meta, tags, source, createdAt, identity_key, expires_at };
+}
+
+export async function captureAndIndex(ctx, data, indexFn) {
+  // For entity upserts, preserve previous file content for safe rollback
+  let previousContent = null;
+  if (categoryFor(data.kind) === "entity" && data.identity_key) {
+    const identitySlug = slugify(data.identity_key);
+    const dir = resolve(ctx.config.vaultDir, kindToPath(data.kind));
+    const existingPath = resolve(dir, `${identitySlug}.md`);
+    if (existsSync(existingPath)) {
+      previousContent = readFileSync(existingPath, "utf-8");
+    }
+  }
+
+  const entry = writeEntry(ctx, data);
+  try {
+    await indexFn(ctx, entry);
+    return entry;
+  } catch (err) {
+    // Rollback: restore previous content for entity upserts, delete for new entries
+    if (previousContent) {
+      try { writeFileSync(entry.filePath, previousContent); } catch {}
+    } else {
+      try { unlinkSync(entry.filePath); } catch {}
+    }
+    throw new Error(
+      `Capture succeeded but indexing failed — file rolled back. ${err.message}`
+    );
+  }
+}

package/src/core/README.md

@@ -0,0 +1,20 @@
+# Core
+
+Shared utilities with zero dependencies on other layers. Every other layer imports from here; this layer imports from nothing except Node.js builtins.
+
+## Modules
+
+| File | Exports | Purpose |
+|------|---------|---------|
+| `config.js` | `resolveConfig()`, `parseArgs()` | 4-step config resolution: defaults → config file → env vars → CLI args |
+| `frontmatter.js` | `formatFrontmatter()`, `parseFrontmatter()`, `parseEntryFromMarkdown()`, `extractCustomMeta()` | YAML frontmatter serialization/deserialization and kind-specific markdown parsing |
+| `files.js` | `ulid()`, `slugify()`, `kindToDir()`, `dirToKind()`, `walkDir()` | ID generation, text normalization, kind/directory mapping, recursive `.md` file discovery |
+| `status.js` | `gatherVaultStatus(ctx)` | Collects diagnostic data: file counts, DB size, stale path detection, kind counts |
+
+## Dependency Rule
+
+```
+core/ → node:fs, node:path, node:os (only)
+```
+
+Never import from `capture/`, `index/`, `retrieve/`, or `server/`.

package/src/core/categories.js

@@ -0,0 +1,50 @@
+/**
+ * categories.js — Static kind→category mapping
+ *
+ * Three categories with distinct write semantics:
+ *   knowledge — append-only, enduring (default)
+ *   entity    — upsert by identity_key, enduring
+ *   event     — append-only, decaying relevance
+ */
+
+const KIND_CATEGORY = {
+  // Knowledge — append-only, enduring
+  insight: "knowledge",
+  decision: "knowledge",
+  pattern: "knowledge",
+  prompt: "knowledge",
+  note: "knowledge",
+  document: "knowledge",
+  reference: "knowledge",
+  // Entity — upsert, enduring
+  contact: "entity",
+  project: "entity",
+  tool: "entity",
+  source: "entity",
+  // Event — append-only, decaying
+  conversation: "event",
+  message: "event",
+  session: "event",
+  task: "event",
+  log: "event",
+};
+
+/** Map category name → directory name on disk */
+const CATEGORY_DIR_NAMES = {
+  knowledge: "knowledge",
+  entity: "entities",
+  event: "events",
+};
+
+/** Set of valid category directory names (for reindex discovery) */
+export const CATEGORY_DIRS = new Set(Object.values(CATEGORY_DIR_NAMES));
+
+export function categoryFor(kind) {
+  return KIND_CATEGORY[kind] || "knowledge";
+}
+
+/** Returns the category directory name for a given kind (e.g. "insight" → "knowledge") */
+export function categoryDirFor(kind) {
+  const cat = categoryFor(kind);
+  return CATEGORY_DIR_NAMES[cat] || "knowledge";
+}

package/src/core/config.js

@@ -0,0 +1,76 @@
+/**
+ * config.js — CLI argument parsing and configuration resolution
+ *
+ * Resolution chain (highest priority last):
+ *   1. Convention defaults
+ *   2. Config file (~/.context-mcp/config.json)
+ *   3. Environment variables (CONTEXT_MCP_*)
+ *   4. CLI arguments
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+export function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === "--vault-dir" && argv[i + 1]) args.vaultDir = argv[++i];
+    else if (argv[i] === "--data-dir" && argv[i + 1]) args.dataDir = argv[++i];
+    else if (argv[i] === "--db-path" && argv[i + 1]) args.dbPath = argv[++i];
+    else if (argv[i] === "--dev-dir" && argv[i + 1]) args.devDir = argv[++i];
+  }
+  return args;
+}
+
+export function resolveConfig() {
+  const HOME = homedir();
+  const cliArgs = parseArgs(process.argv);
+
+  // 1. Convention defaults
+  const dataDir = resolve(cliArgs.dataDir || process.env.CONTEXT_MCP_DATA_DIR || join(HOME, ".context-mcp"));
+  const config = {
+    vaultDir: join(HOME, "vault"),
+    dataDir,
+    dbPath: join(dataDir, "vault.db"),
+    devDir: join(HOME, "dev"),
+    resolvedFrom: "defaults",
+  };
+
+  // 2. Config file
+  const configPath = join(dataDir, "config.json");
+  if (existsSync(configPath)) {
+    try {
+      const fc = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (fc.vaultDir) config.vaultDir = fc.vaultDir;
+      if (fc.dataDir) { config.dataDir = fc.dataDir; config.dbPath = join(resolve(fc.dataDir), "vault.db"); }
+      if (fc.dbPath) config.dbPath = fc.dbPath;
+      if (fc.devDir) config.devDir = fc.devDir;
+      config.resolvedFrom = "config file";
+    } catch (e) {
+      throw new Error(`[context-mcp] Invalid config at ${configPath}: ${e.message}`);
+    }
+  }
+  config.configPath = configPath;
+
+  // 3. Environment variable overrides
+  if (process.env.CONTEXT_MCP_VAULT_DIR) { config.vaultDir = process.env.CONTEXT_MCP_VAULT_DIR; config.resolvedFrom = "env"; }
+  if (process.env.CONTEXT_MCP_DB_PATH) { config.dbPath = process.env.CONTEXT_MCP_DB_PATH; config.resolvedFrom = "env"; }
+  if (process.env.CONTEXT_MCP_DEV_DIR) { config.devDir = process.env.CONTEXT_MCP_DEV_DIR; config.resolvedFrom = "env"; }
+
+  // 4. CLI arg overrides (highest priority)
+  if (cliArgs.vaultDir) { config.vaultDir = cliArgs.vaultDir; config.resolvedFrom = "CLI args"; }
+  if (cliArgs.dbPath) { config.dbPath = cliArgs.dbPath; config.resolvedFrom = "CLI args"; }
+  if (cliArgs.devDir) { config.devDir = cliArgs.devDir; config.resolvedFrom = "CLI args"; }
+
+  // Resolve all paths to absolute
+  config.vaultDir = resolve(config.vaultDir);
+  config.dataDir = resolve(config.dataDir);
+  config.dbPath = resolve(config.dbPath);
+  config.devDir = resolve(config.devDir);
+
+  // Check existence
+  config.vaultDirExists = existsSync(config.vaultDir);
+
+  return config;
+}

package/src/core/files.js

@@ -0,0 +1,114 @@
+/**
+ * files.js — Shared file system utilities used across layers
+ *
+ * ULID generation, slugify, kind/dir mapping, directory walking.
+ */
+
+import { readdirSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { categoryDirFor } from "./categories.js";
+
+// ─── ULID Generator (Crockford Base32) ────────────────────────────────────────
+
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+
+export function ulid() {
+  const now = Date.now();
+  let ts = "";
+  let t = now;
+  for (let i = 0; i < 10; i++) {
+    ts = CROCKFORD[t & 31] + ts;
+    t = Math.floor(t / 32);
+  }
+  let rand = "";
+  for (let i = 0; i < 16; i++) {
+    rand += CROCKFORD[Math.floor(Math.random() * 32)];
+  }
+  return ts + rand;
+}
+
+// ─── Slugify ──────────────────────────────────────────────────────────────────
+
+export function slugify(text, maxLen = 60) {
+  let slug = text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (slug.length > maxLen) {
+    slug = slug.slice(0, maxLen).replace(/-[^-]*$/, "") || slug.slice(0, maxLen);
+  }
+  return slug;
+}
+
+// ─── Kind ↔ Directory Mapping ────────────────────────────────────────────────
+
+const PLURAL_MAP = {
+  insight: "insights",
+  decision: "decisions",
+  pattern: "patterns",
+  status: "statuses",
+  analysis: "analyses",
+  contact: "contacts",
+  project: "projects",
+  tool: "tools",
+  source: "sources",
+  conversation: "conversations",
+  message: "messages",
+  session: "sessions",
+  log: "logs",
+};
+
+const SINGULAR_MAP = Object.fromEntries(
+  Object.entries(PLURAL_MAP).map(([k, v]) => [v, k])
+);
+
+export function kindToDir(kind) {
+  if (PLURAL_MAP[kind]) return PLURAL_MAP[kind];
+  return kind.endsWith("s") ? kind : kind + "s";
+}
+
+export function dirToKind(dirName) {
+  if (SINGULAR_MAP[dirName]) return SINGULAR_MAP[dirName];
+  return dirName.replace(/s$/, "");
+}
+
+/** Normalize a kind input (singular or plural) to its canonical singular form. */
+export function normalizeKind(input) {
+  if (PLURAL_MAP[input]) return input;           // Already a known singular kind
+  if (SINGULAR_MAP[input]) return SINGULAR_MAP[input]; // Known plural → singular
+  return input;                                   // Unknown — use as-is (don't strip 's')
+}
+
+/** Returns relative path from vault root → kind dir: "knowledge/insights", "events/sessions", etc. */
+export function kindToPath(kind) {
+  return `${categoryDirFor(kind)}/${kindToDir(kind)}`;
+}
+
+// ─── Safe Path Join ─────────────────────────────────────────────────────────
+
+export function safeJoin(base, ...parts) {
+  const resolvedBase = resolve(base);
+  const result = resolve(join(base, ...parts));
+  if (!result.startsWith(resolvedBase + sep) && result !== resolvedBase) {
+    throw new Error(`Path traversal blocked: resolved path escapes base directory`);
+  }
+  return result;
+}
+
+// ─── Recursive Directory Walk ────────────────────────────────────────────────
+
+export function walkDir(dir) {
+  const results = [];
+  function walk(currentDir, relDir) {
+    for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith("_")) {
+        walk(fullPath, relDir ? join(relDir, entry.name) : entry.name);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        results.push({ filePath: fullPath, relDir });
+      }
+    }
+  }
+  walk(dir, "");
+  return results;
+}

package/src/core/frontmatter.js

@@ -0,0 +1,108 @@
+/**
+ * frontmatter.js — YAML frontmatter parsing and formatting
+ */
+
+// ─── YAML Frontmatter Helpers ────────────────────────────────────────────────
+
+const NEEDS_QUOTING = /[:#'"{}[\],>|&*?!@`]/;
+
+export function formatFrontmatter(meta) {
+  const lines = ["---"];
+  for (const [k, v] of Object.entries(meta)) {
+    if (v === undefined || v === null) continue;
+    if (Array.isArray(v)) {
+      lines.push(`${k}: [${v.map((i) => JSON.stringify(i)).join(", ")}]`);
+    } else {
+      const str = String(v);
+      lines.push(`${k}: ${NEEDS_QUOTING.test(str) ? JSON.stringify(str) : str}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+
+export function parseFrontmatter(text) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, body: normalized.trim() };
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let val = line.slice(idx + 1).trim();
+    // Unquote JSON-quoted strings from formatFrontmatter
+    if (val.length >= 2 && val.startsWith('"') && val.endsWith('"') && !val.startsWith('["')) {
+      try { val = JSON.parse(val); } catch { /* keep as-is */ }
+    }
+    // Parse arrays: [a, b, c]
+    if (val.startsWith("[") && val.endsWith("]")) {
+      try {
+        val = JSON.parse(val);
+      } catch {
+        val = val
+          .slice(1, -1)
+          .split(",")
+          .map((s) => s.trim().replace(/^"|"$/g, ""));
+      }
+    }
+    meta[key] = val;
+  }
+  return { meta, body: match[2].trim() };
+}
+
+// ─── Extract Custom Meta ────────────────────────────────────────────────────
+
+const RESERVED_FM_KEYS = new Set(["id", "tags", "source", "created", "identity_key", "expires_at"]);
+
+export function extractCustomMeta(fmMeta) {
+  const custom = {};
+  for (const [k, v] of Object.entries(fmMeta)) {
+    if (!RESERVED_FM_KEYS.has(k)) custom[k] = v;
+  }
+  return Object.keys(custom).length ? custom : null;
+}
+
+// ─── Parse Entry From Markdown ──────────────────────────────────────────────
+
+export function parseEntryFromMarkdown(kind, body, fmMeta) {
+  if (kind === "insight") {
+    return {
+      title: null,
+      body,
+      meta: extractCustomMeta(fmMeta),
+    };
+  }
+
+  if (kind === "decision") {
+    const titleMatch = body.match(/^## Decision\s*\n+([\s\S]*?)(?=\n## |\n*$)/);
+    const rationaleMatch = body.match(/## Rationale\s*\n+([\s\S]*?)$/);
+    const title = titleMatch ? titleMatch[1].trim() : body.slice(0, 100);
+    const rationale = rationaleMatch ? rationaleMatch[1].trim() : body;
+    return {
+      title,
+      body: rationale,
+      meta: extractCustomMeta(fmMeta),
+    };
+  }
+
+  if (kind === "pattern") {
+    const titleMatch = body.match(/^# (.+)/);
+    const title = titleMatch ? titleMatch[1].trim() : body.slice(0, 80);
+    const codeMatch = body.match(/```[\w]*\n([\s\S]*?)```/);
+    const content = codeMatch ? codeMatch[1].trim() : body;
+    return {
+      title,
+      body: content,
+      meta: extractCustomMeta(fmMeta),
+    };
+  }
+
+  // Generic: use first heading as title, rest as body
+  const headingMatch = body.match(/^#+ (.+)/);
+  return {
+    title: headingMatch ? headingMatch[1].trim() : null,
+    body,
+    meta: extractCustomMeta(fmMeta),
+  };
+}

package/src/core/status.js

@@ -0,0 +1,105 @@
+/**
+ * status.js — Vault status/diagnostics data gathering
+ */
+
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { walkDir } from "./files.js";
+
+/**
+ * Gather raw vault status data for formatting by consumers.
+ *
+ * @param {{ db, config }} ctx
+ * @returns {{ fileCount, subdirs, kindCounts, dbSize, stalePaths, resolvedFrom, embeddingStatus, errors }}
+ */
+export function gatherVaultStatus(ctx) {
+  const { db, config } = ctx;
+  const errors = [];
+
+  // Count files in vault subdirs (auto-discover)
+  let fileCount = 0;
+  const subdirs = [];
+  try {
+    if (existsSync(config.vaultDir)) {
+      for (const d of readdirSync(config.vaultDir, { withFileTypes: true })) {
+        if (d.isDirectory()) {
+          const dir = join(config.vaultDir, d.name);
+          const count = walkDir(dir).length;
+          fileCount += count;
+          if (count > 0) subdirs.push({ name: d.name, count });
+        }
+      }
+    }
+  } catch (e) {
+    errors.push(`File scan failed: ${e.message}`);
+  }
+
+  // Count DB rows by kind
+  let kindCounts = [];
+  try {
+    kindCounts = db.prepare("SELECT kind, COUNT(*) as c FROM vault GROUP BY kind").all();
+  } catch (e) {
+    errors.push(`Kind count query failed: ${e.message}`);
+  }
+
+  // Count DB rows by category
+  let categoryCounts = [];
+  try {
+    categoryCounts = db.prepare("SELECT category, COUNT(*) as c FROM vault GROUP BY category").all();
+  } catch (e) {
+    errors.push(`Category count query failed: ${e.message}`);
+  }
+
+  // DB file size
+  let dbSize = "n/a";
+  let dbSizeBytes = 0;
+  try {
+    if (existsSync(config.dbPath)) {
+      dbSizeBytes = statSync(config.dbPath).size;
+      dbSize = dbSizeBytes > 1024 * 1024
+        ? `${(dbSizeBytes / 1024 / 1024).toFixed(1)}MB`
+        : `${(dbSizeBytes / 1024).toFixed(1)}KB`;
+    }
+  } catch (e) {
+    errors.push(`DB size check failed: ${e.message}`);
+  }
+
+  // Check for stale paths (count all mismatches, not just a sample)
+  let stalePaths = false;
+  let staleCount = 0;
+  try {
+    const result = db.prepare(
+      "SELECT COUNT(*) as c FROM vault WHERE file_path NOT LIKE ? || '%'"
+    ).get(config.vaultDir);
+    staleCount = result.c;
+    stalePaths = staleCount > 0;
+  } catch (e) {
+    errors.push(`Stale path check failed: ${e.message}`);
+  }
+
+  // Embedding/vector status
+  let embeddingStatus = null;
+  try {
+    const total = db.prepare("SELECT COUNT(*) as c FROM vault").get().c;
+    const indexed = db.prepare(
+      "SELECT COUNT(*) as c FROM vault WHERE rowid IN (SELECT rowid FROM vault_vec)"
+    ).get().c;
+    embeddingStatus = { indexed, total, missing: total - indexed };
+  } catch (e) {
+    errors.push(`Embedding status check failed: ${e.message}`);
+  }
+
+  return {
+    fileCount,
+    subdirs,
+    kindCounts,
+    categoryCounts,
+    dbSize,
+    dbSizeBytes,
+    stalePaths,
+    staleCount,
+    embeddingStatus,
+    resolvedFrom: config.resolvedFrom,
+    errors,
+  };
+}