@swarmvaultai/engine 0.11.0 → 0.12.0

package/dist/index.js

@@ -8379,15 +8379,15 @@ function sourceTypeForNode(node, pagesById) {
   return pagesById.get(node.pageId)?.sourceType;
 }
 function supportingPathDetails(graph, edge) {
-  const path31 = shortestGraphPath(graph, edge.source, edge.target);
+  const path32 = shortestGraphPath(graph, edge.source, edge.target);
   const edgesById = new Map(graph.edges.map((item) => [item.id, item]));
-  const pathEdges = path31.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
+  const pathEdges = path32.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
   return {
-    pathNodeIds: path31.nodeIds,
-    pathEdgeIds: path31.edgeIds,
+    pathNodeIds: path32.nodeIds,
+    pathEdgeIds: path32.edgeIds,
     pathRelations: pathEdges.map((item) => item.relation),
     pathEvidenceClasses: pathEdges.map((item) => item.evidenceClass),
-    pathSummary: path31.summary
+    pathSummary: path32.summary
   };
 }
 function surpriseScore(edge, graph, pagesById, hyperedgesByNodeId) {
@@ -8456,7 +8456,7 @@ function topSurprisingConnections(graph, pagesById) {
     }).map((edge) => {
       const source = nodesById.get(edge.source);
       const target = nodesById.get(edge.target);
-      const path31 = supportingPathDetails(graph, edge);
+      const path32 = supportingPathDetails(graph, edge);
       const scored = surpriseScore(edge, graph, pagesById, hyperedgesByNodeId);
       return {
         id: edge.id,
@@ -8467,11 +8467,11 @@ function topSurprisingConnections(graph, pagesById) {
         relation: edge.relation,
         evidenceClass: edge.evidenceClass,
         confidence: edge.confidence,
-        pathNodeIds: path31.pathNodeIds,
-        pathEdgeIds: path31.pathEdgeIds,
-        pathRelations: path31.pathRelations,
-        pathEvidenceClasses: path31.pathEvidenceClasses,
-        pathSummary: path31.pathSummary,
+        pathNodeIds: path32.pathNodeIds,
+        pathEdgeIds: path32.pathEdgeIds,
+        pathRelations: path32.pathRelations,
+        pathEvidenceClasses: path32.pathEvidenceClasses,
+        pathSummary: path32.pathSummary,
         why: scored.why,
         explanation: scored.explanation,
         surpriseScore: scored.score
@@ -18646,20 +18646,271 @@ async function readExtractionArtifact(rootDir, manifest) {
 }
 
 // src/mcp.ts
-import fs23 from "fs/promises";
-import path27 from "path";
+import fs24 from "fs/promises";
+import path28 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z8 } from "zod";
 
-// src/schema.ts
+// src/migrate.ts
 import fs16 from "fs/promises";
 import path17 from "path";
+import matter9 from "gray-matter";
+var VAULT_VERSION_FILENAME = "vault-version.json";
+async function walkMarkdownFiles(dir) {
+  const results = [];
+  let entries;
+  try {
+    entries = await fs16.readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const full = path17.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await walkMarkdownFiles(full));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+async function readFrontmatterFile(filePath) {
+  try {
+    const raw = await fs16.readFile(filePath, "utf8");
+    const parsed = matter9(raw);
+    const data = parsed.data ?? {};
+    return { data, content: parsed.content };
+  } catch {
+    return null;
+  }
+}
+async function writeFrontmatterFile(filePath, data, content) {
+  await fs16.writeFile(filePath, matter9.stringify(content, data), "utf8");
+}
+function relFromRoot(rootDir, filePath) {
+  return path17.relative(rootDir, filePath) || filePath;
+}
+var MIGRATION_ADD_DECAY_FIELDS = {
+  id: "0.9-to-0.10-add-decay-fields",
+  fromVersion: "0.9.0",
+  toVersion: "0.10.0",
+  description: "Add decay_score and last_confirmed_at frontmatter to pages missing them.",
+  async apply(ctx, options) {
+    const changed = [];
+    const files = await walkMarkdownFiles(ctx.paths.wikiDir);
+    for (const filePath of files) {
+      const parsed = await readFrontmatterFile(filePath);
+      if (!parsed) continue;
+      const { data, content } = parsed;
+      if (!data.page_id) continue;
+      let mutated = false;
+      if (data.decay_score === void 0) {
+        data.decay_score = 1;
+        mutated = true;
+      }
+      if (data.last_confirmed_at === void 0) {
+        data.last_confirmed_at = data.updated_at ?? (/* @__PURE__ */ new Date()).toISOString();
+        mutated = true;
+      }
+      if (mutated) {
+        if (!options.dryRun) {
+          await writeFrontmatterFile(filePath, data, content);
+        }
+        changed.push(relFromRoot(ctx.rootDir, filePath));
+      }
+    }
+    return { changed };
+  }
+};
+var MIGRATION_ADD_TIER_DEFAULT = {
+  id: "0.9-to-0.10-add-tier-default",
+  fromVersion: "0.9.0",
+  toVersion: "0.10.0",
+  description: 'Tag insight pages with tier: "working" when the field is absent.',
+  async apply(ctx, options) {
+    const changed = [];
+    const insightsDir = path17.join(ctx.paths.wikiDir, "insights");
+    const files = await walkMarkdownFiles(insightsDir);
+    for (const filePath of files) {
+      const parsed = await readFrontmatterFile(filePath);
+      if (!parsed) continue;
+      const { data, content } = parsed;
+      if (data.kind !== "insight") continue;
+      if (data.tier !== void 0) continue;
+      data.tier = "working";
+      if (!options.dryRun) {
+        await writeFrontmatterFile(filePath, data, content);
+      }
+      changed.push(relFromRoot(ctx.rootDir, filePath));
+    }
+    return { changed };
+  }
+};
+var MIGRATION_ADD_TAGS_FIELD = {
+  id: "0.10-to-0.11-add-tags-field",
+  fromVersion: "0.10.0",
+  toVersion: "0.11.0",
+  description: 'Add default tags: ["<kind>"] to derived concept and entity pages missing a tags array.',
+  async apply(ctx, options) {
+    const changed = [];
+    const files = await walkMarkdownFiles(ctx.paths.wikiDir);
+    for (const filePath of files) {
+      const parsed = await readFrontmatterFile(filePath);
+      if (!parsed) continue;
+      const { data, content } = parsed;
+      const kind = data.kind;
+      if (kind !== "concept" && kind !== "entity") continue;
+      if (Array.isArray(data.tags) && data.tags.length > 0) continue;
+      data.tags = [kind];
+      if (!options.dryRun) {
+        await writeFrontmatterFile(filePath, data, content);
+      }
+      changed.push(relFromRoot(ctx.rootDir, filePath));
+    }
+    return { changed };
+  }
+};
+var MIGRATION_NOTE_WATCH_BLOCK = {
+  id: "0.10-to-0.11-normalize-config-watch-absence",
+  fromVersion: "0.10.0",
+  toVersion: "0.11.0",
+  description: "Record that swarmvault.config.json watch block is optional in 0.11 (no file changes).",
+  async apply() {
+    return { changed: [] };
+  }
+};
+var MIGRATION_REBUILD_SEARCH_INDEX = {
+  id: "any-to-any-rebuild-search-index",
+  fromVersion: "0.9.0",
+  toVersion: "0.11.0",
+  description: "Mark state/search.sqlite as stale so the next compile regenerates it.",
+  async apply(ctx, options) {
+    const changed = [];
+    const searchPath = path17.join(ctx.paths.stateDir, "search.sqlite");
+    try {
+      await fs16.access(searchPath);
+      if (!options.dryRun) {
+        await fs16.rm(searchPath, { force: true });
+      }
+      changed.push(relFromRoot(ctx.rootDir, searchPath));
+    } catch {
+    }
+    return { changed };
+  }
+};
+var ALL_MIGRATIONS = [
+  MIGRATION_ADD_DECAY_FIELDS,
+  MIGRATION_ADD_TIER_DEFAULT,
+  MIGRATION_ADD_TAGS_FIELD,
+  MIGRATION_NOTE_WATCH_BLOCK,
+  MIGRATION_REBUILD_SEARCH_INDEX
+];
+function compareSemver(a, b) {
+  const pa = a.split(".").map((part) => Number.parseInt(part, 10));
+  const pb = b.split(".").map((part) => Number.parseInt(part, 10));
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+}
+async function readVaultVersionRecord(stateDir) {
+  const filePath = path17.join(stateDir, VAULT_VERSION_FILENAME);
+  try {
+    const raw = await fs16.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version === "string") return parsed;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function readGraphVersion(stateDir) {
+  const filePath = path17.join(stateDir, "graph.json");
+  try {
+    const raw = await fs16.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const version = parsed?.generatedBy?.version;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+async function detectVaultVersion(rootDir) {
+  const { paths } = await initWorkspace(rootDir);
+  const record = await readVaultVersionRecord(paths.stateDir);
+  if (record) return record.version;
+  const graphVersion = await readGraphVersion(paths.stateDir);
+  if (graphVersion) return graphVersion;
+  return null;
+}
+async function currentPackageVersion() {
+  try {
+    const raw = await fs16.readFile(new URL("../package.json", import.meta.url), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function planMigration(rootDir, targetVersion) {
+  const fromVersion = await detectVaultVersion(rootDir);
+  const toVersion = targetVersion ?? await currentPackageVersion();
+  const steps = ALL_MIGRATIONS.filter((step) => compareSemver(step.toVersion, toVersion) <= 0).filter((step) => {
+    if (!fromVersion) return true;
+    return compareSemver(step.toVersion, fromVersion) > 0;
+  });
+  return { fromVersion, toVersion, steps };
+}
+async function writeVaultVersionRecord(stateDir, record) {
+  await fs16.mkdir(stateDir, { recursive: true });
+  await fs16.writeFile(path17.join(stateDir, VAULT_VERSION_FILENAME), `${JSON.stringify(record, null, 2)}
+`, "utf8");
+}
+async function runMigration(rootDir, options = {}) {
+  const dryRun = options.dryRun ?? true;
+  const { paths } = await initWorkspace(rootDir);
+  const plan = await planMigration(rootDir, options.targetVersion);
+  const applied = [];
+  const skipped = [];
+  const ctx = {
+    rootDir,
+    paths: { wikiDir: paths.wikiDir, stateDir: paths.stateDir, rootDir }
+  };
+  for (const step of plan.steps) {
+    const { changed } = await step.apply(ctx, { dryRun });
+    if (changed.length === 0) {
+      skipped.push({ id: step.id, reason: "No changes required." });
+    } else {
+      applied.push({ id: step.id, changed });
+    }
+  }
+  if (!dryRun && applied.length > 0) {
+    await writeVaultVersionRecord(paths.stateDir, {
+      version: plan.toVersion,
+      migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      appliedSteps: applied.map((entry) => entry.id)
+    });
+  }
+  return {
+    planned: plan.steps.length,
+    applied,
+    skipped,
+    dryRun,
+    fromVersion: plan.fromVersion,
+    toVersion: plan.toVersion
+  };
+}
+
+// src/schema.ts
+import fs17 from "fs/promises";
+import path18 from "path";
 function normalizeSchemaContent(content) {
   return content.trim() ? content.trim() : defaultVaultSchema().trim();
 }
 async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
-  const content = await fileExists(schemaPath) ? await fs16.readFile(schemaPath, "utf8") : fallback;
+  const content = await fileExists(schemaPath) ? await fs17.readFile(schemaPath, "utf8") : fallback;
   const normalized = normalizeSchemaContent(content);
   return {
     path: schemaPath,
@@ -18668,7 +18919,7 @@ async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
   };
 }
 function resolveProjectSchemaPath(rootDir, schemaPath) {
-  return path17.resolve(rootDir, schemaPath);
+  return path18.resolve(rootDir, schemaPath);
 }
 function composeVaultSchema(root, projectSchemas = []) {
   if (!projectSchemas.length) {
@@ -18684,7 +18935,7 @@ function composeVaultSchema(root, projectSchemas = []) {
       (schema) => [
         `## Project Schema`,
         "",
-        `Path: ${toPosix(path17.relative(path17.dirname(root.path), schema.path) || schema.path)}`,
+        `Path: ${toPosix(path18.relative(path18.dirname(root.path), schema.path) || schema.path)}`,
         "",
         schema.content
       ].join("\n")
@@ -18760,15 +19011,15 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs21 from "fs/promises";
-import path25 from "path";
+import fs22 from "fs/promises";
+import path26 from "path";
 import Graph from "graphology";
 import louvain from "graphology-communities-louvain";
-import matter12 from "gray-matter";
+import matter13 from "gray-matter";
 import { z as z7 } from "zod";
 
 // src/analysis.ts
-import path18 from "path";
+import path19 from "path";
 import nlp2 from "compromise";
 import { z as z2 } from "zod";
 
@@ -18857,7 +19108,7 @@ var MARKDOWN_RATIONALE_KINDS = /* @__PURE__ */ new Set([
 var PLAIN_TEXT_RATIONALE_KINDS = /* @__PURE__ */ new Set(["text", "transcript", "chat_export", "email", "calendar"]);
 function filenameStemForSource(manifest) {
   const candidate = manifest.repoRelativePath ?? manifest.originalPath ?? manifest.storedPath;
-  const base = path18.basename(candidate);
+  const base = path19.basename(candidate);
   const stem = base.replace(/\.[^.]+$/, "");
   return stem || manifest.title;
 }
@@ -19137,7 +19388,7 @@ function extractionWarningSummary(manifest, extraction) {
   return `Imported ${manifest.sourceKind} source. Text extraction is not yet available for this source.`;
 }
 async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path18.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cachePath = path19.join(paths.analysesDir, `${manifest.sourceId}.json`);
   const cached = await readJsonFile(cachePath);
   if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && (cached.semanticHash ?? cached.sourceHash) === manifest.semanticHash && cached.extractionHash === manifest.extractionHash && cached.schemaHash === schema.hash) {
     const normalizedCached = normalizeSourceAnalysis(manifest, cached);
@@ -19240,9 +19491,9 @@ function conflictConfidence(claimA, claimB) {
 }
 
 // src/deep-lint.ts
-import fs17 from "fs/promises";
-import path21 from "path";
-import matter9 from "gray-matter";
+import fs18 from "fs/promises";
+import path22 from "path";
+import matter10 from "gray-matter";
 import { z as z5 } from "zod";
 
 // src/findings.ts
@@ -19262,7 +19513,7 @@ function normalizeFindingSeverity(value) {
 
 // src/orchestration.ts
 import { spawn } from "child_process";
-import path19 from "path";
+import path20 from "path";
 import { z as z3 } from "zod";
 var orchestrationRoleResultSchema = z3.object({
   summary: z3.string().optional(),
@@ -19355,7 +19606,7 @@ async function runProviderRole(rootDir, role, roleConfig, input) {
 }
 async function runCommandRole(rootDir, role, executor, input) {
   const [command, ...args] = executor.command;
-  const cwd = executor.cwd ? path19.resolve(rootDir, executor.cwd) : rootDir;
+  const cwd = executor.cwd ? path20.resolve(rootDir, executor.cwd) : rootDir;
   const child = spawn(command, args, {
     cwd,
     env: {
@@ -19449,7 +19700,7 @@ function summarizeRoleQuestions(results) {
 }
 
 // src/web-search/registry.ts
-import path20 from "path";
+import path21 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { z as z4 } from "zod";
 
@@ -19547,7 +19798,7 @@ async function createWebSearchAdapter(id, config, rootDir) {
       if (!config.module) {
         throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
       }
-      const resolvedModule = path20.isAbsolute(config.module) ? config.module : path20.resolve(rootDir, config.module);
+      const resolvedModule = path21.isAbsolute(config.module) ? config.module : path21.resolve(rootDir, config.module);
       const loaded = await import(pathToFileURL2(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
@@ -19617,9 +19868,9 @@ async function loadContextPages(rootDir, graph) {
   );
   return Promise.all(
     contextPages.slice(0, 18).map(async (page) => {
-      const absolutePath = path21.join(paths.wikiDir, page.path);
-      const raw = await fs17.readFile(absolutePath, "utf8").catch(() => "");
-      const parsed = matter9(raw);
+      const absolutePath = path22.join(paths.wikiDir, page.path);
+      const raw = await fs18.readFile(absolutePath, "utf8").catch(() => "");
+      const parsed = matter10(raw);
       return {
         id: page.id,
         title: page.title,
@@ -19666,7 +19917,7 @@ function heuristicDeepFindings(contextPages, structuralFindings, graph) {
       code: "missing_citation",
       message: finding.message,
       pagePath: finding.pagePath,
-      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path21.basename(finding.pagePath, ".md")}?` : void 0
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path22.basename(finding.pagePath, ".md")}?` : void 0
     });
   }
   for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
@@ -20039,9 +20290,9 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
-import fs18 from "fs/promises";
-import path22 from "path";
-import matter10 from "gray-matter";
+import fs19 from "fs/promises";
+import path23 from "path";
+import matter11 from "gray-matter";
 function relationRank(outputPage, targetPage) {
   if (outputPage.relatedPageIds.includes(targetPage.id)) {
     return 3;
@@ -20058,19 +20309,19 @@ function relatedOutputsForPage(targetPage, outputPages) {
   return outputPages.map((page) => ({ page, rank: relationRank(page, targetPage) })).filter((item) => item.rank > 0).sort((left, right) => right.rank - left.rank || left.page.title.localeCompare(right.page.title)).map((item) => item.page);
 }
 async function resolveUniqueOutputSlug(wikiDir, baseSlug) {
-  const outputsDir = path22.join(wikiDir, "outputs");
+  const outputsDir = path23.join(wikiDir, "outputs");
   const root = baseSlug || "output";
   let candidate = root;
   let counter = 2;
-  while (await fileExists(path22.join(outputsDir, `${candidate}.md`))) {
+  while (await fileExists(path23.join(outputsDir, `${candidate}.md`))) {
     candidate = `${root}-${counter}`;
     counter++;
   }
   return candidate;
 }
 async function loadSavedOutputPages(wikiDir) {
-  const outputsDir = path22.join(wikiDir, "outputs");
-  const entries = await fs18.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
+  const outputsDir = path23.join(wikiDir, "outputs");
+  const entries = await fs19.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
   const outputs = [];
   const queue = [{ absoluteDir: outputsDir, relativeDir: "outputs" }];
   while (queue.length > 0) {
@@ -20078,24 +20329,24 @@ async function loadSavedOutputPages(wikiDir) {
     if (!current) {
       continue;
     }
-    const currentEntries = current.absoluteDir === outputsDir ? entries : await fs18.readdir(current.absoluteDir, { withFileTypes: true }).catch(() => []);
+    const currentEntries = current.absoluteDir === outputsDir ? entries : await fs19.readdir(current.absoluteDir, { withFileTypes: true }).catch(() => []);
     for (const entry of currentEntries) {
       if (entry.isDirectory()) {
         queue.push({
-          absoluteDir: path22.join(current.absoluteDir, entry.name),
-          relativeDir: path22.posix.join(current.relativeDir, entry.name)
+          absoluteDir: path23.join(current.absoluteDir, entry.name),
+          relativeDir: path23.posix.join(current.relativeDir, entry.name)
         });
         continue;
       }
       if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") {
         continue;
       }
-      const relativePath = path22.posix.join(current.relativeDir, entry.name);
-      const absolutePath = path22.join(current.absoluteDir, entry.name);
-      const content = await fs18.readFile(absolutePath, "utf8");
-      const parsed = matter10(content);
+      const relativePath = path23.posix.join(current.relativeDir, entry.name);
+      const absolutePath = path23.join(current.absoluteDir, entry.name);
+      const content = await fs19.readFile(absolutePath, "utf8");
+      const parsed = matter11(content);
       const slug = relativePath.replace(/^outputs\//, "").replace(/\.md$/, "");
-      const title = typeof parsed.data.title === "string" ? parsed.data.title : path22.basename(slug);
+      const title = typeof parsed.data.title === "string" ? parsed.data.title : path23.basename(slug);
       const pageId = typeof parsed.data.page_id === "string" ? parsed.data.page_id : `output:${slug}`;
       const sourceIds = normalizeStringArray(parsed.data.source_ids);
       const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -20105,7 +20356,7 @@ async function loadSavedOutputPages(wikiDir) {
       const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
       const backlinks = normalizeStringArray(parsed.data.backlinks);
       const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
-      const stats = await fs18.stat(absolutePath);
+      const stats = await fs19.stat(absolutePath);
       const createdAt = typeof parsed.data.created_at === "string" ? parsed.data.created_at : stats.birthtimeMs > 0 ? stats.birthtime.toISOString() : stats.mtime.toISOString();
       const updatedAt = typeof parsed.data.updated_at === "string" ? parsed.data.updated_at : stats.mtime.toISOString();
       outputs.push({
@@ -20145,9 +20396,9 @@ async function loadSavedOutputPages(wikiDir) {
 }
 
 // src/search.ts
-import fs19 from "fs/promises";
-import path23 from "path";
-import matter11 from "gray-matter";
+import fs20 from "fs/promises";
+import path24 from "path";
+import matter12 from "gray-matter";
 function warningMessage(warning) {
   return warning instanceof Error ? warning.message : String(warning);
 }
@@ -20200,7 +20451,7 @@ function normalizeSourceClass2(value) {
   return value === "first_party" || value === "third_party" || value === "resource" || value === "generated" ? value : void 0;
 }
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path23.dirname(dbPath));
+  await ensureDir(path24.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = withSuppressedSqliteExperimentalWarning(() => new DatabaseSync(dbPath));
   db.exec("PRAGMA journal_mode = WAL;");
@@ -20231,21 +20482,21 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
   const insertPage = db.prepare(
     "INSERT INTO pages (id, path, title, body, kind, status, source_type, source_class, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
   );
-  const rootDir = path23.dirname(wikiDir);
+  const rootDir = path24.dirname(wikiDir);
   for (const page of pages) {
-    const absolutePath = path23.join(wikiDir, page.path);
-    const content = await fs19.readFile(absolutePath, "utf8");
-    const parsed = matter11(content);
+    const absolutePath = path24.join(wikiDir, page.path);
+    const content = await fs20.readFile(absolutePath, "utf8");
+    const parsed = matter12(content);
     let body = parsed.content;
     const primarySourceId = Array.isArray(parsed.data.source_ids) && typeof parsed.data.source_ids[0] === "string" ? parsed.data.source_ids[0] : page.sourceIds[0];
     if ((page.kind === "source" || page.kind === "module") && primarySourceId) {
       try {
         const manifest = JSON.parse(
-          await fs19.readFile(path23.join(rootDir, "state", "manifests", `${primarySourceId}.json`), "utf8")
+          await fs20.readFile(path24.join(rootDir, "state", "manifests", `${primarySourceId}.json`), "utf8")
         );
         const excerptPath = manifest.extractedTextPath ?? manifest.storedPath;
         if (excerptPath) {
-          const excerpt = await fs19.readFile(path23.join(rootDir, excerptPath), "utf8");
+          const excerpt = await fs20.readFile(path24.join(rootDir, excerptPath), "utf8");
           if (excerpt.trim()) {
             body = `${body}
 
@@ -20401,16 +20652,16 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
 }
 
 // src/source-sessions.ts
-import fs20 from "fs/promises";
-import path24 from "path";
+import fs21 from "fs/promises";
+import path25 from "path";
 function sessionStatePathFor(paths, sessionId) {
-  return path24.join(paths.sourceSessionsDir, `${sessionId}.json`);
+  return path25.join(paths.sourceSessionsDir, `${sessionId}.json`);
 }
 async function listGuidedSourceSessions(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
-  const entries = await fs20.readdir(paths.sourceSessionsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs21.readdir(paths.sourceSessionsDir, { withFileTypes: true }).catch(() => []);
   const sessions = await Promise.all(
-    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => await readJsonFile(path24.join(paths.sourceSessionsDir, entry.name)))
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => await readJsonFile(path25.join(paths.sourceSessionsDir, entry.name)))
   );
   return sessions.filter((session) => Boolean(session)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
@@ -20430,7 +20681,7 @@ async function writeGuidedSourceSession(rootDir, session) {
     updatedAt: session.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
   };
   const filePath = sessionStatePathFor(paths, session.sessionId);
-  await fs20.writeFile(filePath, `${JSON.stringify(next, null, 2)}
+  await fs21.writeFile(filePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return filePath;
 }
@@ -20506,7 +20757,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path25.join("outputs", "assets", slug, fileName));
+  return toPosix(path26.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -20844,7 +21095,7 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path25.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path26.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
@@ -20870,10 +21121,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path25.isAbsolute(rawPath)) {
+  if (!path26.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path25.relative(rootDir, rawPath));
+  const relative = toPosix(path26.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -21050,7 +21301,7 @@ function pageHashes(pages) {
   return Object.fromEntries(pages.map((page) => [page.page.id, page.contentHash]));
 }
 async function buildManagedGraphPage(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs21.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs22.readFile(absolutePath, "utf8") : null;
   let carriedContent = existingContent;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
@@ -21066,7 +21317,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
         status: defaults.status ?? "active",
         managedBy: defaults.managedBy
       });
-      carriedContent = await fs21.readFile(candidatePath, "utf8");
+      carriedContent = await fs22.readFile(candidatePath, "utf8");
       usedFallbackState = true;
       break;
     }
@@ -21090,7 +21341,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs21.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs22.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -21132,7 +21383,7 @@ function manifestDetailValue(manifest, key) {
 }
 async function loadAnalysesBySourceIds(paths, sourceIds) {
   const analyses = await Promise.all(
-    sourceIds.map(async (sourceId) => await readJsonFile(path25.join(paths.analysesDir, `${sourceId}.json`)))
+    sourceIds.map(async (sourceId) => await readJsonFile(path26.join(paths.analysesDir, `${sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis?.sourceId));
 }
@@ -21157,7 +21408,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
   ).slice(0, 20);
   const sourceSessions = await listGuidedSourceSessions(paths.rootDir);
   const stagedGuideBundles = (await Promise.all(
-    (await fs21.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => await readApprovalManifest(paths, entry.name).catch(() => null))
+    (await fs22.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => await readApprovalManifest(paths, entry.name).catch(() => null))
   )).filter((manifest) => Boolean(manifest)).filter((manifest) => manifest.bundleType === "guided-source" || manifest.bundleType === "guided-session").sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 12);
   const readerFocusPages = uniqueBy([...guidePages, ...briefPages, ...conceptPages, ...entityPages], (page) => page.id).slice(0, 8);
   const diligenceSessions = sourceSessions.filter((session) => session.status === "staged" || session.status === "awaiting_input").slice(0, 8);
@@ -21165,7 +21416,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/index.md",
       title: "Dashboards",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Dashboards",
           "",
@@ -21217,7 +21468,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/recent-sources.md",
       title: "Recent Sources",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Recent Sources",
           "",
@@ -21260,7 +21511,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/reading-log.md",
       title: "Reading Log",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Reading Log",
           "",
@@ -21320,7 +21571,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/timeline.md",
       title: "Timeline",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Timeline",
           "",
@@ -21366,7 +21617,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/source-sessions.md",
       title: "Source Sessions",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Source Sessions",
           "",
@@ -21423,7 +21674,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/source-guides.md",
       title: "Source Guides",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Source Guides",
           "",
@@ -21476,7 +21727,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/research-map.md",
       title: "Research Map",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Research Map",
           "",
@@ -21540,7 +21791,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/contradictions.md",
       title: "Contradictions",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Contradictions",
           "",
@@ -21599,7 +21850,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
     {
       relativePath: "dashboards/open-questions.md",
       title: "Open Questions",
-      content: (metadata) => matter12.stringify(
+      content: (metadata) => matter13.stringify(
         [
           "# Open Questions",
           "",
@@ -21645,7 +21896,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
   ];
   const records = [];
   for (const dashboard of dashboards) {
-    const absolutePath = path25.join(paths.wikiDir, dashboard.relativePath);
+    const absolutePath = path26.join(paths.wikiDir, dashboard.relativePath);
     const compiledFrom = dashboard.relativePath === "dashboards/recent-sources.md" ? recentSourcePages.flatMap((page) => page.sourceIds) : [];
     const content = await buildManagedContent(
       absolutePath,
@@ -21808,7 +22059,7 @@ function resetGraphNodeMetrics(nodes) {
   );
 }
 function manifestRepoPath(manifest) {
-  return toPosix(manifest.repoRelativePath ?? path25.basename(manifest.originalPath ?? manifest.storedPath));
+  return toPosix(manifest.repoRelativePath ?? path26.basename(manifest.originalPath ?? manifest.storedPath));
 }
 function goPackageScopeKey(manifest, analysis) {
   if (analysis.code?.language !== "go") {
@@ -21818,7 +22069,7 @@ function goPackageScopeKey(manifest, analysis) {
   if (!packageName) {
     return null;
   }
-  return `${packageName}:${path25.posix.dirname(manifestRepoPath(manifest))}`;
+  return `${packageName}:${path26.posix.dirname(manifestRepoPath(manifest))}`;
 }
 function buildGoPackageSymbolLookups(analyses, manifestsById) {
   const lookups = /* @__PURE__ */ new Map();
@@ -22343,7 +22594,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
-    const absolutePath = path25.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
+    const absolutePath = path26.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
     communityRecords.push(
       await buildManagedGraphPage(
         absolutePath,
@@ -22373,7 +22624,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     contradictions,
     config
   });
-  const reportAbsolutePath = path25.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path26.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -22394,7 +22645,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path25.resolve(wikiDir, relativePath);
+  const absolutePath = path26.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -22460,29 +22711,29 @@ async function requiredCompileArtifactsExist(paths) {
     paths.graphPath,
     paths.codeIndexPath,
     paths.searchDbPath,
-    path25.join(paths.wikiDir, "index.md"),
-    path25.join(paths.wikiDir, "sources", "index.md"),
-    path25.join(paths.wikiDir, "code", "index.md"),
-    path25.join(paths.wikiDir, "concepts", "index.md"),
-    path25.join(paths.wikiDir, "entities", "index.md"),
-    path25.join(paths.wikiDir, "outputs", "index.md"),
-    path25.join(paths.wikiDir, "projects", "index.md"),
-    path25.join(paths.wikiDir, "candidates", "index.md")
+    path26.join(paths.wikiDir, "index.md"),
+    path26.join(paths.wikiDir, "sources", "index.md"),
+    path26.join(paths.wikiDir, "code", "index.md"),
+    path26.join(paths.wikiDir, "concepts", "index.md"),
+    path26.join(paths.wikiDir, "entities", "index.md"),
+    path26.join(paths.wikiDir, "outputs", "index.md"),
+    path26.join(paths.wikiDir, "projects", "index.md"),
+    path26.join(paths.wikiDir, "candidates", "index.md")
   ];
   const checks = await Promise.all(requiredPaths.map((filePath) => fileExists(filePath)));
   return checks.every(Boolean);
 }
 async function loadAvailableCachedAnalyses(paths, manifests) {
   const analyses = await Promise.all(
-    manifests.map(async (manifest) => readJsonFile(path25.join(paths.analysesDir, `${manifest.sourceId}.json`)))
+    manifests.map(async (manifest) => readJsonFile(path26.join(paths.analysesDir, `${manifest.sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis));
 }
 function approvalManifestPath(paths, approvalId) {
-  return path25.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path26.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path25.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path26.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 function normalizeApprovalBundleType(raw) {
   if (!raw) return void 0;
@@ -22503,7 +22754,7 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs21.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs22.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph, labelsByPath = /* @__PURE__ */ new Map()) {
@@ -22518,7 +22769,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path25.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path26.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -22553,7 +22804,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path25.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path26.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
@@ -22566,16 +22817,16 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
 }
 async function stageApprovalBundle(paths, changedFiles, deletedPaths, previousGraph, graph) {
   const approvalId = `compile-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path25.join(paths.approvalsDir, approvalId);
+  const approvalDir = path26.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path25.join(approvalDir, "wiki"));
-  await ensureDir(path25.join(approvalDir, "state"));
+  await ensureDir(path26.join(approvalDir, "wiki"));
+  await ensureDir(path26.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path25.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path25.dirname(targetPath));
-    await fs21.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path26.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path26.dirname(targetPath));
+    await fs22.writeFile(targetPath, file.content, "utf8");
   }
-  await fs21.writeFile(path25.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs22.writeFile(path26.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -22641,7 +22892,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path25.join(paths.wikiDir, preview.path),
+      path26.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -22688,7 +22939,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path25.join(paths.wikiDir, modulePreview.path),
+          path26.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -22722,8 +22973,8 @@ async function syncVaultArtifacts(rootDir, input) {
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const aggregateSourceClass2 = aggregateManifestSourceClass(input.manifests, sourceIds);
       const fallbackPaths = [
-        path25.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path25.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path26.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path26.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -22741,7 +22992,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path25.join(paths.wikiDir, relativePath),
+        path26.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -22878,7 +23129,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path25.join(paths.wikiDir, "projects", "index.md"),
+      path26.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -22902,7 +23153,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path25.join(paths.wikiDir, projectIndexRef.path),
+        path26.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -22930,7 +23181,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path25.join(paths.wikiDir, "index.md"),
+      path26.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -22966,7 +23217,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path25.join(paths.wikiDir, relativePath),
+        path26.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -22977,12 +23228,12 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const nextPagePaths = new Set(records.map((record) => record.page.path));
   const obsoleteGraphPaths = (previousGraph?.pages ?? []).filter((page) => page.kind !== "output" && page.kind !== "insight").map((page) => page.path).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path25.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path26.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
   const obsoletePaths = uniqueStrings4([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path25.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs21.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path26.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs22.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -23007,10 +23258,10 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs21.rm(path25.join(paths.wikiDir, relativePath), { force: true });
+    await fs22.rm(path26.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
-  await writeJsonFile(path25.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+  await writeJsonFile(path26.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   await writeJsonFile(paths.codeIndexPath, input.codeIndex);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
@@ -23108,18 +23359,18 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path25.join(paths.wikiDir, "sources")),
-    ensureDir(path25.join(paths.wikiDir, "code")),
-    ensureDir(path25.join(paths.wikiDir, "concepts")),
-    ensureDir(path25.join(paths.wikiDir, "entities")),
-    ensureDir(path25.join(paths.wikiDir, "outputs")),
-    ensureDir(path25.join(paths.wikiDir, "dashboards")),
-    ensureDir(path25.join(paths.wikiDir, "graph")),
-    ensureDir(path25.join(paths.wikiDir, "graph", "communities")),
-    ensureDir(path25.join(paths.wikiDir, "projects")),
-    ensureDir(path25.join(paths.wikiDir, "candidates"))
+    ensureDir(path26.join(paths.wikiDir, "sources")),
+    ensureDir(path26.join(paths.wikiDir, "code")),
+    ensureDir(path26.join(paths.wikiDir, "concepts")),
+    ensureDir(path26.join(paths.wikiDir, "entities")),
+    ensureDir(path26.join(paths.wikiDir, "outputs")),
+    ensureDir(path26.join(paths.wikiDir, "dashboards")),
+    ensureDir(path26.join(paths.wikiDir, "graph")),
+    ensureDir(path26.join(paths.wikiDir, "graph", "communities")),
+    ensureDir(path26.join(paths.wikiDir, "projects")),
+    ensureDir(path26.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path25.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path26.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -23140,7 +23391,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       outputs: pages.filter((page) => page.kind === "output" && page.projectIds.includes(project.id)),
       candidates: pages.filter((page) => page.status === "candidate" && page.projectIds.includes(project.id))
     };
-    const absolutePath = path25.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path26.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -23158,7 +23409,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path25.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path26.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -23184,7 +23435,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ["candidates/index.md", "candidates", pagesWithGraph.filter((page) => page.status === "candidate")],
     ["graph/index.md", "graph", pagesWithGraph.filter((page) => page.kind === "graph_report" || page.kind === "community_summary")]
   ]) {
-    const absolutePath = path25.join(paths.wikiDir, relativePath);
+    const absolutePath = path26.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -23198,31 +23449,31 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     );
   }
   for (const record of graphOrientation.records) {
-    await writeFileIfChanged(path25.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path26.join(paths.wikiDir, record.page.path), record.content);
   }
   for (const record of dashboardRecords) {
-    await writeFileIfChanged(path25.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path26.join(paths.wikiDir, record.page.path), record.content);
   }
   if (graphOrientation.report) {
-    await writeJsonFile(path25.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+    await writeJsonFile(path26.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path25.relative(paths.wikiDir, absolutePath)));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path26.relative(paths.wikiDir, absolutePath)));
   const allowedProjectIndexPaths = /* @__PURE__ */ new Set([
     "projects/index.md",
     ...configuredProjects.map((project) => `projects/${project.id}/index.md`)
   ]);
   await Promise.all(
-    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs21.rm(path25.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs22.rm(path26.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingGraphPages = (await listFilesRecursive(path25.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path25.relative(paths.wikiDir, absolutePath)));
+  const existingGraphPages = (await listFilesRecursive(path26.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path26.relative(paths.wikiDir, absolutePath)));
   const allowedGraphPages = /* @__PURE__ */ new Set(["graph/index.md", ...graphOrientation.records.map((record) => record.page.path)]);
   await Promise.all(
-    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs21.rm(path25.join(paths.wikiDir, relativePath), { force: true }))
+    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs22.rm(path26.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingDashboardPages = (await listFilesRecursive(path25.join(paths.wikiDir, "dashboards")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path25.relative(paths.wikiDir, absolutePath)));
+  const existingDashboardPages = (await listFilesRecursive(path26.join(paths.wikiDir, "dashboards")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path26.relative(paths.wikiDir, absolutePath)));
   const allowedDashboardPages = /* @__PURE__ */ new Set(["dashboards/index.md", ...dashboardRecords.map((record) => record.page.path)]);
   await Promise.all(
-    existingDashboardPages.filter((relativePath) => !allowedDashboardPages.has(relativePath)).map((relativePath) => fs21.rm(path25.join(paths.wikiDir, relativePath), { force: true }))
+    existingDashboardPages.filter((relativePath) => !allowedDashboardPages.has(relativePath)).map((relativePath) => fs22.rm(path26.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
@@ -23242,7 +23493,7 @@ async function prepareOutputPageSave(rootDir, input) {
       confidence: 0.74
     }
   });
-  const absolutePath = path25.join(paths.wikiDir, output.page.path);
+  const absolutePath = path26.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -23254,15 +23505,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path25.dirname(prepared.savedPath));
-  await fs21.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path26.dirname(prepared.savedPath));
+  await fs22.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path25.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path25.dirname(assetPath));
+    const assetPath = path26.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path26.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs21.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs22.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs21.writeFile(assetPath, assetFile.content);
+      await fs22.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -23283,7 +23534,7 @@ async function prepareExploreHubSave(rootDir, input) {
       confidence: 0.76
     }
   });
-  const absolutePath = path25.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path26.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -23295,15 +23546,15 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path25.dirname(prepared.savedPath));
-  await fs21.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path26.dirname(prepared.savedPath));
+  await fs22.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path25.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path25.dirname(assetPath));
+    const assetPath = path26.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path26.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs21.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs22.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs21.writeFile(assetPath, assetFile.content);
+      await fs22.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -23321,17 +23572,17 @@ async function stageOutputApprovalBundle(rootDir, stagedPages, options = {}) {
   ]);
   const labelsByPath = new Map(stagedPages.filter((item) => item.label).map((item) => [item.page.path, item.label]));
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path25.join(paths.approvalsDir, approvalId);
+  const approvalDir = path26.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path25.join(approvalDir, "wiki"));
-  await ensureDir(path25.join(approvalDir, "state"));
+  await ensureDir(path26.join(approvalDir, "wiki"));
+  await ensureDir(path26.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path25.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path25.dirname(targetPath));
+    const targetPath = path26.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path26.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs21.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs22.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs21.writeFile(targetPath, file.content, "utf8");
+      await fs22.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -23346,7 +23597,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages, options = {}) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs21.writeFile(path25.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs22.writeFile(path26.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -23396,10 +23647,10 @@ async function executeQuery(rootDir, question, format, options = {}) {
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path25.join(paths.wikiDir, result.path);
+      const absolutePath = path26.join(paths.wikiDir, result.path);
       try {
-        const content = await fs21.readFile(absolutePath, "utf8");
-        const parsed = matter12(content);
+        const content = await fs22.readFile(absolutePath, "utf8");
+        const parsed = matter13(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
       } catch {
@@ -23672,12 +23923,12 @@ function computeStructuredDiff(current, staged, isBinaryAsset) {
   let currentBody = current ?? "";
   let stagedBody = staged ?? "";
   if (current) {
-    const parsed = matter12(current);
+    const parsed = matter13(current);
     currentData = parsed.data ?? {};
     currentBody = parsed.content;
   }
   if (staged) {
-    const parsed = matter12(staged);
+    const parsed = matter13(staged);
     stagedData = parsed.data ?? {};
     stagedBody = parsed.content;
   }
@@ -23705,8 +23956,8 @@ function computeChangeSummary(current, staged, changeType) {
   if (changeType === "delete") return "Removed page";
   if (changeType === "promote") return "Promoted from candidate";
   if (!current || !staged) return "Updated page";
-  const currentParsed = matter12(current);
-  const stagedParsed = matter12(staged);
+  const currentParsed = matter13(current);
+  const stagedParsed = matter13(staged);
   const changes = [];
   const currentTags = currentParsed.data.tags ?? [];
   const stagedTags = stagedParsed.data.tags ?? [];
@@ -23726,7 +23977,7 @@ function computeChangeSummary(current, staged, changeType) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs21.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs22.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -23742,8 +23993,8 @@ async function readApproval(rootDir, approvalId, options) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs21.readFile(path25.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs21.readFile(path25.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs22.readFile(path26.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs22.readFile(path26.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       const detail = {
         ...entry,
         currentContent,
@@ -23785,26 +24036,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path25.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs21.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path25.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path25.dirname(targetAbsolutePath));
-      await fs21.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path26.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs22.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path26.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path26.dirname(targetAbsolutePath));
+      await fs22.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs21.rm(path25.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs22.rm(path26.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       const nextPage = bundleGraph?.pages.find((page) => page.id === entry.pageId && page.path === entry.nextPath) ?? parseStoredPage(entry.nextPath, stagedContent);
       if (nextPage.kind === "output" && nextPage.outputAssets?.length) {
-        const outputAssetDir = path25.join(paths.wikiDir, "outputs", "assets", path25.basename(nextPage.path, ".md"));
-        await fs21.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path26.join(paths.wikiDir, "outputs", "assets", path26.basename(nextPage.path, ".md"));
+        await fs22.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path25.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path26.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path25.join(paths.wikiDir, asset.path);
-          await ensureDir(path25.dirname(targetAssetPath));
-          await fs21.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path26.join(paths.wikiDir, asset.path);
+          await ensureDir(path26.dirname(targetAssetPath));
+          await fs22.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -23815,10 +24066,10 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
     } else {
       const deletedPage = nextPages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? bundleGraph?.pages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? null;
       if (entry.previousPath) {
-        await fs21.rm(path25.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs22.rm(path26.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs21.rm(path25.join(paths.wikiDir, "outputs", "assets", path25.basename(deletedPage.path, ".md")), {
+        await fs22.rm(path26.join(paths.wikiDir, "outputs", "assets", path26.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -23949,10 +24200,10 @@ async function promoteCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  const raw = await fs21.readFile(path25.join(paths.wikiDir, candidate.path), "utf8");
-  const parsed = matter12(raw);
+  const raw = await fs22.readFile(path26.join(paths.wikiDir, candidate.path), "utf8");
+  const parsed = matter13(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const nextContent = matter12.stringify(parsed.content, {
+  const nextContent = matter13.stringify(parsed.content, {
     ...parsed.data,
     status: "active",
     updated_at: nextUpdatedAt,
@@ -23961,10 +24212,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path25.join(paths.wikiDir, nextPath);
-  await ensureDir(path25.dirname(nextAbsolutePath));
-  await fs21.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs21.rm(path25.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path26.join(paths.wikiDir, nextPath);
+  await ensureDir(path26.dirname(nextAbsolutePath));
+  await fs22.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs22.rm(path26.join(paths.wikiDir, candidate.path), { force: true });
   const nextPage = parseStoredPage(nextPath, nextContent, { createdAt: candidate.createdAt, updatedAt: nextUpdatedAt });
   const nextPages = sortGraphPages(
     (graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path).concat(nextPage)
@@ -24105,10 +24356,10 @@ async function createSupersessionEdge(rootDir, oldPageIdOrPath, newPageIdOrPath)
   }
   const now = /* @__PURE__ */ new Date();
   const nextOldPage = markSuperseded(oldPage, newPage.id, now);
-  const oldAbsolutePath = path25.join(paths.wikiDir, oldPage.path);
+  const oldAbsolutePath = path26.join(paths.wikiDir, oldPage.path);
   if (await fileExists(oldAbsolutePath)) {
-    const current = await fs21.readFile(oldAbsolutePath, "utf8");
-    const parsed = matter12(current);
+    const current = await fs22.readFile(oldAbsolutePath, "utf8");
+    const parsed = matter13(current);
     const nextData = {
       ...parsed.data,
       freshness: "stale",
@@ -24116,7 +24367,7 @@ async function createSupersessionEdge(rootDir, oldPageIdOrPath, newPageIdOrPath)
       superseded_by: newPage.id,
       updated_at: nextOldPage.updatedAt
     };
-    await fs21.writeFile(oldAbsolutePath, matter12.stringify(parsed.content, nextData), "utf8");
+    await fs22.writeFile(oldAbsolutePath, matter13.stringify(parsed.content, nextData), "utf8");
   }
   const resolveNodeId = (pageId) => {
     const node = graph.nodes.find((item) => item.pageId === pageId);
@@ -24167,7 +24418,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs21.rm(path25.join(paths.wikiDir, candidate.path), { force: true });
+  await fs22.rm(path26.join(paths.wikiDir, candidate.path), { force: true });
   const nextPages = sortGraphPages((graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path));
   const nextGraph = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -24206,18 +24457,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path25.join(rootDir, ".obsidian");
+  const obsidianDir = path26.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path25.join(obsidianDir, "app.json"), {
+    writeJsonFile(path26.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path25.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path26.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -24227,7 +24478,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path25.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path26.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -24247,7 +24498,7 @@ async function ensureObsidianWorkspace(rootDir) {
       ],
       localJumps: false
     }),
-    writeJsonFile(path25.join(obsidianDir, "types.json"), {
+    writeJsonFile(path26.join(obsidianDir, "types.json"), {
       types: {
         page_id: "text",
         kind: "text",
@@ -24268,7 +24519,7 @@ async function ensureObsidianWorkspace(rootDir) {
         cssclasses: "multitext"
       }
     }),
-    writeJsonFile(path25.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path26.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -24281,20 +24532,20 @@ async function ensureObsidianWorkspace(rootDir) {
   ]);
 }
 async function initLiteVault(rootDir, options) {
-  const rawDir = path25.join(rootDir, "raw");
-  const wikiDir = path25.join(rootDir, "wiki");
-  const schemaPath = path25.join(rootDir, PRIMARY_SCHEMA_FILENAME);
-  const indexPath = path25.join(wikiDir, "index.md");
-  const logPath = path25.join(wikiDir, "log.md");
+  const rawDir = path26.join(rootDir, "raw");
+  const wikiDir = path26.join(rootDir, "wiki");
+  const schemaPath = path26.join(rootDir, PRIMARY_SCHEMA_FILENAME);
+  const indexPath = path26.join(wikiDir, "index.md");
+  const logPath = path26.join(wikiDir, "log.md");
   await Promise.all([ensureDir(rawDir), ensureDir(wikiDir)]);
   if (!await fileExists(schemaPath)) {
-    await fs21.writeFile(schemaPath, defaultVaultSchema("default"), "utf8");
+    await fs22.writeFile(schemaPath, defaultVaultSchema("default"), "utf8");
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (!await fileExists(indexPath)) {
-    await fs21.writeFile(
+    await fs22.writeFile(
       indexPath,
-      matter12.stringify(
+      matter13.stringify(
         [
           "# Wiki Index",
           "",
@@ -24330,9 +24581,9 @@ async function initLiteVault(rootDir, options) {
     );
   }
   if (!await fileExists(logPath)) {
-    await fs21.writeFile(
+    await fs22.writeFile(
       logPath,
-      matter12.stringify(
+      matter13.stringify(
         [
           "# Activity Log",
           "",
@@ -24366,7 +24617,7 @@ async function initLiteVault(rootDir, options) {
     );
   }
   if (options.obsidian) {
-    const obsidianDir = path25.join(rootDir, ".obsidian");
+    const obsidianDir = path26.join(rootDir, ".obsidian");
     await ensureDir(obsidianDir);
   }
 }
@@ -24380,11 +24631,11 @@ async function initVault(rootDir, options = {}) {
   const profile = config.profile;
   const isResearchProfile = profile.presets.length > 0 || profile.guidedSessionMode === "canonical_review" || profile.dataviewBlocks;
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path25.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path26.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
-    matter12.stringify(
+    matter13.stringify(
       (isResearchProfile ? [
         "# Insights",
         "",
@@ -24430,8 +24681,8 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path25.join(paths.wikiDir, "projects", "index.md"),
-    matter12.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
+    path26.join(paths.wikiDir, "projects", "index.md"),
+    matter13.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
       title: "Projects",
@@ -24453,8 +24704,8 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path25.join(paths.wikiDir, "candidates", "index.md"),
-    matter12.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
+    path26.join(paths.wikiDir, "candidates", "index.md"),
+    matter13.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
       title: "Candidates",
@@ -24480,8 +24731,8 @@ async function initVault(rootDir, options = {}) {
   }
   if (isResearchProfile) {
     await writeFileIfChanged(
-      path25.join(paths.wikiDir, "insights", "research-playbook.md"),
-      matter12.stringify(
+      path26.join(paths.wikiDir, "insights", "research-playbook.md"),
+      matter13.stringify(
         [
           `# ${requestedProfile === "personal-research" ? "Personal Research Playbook" : "Research Playbook"}`,
           "",
@@ -24639,7 +24890,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path25.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path26.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           analysisProgress.tick(manifest.title);
           return cached;
@@ -24667,22 +24918,22 @@ async function compileVault(rootDir, options = {}) {
       }
       const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
       if (analysisSignature(enriched) !== analysisSignature(analysis)) {
-        await writeJsonFile(path25.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+        await writeJsonFile(path26.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
       }
       return enriched;
     })
   );
   await Promise.all([
-    ensureDir(path25.join(paths.wikiDir, "sources")),
-    ensureDir(path25.join(paths.wikiDir, "code")),
-    ensureDir(path25.join(paths.wikiDir, "concepts")),
-    ensureDir(path25.join(paths.wikiDir, "entities")),
-    ensureDir(path25.join(paths.wikiDir, "outputs")),
-    ensureDir(path25.join(paths.wikiDir, "projects")),
-    ensureDir(path25.join(paths.wikiDir, "insights")),
-    ensureDir(path25.join(paths.wikiDir, "candidates")),
-    ensureDir(path25.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path25.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path26.join(paths.wikiDir, "sources")),
+    ensureDir(path26.join(paths.wikiDir, "code")),
+    ensureDir(path26.join(paths.wikiDir, "concepts")),
+    ensureDir(path26.join(paths.wikiDir, "entities")),
+    ensureDir(path26.join(paths.wikiDir, "outputs")),
+    ensureDir(path26.join(paths.wikiDir, "projects")),
+    ensureDir(path26.join(paths.wikiDir, "insights")),
+    ensureDir(path26.join(paths.wikiDir, "candidates")),
+    ensureDir(path26.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path26.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
@@ -24802,10 +25053,10 @@ async function compileVault(rootDir, options = {}) {
     }
     const estimates = await Promise.all(
       sync.allPages.map(async (page) => {
-        const fullPath = path25.join(paths.wikiDir, page.path);
+        const fullPath = path26.join(paths.wikiDir, page.path);
         let content = "";
         try {
-          content = await fs21.readFile(fullPath, "utf8");
+          content = await fs22.readFile(fullPath, "utf8");
         } catch {
         }
         return estimatePageTokens2(page.id, page.path, page.kind, content, nodeDegreeLookup.get(page.id), page.confidence);
@@ -24813,9 +25064,9 @@ async function compileVault(rootDir, options = {}) {
     );
     const budgetResult = trimToTokenBudget2(estimates, options.maxTokens);
     for (const dropped of budgetResult.dropped) {
-      const fullPath = path25.join(paths.wikiDir, dropped.path);
+      const fullPath = path26.join(paths.wikiDir, dropped.path);
       try {
-        await fs21.unlink(fullPath);
+        await fs22.unlink(fullPath);
       } catch {
       }
     }
@@ -24910,7 +25161,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path25.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path26.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -25169,9 +25420,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path25.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path26.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path25.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path26.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -25315,11 +25566,11 @@ async function benchmarkVault(rootDir, options = {}) {
     }
   }
   for (const page of graph.pages) {
-    const absolutePath = path25.join(paths.wikiDir, page.path);
+    const absolutePath = path26.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const parsed = matter12(await fs21.readFile(absolutePath, "utf8"));
+    const parsed = matter13(await fs22.readFile(absolutePath, "utf8"));
     pageContentsById.set(page.id, parsed.content);
   }
   const configuredQuestions = (config.benchmark?.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
@@ -25414,7 +25665,7 @@ async function listGraphHyperedges(rootDir, target, limit = 25) {
 }
 async function readGraphReport(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
-  return readJsonFile(path25.join(paths.wikiDir, "graph", "report.json"));
+  return readJsonFile(path26.join(paths.wikiDir, "graph", "report.json"));
 }
 async function listGodNodes(rootDir, limit) {
   const graph = await ensureCompiledGraph(rootDir);
@@ -25440,19 +25691,19 @@ async function readPage(rootDir, relativePath) {
     return null;
   }
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path25.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path26.resolve(paths.wikiDir, relativePath);
   if (!isPathWithin(paths.wikiDir, absolutePath)) {
     return null;
   }
-  const stats = await fs21.stat(absolutePath).catch(() => null);
+  const stats = await fs22.stat(absolutePath).catch(() => null);
   if (!stats?.isFile()) {
     return null;
   }
-  const raw = await fs21.readFile(absolutePath, "utf8");
-  const parsed = matter12(raw);
+  const raw = await fs22.readFile(absolutePath, "utf8");
+  const parsed = matter13(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path25.basename(relativePath, path25.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path26.basename(relativePath, path26.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -25519,7 +25770,7 @@ function tierLintFindings(paths, graph, consolidationConfig, now = /* @__PURE__
           severity: "info",
           code: "stale_working_tier",
           message: `Working-tier insight ${page.title} has not been consolidated after the session window.`,
-          pagePath: path25.join(paths.wikiDir, page.path),
+          pagePath: path26.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -25531,7 +25782,7 @@ function tierLintFindings(paths, graph, consolidationConfig, now = /* @__PURE__
           severity: "warning",
           code: "broken_consolidation_basis",
           message: `Tier page ${page.title} references missing lower-tier page ids: ${missing.join(", ")}.`,
-          pagePath: path25.join(paths.wikiDir, page.path),
+          pagePath: path26.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -25541,7 +25792,7 @@ function tierLintFindings(paths, graph, consolidationConfig, now = /* @__PURE__
         severity: "warning",
         code: "semantic_without_episodic_basis",
         message: `Semantic-tier page ${page.title} has no episodic basis recorded.`,
-        pagePath: path25.join(paths.wikiDir, page.path),
+        pagePath: path26.join(paths.wikiDir, page.path),
         relatedPageIds: [page.id]
       });
     }
@@ -25562,7 +25813,7 @@ function decayLintFindings(paths, graph, freshnessConfig, now = /* @__PURE__ */
         severity: "info",
         code: "decayed-pages",
         message: `Page ${page.title} has decayed (score=${score.toFixed(2)}, below threshold ${staleThreshold}).`,
-        pagePath: path25.join(paths.wikiDir, page.path),
+        pagePath: path26.join(paths.wikiDir, page.path),
         relatedPageIds: [page.id]
       });
     }
@@ -25571,7 +25822,7 @@ function decayLintFindings(paths, graph, freshnessConfig, now = /* @__PURE__ */
         severity: "warning",
         code: "broken_supersession",
         message: `Page ${page.title} is marked supersededBy ${supersededBy}, but that page does not exist.`,
-        pagePath: path25.join(paths.wikiDir, page.path),
+        pagePath: path26.join(paths.wikiDir, page.path),
         relatedPageIds: [page.id]
       });
     }
@@ -25580,7 +25831,7 @@ function decayLintFindings(paths, graph, freshnessConfig, now = /* @__PURE__ */
         severity: "info",
         code: "inconsistent_decay",
         message: `Page ${page.title} is marked stale but decay score ${score.toFixed(2)} is above the threshold.`,
-        pagePath: path25.join(paths.wikiDir, page.path),
+        pagePath: path26.join(paths.wikiDir, page.path),
         relatedPageIds: [page.id]
       });
     }
@@ -25602,7 +25853,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "warning",
           code: "stale_page",
           message: `Page ${page.title} is stale because the vault schema changed.`,
-          pagePath: path25.join(paths.wikiDir, page.path),
+          pagePath: path26.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -25615,7 +25866,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
             severity: "warning",
             code: "stale_page",
             message: `Page ${page.title} is stale because source ${sourceId} changed.`,
-            pagePath: path25.join(paths.wikiDir, page.path),
+            pagePath: path26.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -25626,13 +25877,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path25.join(paths.wikiDir, page.path),
+          pagePath: path26.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path25.join(paths.wikiDir, page.path);
+      const absolutePath = path26.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs21.readFile(absolutePath, "utf8");
+        const content = await fs22.readFile(absolutePath, "utf8");
         const claimLines = extractClaimSectionLines(content);
         if (claimLines !== null) {
           const uncited = claimLines.filter(
@@ -25789,8 +26040,8 @@ async function consolidateVault(rootDir, options = {}) {
 }
 
 // src/watch.ts
-import fs22 from "fs/promises";
-import path26 from "path";
+import fs23 from "fs/promises";
+import path27 from "path";
 import process3 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
@@ -25844,7 +26095,7 @@ function isCodeOnlyChange(reasons) {
   for (const reason of reasons) {
     const match = reason.match(FILE_CHANGE_RE);
     if (!match) return false;
-    const ext = path26.extname(match[1]).toLowerCase();
+    const ext = path27.extname(match[1]).toLowerCase();
     if (!ext || !CODE_EXTENSIONS.has(ext)) return false;
   }
   return reasons.size > 0;
@@ -25853,7 +26104,7 @@ function hasNonCodeChanges(reasons) {
   for (const reason of reasons) {
     const match = reason.match(FILE_CHANGE_RE);
     if (!match) return true;
-    const ext = path26.extname(match[1]).toLowerCase();
+    const ext = path27.extname(match[1]).toLowerCase();
     if (!ext || !CODE_EXTENSIONS.has(ext)) return true;
   }
   return false;
@@ -25866,17 +26117,17 @@ function collectNonCodePaths(reasons) {
       result.push(reason);
       continue;
     }
-    const ext = path26.extname(match[1]).toLowerCase();
+    const ext = path27.extname(match[1]).toLowerCase();
     if (!ext || !CODE_EXTENSIONS.has(ext)) result.push(match[1]);
   }
   return result;
 }
 function hasIgnoredRepoSegment(baseDir, targetPath) {
-  const relativePath = path26.relative(baseDir, targetPath);
+  const relativePath = path27.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath.split(path26.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+  return relativePath.split(path27.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
 }
 function workspaceIgnoreRoots(rootDir, paths) {
   return [
@@ -25885,22 +26136,22 @@ function workspaceIgnoreRoots(rootDir, paths) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path26.join(rootDir, ".claude"),
-    path26.join(rootDir, ".cursor"),
-    path26.join(rootDir, ".obsidian")
-  ].map((candidate) => path26.resolve(candidate));
+    path27.join(rootDir, ".claude"),
+    path27.join(rootDir, ".cursor"),
+    path27.join(rootDir, ".obsidian")
+  ].map((candidate) => path27.resolve(candidate));
 }
 async function resolveWatchTargets(rootDir, paths, options) {
-  const targets = /* @__PURE__ */ new Set([path26.resolve(paths.inboxDir)]);
+  const targets = /* @__PURE__ */ new Set([path27.resolve(paths.inboxDir)]);
   if (options.repo) {
     for (const repoRoot of await resolveWatchedRepoRoots(rootDir, { overrideRoots: options.overrideRoots })) {
-      targets.add(path26.resolve(repoRoot));
+      targets.add(path27.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
 }
 function resolveRootRelative(rootDir, candidate) {
-  return path26.isAbsolute(candidate) ? path26.resolve(candidate) : path26.resolve(rootDir, candidate);
+  return path27.isAbsolute(candidate) ? path27.resolve(candidate) : path27.resolve(rootDir, candidate);
 }
 async function resolveWatchedRepoRoots(rootDir, options = {}) {
   const override = options.overrideRoots?.filter(Boolean) ?? [];
@@ -25914,17 +26165,17 @@ async function resolveWatchedRepoRoots(rootDir, options = {}) {
   const excluded = new Set(
     (watchConfig.excludeRepoRoots ?? []).filter(Boolean).map((candidate) => resolveRootRelative(rootDir, candidate))
   );
-  return dedupeSorted(baseRoots.filter((candidate) => !excluded.has(path26.resolve(candidate))));
+  return dedupeSorted(baseRoots.filter((candidate) => !excluded.has(path27.resolve(candidate))));
 }
 async function listWatchedRoots(rootDir, options = {}) {
   return resolveWatchedRepoRoots(rootDir, options);
 }
 function dedupeSorted(values) {
-  return [...new Set(values.map((value) => path26.resolve(value)))].sort((left, right) => left.localeCompare(right));
+  return [...new Set(values.map((value) => path27.resolve(value)))].sort((left, right) => left.localeCompare(right));
 }
 async function readConfigJson(rootDir) {
-  const configPath = path26.join(rootDir, "swarmvault.config.json");
-  const raw = await fs22.readFile(configPath, "utf8");
+  const configPath = path27.join(rootDir, "swarmvault.config.json");
+  const raw = await fs23.readFile(configPath, "utf8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("swarmvault.config.json must contain a JSON object.");
@@ -25932,7 +26183,7 @@ async function readConfigJson(rootDir) {
   return { path: configPath, content: parsed };
 }
 async function writeConfigJson(configPath, content) {
-  await fs22.writeFile(configPath, `${JSON.stringify(content, null, 2)}
+  await fs23.writeFile(configPath, `${JSON.stringify(content, null, 2)}
 `, "utf8");
 }
 function getWatchBlock(config) {
@@ -26105,7 +26356,7 @@ async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   const baseDebounceMs = options.debounceMs ?? 900;
   const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
-  const inboxWatchRoot = path26.resolve(paths.inboxDir);
+  const inboxWatchRoot = path27.resolve(paths.inboxDir);
   let watchTargets = await resolveWatchTargets(rootDir, paths, options);
   let timer;
   let running = false;
@@ -26120,7 +26371,7 @@ async function watchVault(rootDir, options = {}) {
     usePolling: true,
     interval: 100,
     ignored: (targetPath) => {
-      const absolutePath = path26.resolve(targetPath);
+      const absolutePath = path27.resolve(targetPath);
       const primaryTarget = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
@@ -26322,8 +26573,8 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, path26.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
-    return path26.relative(baseDir, targetPath) || ".";
+    const baseDir = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, path27.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path27.relative(baseDir, targetPath) || ".";
   };
   watcher.on("add", (filePath) => schedule(`add:${reasonForPath(filePath)}`)).on("change", (filePath) => schedule(`change:${reasonForPath(filePath)}`)).on("unlink", (filePath) => schedule(`unlink:${reasonForPath(filePath)}`)).on("addDir", (dirPath) => schedule(`addDir:${reasonForPath(dirPath)}`)).on("unlinkDir", (dirPath) => schedule(`unlinkDir:${reasonForPath(dirPath)}`)).on("error", (caught) => schedule(`error:${caught instanceof Error ? caught.message : String(caught)}`));
   await new Promise((resolve, reject) => {
@@ -26362,7 +26613,7 @@ async function getWatchStatus(rootDir) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.11.0";
+var SERVER_VERSION = "0.12.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -26694,6 +26945,19 @@ async function createMcpServer(rootDir) {
       return asToolText(result);
     })
   );
+  server.registerTool(
+    "migrate",
+    {
+      description: "Detect the vault's version and preview the migration plan to the current SwarmVault version.",
+      inputSchema: {
+        target: z8.string().optional().describe("Optional target version cap (migrations with toVersion above this are skipped)")
+      }
+    },
+    safeHandler(async ({ target }) => {
+      const plan = await runMigration(rootDir, { targetVersion: target, dryRun: true });
+      return asToolText(plan);
+    })
+  );
   server.registerResource(
     "swarmvault-config",
     "swarmvault://config",
@@ -26760,7 +27024,7 @@ async function createMcpServer(rootDir) {
     },
     async () => {
       const { paths } = await loadVaultConfig(rootDir);
-      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path27.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path28.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -26793,8 +27057,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path27.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs23.readFile(absolutePath, "utf8"));
+      const absolutePath = path28.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs24.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -26802,11 +27066,11 @@ async function createMcpServer(rootDir) {
     new ResourceTemplate("swarmvault://sessions/{path}", {
       list: async () => {
         const { paths } = await loadVaultConfig(rootDir);
-        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path27.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path28.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path27.basename(relativePath, ".md"),
+            name: path28.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -26823,11 +27087,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path27.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path28.resolve(paths.sessionsDir, relativePath);
       if (!isPathWithin(paths.sessionsDir, absolutePath) || !await fileExists(absolutePath)) {
         return asTextResource(`swarmvault://sessions/${encodedPath}`, `Session not found: ${relativePath}`);
       }
-      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs23.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs24.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -26885,14 +27149,76 @@ function asTextResource(uri, text) {
   };
 }
 
+// src/providers/openai-compatible-capabilities.ts
+var OPENAI_COMPATIBLE_CAPABILITY_MATRIX = Object.freeze({
+  openai: {
+    presetId: "openai",
+    apiStyle: "responses",
+    capabilities: ["responses", "chat", "structured", "tools", "vision", "embeddings", "streaming", "image_generation", "audio"],
+    notes: "Reference implementation. Supports responses API, strict structured output, tool calling, vision, image generation, and Whisper transcription."
+  },
+  "openai-compatible": {
+    presetId: "openai-compatible",
+    apiStyle: "responses",
+    capabilities: ["chat", "structured", "embeddings", "audio"],
+    notes: "Generic fallback for self-hosted backends. Structured output adherence varies; verify capability flags per deployment."
+  },
+  openrouter: {
+    presetId: "openrouter",
+    apiStyle: "chat",
+    capabilities: ["chat", "structured", "embeddings"],
+    notes: "Router of upstream models. No responses API, no vision at the gateway level, structured output requires model-specific care."
+  },
+  groq: {
+    presetId: "groq",
+    apiStyle: "chat",
+    capabilities: ["chat", "structured", "embeddings", "audio"],
+    notes: "Fast chat completions, Whisper-compatible audio endpoint, no vision, no responses API."
+  },
+  together: {
+    presetId: "together",
+    apiStyle: "chat",
+    capabilities: ["chat", "structured", "embeddings"],
+    notes: "Chat completions with mixed structured-output reliability across hosted models. No vision or audio."
+  },
+  xai: {
+    presetId: "xai",
+    apiStyle: "chat",
+    capabilities: ["chat", "structured", "embeddings"],
+    notes: "Grok API. Chat and structured output; no vision or audio in the open surface."
+  },
+  cerebras: {
+    presetId: "cerebras",
+    apiStyle: "chat",
+    capabilities: ["chat", "structured", "embeddings"],
+    notes: "High-throughput inference. No vision, no audio, no image generation."
+  },
+  ollama: {
+    presetId: "ollama",
+    apiStyle: "chat",
+    capabilities: ["chat", "structured", "tools", "vision", "embeddings", "streaming", "local", "audio"],
+    notes: "Local-first. Capabilities depend on which models are installed; structured output is best-effort."
+  }
+});
+function lookupPresetCapabilities(presetId) {
+  return OPENAI_COMPATIBLE_CAPABILITY_MATRIX[presetId] ?? null;
+}
+async function withCapabilityFallback(provider, capability, run, fallback) {
+  if (provider.capabilities.has(capability)) {
+    return { supported: true, reason: null, value: await run() };
+  }
+  const fallbackValue = await fallback();
+  return { supported: false, reason: "unsupported", value: fallbackValue };
+}
+
 // src/schedule.ts
-import fs24 from "fs/promises";
-import path28 from "path";
+import fs25 from "fs/promises";
+import path29 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path28.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path29.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path28.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path29.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -26995,13 +27321,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs24.open(leasePath, "wx");
+  const handle = await fs25.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs24.rm(leasePath, { force: true });
+    await fs25.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -27160,9 +27486,9 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/sources.ts
 import { spawn as spawn2 } from "child_process";
-import fs25 from "fs/promises";
-import path29 from "path";
-import matter13 from "gray-matter";
+import fs26 from "fs/promises";
+import path30 from "path";
+import matter14 from "gray-matter";
 import { JSDOM as JSDOM3 } from "jsdom";
 var DEFAULT_CRAWL_MAX_PAGES = 12;
 var DEFAULT_CRAWL_MAX_DEPTH = 2;
@@ -27207,24 +27533,24 @@ function emptyManagedSourceSyncCounts() {
   };
 }
 function withinRoot2(rootPath, targetPath) {
-  const relative = path29.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path29.isAbsolute(relative);
+  const relative = path30.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path30.isAbsolute(relative);
 }
 async function findNearestGitRoot3(startPath) {
-  let current = path29.resolve(startPath);
+  let current = path30.resolve(startPath);
   try {
-    const stat = await fs25.stat(current);
+    const stat = await fs26.stat(current);
     if (!stat.isDirectory()) {
-      current = path29.dirname(current);
+      current = path30.dirname(current);
     }
   } catch {
-    current = path29.dirname(current);
+    current = path30.dirname(current);
   }
   while (true) {
-    if (await fileExists(path29.join(current, ".git"))) {
+    if (await fileExists(path30.join(current, ".git"))) {
       return current;
     }
-    const parent = path29.dirname(current);
+    const parent = path30.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -27298,7 +27624,7 @@ function isAllowedDocsCandidate(candidate, startUrl) {
   if (candidate.origin !== startUrl.origin) {
     return false;
   }
-  const extension = path29.extname(candidate.pathname).toLowerCase();
+  const extension = path30.extname(candidate.pathname).toLowerCase();
   if (extension && extension !== ".html" && extension !== ".htm" && extension !== ".md") {
     return false;
   }
@@ -27387,14 +27713,14 @@ function matchesManagedSourceSpec(existing, input) {
     return false;
   }
   if (input.kind === "directory" || input.kind === "file") {
-    return path29.resolve(existing.path ?? "") === path29.resolve(input.path);
+    return path30.resolve(existing.path ?? "") === path30.resolve(input.path);
   }
   return (existing.url ?? "") === input.url;
 }
 async function resolveManagedSourceInput(rootDir, input) {
-  const absoluteInput = path29.resolve(rootDir, input);
+  const absoluteInput = path30.resolve(rootDir, input);
   if (!(input.startsWith("http://") || input.startsWith("https://"))) {
-    const stat = await fs25.stat(absoluteInput).catch(() => null);
+    const stat = await fs26.stat(absoluteInput).catch(() => null);
     if (!stat) {
       throw new Error(`Source not found: ${input}`);
     }
@@ -27402,7 +27728,7 @@ async function resolveManagedSourceInput(rootDir, input) {
       return {
         kind: "file",
         path: absoluteInput,
-        title: path29.basename(absoluteInput, path29.extname(absoluteInput)) || absoluteInput
+        title: path30.basename(absoluteInput, path30.extname(absoluteInput)) || absoluteInput
       };
     }
     if (!stat.isDirectory()) {
@@ -27414,7 +27740,7 @@ async function resolveManagedSourceInput(rootDir, input) {
       kind: "directory",
       path: absoluteInput,
       repoRoot,
-      title: path29.basename(absoluteInput) || absoluteInput
+      title: path30.basename(absoluteInput) || absoluteInput
     };
   }
   const github = normalizeGitHubRepoRootUrl(input);
@@ -27437,16 +27763,16 @@ async function resolveManagedSourceInput(rootDir, input) {
   };
 }
 function directorySourceIdsFor(manifests, inputPath) {
-  return manifests.filter((manifest) => manifest.originalPath && withinRoot2(path29.resolve(inputPath), path29.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+  return manifests.filter((manifest) => manifest.originalPath && withinRoot2(path30.resolve(inputPath), path30.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
 }
 function fileSourceIdsFor(manifests, inputPath) {
-  const absoluteInput = path29.resolve(inputPath);
-  return manifests.filter((manifest) => manifest.originalPath && path29.resolve(manifest.originalPath) === absoluteInput).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+  const absoluteInput = path30.resolve(inputPath);
+  return manifests.filter((manifest) => manifest.originalPath && path30.resolve(manifest.originalPath) === absoluteInput).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
 }
 async function syncDirectorySource(rootDir, inputPath, repoRoot) {
   const manifestsBefore = await listManifests(rootDir);
   const previousInScope = manifestsBefore.filter(
-    (manifest) => manifest.originalPath && withinRoot2(path29.resolve(inputPath), path29.resolve(manifest.originalPath))
+    (manifest) => manifest.originalPath && withinRoot2(path30.resolve(inputPath), path30.resolve(manifest.originalPath))
   );
   const result = await ingestDirectory(rootDir, inputPath, { repoRoot });
   const removed = [];
@@ -27454,7 +27780,7 @@ async function syncDirectorySource(rootDir, inputPath, repoRoot) {
     if (!manifest.originalPath) {
       continue;
     }
-    if (await fileExists(path29.resolve(manifest.originalPath))) {
+    if (await fileExists(path30.resolve(manifest.originalPath))) {
       continue;
     }
     const removedManifest = await removeManifestBySourceId(rootDir, manifest.sourceId);
@@ -27464,7 +27790,7 @@ async function syncDirectorySource(rootDir, inputPath, repoRoot) {
   }
   const manifestsAfter = await listManifests(rootDir);
   return {
-    title: path29.basename(inputPath) || inputPath,
+    title: path30.basename(inputPath) || inputPath,
     sourceIds: directorySourceIdsFor(manifestsAfter, inputPath),
     counts: {
       scannedCount: result.scannedCount,
@@ -27480,7 +27806,7 @@ async function syncFileSource(rootDir, inputPath) {
   const result = await ingestInputDetailed(rootDir, inputPath);
   const manifestsAfter = await listManifests(rootDir);
   return {
-    title: path29.basename(inputPath, path29.extname(inputPath)) || inputPath,
+    title: path30.basename(inputPath, path30.extname(inputPath)) || inputPath,
     sourceIds: fileSourceIdsFor(manifestsAfter, inputPath),
     counts: {
       scannedCount: result.scannedCount,
@@ -27514,8 +27840,8 @@ async function runGitCommand(cwd, args) {
 }
 async function syncGitHubRepoSource(rootDir, entry) {
   const workingDir = await managedSourceWorkingDir(rootDir, entry.id);
-  const checkoutDir = path29.join(workingDir, "checkout");
-  await fs25.rm(checkoutDir, { recursive: true, force: true });
+  const checkoutDir = path30.join(workingDir, "checkout");
+  await fs26.rm(checkoutDir, { recursive: true, force: true });
   await ensureDir(workingDir);
   if (!entry.url) {
     throw new Error(`Managed source ${entry.id} is missing its repository URL.`);
@@ -27645,7 +27971,7 @@ function scopedNodeIds(graph, sourceIds) {
 async function loadSourceAnalyses(rootDir, sourceIds) {
   const { paths } = await loadVaultConfig(rootDir);
   const analyses = await Promise.all(
-    sourceIds.map(async (sourceId) => await readJsonFile(path29.join(paths.analysesDir, `${sourceId}.json`)))
+    sourceIds.map(async (sourceId) => await readJsonFile(path30.join(paths.analysesDir, `${sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis?.sourceId));
 }
@@ -27806,9 +28132,9 @@ async function writeSourceBriefForScope(rootDir, source) {
       confidence: 0.82
     }
   });
-  const absolutePath = path29.join(paths.wikiDir, output.page.path);
-  await ensureDir(path29.dirname(absolutePath));
-  await fs25.writeFile(absolutePath, output.content, "utf8");
+  const absolutePath = path30.join(paths.wikiDir, output.page.path);
+  await ensureDir(path30.dirname(absolutePath));
+  await fs26.writeFile(absolutePath, output.content, "utf8");
   return absolutePath;
 }
 async function writeSourceBrief(rootDir, source) {
@@ -28096,7 +28422,7 @@ function selectGuidedTargetPages(scope, sourcePages, questions) {
   return (matchedTargets.length ? matchedTargets : canonicalPages).slice(0, 6);
 }
 function insightRelativePathForTarget(page, scope) {
-  const basename = path29.basename(page.path);
+  const basename = path30.basename(page.path);
   if (page.kind === "concept") {
     return `insights/concepts/${basename}`;
   }
@@ -28323,7 +28649,7 @@ async function stageSourceReviewForScope(rootDir, scope) {
   return {
     sourceId: scope.id,
     pageId: output.page.id,
-    reviewPath: path29.join(approval.approvalDir, "wiki", output.page.path),
+    reviewPath: path30.join(approval.approvalDir, "wiki", output.page.path),
     staged: true,
     approvalId: approval.approvalId,
     approvalDir: approval.approvalDir
@@ -28390,7 +28716,7 @@ async function buildSourceSessionSavedPage(rootDir, scope, session) {
   const evidenceState = contradictions.length > 0 ? "conflicting" : session.targetedPagePaths.some(
     (targetPath) => sourcePages.some((page) => page.path === targetPath && page.sourceIds.some((sourceId) => !scope.sourceIds.includes(sourceId)))
   ) ? "reinforcing" : session.targetedPagePaths.length ? "new" : "needs_judgment";
-  const relativeBriefPath = session.briefPath && path29.isAbsolute(session.briefPath) ? path29.relative(paths.wikiDir, session.briefPath) : session.briefPath;
+  const relativeBriefPath = session.briefPath && path30.isAbsolute(session.briefPath) ? path30.relative(paths.wikiDir, session.briefPath) : session.briefPath;
   const sessionMarkdown = [
     `# Guided Session: ${scope.title}`,
     "",
@@ -28473,9 +28799,9 @@ async function buildSourceSessionSavedPage(rootDir, scope, session) {
 async function persistSourceSessionPage(rootDir, scope, session) {
   const { paths } = await loadVaultConfig(rootDir);
   const output = await buildSourceSessionSavedPage(rootDir, scope, session);
-  const absolutePath = path29.join(paths.wikiDir, output.page.path);
-  await ensureDir(path29.dirname(absolutePath));
-  await fs25.writeFile(absolutePath, output.content, "utf8");
+  const absolutePath = path30.join(paths.wikiDir, output.page.path);
+  await ensureDir(path30.dirname(absolutePath));
+  await fs26.writeFile(absolutePath, output.content, "utf8");
   return { pageId: output.page.id, sessionPath: absolutePath };
 }
 async function buildGuidedUpdatePages(rootDir, scope, session) {
@@ -28503,9 +28829,9 @@ async function buildGuidedUpdatePages(rootDir, scope, session) {
     targetPages.map(async (targetPage) => {
       const evidenceState = classifyGuidedEvidenceState(scope, targetPage, contradictions);
       const relativePath = useCanonicalTargets && targetPage ? targetPage.path : targetPage ? insightRelativePathForTarget(targetPage, scope) : `insights/topics/${slugify(scope.title)}.md`;
-      const absolutePath = path29.join(paths.wikiDir, relativePath);
-      const existingContent = await fileExists(absolutePath) ? await fs25.readFile(absolutePath, "utf8") : "";
-      const parsed = existingContent ? matter13(existingContent) : { data: {}, content: "" };
+      const absolutePath = path30.join(paths.wikiDir, relativePath);
+      const existingContent = await fileExists(absolutePath) ? await fs26.readFile(absolutePath, "utf8") : "";
+      const parsed = existingContent ? matter14(existingContent) : { data: {}, content: "" };
       const existingData = parsed.data;
       const existingSourceIds = Array.isArray(existingData.source_ids) ? existingData.source_ids.filter((value) => typeof value === "string") : [];
       const existingProjectIds = Array.isArray(existingData.project_ids) ? existingData.project_ids.filter((value) => typeof value === "string") : [];
@@ -28566,7 +28892,7 @@ async function buildGuidedUpdatePages(rootDir, scope, session) {
         ""
       ].join("\n");
       const nextBody = replaceMarkedSection(baseBody, scope.id, updateBlock);
-      const content = matter13.stringify(
+      const content = matter14.stringify(
         `${nextBody.trimEnd()}
 `,
         JSON.parse(
@@ -28675,8 +29001,8 @@ async function stageSourceGuideForScope(rootDir, scope, options = {}) {
     }
   );
   session.status = "staged";
-  session.reviewPath = path29.join(approval.approvalDir, "wiki", reviewOutput.page.path);
-  session.guidePath = path29.join(approval.approvalDir, "wiki", guideOutput.page.path);
+  session.reviewPath = path30.join(approval.approvalDir, "wiki", reviewOutput.page.path);
+  session.guidePath = path30.join(approval.approvalDir, "wiki", guideOutput.page.path);
   session.approvalId = approval.approvalId;
   session.approvalDir = approval.approvalDir;
   const persisted = await persistSourceSessionPage(rootDir, scope, session);
@@ -28814,7 +29140,7 @@ async function addManagedSource(rootDir, input, options = {}) {
   const existing = sources.find((candidate) => matchesManagedSourceSpec(candidate, resolved));
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const source = existing ?? {
-    id: resolved.kind === "directory" || resolved.kind === "file" ? stableManagedSourceId(resolved.kind, path29.resolve(resolved.path), resolved.title) : stableManagedSourceId(resolved.kind, resolved.url, resolved.title),
+    id: resolved.kind === "directory" || resolved.kind === "file" ? stableManagedSourceId(resolved.kind, path30.resolve(resolved.path), resolved.title) : stableManagedSourceId(resolved.kind, resolved.url, resolved.title),
     kind: resolved.kind,
     title: resolved.title,
     path: resolved.kind === "directory" || resolved.kind === "file" ? resolved.path : void 0,
@@ -28942,7 +29268,7 @@ async function deleteManagedSource(rootDir, id) {
     sources.filter((source) => source.id !== id)
   );
   const workingDir = await managedSourceWorkingDir(rootDir, id);
-  await fs25.rm(workingDir, { recursive: true, force: true });
+  await fs26.rm(workingDir, { recursive: true, force: true });
   return { removed: target };
 }
 
@@ -28950,11 +29276,11 @@ async function deleteManagedSource(rootDir, id) {
 import { execFile as execFile2 } from "child_process";
 import { randomUUID } from "crypto";
 import { EventEmitter } from "events";
-import fs26 from "fs/promises";
+import fs27 from "fs/promises";
 import http from "http";
-import path30 from "path";
+import path31 from "path";
 import { promisify as promisify2 } from "util";
-import matter14 from "gray-matter";
+import matter15 from "gray-matter";
 import mime2 from "mime-types";
 
 // src/graph-presentation.ts
@@ -29106,7 +29432,7 @@ function toViewerLintFindings(findings) {
 var execFileAsync2 = promisify2(execFile2);
 async function isReadableFile(absolutePath) {
   try {
-    const stats = await fs26.stat(absolutePath);
+    const stats = await fs27.stat(absolutePath);
     return stats.isFile();
   } catch {
     return false;
@@ -29117,15 +29443,15 @@ async function readViewerPage(rootDir, relativePath) {
     return null;
   }
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path30.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path31.resolve(paths.wikiDir, relativePath);
   if (!isPathWithin(paths.wikiDir, absolutePath) || !await isReadableFile(absolutePath)) {
     return null;
   }
-  const raw = await fs26.readFile(absolutePath, "utf8");
-  const parsed = matter14(raw);
+  const raw = await fs27.readFile(absolutePath, "utf8");
+  const parsed = matter15(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path30.basename(relativePath, path30.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path31.basename(relativePath, path31.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -29136,12 +29462,12 @@ async function readViewerAsset(rootDir, relativePath) {
     return null;
   }
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path30.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path31.resolve(paths.wikiDir, relativePath);
   if (!isPathWithin(paths.wikiDir, absolutePath) || !await isReadableFile(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs26.readFile(absolutePath),
+    buffer: await fs27.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -29164,12 +29490,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path30.join(viewerDistDir, "index.html");
+  const indexPath = path31.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path30.dirname(viewerDistDir);
-  if (await fileExists(path30.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path31.dirname(viewerDistDir);
+  if (await fileExists(path31.join(viewerProjectDir, "package.json"))) {
     await execFileAsync2("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -29192,7 +29518,7 @@ async function startGraphServer(rootDir, port, options = {}) {
           response.end(JSON.stringify({ error: "Graph artifact not found. Run `swarmvault compile` first." }));
           return;
         }
-        const reportPath = path30.join(paths.wikiDir, "graph", "report.json");
+        const reportPath = path31.join(paths.wikiDir, "graph", "report.json");
         const report = await readJsonFile(reportPath) ?? null;
         response.writeHead(200, { "content-type": "application/json" });
         response.end(JSON.stringify(buildViewerGraphArtifact(graph, { report, full: options.full ?? false })));
@@ -29256,13 +29582,13 @@ async function startGraphServer(rootDir, port, options = {}) {
         return;
       }
       if (url.pathname === "/api/graph-report") {
-        const reportPath = path30.join(paths.wikiDir, "graph", "report.json");
+        const reportPath = path31.join(paths.wikiDir, "graph", "report.json");
         if (!await fileExists(reportPath)) {
           response.writeHead(404, { "content-type": "application/json" });
           response.end(JSON.stringify({ error: "Graph report artifact not found. Run `swarmvault compile` first." }));
           return;
         }
-        const body = await fs26.readFile(reportPath, "utf8");
+        const body = await fs27.readFile(reportPath, "utf8");
         response.writeHead(200, { "content-type": "application/json" });
         response.end(body);
         return;
@@ -29363,7 +29689,7 @@ async function startGraphServer(rootDir, port, options = {}) {
         return;
       }
       if (url.pathname === "/api/workspace") {
-        const reportPath = path30.join(paths.wikiDir, "graph", "report.json");
+        const reportPath = path31.join(paths.wikiDir, "graph", "report.json");
         const [graphRaw, reportRaw, approvalsRaw, candidatesRaw, watchStatusRaw, lintRaw] = await Promise.all([
           readJsonFile(paths.graphPath).catch(() => null),
           readJsonFile(reportPath).catch(() => null),
@@ -29459,15 +29785,15 @@ async function startGraphServer(rootDir, port, options = {}) {
         return;
       }
       const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-      const target = path30.join(paths.viewerDistDir, relativePath);
-      const fallback = path30.join(paths.viewerDistDir, "index.html");
+      const target = path31.join(paths.viewerDistDir, relativePath);
+      const fallback = path31.join(paths.viewerDistDir, "index.html");
       const filePath = await fileExists(target) ? target : fallback;
       if (!await fileExists(filePath)) {
         response.writeHead(503, { "content-type": "text/plain" });
         response.end("Viewer build not found. Run `pnpm build` first.");
         return;
       }
-      const staticBody = await fs26.readFile(filePath);
+      const staticBody = await fs27.readFile(filePath);
       response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
       response.end(staticBody);
     } catch (error) {
@@ -29507,7 +29833,7 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path30.join(paths.viewerDistDir, "index.html");
+  const indexPath = path31.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -29533,17 +29859,17 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
       } : null;
     })
   );
-  const rawHtml = await fs26.readFile(indexPath, "utf8");
+  const rawHtml = await fs27.readFile(indexPath, "utf8");
   const scriptMatch = rawHtml.match(/<script type="module" crossorigin src="([^"]+)"><\/script>/);
   const styleMatch = rawHtml.match(/<link rel="stylesheet" crossorigin href="([^"]+)">/);
-  const scriptPath = scriptMatch?.[1] ? path30.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path30.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path31.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path31.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
   if (!scriptPath || !await fileExists(scriptPath)) {
     throw new Error("Viewer script bundle not found. Run `pnpm build` first.");
   }
-  const script = await fs26.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs26.readFile(stylePath, "utf8") : "";
-  const report = await readJsonFile(path30.join(paths.wikiDir, "graph", "report.json"));
+  const script = await fs27.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs27.readFile(stylePath, "utf8") : "";
+  const report = await readJsonFile(path31.join(paths.wikiDir, "graph", "report.json"));
   const embeddedData = JSON.stringify(
     { graph: buildViewerGraphArtifact(graph, { report, full: options.full ?? false }), pages: pages.filter(Boolean), report },
     null,
@@ -29566,11 +29892,12 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs26.mkdir(path30.dirname(outputPath), { recursive: true });
-  await fs26.writeFile(outputPath, html, "utf8");
-  return path30.resolve(outputPath);
+  await fs27.mkdir(path31.dirname(outputPath), { recursive: true });
+  await fs27.writeFile(outputPath, html, "utf8");
+  return path31.resolve(outputPath);
 }
 export {
+  ALL_MIGRATIONS,
   DEFAULT_CONSOLIDATION_CONFIG,
   DEFAULT_HALF_LIFE_DAYS,
   DEFAULT_HALF_LIFE_DAYS_BY_SOURCE_CLASS,
@@ -29578,6 +29905,7 @@ export {
   DEFAULT_REDACTION_PATTERNS,
   DEFAULT_STALE_THRESHOLD,
   LARGE_REPO_NODE_THRESHOLD,
+  OPENAI_COMPATIBLE_CAPABILITY_MATRIX,
   acceptApproval,
   addInput,
   addManagedSource,
@@ -29602,6 +29930,7 @@ export {
   defaultVaultConfig,
   defaultVaultSchema,
   deleteManagedSource,
+  detectVaultVersion,
   estimatePageTokens,
   estimateTokens,
   evaluateCandidateForPromotion,
@@ -29643,9 +29972,11 @@ export {
   loadVaultConfig,
   loadVaultSchema,
   loadVaultSchemas,
+  lookupPresetCapabilities,
   markSuperseded,
   pathGraphVault,
   persistDecayFrontmatter,
+  planMigration,
   previewCandidatePromotions,
   promoteCandidate,
   pushGraphNeo4j,
@@ -29671,6 +30002,7 @@ export {
   runAutoPromotion,
   runConsolidation,
   runDecayPass,
+  runMigration,
   runSchedule,
   runWatchCycle,
   searchVault,
@@ -29683,5 +30015,6 @@ export {
   synthesizeHyperedgeHubs,
   trimToTokenBudget,
   uninstallGitHooks,
-  watchVault
+  watchVault,
+  withCapabilityFallback
 };