@swarmvaultai/engine 3.11.0 → 3.12.0

package/dist/index.js

@@ -128,7 +128,7 @@ import {
   writeGuidedSourceSession,
   writeRetrievalManifest,
   writeWatchStatusArtifact
-} from "./chunk-2PN46RDI.js";
+} from "./chunk-Z552HHPV.js";
 import {
   LocalWhisperProviderAdapter,
   SWARMVAULT_OUT_ENV,
@@ -148,6 +148,7 @@ import {
   readJsonFile,
   resolveArtifactRootDir,
   resolvePaths,
+  safeFrontmatter,
   sha256,
   slugify,
   toPosix,
@@ -161,6 +162,323 @@ import {
   trimToTokenBudget
 } from "./chunk-NAIERP4C.js";
 
+// src/ai-export.ts
+import fs from "fs/promises";
+import path from "path";
+import matter from "gray-matter";
+var DEFAULT_MAX_FULL_CHARS = 5e6;
+var MAX_INDEX_EXCERPT_CHARS = 220;
+function relativeOutputPath(outputDir, filePath) {
+  return toPosix(path.relative(outputDir, filePath));
+}
+async function writeTrackedText(files, outputDir, kind, filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf8");
+  files.push({
+    kind,
+    path: relativeOutputPath(outputDir, filePath),
+    bytes: Buffer.byteLength(content),
+    sha256: sha256(content)
+  });
+}
+async function writeTrackedJson(files, outputDir, kind, filePath, value) {
+  const content = `${JSON.stringify(value, null, 2)}
+`;
+  await writeTrackedText(files, outputDir, kind, filePath, content);
+}
+function graphPathForNode(nodeId) {
+  return `swarmvault:node:${encodeURIComponent(nodeId)}`;
+}
+function graphPathForPage(pageId) {
+  return `swarmvault:page:${encodeURIComponent(pageId)}`;
+}
+function renderPageLine(page) {
+  const excerpt = truncate(normalizeWhitespace(page.body.replace(/^---[\s\S]*?---/, "")), MAX_INDEX_EXCERPT_CHARS);
+  const bits = [
+    `- ${page.graphPage.title} (${page.graphPage.kind}, ${page.graphPage.freshness})`,
+    `  - path: wiki/${page.graphPage.path}`,
+    `  - page_id: ${page.graphPage.id}`,
+    page.graphPage.sourceIds.length ? `  - sources: ${page.graphPage.sourceIds.slice(0, 6).join(", ")}` : void 0,
+    excerpt ? `  - excerpt: ${excerpt}` : void 0
+  ].filter((line) => Boolean(line));
+  return bits.join("\n");
+}
+function renderLlmsIndex(input) {
+  const topPages = [...input.pages].sort(
+    (left, right) => right.graphPage.confidence - left.graphPage.confidence || right.graphPage.relatedPageIds.length - left.graphPage.relatedPageIds.length || left.graphPage.path.localeCompare(right.graphPage.path)
+  ).slice(0, 80);
+  const communities = (input.graph.communities ?? []).slice(0, 20).map((community) => `- ${community.label} (${community.nodeIds.length} nodes)`).join("\n");
+  return [
+    "# SwarmVault AI Index",
+    "",
+    `Generated: ${input.generatedAt}`,
+    `Vault: ${input.vaultName}`,
+    "",
+    "## Use This Export",
+    "",
+    "- Start with `ai-readme.md` for navigation guidance.",
+    "- Use `llms-full.txt` when an agent needs a bounded plain-text dump of the compiled wiki.",
+    "- Use `graph.jsonld` when an agent or crawler needs a structured page/node/relation graph.",
+    "- Use `pages/` for per-page `.txt` and `.json` siblings when `--page-siblings` is enabled.",
+    "",
+    "## Counts",
+    "",
+    `- Sources: ${input.graph.sources.length}`,
+    `- Pages: ${input.graph.pages.length}`,
+    `- Nodes: ${input.graph.nodes.length}`,
+    `- Edges: ${input.graph.edges.length}`,
+    `- Hyperedges: ${input.graph.hyperedges.length}`,
+    "",
+    "## Commands",
+    "",
+    '- `swarmvault query "question"` asks the compiled wiki.',
+    '- `swarmvault chat "question"` keeps a persisted multi-turn session.',
+    '- `swarmvault context build "goal" --target <path>` creates a token-bounded handoff.',
+    "- `swarmvault graph serve` opens the workbench and graph viewer.",
+    "- `swarmvault doctor` checks graph, retrieval, review, watch, and task state.",
+    "",
+    communities ? "## Communities" : void 0,
+    communities || void 0,
+    "",
+    "## High-Signal Pages",
+    "",
+    topPages.map(renderPageLine).join("\n\n")
+  ].filter((line) => line !== void 0).join("\n").trimEnd().concat("\n");
+}
+function renderAiReadme(input) {
+  return [
+    "# AI Handoff Pack",
+    "",
+    `Generated: ${input.generatedAt}`,
+    `Vault: ${input.vaultName}`,
+    "",
+    "This folder is a portable, static export of the compiled SwarmVault wiki for agents, crawlers, and documentation systems.",
+    "",
+    "## Files",
+    "",
+    "- `llms.txt` - concise index with stats, command hints, communities, and high-signal pages.",
+    `- \`llms-full.txt\` - plain-text wiki dump${input.truncatedFullText ? " truncated at the requested character cap" : ""}.`,
+    "- `graph.jsonld` - structured graph with pages, nodes, sources, and relation edges.",
+    "- `manifest.json` - file list, hashes, counts, and export settings.",
+    input.pageSiblings ? "- `pages/` - per-page `.txt` and `.json` siblings for direct retrieval." : void 0,
+    "",
+    "## Suggested Agent Flow",
+    "",
+    "1. Read `llms.txt` to understand the vault shape.",
+    "2. Search `llms-full.txt` or `pages/` for the specific topic.",
+    "3. Use `graph.jsonld` to follow page, node, and relation IDs when provenance matters.",
+    "4. Ask the live vault with `swarmvault query` or continue a session with `swarmvault chat` when shell access is available."
+  ].filter((line) => line !== void 0).join("\n").trimEnd().concat("\n");
+}
+function renderFullText(input) {
+  const chunks = [
+    "# SwarmVault Full Wiki Export",
+    "",
+    `Generated: ${input.generatedAt}`,
+    `Vault: ${input.vaultName}`,
+    "",
+    "The sections below are compiled wiki pages separated by stable path markers.",
+    ""
+  ];
+  let usedChars = chunks.join("\n").length;
+  let truncated = false;
+  for (const page of input.pages) {
+    const section = [
+      "",
+      `--- PAGE: wiki/${page.graphPage.path} ---`,
+      `Title: ${page.graphPage.title}`,
+      `Page ID: ${page.graphPage.id}`,
+      `Kind: ${page.graphPage.kind}`,
+      page.graphPage.sourceIds.length ? `Source IDs: ${page.graphPage.sourceIds.join(", ")}` : void 0,
+      "",
+      page.content.trim(),
+      ""
+    ].filter((line) => line !== void 0).join("\n");
+    if (usedChars + section.length > input.maxChars) {
+      const remaining = Math.max(0, input.maxChars - usedChars);
+      if (remaining > 0) {
+        chunks.push(section.slice(0, remaining));
+      }
+      truncated = true;
+      break;
+    }
+    chunks.push(section);
+    usedChars += section.length;
+  }
+  if (truncated) {
+    chunks.push("", "[truncated: increase --max-full-chars to include more pages]");
+  }
+  return { content: chunks.join("\n").trimEnd().concat("\n"), truncated };
+}
+function buildJsonLd(input) {
+  const graphItems = [
+    {
+      "@id": "swarmvault:vault",
+      "@type": "Dataset",
+      name: input.vaultName,
+      dateModified: input.graph.generatedAt,
+      datePublished: input.generatedAt,
+      additionalType: "SwarmVaultKnowledgeGraph"
+    },
+    ...input.graph.sources.map((source) => ({
+      "@id": `swarmvault:source:${encodeURIComponent(source.sourceId)}`,
+      "@type": "CreativeWork",
+      name: source.title,
+      encodingFormat: source.mimeType,
+      dateCreated: source.createdAt,
+      dateModified: source.updatedAt,
+      url: source.url,
+      fileFormat: source.sourceKind,
+      identifier: source.sourceId
+    })),
+    ...input.graph.pages.map((page) => ({
+      "@id": graphPathForPage(page.id),
+      "@type": "CreativeWork",
+      name: page.title,
+      identifier: page.id,
+      url: `wiki/${page.path}`,
+      genre: page.kind,
+      dateCreated: page.createdAt,
+      dateModified: page.updatedAt,
+      about: page.nodeIds.map((nodeId) => ({ "@id": graphPathForNode(nodeId) })),
+      citation: page.sourceIds.map((sourceId) => ({ "@id": `swarmvault:source:${encodeURIComponent(sourceId)}` })),
+      isPartOf: { "@id": "swarmvault:vault" }
+    })),
+    ...input.graph.nodes.map((node) => ({
+      "@id": graphPathForNode(node.id),
+      "@type": "Thing",
+      name: node.label,
+      identifier: node.id,
+      additionalType: node.type,
+      isPartOf: node.pageId ? { "@id": graphPathForPage(node.pageId) } : { "@id": "swarmvault:vault" },
+      sameAs: node.sourceIds.map((sourceId) => `swarmvault:source:${encodeURIComponent(sourceId)}`)
+    })),
+    ...input.graph.edges.map((edge) => ({
+      "@id": `swarmvault:edge:${encodeURIComponent(edge.id)}`,
+      "@type": "swarmvault:Relation",
+      name: edge.relation,
+      identifier: edge.id,
+      "swarmvault:source": { "@id": graphPathForNode(edge.source) },
+      "swarmvault:target": { "@id": graphPathForNode(edge.target) },
+      "swarmvault:evidenceClass": edge.evidenceClass,
+      "swarmvault:confidence": edge.confidence,
+      "swarmvault:provenance": edge.provenance
+    }))
+  ];
+  return {
+    "@context": {
+      "@vocab": "https://schema.org/",
+      swarmvault: "https://www.swarmvault.ai/ns#"
+    },
+    "@graph": graphItems
+  };
+}
+async function loadPages(rootDir, wikiDir, graph) {
+  const pages = [];
+  const sortedPages = [...graph.pages].sort((left, right) => left.path.localeCompare(right.path));
+  for (const graphPage of sortedPages) {
+    const absolutePath = path.join(wikiDir, graphPage.path);
+    if (!await fileExists(absolutePath)) {
+      continue;
+    }
+    const content = await fs.readFile(absolutePath, "utf8");
+    const parsed = matter(content);
+    pages.push({
+      graphPage,
+      absolutePath: path.resolve(rootDir, absolutePath),
+      content,
+      body: parsed.content,
+      data: parsed.data
+    });
+  }
+  return pages;
+}
+async function exportAiPack(rootDir, options = {}) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
+  }
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const vaultName = path.basename(paths.rootDir);
+  const outputDir = path.resolve(rootDir, options.outDir ?? path.join("wiki", "exports", "ai"));
+  const maxFullChars = Math.max(1e3, options.maxFullChars ?? DEFAULT_MAX_FULL_CHARS);
+  const pageSiblings = options.pageSiblings ?? true;
+  await ensureDir(outputDir);
+  const pages = await loadPages(rootDir, paths.wikiDir, graph);
+  const files = [];
+  const fullText = renderFullText({ generatedAt, vaultName, pages, maxChars: maxFullChars });
+  await writeTrackedText(
+    files,
+    outputDir,
+    "index",
+    path.join(outputDir, "llms.txt"),
+    renderLlmsIndex({ generatedAt, vaultName, graph, pages })
+  );
+  await writeTrackedText(files, outputDir, "full-text", path.join(outputDir, "llms-full.txt"), fullText.content);
+  await writeTrackedJson(
+    files,
+    outputDir,
+    "graph-jsonld",
+    path.join(outputDir, "graph.jsonld"),
+    buildJsonLd({ generatedAt, vaultName, graph })
+  );
+  await writeTrackedText(
+    files,
+    outputDir,
+    "readme",
+    path.join(outputDir, "ai-readme.md"),
+    renderAiReadme({ generatedAt, vaultName, truncatedFullText: fullText.truncated, pageSiblings })
+  );
+  if (pageSiblings) {
+    for (const page of pages) {
+      const siblingBase = path.join(outputDir, "pages", page.graphPage.path.replace(/\.md$/u, ""));
+      await writeTrackedText(files, outputDir, "page-text", `${siblingBase}.txt`, page.body.trim().concat("\n"));
+      await writeTrackedJson(files, outputDir, "page-json", `${siblingBase}.json`, {
+        title: page.graphPage.title,
+        path: page.graphPage.path,
+        pageId: page.graphPage.id,
+        kind: page.graphPage.kind,
+        freshness: page.graphPage.freshness,
+        confidence: page.graphPage.confidence,
+        sourceIds: page.graphPage.sourceIds,
+        nodeIds: page.graphPage.nodeIds,
+        relatedPageIds: page.graphPage.relatedPageIds,
+        relatedNodeIds: page.graphPage.relatedNodeIds,
+        frontmatter: page.data,
+        body: page.body.trim(),
+        contentSha256: sha256(page.content)
+      });
+    }
+  }
+  const result = {
+    outputDir,
+    generatedAt,
+    pageCount: graph.pages.length,
+    sourceCount: graph.sources.length,
+    nodeCount: graph.nodes.length,
+    edgeCount: graph.edges.length,
+    truncatedFullText: fullText.truncated,
+    files
+  };
+  const manifestPath = path.join(outputDir, "manifest.json");
+  await writeJsonFile(manifestPath, {
+    ...result,
+    files: [...files].sort((left, right) => left.path.localeCompare(right.path))
+  });
+  const manifestContent = await fs.readFile(manifestPath, "utf8");
+  files.push({
+    kind: "manifest",
+    path: relativeOutputPath(outputDir, manifestPath),
+    bytes: Buffer.byteLength(manifestContent),
+    sha256: sha256(manifestContent)
+  });
+  return {
+    ...result,
+    files: [...files].sort((left, right) => left.path.localeCompare(right.path))
+  };
+}
+
 // src/auto-commit.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -198,25 +516,235 @@ async function autoCommitWikiChanges(rootDir, operation, detail, options) {
   return message;
 }
 
+// src/chat.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import matter2 from "gray-matter";
+var DEFAULT_HISTORY_TURNS = 6;
+function timestampIdPrefix() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/u, "Z").replace("T", "-");
+}
+function chatDirs(paths) {
+  return {
+    stateDir: path2.join(paths.stateDir, "chat-sessions"),
+    wikiDir: path2.join(paths.wikiDir, "outputs", "chat-sessions")
+  };
+}
+function sessionStatePath(stateDir, id) {
+  return path2.join(stateDir, `${id}.json`);
+}
+function sessionMarkdownPath(wikiDir, id) {
+  return path2.join(wikiDir, `${id}.md`);
+}
+function summarizeSession(session) {
+  return {
+    id: session.id,
+    title: session.title,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    turnCount: session.turns.length,
+    markdownPath: session.markdownPath
+  };
+}
+function renderSessionMarkdown(session) {
+  const body = [
+    `# ${session.title}`,
+    "",
+    `Session ID: \`${session.id}\``,
+    `Updated: ${session.updatedAt}`,
+    "",
+    ...session.turns.flatMap((turn, index) => [
+      `## Turn ${index + 1} - ${turn.createdAt}`,
+      "",
+      "### Question",
+      "",
+      turn.question,
+      "",
+      "### Answer",
+      "",
+      turn.answer,
+      "",
+      turn.citations.length ? "### Citations" : void 0,
+      turn.citations.length ? "" : void 0,
+      ...turn.citations.map((citation) => `- ${citation}`),
+      turn.savedPath ? "" : void 0,
+      turn.savedPath ? `Saved output: \`${turn.savedPath}\`` : void 0,
+      ""
+    ])
+  ].filter((line) => line !== void 0).join("\n");
+  return matter2.stringify(
+    body,
+    safeFrontmatter({
+      session_id: session.id,
+      title: session.title,
+      created_at: session.createdAt,
+      updated_at: session.updatedAt,
+      turn_count: session.turns.length,
+      page_id: `chat:${session.id}`,
+      freshness: "fresh",
+      node_ids: [],
+      source_ids: [],
+      source_hashes: {}
+    })
+  );
+}
+async function persistSession(session, stateDir, wikiDir) {
+  await ensureDir(stateDir);
+  await ensureDir(wikiDir);
+  const statePath = sessionStatePath(stateDir, session.id);
+  const markdownPath = sessionMarkdownPath(wikiDir, session.id);
+  const persisted = { ...session, markdownPath };
+  await writeJsonFile(statePath, persisted);
+  await fs2.writeFile(markdownPath, renderSessionMarkdown(persisted), "utf8");
+  return { statePath, markdownPath };
+}
+async function resolveSessionId(stateDir, idOrPrefix) {
+  const direct = sessionStatePath(stateDir, idOrPrefix);
+  if (await fileExists(direct)) {
+    return idOrPrefix;
+  }
+  const entries = await fs2.readdir(stateDir).catch(() => []);
+  const matches = entries.filter((entry) => entry.endsWith(".json")).map((entry) => entry.slice(0, -".json".length)).filter((id) => id.startsWith(idOrPrefix));
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length > 1) {
+    throw new Error(`Chat session prefix "${idOrPrefix}" is ambiguous: ${matches.slice(0, 8).join(", ")}`);
+  }
+  throw new Error(`Chat session not found: ${idOrPrefix}`);
+}
+async function loadSession(stateDir, idOrPrefix) {
+  const id = await resolveSessionId(stateDir, idOrPrefix);
+  const session = await readJsonFile(sessionStatePath(stateDir, id));
+  if (!session) {
+    throw new Error(`Chat session not found: ${id}`);
+  }
+  return session;
+}
+function createSession(rootDir, wikiDir, options, now) {
+  const title = truncate(options.title?.trim() || normalizeWhitespace(options.question), 80);
+  const id = `${timestampIdPrefix()}-${slugify(title)}`;
+  return {
+    id,
+    title,
+    createdAt: now,
+    updatedAt: now,
+    rootDir,
+    markdownPath: sessionMarkdownPath(wikiDir, id),
+    turns: []
+  };
+}
+function buildPrompt(session, question, maxHistoryTurns) {
+  const recentTurns = session.turns.slice(-maxHistoryTurns);
+  if (!recentTurns.length) {
+    return question;
+  }
+  const history = recentTurns.map(
+    (turn, index) => [
+      `Turn ${index + 1}`,
+      `User: ${turn.question}`,
+      `Assistant: ${truncate(normalizeWhitespace(turn.answer), 1200)}`,
+      turn.citations.length ? `Citations: ${turn.citations.join(", ")}` : void 0
+    ].filter((line) => line !== void 0).join("\n")
+  ).join("\n\n");
+  return [
+    "Continue this SwarmVault chat session using the compiled wiki as the source of truth.",
+    "Use prior turns only for conversational continuity. Prefer current vault evidence over prior wording.",
+    "",
+    "Prior turns:",
+    history,
+    "",
+    "Current question:",
+    question
+  ].join("\n");
+}
+async function listChatSessions(rootDir) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const { stateDir } = chatDirs(paths);
+  const entries = await fs2.readdir(stateDir).catch(() => []);
+  const sessions = await Promise.all(
+    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readJsonFile(path2.join(stateDir, entry)))
+  );
+  return sessions.filter((session) => Boolean(session)).map(summarizeSession).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+async function readChatSession(rootDir, idOrPrefix) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const { stateDir } = chatDirs(paths);
+  return loadSession(stateDir, idOrPrefix);
+}
+async function deleteChatSession(rootDir, idOrPrefix) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const { stateDir, wikiDir } = chatDirs(paths);
+  const session = await loadSession(stateDir, idOrPrefix);
+  await fs2.rm(sessionStatePath(stateDir, session.id), { force: true });
+  await fs2.rm(sessionMarkdownPath(wikiDir, session.id), { force: true });
+  return summarizeSession(session);
+}
+async function askChatSession(rootDir, options) {
+  const question = normalizeWhitespace(options.question);
+  if (!question) {
+    throw new Error("Chat question is required.");
+  }
+  const { paths } = await loadVaultConfig(rootDir);
+  const { stateDir, wikiDir } = chatDirs(paths);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const resumed = Boolean(options.sessionId);
+  const session = options.sessionId ? await loadSession(stateDir, options.sessionId) : createSession(paths.rootDir, wikiDir, options, now);
+  const prompt = buildPrompt(session, question, Math.max(0, options.maxHistoryTurns ?? DEFAULT_HISTORY_TURNS));
+  const query = await queryVault(paths.rootDir, {
+    question: prompt,
+    save: options.saveOutput ?? false,
+    format: options.format,
+    gapFill: options.gapFill
+  });
+  const turn = {
+    id: `${session.turns.length + 1}`,
+    createdAt: now,
+    question,
+    answer: query.answer,
+    citations: query.citations,
+    relatedPageIds: query.relatedPageIds,
+    relatedNodeIds: query.relatedNodeIds,
+    relatedSourceIds: query.relatedSourceIds,
+    outputFormat: query.outputFormat,
+    savedPath: query.savedPath
+  };
+  const updatedSession = {
+    ...session,
+    updatedAt: now,
+    markdownPath: sessionMarkdownPath(wikiDir, session.id),
+    turns: [...session.turns, turn]
+  };
+  const persisted = await persistSession(updatedSession, stateDir, wikiDir);
+  return {
+    session: { ...updatedSession, markdownPath: persisted.markdownPath },
+    turn,
+    answer: query.answer,
+    markdownPath: persisted.markdownPath,
+    statePath: persisted.statePath,
+    resumed
+  };
+}
+
 // src/doctor.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 
 // src/migrate.ts
-import fs from "fs/promises";
-import path from "path";
-import matter from "gray-matter";
+import fs3 from "fs/promises";
+import path3 from "path";
+import matter3 from "gray-matter";
 var VAULT_VERSION_FILENAME = "vault-version.json";
 async function walkMarkdownFiles(dir) {
   const results = [];
   let entries;
   try {
-    entries = await fs.readdir(dir, { withFileTypes: true });
+    entries = await fs3.readdir(dir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const entry of entries) {
-    const full = path.join(dir, entry.name);
+    const full = path3.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...await walkMarkdownFiles(full));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -227,8 +755,8 @@ async function walkMarkdownFiles(dir) {
 }
 async function readFrontmatterFile(filePath) {
   try {
-    const raw = await fs.readFile(filePath, "utf8");
-    const parsed = matter(raw);
+    const raw = await fs3.readFile(filePath, "utf8");
+    const parsed = matter3(raw);
     const data = parsed.data ?? {};
     return { data, content: parsed.content };
   } catch {
@@ -236,10 +764,10 @@ async function readFrontmatterFile(filePath) {
   }
 }
 async function writeFrontmatterFile(filePath, data, content) {
-  await fs.writeFile(filePath, matter.stringify(content, data), "utf8");
+  await fs3.writeFile(filePath, matter3.stringify(content, data), "utf8");
 }
 function relFromRoot(rootDir, filePath) {
-  return path.relative(rootDir, filePath) || filePath;
+  return path3.relative(rootDir, filePath) || filePath;
 }
 var MIGRATION_ADD_DECAY_FIELDS = {
   id: "0.9-to-0.10-add-decay-fields",
@@ -280,7 +808,7 @@ var MIGRATION_ADD_TIER_DEFAULT = {
   description: 'Tag insight pages with tier: "working" when the field is absent.',
   async apply(ctx, options) {
     const changed = [];
-    const insightsDir = path.join(ctx.paths.wikiDir, "insights");
+    const insightsDir = path3.join(ctx.paths.wikiDir, "insights");
     const files = await walkMarkdownFiles(insightsDir);
     for (const filePath of files) {
       const parsed = await readFrontmatterFile(filePath);
@@ -337,11 +865,11 @@ var MIGRATION_REBUILD_SEARCH_INDEX = {
   description: "Mark state/search.sqlite as stale so the next compile regenerates it.",
   async apply(ctx, options) {
     const changed = [];
-    const searchPath = path.join(ctx.paths.stateDir, "search.sqlite");
+    const searchPath = path3.join(ctx.paths.stateDir, "search.sqlite");
     try {
-      await fs.access(searchPath);
+      await fs3.access(searchPath);
       if (!options.dryRun) {
-        await fs.rm(searchPath, { force: true });
+        await fs3.rm(searchPath, { force: true });
       }
       changed.push(relFromRoot(ctx.rootDir, searchPath));
     } catch {
@@ -358,8 +886,8 @@ var MIGRATION_ADD_MEMORY_LEDGER = {
     if (options.dryRun) {
       return {
         changed: [
-          relFromRoot(ctx.rootDir, path.join(ctx.paths.stateDir, "memory", "tasks")),
-          relFromRoot(ctx.rootDir, path.join(ctx.paths.wikiDir, "memory", "index.md"))
+          relFromRoot(ctx.rootDir, path3.join(ctx.paths.stateDir, "memory", "tasks")),
+          relFromRoot(ctx.rootDir, path3.join(ctx.paths.wikiDir, "memory", "index.md"))
         ]
       };
     }
@@ -373,9 +901,9 @@ var MIGRATION_3_0_RETRIEVAL_AND_TASKS = {
   description: "Move search config into retrieval, create state/retrieval, remove the legacy search index, and add task aliases to memory frontmatter.",
   async apply(ctx, options) {
     const changed = [];
-    const configPath = path.join(ctx.rootDir, "swarmvault.config.json");
+    const configPath = path3.join(ctx.rootDir, "swarmvault.config.json");
     try {
-      const raw = await fs.readFile(configPath, "utf8");
+      const raw = await fs3.readFile(configPath, "utf8");
       const config = JSON.parse(raw);
       let mutated = false;
       if (config.search) {
@@ -401,28 +929,28 @@ var MIGRATION_3_0_RETRIEVAL_AND_TASKS = {
       }
       if (mutated) {
         if (!options.dryRun) {
-          await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+          await fs3.writeFile(configPath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
         }
         changed.push(relFromRoot(ctx.rootDir, configPath));
       }
     } catch {
     }
-    const retrievalDir = path.join(ctx.paths.stateDir, "retrieval");
+    const retrievalDir = path3.join(ctx.paths.stateDir, "retrieval");
     if (!options.dryRun) {
       await ensureDir(retrievalDir);
     }
     changed.push(relFromRoot(ctx.rootDir, retrievalDir));
-    const legacySearchPath = path.join(ctx.paths.stateDir, "search.sqlite");
+    const legacySearchPath = path3.join(ctx.paths.stateDir, "search.sqlite");
     try {
-      await fs.access(legacySearchPath);
+      await fs3.access(legacySearchPath);
       if (!options.dryRun) {
-        await fs.rm(legacySearchPath, { force: true });
+        await fs3.rm(legacySearchPath, { force: true });
       }
       changed.push(relFromRoot(ctx.rootDir, legacySearchPath));
     } catch {
     }
-    const memoryTaskDir = path.join(ctx.paths.wikiDir, "memory", "tasks");
+    const memoryTaskDir = path3.join(ctx.paths.wikiDir, "memory", "tasks");
     const files = await walkMarkdownFiles(memoryTaskDir);
     for (const filePath of files) {
       const parsed = await readFrontmatterFile(filePath);
@@ -471,9 +999,9 @@ function compareSemver(a, b) {
   return 0;
 }
 async function readVaultVersionRecord(stateDir) {
-  const filePath = path.join(stateDir, VAULT_VERSION_FILENAME);
+  const filePath = path3.join(stateDir, VAULT_VERSION_FILENAME);
   try {
-    const raw = await fs.readFile(filePath, "utf8");
+    const raw = await fs3.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version === "string") return parsed;
     return null;
@@ -482,9 +1010,9 @@ async function readVaultVersionRecord(stateDir) {
   }
 }
 async function readGraphVersion(stateDir) {
-  const filePath = path.join(stateDir, "graph.json");
+  const filePath = path3.join(stateDir, "graph.json");
   try {
-    const raw = await fs.readFile(filePath, "utf8");
+    const raw = await fs3.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     const version = parsed?.generatedBy?.version;
     return typeof version === "string" ? version : null;
@@ -502,7 +1030,7 @@ async function detectVaultVersion(rootDir) {
 }
 async function currentPackageVersion() {
   try {
-    const raw = await fs.readFile(new URL("../package.json", import.meta.url), "utf8");
+    const raw = await fs3.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 {
@@ -519,8 +1047,8 @@ async function planMigration(rootDir, targetVersion) {
   return { fromVersion, toVersion, steps };
 }
 async function writeVaultVersionRecord(stateDir, record) {
-  await fs.mkdir(stateDir, { recursive: true });
-  await fs.writeFile(path.join(stateDir, VAULT_VERSION_FILENAME), `${JSON.stringify(record, null, 2)}
+  await fs3.mkdir(stateDir, { recursive: true });
+  await fs3.writeFile(path3.join(stateDir, VAULT_VERSION_FILENAME), `${JSON.stringify(record, null, 2)}
 `, "utf8");
 }
 async function runMigration(rootDir, options = {}) {
@@ -559,8 +1087,8 @@ async function runMigration(rootDir, options = {}) {
 }
 
 // src/watch.ts
-import fs2 from "fs/promises";
-import path2 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 import process2 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
@@ -620,7 +1148,7 @@ function isCodeOnlyChange(reasons) {
   for (const reason of reasons) {
     const match = reason.match(FILE_CHANGE_RE);
     if (!match) return false;
-    const ext = path2.extname(match[1]).toLowerCase();
+    const ext = path4.extname(match[1]).toLowerCase();
     if (!ext || !CODE_EXTENSIONS.has(ext)) return false;
   }
   return reasons.size > 0;
@@ -629,7 +1157,7 @@ function hasNonCodeChanges(reasons) {
   for (const reason of reasons) {
     const match = reason.match(FILE_CHANGE_RE);
     if (!match) return true;
-    const ext = path2.extname(match[1]).toLowerCase();
+    const ext = path4.extname(match[1]).toLowerCase();
     if (!ext || !CODE_EXTENSIONS.has(ext)) return true;
   }
   return false;
@@ -642,7 +1170,7 @@ function collectNonCodePaths(reasons) {
       result.push(reason);
       continue;
     }
-    const ext = path2.extname(match[1]).toLowerCase();
+    const ext = path4.extname(match[1]).toLowerCase();
     if (!ext || !CODE_EXTENSIONS.has(ext)) result.push(match[1]);
   }
   return result;
@@ -704,11 +1232,11 @@ async function predictRemovedSourceIdsFromRepoSync(rootDir, options) {
   ];
 }
 function hasIgnoredRepoSegment(baseDir, targetPath) {
-  const relativePath = path2.relative(baseDir, targetPath);
+  const relativePath = path4.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath.split(path2.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+  return relativePath.split(path4.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
 }
 function workspaceIgnoreRoots(rootDir, paths) {
   return [
@@ -717,22 +1245,22 @@ function workspaceIgnoreRoots(rootDir, paths) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path2.join(rootDir, ".claude"),
-    path2.join(rootDir, ".cursor"),
-    path2.join(rootDir, ".obsidian")
-  ].map((candidate) => path2.resolve(candidate));
+    path4.join(rootDir, ".claude"),
+    path4.join(rootDir, ".cursor"),
+    path4.join(rootDir, ".obsidian")
+  ].map((candidate) => path4.resolve(candidate));
 }
 async function resolveWatchTargets(rootDir, paths, options) {
-  const targets = /* @__PURE__ */ new Set([path2.resolve(paths.inboxDir)]);
+  const targets = /* @__PURE__ */ new Set([path4.resolve(paths.inboxDir)]);
   if (options.repo) {
     for (const repoRoot of await resolveWatchedRepoRoots(rootDir, { overrideRoots: options.overrideRoots })) {
-      targets.add(path2.resolve(repoRoot));
+      targets.add(path4.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
 }
 function resolveRootRelative(rootDir, candidate) {
-  return path2.isAbsolute(candidate) ? path2.resolve(candidate) : path2.resolve(rootDir, candidate);
+  return path4.isAbsolute(candidate) ? path4.resolve(candidate) : path4.resolve(rootDir, candidate);
 }
 async function resolveWatchedRepoRoots(rootDir, options = {}) {
   const override = options.overrideRoots?.filter(Boolean) ?? [];
@@ -746,17 +1274,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(path2.resolve(candidate))));
+  return dedupeSorted(baseRoots.filter((candidate) => !excluded.has(path4.resolve(candidate))));
 }
 async function listWatchedRoots(rootDir, options = {}) {
   return resolveWatchedRepoRoots(rootDir, options);
 }
 function dedupeSorted(values) {
-  return [...new Set(values.map((value) => path2.resolve(value)))].sort((left, right) => left.localeCompare(right));
+  return [...new Set(values.map((value) => path4.resolve(value)))].sort((left, right) => left.localeCompare(right));
 }
 async function readConfigJson(rootDir) {
-  const configPath = path2.join(rootDir, "swarmvault.config.json");
-  const raw = await fs2.readFile(configPath, "utf8");
+  const configPath = path4.join(rootDir, "swarmvault.config.json");
+  const raw = await fs4.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.");
@@ -764,7 +1292,7 @@ async function readConfigJson(rootDir) {
   return { path: configPath, content: parsed };
 }
 async function writeConfigJson(configPath, content) {
-  await fs2.writeFile(configPath, `${JSON.stringify(content, null, 2)}
+  await fs4.writeFile(configPath, `${JSON.stringify(content, null, 2)}
 `, "utf8");
 }
 function getWatchBlock(config) {
@@ -948,7 +1476,7 @@ async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   const baseDebounceMs = options.debounceMs ?? 900;
   const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
-  const inboxWatchRoot = path2.resolve(paths.inboxDir);
+  const inboxWatchRoot = path4.resolve(paths.inboxDir);
   let watchTargets = await resolveWatchTargets(rootDir, paths, options);
   let timer;
   let running = false;
@@ -963,7 +1491,7 @@ async function watchVault(rootDir, options = {}) {
     usePolling: true,
     interval: 100,
     ignored: (targetPath) => {
-      const absolutePath = path2.resolve(targetPath);
+      const absolutePath = path4.resolve(targetPath);
       const primaryTarget = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
@@ -1165,8 +1693,8 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, path2.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
-    return path2.relative(baseDir, targetPath) || ".";
+    const baseDir = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, path4.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path4.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) => {
@@ -1239,7 +1767,7 @@ function buildRecommendations(checks) {
 }
 async function currentPackageVersion2() {
   try {
-    const raw = await fs3.readFile(new URL("../package.json", import.meta.url), "utf8");
+    const raw = await fs5.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 {
@@ -1401,7 +1929,7 @@ async function doctorVault(rootDir, options = {}) {
     ok: status === "ok",
     status,
     generatedAt,
-    rootDir: path3.resolve(rootDir),
+    rootDir: path5.resolve(rootDir),
     version,
     counts: {
       sources: manifests.length,
@@ -1422,10 +1950,10 @@ async function doctorVault(rootDir, options = {}) {
 
 // src/graph-export.ts
 import { readFileSync } from "fs";
-import fs4 from "fs/promises";
+import fs6 from "fs/promises";
 import { createRequire } from "module";
-import path4 from "path";
-import matter2 from "gray-matter";
+import path6 from "path";
+import matter4 from "gray-matter";
 
 // src/graph-interchange.ts
 function exportHyperedgeNodeId(hyperedge) {
@@ -1902,8 +2430,8 @@ var _visNetworkJs;
 function loadVisNetworkJs() {
   if (!_visNetworkJs) {
     const require2 = createRequire(import.meta.url);
-    const pkgDir = path4.dirname(require2.resolve("vis-network/package.json"));
-    _visNetworkJs = readFileSync(path4.join(pkgDir, "standalone/umd/vis-network.min.js"), "utf8");
+    const pkgDir = path6.dirname(require2.resolve("vis-network/package.json"));
+    _visNetworkJs = readFileSync(path6.join(pkgDir, "standalone/umd/vis-network.min.js"), "utf8");
   }
   return _visNetworkJs;
 }
@@ -3238,9 +3766,9 @@ async function loadGraph(rootDir) {
   return graph;
 }
 async function writeGraphExport(outputPath, content) {
-  await ensureDir(path4.dirname(outputPath));
-  await fs4.writeFile(outputPath, content, "utf8");
-  return path4.resolve(outputPath);
+  await ensureDir(path6.dirname(outputPath));
+  await fs6.writeFile(outputPath, content, "utf8");
+  return path6.resolve(outputPath);
 }
 async function exportGraphFormat(rootDir, format, outputPath) {
   const graph = await loadGraph(rootDir);
@@ -3251,7 +3779,7 @@ async function exportGraphFormat(rootDir, format, outputPath) {
 async function exportGraphReportHtml(rootDir, outputPath) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await loadGraph(rootDir);
-  const report = await readJsonFile(path4.join(paths.wikiDir, "graph", "report.json"));
+  const report = await readJsonFile(path6.join(paths.wikiDir, "graph", "report.json"));
   const html = renderGraphReportHtml(graph, report);
   const resolvedPath = await writeGraphExport(outputPath, html);
   return { format: "report", outputPath: resolvedPath };
@@ -3283,7 +3811,7 @@ function typePluralDir(nodeType) {
 function obsidianNodeSlug(node, pageById) {
   if (node.pageId) {
     const page = pageById.get(node.pageId);
-    if (page) return path4.basename(page.path, ".md");
+    if (page) return path6.basename(page.path, ".md");
   }
   return slugify(node.label);
 }
@@ -3313,14 +3841,14 @@ async function listFilesRecursive2(dir, base = "") {
   const results = [];
   let entries;
   try {
-    entries = await fs4.readdir(dir, { withFileTypes: true });
+    entries = await fs6.readdir(dir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const entry of entries) {
     const rel = base ? `${base}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      results.push(...await listFilesRecursive2(path4.join(dir, entry.name), rel));
+      results.push(...await listFilesRecursive2(path6.join(dir, entry.name), rel));
     } else {
       results.push(rel);
     }
@@ -3366,7 +3894,7 @@ function typedLinkFrontmatter(nodeIds, adjacency, nodesById, wikilinkTarget) {
 async function exportObsidianVault(rootDir, outputDir) {
   const graph = await loadGraph(rootDir);
   const { paths } = await loadVaultConfig(rootDir);
-  const resolvedOutputDir = path4.resolve(outputDir);
+  const resolvedOutputDir = path6.resolve(outputDir);
   await ensureDir(resolvedOutputDir);
   const nodesById = graphNodeById(graph);
   const pageById = graphPageById(graph);
@@ -3406,18 +3934,18 @@ async function exportObsidianVault(rootDir, outputDir) {
   const pageByPath = new Map(graph.pages.map((p) => [p.path, p]));
   for (const relPath of wikiFiles) {
     if (!relPath.endsWith(".md")) continue;
-    const srcFile = path4.join(paths.wikiDir, relPath);
-    const destFile = path4.join(resolvedOutputDir, relPath);
-    await ensureDir(path4.dirname(destFile));
+    const srcFile = path6.join(paths.wikiDir, relPath);
+    const destFile = path6.join(resolvedOutputDir, relPath);
+    await ensureDir(path6.dirname(destFile));
     let rawContent;
     try {
-      rawContent = await fs4.readFile(srcFile, "utf8");
+      rawContent = await fs6.readFile(srcFile, "utf8");
     } catch {
       continue;
     }
     const matchingPage = pageByPath.get(relPath);
     const pageNodes = matchingPage ? nodesByPageId.get(matchingPage.id) ?? [] : [];
-    const parsed = matter2(rawContent);
+    const parsed = matter4(rawContent);
     const data = parsed.data;
     if (pageNodes.length > 0) {
       const primaryNode = pageNodes[0];
@@ -3444,7 +3972,7 @@ async function exportObsidianVault(rootDir, outputDir) {
         data[relation] = links;
       }
     }
-    let outputContent = matter2.stringify(parsed.content, data);
+    let outputContent = matter4.stringify(parsed.content, data);
     if (pageNodes.length > 0) {
       const connLines = connectionsSection(
         pageNodes.map((n) => n.id),
@@ -3461,14 +3989,14 @@ ${connLines.join("\n")}
 `;
       }
     }
-    await fs4.writeFile(destFile, outputContent, "utf8");
+    await fs6.writeFile(destFile, outputContent, "utf8");
     fileCount++;
   }
   for (const node of orphanNodes) {
     const relPath = orphanFilePath.get(node.id);
-    const destFile = path4.join(resolvedOutputDir, relPath);
-    await ensureDir(path4.dirname(destFile));
-    const slug = path4.basename(relPath, ".md");
+    const destFile = path6.join(resolvedOutputDir, relPath);
+    await ensureDir(path6.dirname(destFile));
+    const slug = path6.basename(relPath, ".md");
     const aliases = node.label !== slug ? [node.label] : [];
     const frontmatter = {
       id: node.id,
@@ -3494,8 +4022,8 @@ ${connLines.join("\n")}
     if (connLines.length > 0) {
       lines.push("## Connections", "", ...connLines, "");
     }
-    const content = matter2.stringify(lines.join("\n"), frontmatter);
-    await fs4.writeFile(destFile, content, "utf8");
+    const content = matter4.stringify(lines.join("\n"), frontmatter);
+    await fs6.writeFile(destFile, content, "utf8");
     fileCount++;
   }
   const usedCommunityFileNames = /* @__PURE__ */ new Set();
@@ -3523,8 +4051,8 @@ ${connLines.join("\n")}
       });
     });
     const communitySlug = deduplicateFileName(safeFileName(community.label), usedCommunityFileNames);
-    const destFile = path4.join(resolvedOutputDir, "graph", "communities", `${communitySlug}.md`);
-    await ensureDir(path4.dirname(destFile));
+    const destFile = path6.join(resolvedOutputDir, "graph", "communities", `${communitySlug}.md`);
+    await ensureDir(path6.dirname(destFile));
     const lines = [`# ${community.label}`, "", "## Members", ""];
     for (const member of memberNodes) {
       const target = wikilinkTarget.get(member.id);
@@ -3552,18 +4080,18 @@ ${connLines.join("\n")}
       node_count: memberNodes.length,
       cohesion: Number(cohesion.toFixed(4))
     };
-    const content = matter2.stringify(lines.join("\n"), frontmatter);
-    await fs4.writeFile(destFile, content, "utf8");
+    const content = matter4.stringify(lines.join("\n"), frontmatter);
+    await fs6.writeFile(destFile, content, "utf8");
     fileCount++;
   }
-  const outputsAssetsDir = path4.join(paths.wikiDir, "outputs", "assets");
+  const outputsAssetsDir = path6.join(paths.wikiDir, "outputs", "assets");
   try {
     const assetFiles = await listFilesRecursive2(outputsAssetsDir);
     for (const relAsset of assetFiles) {
-      const src = path4.join(outputsAssetsDir, relAsset);
-      const dest = path4.join(resolvedOutputDir, "outputs", "assets", relAsset);
-      await ensureDir(path4.dirname(dest));
-      await fs4.copyFile(src, dest);
+      const src = path6.join(outputsAssetsDir, relAsset);
+      const dest = path6.join(resolvedOutputDir, "outputs", "assets", relAsset);
+      await ensureDir(path6.dirname(dest));
+      await fs6.copyFile(src, dest);
       fileCount++;
     }
   } catch {
@@ -3571,15 +4099,15 @@ ${connLines.join("\n")}
   try {
     const rawAssetFiles = await listFilesRecursive2(paths.rawAssetsDir);
     for (const relAsset of rawAssetFiles) {
-      const src = path4.join(paths.rawAssetsDir, relAsset);
-      const dest = path4.join(resolvedOutputDir, "raw", "assets", relAsset);
-      await ensureDir(path4.dirname(dest));
-      await fs4.copyFile(src, dest);
+      const src = path6.join(paths.rawAssetsDir, relAsset);
+      const dest = path6.join(resolvedOutputDir, "raw", "assets", relAsset);
+      await ensureDir(path6.dirname(dest));
+      await fs6.copyFile(src, dest);
       fileCount++;
     }
   } catch {
   }
-  const obsidianDir = path4.join(resolvedOutputDir, ".obsidian");
+  const obsidianDir = path6.join(resolvedOutputDir, ".obsidian");
   await ensureDir(obsidianDir);
   const projectIds = Object.keys(
     graph.pages.reduce(
@@ -3603,8 +4131,8 @@ ${connLines.join("\n")}
     color: hexToObsidianColor(["#0ea5e9", "#22c55e", "#f59e0b", "#8b5cf6", "#fb7185", "#14b8a6"][index % 6])
   }));
   const colorGroups = [...nodeTypeGroups, ...projectColorGroups];
-  await fs4.writeFile(
-    path4.join(obsidianDir, "app.json"),
+  await fs6.writeFile(
+    path6.join(obsidianDir, "app.json"),
     JSON.stringify(
       { newFileLocation: "folder", newFileFolderPath: "outputs", attachmentFolderPath: "raw/assets", useMarkdownLinks: false },
       null,
@@ -3612,13 +4140,13 @@ ${connLines.join("\n")}
     ),
     "utf8"
   );
-  await fs4.writeFile(
-    path4.join(obsidianDir, "core-plugins.json"),
+  await fs6.writeFile(
+    path6.join(obsidianDir, "core-plugins.json"),
     JSON.stringify(["file-explorer", "global-search", "graph", "backlink", "tag-pane", "page-preview", "outline"], null, 2),
     "utf8"
   );
-  await fs4.writeFile(
-    path4.join(obsidianDir, "graph.json"),
+  await fs6.writeFile(
+    path6.join(obsidianDir, "graph.json"),
     JSON.stringify(
       { colorGroups, "collapse-filter": false, search: "", showTags: true, showAttachments: false, showOrphans: true },
       null,
@@ -3626,9 +4154,9 @@ ${connLines.join("\n")}
     ),
     "utf8"
   );
-  await fs4.writeFile(path4.join(obsidianDir, "types.json"), JSON.stringify({ types: OBSIDIAN_PROPERTY_TYPES }, null, 2), "utf8");
+  await fs6.writeFile(path6.join(obsidianDir, "types.json"), JSON.stringify({ types: OBSIDIAN_PROPERTY_TYPES }, null, 2), "utf8");
   fileCount += 4;
-  const dashboardDir = path4.join(resolvedOutputDir, "graph", "dashboards");
+  const dashboardDir = path6.join(resolvedOutputDir, "graph", "dashboards");
   await ensureDir(dashboardDir);
   const dvPages = [
     {
@@ -3665,7 +4193,7 @@ ${connLines.join("\n")}
 ${dv.query}
 \`\`\`
 `;
-    await fs4.writeFile(path4.join(dashboardDir, `${dv.name}.md`), matter2.stringify(dvBody, dvFrontmatter), "utf8");
+    await fs6.writeFile(path6.join(dashboardDir, `${dv.name}.md`), matter4.stringify(dvBody, dvFrontmatter), "utf8");
     fileCount++;
   }
   return { format: "obsidian", outputPath: resolvedOutputDir, fileCount };
@@ -3787,8 +4315,8 @@ Community: ${communityLabel}`,
 }
 
 // src/graph-merge.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs7 from "fs/promises";
+import path7 from "path";
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -3816,7 +4344,7 @@ function numberField(record, field, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 function safePrefix(inputPath, index) {
-  return slugify(path5.basename(inputPath, path5.extname(inputPath)) || `graph-${index + 1}`);
+  return slugify(path7.basename(inputPath, path7.extname(inputPath)) || `graph-${index + 1}`);
 }
 function prefixed(prefix, id) {
   return `${prefix}:${id}`;
@@ -3866,7 +4394,7 @@ function remapSwarmVaultGraph(inputPath, graph, prefix) {
   const pages = graph.pages.map((page) => ({
     ...page,
     id: pageMap.get(page.id) ?? prefixed(prefix, page.id),
-    path: toPosix(path5.posix.join("merged", prefix, page.path)),
+    path: toPosix(path7.posix.join("merged", prefix, page.path)),
     sourceIds: page.sourceIds.map((sourceId) => sourceMap.get(sourceId) ?? prefixed(prefix, sourceId)),
     nodeIds: page.nodeIds.map((nodeId) => nodeMap.get(nodeId) ?? prefixed(prefix, nodeId)),
     relatedPageIds: page.relatedPageIds.map((pageId) => pageMap.get(pageId) ?? prefixed(prefix, pageId)),
@@ -4008,7 +4536,7 @@ function remapNodeLinkGraph(inputPath, raw, prefix, now) {
   });
   const page = {
     id: prefixed(prefix, "page"),
-    path: toPosix(path5.posix.join("merged", prefix, "index.md")),
+    path: toPosix(path7.posix.join("merged", prefix, "index.md")),
     title: `${prefix} merged graph`,
     kind: "source",
     sourceClass: "generated",
@@ -4079,8 +4607,8 @@ async function mergeGraphFiles(inputPaths, outputPath, options = {}) {
   const inputGraphs = [];
   const warnings = [];
   for (const [index, inputPath] of inputPaths.entries()) {
-    const resolvedInputPath = path5.resolve(inputPath);
-    const raw = JSON.parse(await fs5.readFile(resolvedInputPath, "utf8"));
+    const resolvedInputPath = path7.resolve(inputPath);
+    const raw = JSON.parse(await fs7.readFile(resolvedInputPath, "utf8"));
     const prefix = ensureUniquePrefix(
       inputPaths.length === 1 && options.label ? slugify(options.label) : safePrefix(resolvedInputPath, index),
       usedPrefixes
@@ -4115,9 +4643,9 @@ async function mergeGraphFiles(inputPaths, outputPath, options = {}) {
     throw new Error("No supported graph inputs were found.");
   }
   const graph = mergeGraphs(graphs, now);
-  const resolvedOutputPath = path5.resolve(outputPath);
-  await ensureDir(path5.dirname(resolvedOutputPath));
-  await fs5.writeFile(resolvedOutputPath, `${JSON.stringify(graph, null, 2)}
+  const resolvedOutputPath = path7.resolve(outputPath);
+  await ensureDir(path7.dirname(resolvedOutputPath));
+  await fs7.writeFile(resolvedOutputPath, `${JSON.stringify(graph, null, 2)}
 `, "utf8");
   return {
     outputPath: resolvedOutputPath,
@@ -4128,8 +4656,8 @@ async function mergeGraphFiles(inputPaths, outputPath, options = {}) {
 }
 
 // src/graph-push.ts
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import neo4j from "neo4j-driver";
 var DEFAULT_NEO4J_BATCH_SIZE = 500;
 var DEFAULT_NEO4J_DATABASE = "neo4j";
@@ -4140,8 +4668,8 @@ function requireConfigValue(value, name) {
   throw new Error(`Neo4j push requires ${name}. Configure \`graphSinks.neo4j.${name}\` or pass the matching CLI flag.`);
 }
 async function deriveVaultId(rootDir) {
-  const realRoot = await fs6.realpath(rootDir).catch(() => path6.resolve(rootDir));
-  const label = slugify(path6.basename(realRoot));
+  const realRoot = await fs8.realpath(rootDir).catch(() => path8.resolve(rootDir));
+  const label = slugify(path8.basename(realRoot));
   return `${label}-${sha256(realRoot).slice(0, 12)}`;
 }
 async function resolveNeo4jPushConfig(rootDir, options) {
@@ -4171,7 +4699,7 @@ function normalizeBatchSize(value) {
 }
 async function loadGraph2(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
-  const raw = JSON.parse(await fs6.readFile(paths.graphPath, "utf8"));
+  const raw = JSON.parse(await fs8.readFile(paths.graphPath, "utf8"));
   return raw;
 }
 function buildResult(input) {
@@ -4256,7 +4784,7 @@ async function writeSyncNode(session, input) {
       ].join("\n"),
       {
         vaultId: input.vaultId,
-        rootDir: path6.resolve(input.rootDir),
+        rootDir: path8.resolve(input.rootDir),
         graphGeneratedAt: input.graph.generatedAt,
         graphHash: graphHash(input.graph),
         pushedAt: input.pushedAt,
@@ -4342,7 +4870,7 @@ async function pushGraphNeo4j(rootDir, options = {}) {
 }
 
 // src/graph-status.ts
-import path7 from "path";
+import path9 from "path";
 function recommendedCommand(input) {
   if (!input.graphExists || !input.reportExists) {
     return "swarmvault compile";
@@ -4358,8 +4886,8 @@ function recommendedCommand(input) {
 async function getGraphStatus(rootDir, options = {}) {
   const { paths } = await loadVaultConfig(rootDir);
   const graphPath = paths.graphPath;
-  const reportPath = path7.join(paths.wikiDir, "graph", "report.md");
-  const resolvedOverrideRoots = options.repoRoots?.map((repoRoot) => path7.resolve(rootDir, repoRoot));
+  const reportPath = path9.join(paths.wikiDir, "graph", "report.md");
+  const resolvedOverrideRoots = options.repoRoots?.map((repoRoot) => path9.resolve(rootDir, repoRoot));
   const [graphExists, reportExists, trackedRepoRoots, changes, pendingSemanticRefresh] = await Promise.all([
     fileExists(graphPath),
     fileExists(reportPath),
@@ -4393,7 +4921,7 @@ async function getGraphStatus(rootDir, options = {}) {
 }
 
 // src/graph-tree.ts
-import path8 from "path";
+import path10 from "path";
 var DEFAULT_MAX_CHILDREN = 250;
 function compareTreeNodes(left, right) {
   const kindOrder = /* @__PURE__ */ new Map([
@@ -4435,11 +4963,11 @@ function normalizeSourcePath(rootDir, source) {
   if (source.repoRelativePath) {
     return toPosix(source.repoRelativePath);
   }
-  if (rootDir && path8.isAbsolute(candidate) && isPathWithin(rootDir, candidate)) {
-    return toPosix(path8.relative(rootDir, candidate));
+  if (rootDir && path10.isAbsolute(candidate) && isPathWithin(rootDir, candidate)) {
+    return toPosix(path10.relative(rootDir, candidate));
   }
-  if (path8.isAbsolute(candidate)) {
-    return toPosix(path8.basename(candidate));
+  if (path10.isAbsolute(candidate)) {
+    return toPosix(path10.basename(candidate));
   }
   return toPosix(candidate).replace(/^\/+/, "") || source.title || source.sourceId;
 }
@@ -4758,9 +5286,9 @@ async function exportGraphTree(rootDir, outputPath, options = {}) {
     throw new Error(`Graph artifact not found at ${paths.graphPath}. Run swarmvault compile first.`);
   }
   const tree = buildGraphTree(graph, { ...options, rootDir });
-  const resolvedOutputPath = path8.resolve(rootDir, outputPath ?? path8.join(paths.wikiDir, "graph", "tree.html"));
-  await ensureDir(path8.dirname(resolvedOutputPath));
-  await import("fs/promises").then((fs13) => fs13.writeFile(resolvedOutputPath, renderGraphTreeHtml(tree, graph), "utf8"));
+  const resolvedOutputPath = path10.resolve(rootDir, outputPath ?? path10.join(paths.wikiDir, "graph", "tree.html"));
+  await ensureDir(path10.dirname(resolvedOutputPath));
+  await import("fs/promises").then((fs15) => fs15.writeFile(resolvedOutputPath, renderGraphTreeHtml(tree, graph), "utf8"));
   return {
     outputPath: resolvedOutputPath,
     sourceCount: graph.sources.length,
@@ -4770,26 +5298,26 @@ async function exportGraphTree(rootDir, outputPath, options = {}) {
 }
 
 // src/hooks.ts
-import fs7 from "fs/promises";
-import path9 from "path";
+import fs9 from "fs/promises";
+import path11 from "path";
 import process3 from "process";
 var hookStart = "# >>> swarmvault hook >>>";
 var hookEnd = "# <<< swarmvault hook <<<";
 async function findNearestGitRoot(startPath) {
-  let current = path9.resolve(startPath);
+  let current = path11.resolve(startPath);
   try {
-    const stat = await fs7.stat(current);
+    const stat = await fs9.stat(current);
     if (!stat.isDirectory()) {
-      current = path9.dirname(current);
+      current = path11.dirname(current);
     }
   } catch {
-    current = path9.dirname(current);
+    current = path11.dirname(current);
   }
   while (true) {
-    if (await fileExists(path9.join(current, ".git"))) {
+    if (await fileExists(path11.join(current, ".git"))) {
       return current;
     }
-    const parent = path9.dirname(current);
+    const parent = path11.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -4801,8 +5329,8 @@ function shellQuote(value) {
 }
 function resolveSwarmvaultExecutableCandidate() {
   const argvPath = process3.argv[1];
-  if (typeof argvPath === "string" && argvPath.trim() && (argvPath.includes(`${path9.sep}@swarmvaultai${path9.sep}cli${path9.sep}`) || argvPath.includes(`${path9.sep}packages${path9.sep}cli${path9.sep}`))) {
-    return path9.resolve(argvPath);
+  if (typeof argvPath === "string" && argvPath.trim() && (argvPath.includes(`${path11.sep}@swarmvaultai${path11.sep}cli${path11.sep}`) || argvPath.includes(`${path11.sep}packages${path11.sep}cli${path11.sep}`))) {
+    return path11.resolve(argvPath);
   }
   return "swarmvault";
 }
@@ -4821,17 +5349,17 @@ function managedHookBlock(vaultRoot) {
   ].join("\n");
 }
 function hookPath(repoRoot, hookName) {
-  return path9.join(repoRoot, ".git", "hooks", hookName);
+  return path11.join(repoRoot, ".git", "hooks", hookName);
 }
 async function readHookStatus(filePath) {
   if (!await fileExists(filePath)) {
     return "not_installed";
   }
-  const content = await fs7.readFile(filePath, "utf8");
+  const content = await fs9.readFile(filePath, "utf8");
   return content.includes(hookStart) && content.includes(hookEnd) ? "installed" : "other_content";
 }
 async function upsertHookFile(filePath, block) {
-  const existing = await fileExists(filePath) ? await fs7.readFile(filePath, "utf8") : "";
+  const existing = await fileExists(filePath) ? await fs9.readFile(filePath, "utf8") : "";
   let next;
   const startIndex = existing.indexOf(hookStart);
   const endIndex = existing.indexOf(hookEnd);
@@ -4845,16 +5373,16 @@ ${block}`.trimEnd();
     next = `#!/bin/sh
 ${block}`.trimEnd();
   }
-  await ensureDir(path9.dirname(filePath));
-  await fs7.writeFile(filePath, `${next}
+  await ensureDir(path11.dirname(filePath));
+  await fs9.writeFile(filePath, `${next}
 `, { mode: 493, encoding: "utf8" });
-  await fs7.chmod(filePath, 493);
+  await fs9.chmod(filePath, 493);
 }
 async function removeHookBlock(filePath) {
   if (!await fileExists(filePath)) {
     return;
   }
-  const existing = await fs7.readFile(filePath, "utf8");
+  const existing = await fs9.readFile(filePath, "utf8");
   const startIndex = existing.indexOf(hookStart);
   const endIndex = existing.indexOf(hookEnd);
   if (startIndex === -1 || endIndex === -1) {
@@ -4862,10 +5390,10 @@ async function removeHookBlock(filePath) {
   }
   const next = `${existing.slice(0, startIndex)}${existing.slice(endIndex + hookEnd.length)}`.trim();
   if (!next || next === "#!/bin/sh") {
-    await fs7.rm(filePath, { force: true });
+    await fs9.rm(filePath, { force: true });
     return;
   }
-  await fs7.writeFile(filePath, `${next}
+  await fs9.writeFile(filePath, `${next}
 `, "utf8");
 }
 async function getGitHookStatus(rootDir) {
@@ -4888,7 +5416,7 @@ async function installGitHooks(rootDir) {
   if (!repoRoot) {
     throw new Error("No git repository found above the current vault.");
   }
-  const block = managedHookBlock(path9.resolve(rootDir));
+  const block = managedHookBlock(path11.resolve(rootDir));
   await upsertHookFile(hookPath(repoRoot, "post-commit"), block);
   await upsertHookFile(hookPath(repoRoot, "post-checkout"), block);
   return getGitHookStatus(rootDir);
@@ -4908,12 +5436,12 @@ async function uninstallGitHooks(rootDir) {
 }
 
 // src/mcp.ts
-import fs8 from "fs/promises";
-import path10 from "path";
+import fs10 from "fs/promises";
+import path12 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-var SERVER_VERSION = "3.11.0";
+var SERVER_VERSION = "3.12.0";
 var codeLanguageSchema = z.enum([
   "javascript",
   "jsx",
@@ -5670,7 +6198,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(path10.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path12.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -5739,8 +6267,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path10.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs8.readFile(absolutePath, "utf8"));
+      const absolutePath = path12.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs10.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -5748,11 +6276,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(path10.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path12.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path10.basename(relativePath, ".md"),
+            name: path12.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -5769,11 +6297,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path10.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path12.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 fs8.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs10.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -5833,9 +6361,9 @@ function asTextResource(uri, text) {
 
 // src/providers/local-whisper-setup.ts
 import { createWriteStream, constants as fsConstants } from "fs";
-import fs9 from "fs/promises";
+import fs11 from "fs/promises";
 import os from "os";
-import path11 from "path";
+import path13 from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 var BINARY_CANDIDATES = ["whisper-cli", "whisper-cpp", "whisper"];
@@ -5863,10 +6391,10 @@ async function discoverLocalWhisperBinary(options = {}) {
   }
   const pathValue = env.PATH ?? "";
   const candidates = [];
-  for (const dir of pathValue.split(path11.delimiter)) {
+  for (const dir of pathValue.split(path13.delimiter)) {
     if (!dir) continue;
     for (const name of BINARY_CANDIDATES) {
-      const full = path11.join(dir, name);
+      const full = path13.join(dir, name);
       candidates.push(full);
       if (await isExecutable(full)) {
         return { binaryPath: full, candidates, source: "path" };
@@ -5877,14 +6405,14 @@ async function discoverLocalWhisperBinary(options = {}) {
 }
 function expectedModelPath(modelName, homeDir) {
   const home = homeDir ?? os.homedir();
-  return path11.join(home, ".swarmvault", "models", `ggml-${modelName}.bin`);
+  return path13.join(home, ".swarmvault", "models", `ggml-${modelName}.bin`);
 }
 function modelDownloadUrl(modelName) {
   return `${HUGGINGFACE_BASE}/ggml-${modelName}.bin`;
 }
 async function downloadWhisperModel(options) {
   const destPath = expectedModelPath(options.modelName, options.homeDir);
-  await ensureDir(path11.dirname(destPath));
+  await ensureDir(path13.dirname(destPath));
   const doFetch = options.fetchImpl ?? fetch;
   const url = modelDownloadUrl(options.modelName);
   const response = await doFetch(url);
@@ -5905,8 +6433,8 @@ async function downloadWhisperModel(options) {
   });
   const tmpPath = `${destPath}.part`;
   await pipeline(source, createWriteStream(tmpPath));
-  await fs9.rename(tmpPath, destPath);
-  const stat = await fs9.stat(destPath);
+  await fs11.rename(tmpPath, destPath);
+  const stat = await fs11.stat(destPath);
   return { path: destPath, bytes: stat.size };
 }
 async function registerLocalWhisperProvider(options) {
@@ -5973,7 +6501,7 @@ async function summarizeLocalWhisperSetup(options) {
 }
 async function isExecutable(p) {
   try {
-    await fs9.access(p, fsConstants.X_OK);
+    await fs11.access(p, fsConstants.X_OK);
     return true;
   } catch {
     return false;
@@ -6043,13 +6571,13 @@ async function withCapabilityFallback(provider, capability, run, fallback) {
 }
 
 // src/schedule.ts
-import fs10 from "fs/promises";
-import path12 from "path";
+import fs12 from "fs/promises";
+import path14 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path12.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path14.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path12.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path14.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -6152,13 +6680,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs10.open(leasePath, "wx");
+  const handle = await fs12.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs10.rm(leasePath, { force: true });
+    await fs12.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -6317,9 +6845,9 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/sources.ts
 import { spawn } from "child_process";
-import fs11 from "fs/promises";
-import path13 from "path";
-import matter3 from "gray-matter";
+import fs13 from "fs/promises";
+import path15 from "path";
+import matter5 from "gray-matter";
 import { JSDOM } from "jsdom";
 var DEFAULT_CRAWL_MAX_PAGES = 12;
 var DEFAULT_CRAWL_MAX_DEPTH = 2;
@@ -6364,24 +6892,24 @@ function emptyManagedSourceSyncCounts() {
   };
 }
 function withinRoot(rootPath, targetPath) {
-  const relative = path13.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative);
+  const relative = path15.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path15.isAbsolute(relative);
 }
 async function findNearestGitRoot2(startPath) {
-  let current = path13.resolve(startPath);
+  let current = path15.resolve(startPath);
   try {
-    const stat = await fs11.stat(current);
+    const stat = await fs13.stat(current);
     if (!stat.isDirectory()) {
-      current = path13.dirname(current);
+      current = path15.dirname(current);
     }
   } catch {
-    current = path13.dirname(current);
+    current = path15.dirname(current);
   }
   while (true) {
-    if (await fileExists(path13.join(current, ".git"))) {
+    if (await fileExists(path15.join(current, ".git"))) {
       return current;
     }
-    const parent = path13.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -6455,7 +6983,7 @@ function isAllowedDocsCandidate(candidate, startUrl) {
   if (candidate.origin !== startUrl.origin) {
     return false;
   }
-  const extension = path13.extname(candidate.pathname).toLowerCase();
+  const extension = path15.extname(candidate.pathname).toLowerCase();
   if (extension && extension !== ".html" && extension !== ".htm" && extension !== ".md") {
     return false;
   }
@@ -6544,7 +7072,7 @@ function matchesManagedSourceSpec(existing, input) {
     return false;
   }
   if (input.kind === "directory" || input.kind === "file") {
-    return path13.resolve(existing.path ?? "") === path13.resolve(input.path);
+    return path15.resolve(existing.path ?? "") === path15.resolve(input.path);
   }
   if (input.kind === "github_repo") {
     return (existing.url ?? "") === input.url && (existing.branch ?? "") === (input.branch ?? "") && (existing.ref ?? "") === (input.ref ?? "");
@@ -6569,15 +7097,15 @@ function normalizeCheckoutDir(rootDir, value) {
   if (!trimmed) {
     return void 0;
   }
-  return path13.isAbsolute(trimmed) ? path13.resolve(trimmed) : path13.resolve(rootDir, trimmed);
+  return path15.isAbsolute(trimmed) ? path15.resolve(trimmed) : path15.resolve(rootDir, trimmed);
 }
 async function resolveManagedSourceInput(rootDir, input, options = {}) {
-  const absoluteInput = path13.resolve(rootDir, input);
+  const absoluteInput = path15.resolve(rootDir, input);
   if (!(input.startsWith("http://") || input.startsWith("https://"))) {
     if (options.branch || options.ref || options.checkoutDir) {
       throw new Error("Git branch/ref/checkout options are only supported for public GitHub repo root URLs.");
     }
-    const stat = await fs11.stat(absoluteInput).catch(() => null);
+    const stat = await fs13.stat(absoluteInput).catch(() => null);
     if (!stat) {
       throw new Error(`Source not found: ${input}`);
     }
@@ -6585,7 +7113,7 @@ async function resolveManagedSourceInput(rootDir, input, options = {}) {
       return {
         kind: "file",
         path: absoluteInput,
-        title: path13.basename(absoluteInput, path13.extname(absoluteInput)) || absoluteInput
+        title: path15.basename(absoluteInput, path15.extname(absoluteInput)) || absoluteInput
       };
     }
     if (!stat.isDirectory()) {
@@ -6597,7 +7125,7 @@ async function resolveManagedSourceInput(rootDir, input, options = {}) {
       kind: "directory",
       path: absoluteInput,
       repoRoot,
-      title: path13.basename(absoluteInput) || absoluteInput
+      title: path15.basename(absoluteInput) || absoluteInput
     };
   }
   const github = normalizeGitHubRepoRootUrl(input);
@@ -6626,16 +7154,16 @@ async function resolveManagedSourceInput(rootDir, input, options = {}) {
   };
 }
 function directorySourceIdsFor(manifests, inputPath) {
-  return manifests.filter((manifest) => manifest.originalPath && withinRoot(path13.resolve(inputPath), path13.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+  return manifests.filter((manifest) => manifest.originalPath && withinRoot(path15.resolve(inputPath), path15.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
 }
 function fileSourceIdsFor(manifests, inputPath) {
-  const absoluteInput = path13.resolve(inputPath);
-  return manifests.filter((manifest) => manifest.originalPath && path13.resolve(manifest.originalPath) === absoluteInput).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+  const absoluteInput = path15.resolve(inputPath);
+  return manifests.filter((manifest) => manifest.originalPath && path15.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 && withinRoot(path13.resolve(inputPath), path13.resolve(manifest.originalPath))
+    (manifest) => manifest.originalPath && withinRoot(path15.resolve(inputPath), path15.resolve(manifest.originalPath))
   );
   const result = await ingestDirectory(rootDir, inputPath, { repoRoot });
   const removed = [];
@@ -6643,7 +7171,7 @@ async function syncDirectorySource(rootDir, inputPath, repoRoot) {
     if (!manifest.originalPath) {
       continue;
     }
-    if (await fileExists(path13.resolve(manifest.originalPath))) {
+    if (await fileExists(path15.resolve(manifest.originalPath))) {
       continue;
     }
     const removedManifest = await removeManifestBySourceId(rootDir, manifest.sourceId);
@@ -6653,7 +7181,7 @@ async function syncDirectorySource(rootDir, inputPath, repoRoot) {
   }
   const manifestsAfter = await listManifests(rootDir);
   return {
-    title: path13.basename(inputPath) || inputPath,
+    title: path15.basename(inputPath) || inputPath,
     sourceIds: directorySourceIdsFor(manifestsAfter, inputPath),
     counts: {
       scannedCount: result.scannedCount,
@@ -6669,7 +7197,7 @@ async function syncFileSource(rootDir, inputPath) {
   const result = await ingestInputDetailed(rootDir, inputPath);
   const manifestsAfter = await listManifests(rootDir);
   return {
-    title: path13.basename(inputPath, path13.extname(inputPath)) || inputPath,
+    title: path15.basename(inputPath, path15.extname(inputPath)) || inputPath,
     sourceIds: fileSourceIdsFor(manifestsAfter, inputPath),
     counts: {
       scannedCount: result.scannedCount,
@@ -6703,10 +7231,10 @@ async function runGitCommand(cwd, args) {
 }
 async function syncGitHubRepoSource(rootDir, entry) {
   const workingDir = await managedSourceWorkingDir(rootDir, entry.id);
-  const externalCheckoutDir = entry.checkoutDir ? path13.resolve(entry.checkoutDir) : void 0;
-  const checkoutDir = externalCheckoutDir ?? path13.join(workingDir, "checkout");
+  const externalCheckoutDir = entry.checkoutDir ? path15.resolve(entry.checkoutDir) : void 0;
+  const checkoutDir = externalCheckoutDir ?? path15.join(workingDir, "checkout");
   if (!externalCheckoutDir) {
-    await fs11.rm(checkoutDir, { recursive: true, force: true });
+    await fs13.rm(checkoutDir, { recursive: true, force: true });
   }
   await ensureDir(workingDir);
   if (!entry.url) {
@@ -6723,7 +7251,7 @@ async function syncGitHubRepoSource(rootDir, entry) {
     cloneArgs.push("--branch", branch);
   }
   cloneArgs.push(github.cloneUrl, checkoutDir);
-  if (await fileExists(path13.join(checkoutDir, ".git"))) {
+  if (await fileExists(path15.join(checkoutDir, ".git"))) {
     await runGitCommand(checkoutDir, ["remote", "set-url", "origin", github.cloneUrl]);
     if (branch) {
       await runGitCommand(checkoutDir, ["fetch", "--depth", "1", "origin", branch]);
@@ -6734,11 +7262,11 @@ async function syncGitHubRepoSource(rootDir, entry) {
       await runGitCommand(checkoutDir, ["checkout", "--detach", "FETCH_HEAD"]);
     }
   } else {
-    const existingEntries = await fs11.readdir(checkoutDir).catch(() => []);
+    const existingEntries = await fs13.readdir(checkoutDir).catch(() => []);
     if (externalCheckoutDir && existingEntries.length > 0) {
       throw new Error(`Checkout directory exists but is not a Git repository: ${checkoutDir}`);
     }
-    await ensureDir(path13.dirname(checkoutDir));
+    await ensureDir(path15.dirname(checkoutDir));
     await runGitCommand(workingDir, cloneArgs);
   }
   if (ref) {
@@ -6865,7 +7393,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(path13.join(paths.analysesDir, `${sourceId}.json`)))
+    sourceIds.map(async (sourceId) => await readJsonFile(path15.join(paths.analysesDir, `${sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis?.sourceId));
 }
@@ -7026,9 +7554,9 @@ async function writeSourceBriefForScope(rootDir, source) {
       confidence: 0.82
     }
   });
-  const absolutePath = path13.join(paths.wikiDir, output.page.path);
-  await ensureDir(path13.dirname(absolutePath));
-  await fs11.writeFile(absolutePath, output.content, "utf8");
+  const absolutePath = path15.join(paths.wikiDir, output.page.path);
+  await ensureDir(path15.dirname(absolutePath));
+  await fs13.writeFile(absolutePath, output.content, "utf8");
   return absolutePath;
 }
 async function writeSourceBrief(rootDir, source) {
@@ -7316,7 +7844,7 @@ function selectGuidedTargetPages(scope, sourcePages, questions) {
   return (matchedTargets.length ? matchedTargets : canonicalPages).slice(0, 6);
 }
 function insightRelativePathForTarget(page, scope) {
-  const basename = path13.basename(page.path);
+  const basename = path15.basename(page.path);
   if (page.kind === "concept") {
     return `insights/concepts/${basename}`;
   }
@@ -7543,7 +8071,7 @@ async function stageSourceReviewForScope(rootDir, scope) {
   return {
     sourceId: scope.id,
     pageId: output.page.id,
-    reviewPath: path13.join(approval.approvalDir, "wiki", output.page.path),
+    reviewPath: path15.join(approval.approvalDir, "wiki", output.page.path),
     staged: true,
     approvalId: approval.approvalId,
     approvalDir: approval.approvalDir
@@ -7610,7 +8138,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 && path13.isAbsolute(session.briefPath) ? path13.relative(paths.wikiDir, session.briefPath) : session.briefPath;
+  const relativeBriefPath = session.briefPath && path15.isAbsolute(session.briefPath) ? path15.relative(paths.wikiDir, session.briefPath) : session.briefPath;
   const sessionMarkdown = [
     `# Guided Session: ${scope.title}`,
     "",
@@ -7693,9 +8221,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 = path13.join(paths.wikiDir, output.page.path);
-  await ensureDir(path13.dirname(absolutePath));
-  await fs11.writeFile(absolutePath, output.content, "utf8");
+  const absolutePath = path15.join(paths.wikiDir, output.page.path);
+  await ensureDir(path15.dirname(absolutePath));
+  await fs13.writeFile(absolutePath, output.content, "utf8");
   return { pageId: output.page.id, sessionPath: absolutePath };
 }
 async function buildGuidedUpdatePages(rootDir, scope, session) {
@@ -7723,9 +8251,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 = path13.join(paths.wikiDir, relativePath);
-      const existingContent = await fileExists(absolutePath) ? await fs11.readFile(absolutePath, "utf8") : "";
-      const parsed = existingContent ? matter3(existingContent) : { data: {}, content: "" };
+      const absolutePath = path15.join(paths.wikiDir, relativePath);
+      const existingContent = await fileExists(absolutePath) ? await fs13.readFile(absolutePath, "utf8") : "";
+      const parsed = existingContent ? matter5(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") : [];
@@ -7786,7 +8314,7 @@ async function buildGuidedUpdatePages(rootDir, scope, session) {
         ""
       ].join("\n");
       const nextBody = replaceMarkedSection(baseBody, scope.id, updateBlock);
-      const content = matter3.stringify(
+      const content = matter5.stringify(
         `${nextBody.trimEnd()}
 `,
         JSON.parse(
@@ -7895,8 +8423,8 @@ async function stageSourceGuideForScope(rootDir, scope, options = {}) {
     }
   );
   session.status = "staged";
-  session.reviewPath = path13.join(approval.approvalDir, "wiki", reviewOutput.page.path);
-  session.guidePath = path13.join(approval.approvalDir, "wiki", guideOutput.page.path);
+  session.reviewPath = path15.join(approval.approvalDir, "wiki", reviewOutput.page.path);
+  session.guidePath = path15.join(approval.approvalDir, "wiki", guideOutput.page.path);
   session.approvalId = approval.approvalId;
   session.approvalDir = approval.approvalDir;
   const persisted = await persistSourceSessionPage(rootDir, scope, session);
@@ -8039,7 +8567,7 @@ async function addManagedSource(rootDir, input, options = {}) {
     ref: resolved.kind === "github_repo" ? resolved.ref : existing.ref,
     checkoutDir: resolved.kind === "github_repo" ? resolved.checkoutDir ?? existing.checkoutDir : existing.checkoutDir
   } : {
-    id: resolved.kind === "directory" || resolved.kind === "file" ? stableManagedSourceId(resolved.kind, path13.resolve(resolved.path), resolved.title) : stableManagedSourceId(
+    id: resolved.kind === "directory" || resolved.kind === "file" ? stableManagedSourceId(resolved.kind, path15.resolve(resolved.path), resolved.title) : stableManagedSourceId(
       resolved.kind,
       resolved.kind === "github_repo" ? `${resolved.url}#branch=${resolved.branch ?? ""}#ref=${resolved.ref ?? ""}` : resolved.url,
       resolved.title
@@ -8174,7 +8702,7 @@ async function deleteManagedSource(rootDir, id) {
     sources.filter((source) => source.id !== id)
   );
   const workingDir = await managedSourceWorkingDir(rootDir, id);
-  await fs11.rm(workingDir, { recursive: true, force: true });
+  await fs13.rm(workingDir, { recursive: true, force: true });
   return { removed: target };
 }
 
@@ -8182,11 +8710,11 @@ async function deleteManagedSource(rootDir, id) {
 import { execFile as execFile2 } from "child_process";
 import { randomUUID } from "crypto";
 import { EventEmitter } from "events";
-import fs12 from "fs/promises";
+import fs14 from "fs/promises";
 import http from "http";
-import path14 from "path";
+import path16 from "path";
 import { promisify as promisify2 } from "util";
-import matter4 from "gray-matter";
+import matter6 from "gray-matter";
 import mime from "mime-types";
 
 // src/graph-presentation.ts
@@ -8338,7 +8866,7 @@ function toViewerLintFindings(findings) {
 var execFileAsync2 = promisify2(execFile2);
 async function isReadableFile(absolutePath) {
   try {
-    const stats = await fs12.stat(absolutePath);
+    const stats = await fs14.stat(absolutePath);
     return stats.isFile();
   } catch {
     return false;
@@ -8349,15 +8877,15 @@ async function readViewerPage(rootDir, relativePath) {
     return null;
   }
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path14.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path16.resolve(paths.wikiDir, relativePath);
   if (!isPathWithin(paths.wikiDir, absolutePath) || !await isReadableFile(absolutePath)) {
     return null;
   }
-  const raw = await fs12.readFile(absolutePath, "utf8");
-  const parsed = matter4(raw);
+  const raw = await fs14.readFile(absolutePath, "utf8");
+  const parsed = matter6(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path14.basename(relativePath, path14.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path16.basename(relativePath, path16.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -8368,12 +8896,12 @@ async function readViewerAsset(rootDir, relativePath) {
     return null;
   }
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path14.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path16.resolve(paths.wikiDir, relativePath);
   if (!isPathWithin(paths.wikiDir, absolutePath) || !await isReadableFile(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs12.readFile(absolutePath),
+    buffer: await fs14.readFile(absolutePath),
     mimeType: mime.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -8409,8 +8937,8 @@ async function writeInboxClip(rootDir, body) {
   const tags = Array.isArray(body.tags) ? body.tags.filter((tag) => typeof tag === "string" && tag.trim().length > 0) : [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const fileName = `${now.replace(/[:.]/g, "-")}-${slugForClip(title)}.md`;
-  const inboxPath = path14.join(paths.inboxDir, fileName);
-  await fs12.mkdir(paths.inboxDir, { recursive: true });
+  const inboxPath = path16.join(paths.inboxDir, fileName);
+  await fs14.mkdir(paths.inboxDir, { recursive: true });
   const lines = [
     "---",
     `title: ${JSON.stringify(title)}`,
@@ -8427,17 +8955,17 @@ async function writeInboxClip(rootDir, body) {
     selectionHtml && !markdown ? ["", "## Original HTML", "", "```html", selectionHtml, "```"].join("\n") : void 0,
     ""
   ].filter((line) => line !== void 0);
-  await fs12.writeFile(inboxPath, lines.join("\n"), "utf8");
+  await fs14.writeFile(inboxPath, lines.join("\n"), "utf8");
   const result = await importInbox(rootDir, paths.inboxDir);
   return { mode: "inbox", inboxPath, result };
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path14.join(viewerDistDir, "index.html");
+  const indexPath = path16.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path14.dirname(viewerDistDir);
-  if (await fileExists(path14.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path16.dirname(viewerDistDir);
+  if (await fileExists(path16.join(viewerProjectDir, "package.json"))) {
     await execFileAsync2("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -8460,7 +8988,7 @@ async function startGraphServer(rootDir, port, options = {}) {
           response.end(JSON.stringify({ error: "Graph artifact not found. Run `swarmvault compile` first." }));
           return;
         }
-        const reportPath = path14.join(paths.wikiDir, "graph", "report.json");
+        const reportPath = path16.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 })));
@@ -8524,13 +9052,13 @@ async function startGraphServer(rootDir, port, options = {}) {
         return;
       }
       if (url.pathname === "/api/graph-report") {
-        const reportPath = path14.join(paths.wikiDir, "graph", "report.json");
+        const reportPath = path16.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 fs12.readFile(reportPath, "utf8");
+        const body = await fs14.readFile(reportPath, "utf8");
         response.writeHead(200, { "content-type": "application/json" });
         response.end(body);
         return;
@@ -8768,7 +9296,7 @@ async function startGraphServer(rootDir, port, options = {}) {
         return;
       }
       if (url.pathname === "/api/workspace") {
-        const reportPath = path14.join(paths.wikiDir, "graph", "report.json");
+        const reportPath = path16.join(paths.wikiDir, "graph", "report.json");
         const [graphRaw, reportRaw, approvalsRaw, candidatesRaw, memoryTasksRaw, watchStatusRaw, lintRaw, doctorRaw] = await Promise.all([
           readJsonFile(paths.graphPath).catch(() => null),
           readJsonFile(reportPath).catch(() => null),
@@ -8893,15 +9421,15 @@ async function startGraphServer(rootDir, port, options = {}) {
         return;
       }
       const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-      const target = path14.join(paths.viewerDistDir, relativePath);
-      const fallback = path14.join(paths.viewerDistDir, "index.html");
+      const target = path16.join(paths.viewerDistDir, relativePath);
+      const fallback = path16.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 fs12.readFile(filePath);
+      const staticBody = await fs14.readFile(filePath);
       response.writeHead(200, { "content-type": mime.lookup(filePath) || "text/plain" });
       response.end(staticBody);
     } catch (error) {
@@ -8941,7 +9469,7 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path14.join(paths.viewerDistDir, "index.html");
+  const indexPath = path16.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -8967,17 +9495,17 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
       } : null;
     })
   );
-  const rawHtml = await fs12.readFile(indexPath, "utf8");
+  const rawHtml = await fs14.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] ? path14.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path14.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path16.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path16.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 fs12.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs12.readFile(stylePath, "utf8") : "";
-  const report = await readJsonFile(path14.join(paths.wikiDir, "graph", "report.json"));
+  const script = await fs14.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs14.readFile(stylePath, "utf8") : "";
+  const report = await readJsonFile(path16.join(paths.wikiDir, "graph", "report.json"));
   const embeddedData = JSON.stringify(
     { graph: buildViewerGraphArtifact(graph, { report, full: options.full ?? false }), pages: pages.filter(Boolean), report },
     null,
@@ -9000,9 +9528,9 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs12.mkdir(path14.dirname(outputPath), { recursive: true });
-  await fs12.writeFile(outputPath, html, "utf8");
-  return path14.resolve(outputPath);
+  await fs14.mkdir(path16.dirname(outputPath), { recursive: true });
+  await fs14.writeFile(outputPath, html, "utf8");
+  return path16.resolve(outputPath);
 }
 export {
   ALL_MIGRATIONS,
@@ -9023,6 +9551,7 @@ export {
   addWatchedRoot,
   applyDecayToPages,
   archiveCandidate,
+  askChatSession,
   assertProviderCapability,
   autoCommitWikiChanges,
   benchmarkVault,
@@ -9045,6 +9574,7 @@ export {
   createWebSearchAdapter,
   defaultVaultConfig,
   defaultVaultSchema,
+  deleteChatSession,
   deleteContextPack,
   deleteManagedSource,
   detectVaultVersion,
@@ -9060,6 +9590,7 @@ export {
   expectedModelPath,
   explainGraphVault,
   exploreVault,
+  exportAiPack,
   exportGraphFormat,
   exportGraphHtml,
   exportGraphReportHtml,
@@ -9092,6 +9623,7 @@ export {
   lintVault,
   listApprovals,
   listCandidates,
+  listChatSessions,
   listContextPacks,
   listGodNodes,
   listGraphHyperedges,
@@ -9121,6 +9653,7 @@ export {
   queryGraphVault,
   queryVault,
   readApproval,
+  readChatSession,
   readContextPack,
   readExtractedText,
   readGraphReport,