@swarmvaultai/engine 0.1.28 → 0.1.30

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-EXD4RWT3.js";
+} from "./chunk-IAEYFTUS.js";
 
 // src/agents.ts
 import crypto from "crypto";
@@ -32,8 +32,8 @@ var managedStart = "<!-- swarmvault:managed:start -->";
 var managedEnd = "<!-- swarmvault:managed:end -->";
 var legacyManagedStart = "<!-- vault:managed:start -->";
 var legacyManagedEnd = "<!-- vault:managed:end -->";
-var claudeHookMatcher = "Glob|Grep";
-var claudeHookCommand = "if [ -f wiki/graph/report.md ]; then echo 'swarmvault: Graph report exists. Read wiki/graph/report.md before broad raw-file searching.'; fi";
+var claudeSearchMatcher = "Glob|Grep";
+var claudeSessionMatchers = ["startup", "resume", "clear", "compact"];
 var geminiSessionMatcher = "startup";
 var geminiSearchMatcher = "glob|grep|search|find";
 var copilotHookVersion = 1;
@@ -89,6 +89,8 @@ function primaryTargetPathForAgent(rootDir, agent) {
 }
 function hookScriptPathForAgent(rootDir, agent) {
   switch (agent) {
+    case "claude":
+      return path.join(rootDir, ".claude", "hooks", "swarmvault-graph-first.js");
     case "opencode":
       return path.join(rootDir, ".opencode", "plugins", "swarmvault-graph-first.js");
     case "gemini":
@@ -177,25 +179,106 @@ async function readJsonWithWarnings(filePath, fallback, label) {
 }
 async function installClaudeHook(rootDir) {
   const settingsPath = path.join(rootDir, ".claude", "settings.json");
+  const scriptPath = path.join(rootDir, ".claude", "hooks", "swarmvault-graph-first.js");
+  await writeOwnedFile(scriptPath, buildClaudeHookScript(), true);
   await ensureDir(path.dirname(settingsPath));
   const { data: settings, warnings } = await readJsonWithWarnings(settingsPath, {}, ".claude/settings.json");
   if (warnings.length > 0 && await fileExists(settingsPath)) {
     return { path: settingsPath, warnings };
   }
   const hooks = settings.hooks ?? {};
+  const sessionStart = hooks.SessionStart ?? [];
   const preToolUse = hooks.PreToolUse ?? [];
-  const exists = preToolUse.some((entry) => entry.matcher === claudeHookMatcher && JSON.stringify(entry).includes("swarmvault:"));
-  if (!exists) {
+  const sessionCommand = 'node "$CLAUDE_PROJECT_DIR/.claude/hooks/swarmvault-graph-first.js" session-start';
+  const preToolUseCommand = 'node "$CLAUDE_PROJECT_DIR/.claude/hooks/swarmvault-graph-first.js" pre-tool-use';
+  for (const matcher of claudeSessionMatchers) {
+    if (!sessionStart.some((entry) => entry.matcher === matcher && JSON.stringify(entry).includes("swarmvault-graph-first.js"))) {
+      sessionStart.push({
+        matcher,
+        hooks: [{ type: "command", command: sessionCommand }]
+      });
+    }
+  }
+  if (!preToolUse.some((entry) => entry.matcher === claudeSearchMatcher && JSON.stringify(entry).includes("swarmvault-graph-first.js"))) {
     preToolUse.push({
-      matcher: claudeHookMatcher,
-      hooks: [{ type: "command", command: claudeHookCommand }]
+      matcher: claudeSearchMatcher,
+      hooks: [{ type: "command", command: preToolUseCommand }]
     });
   }
-  settings.hooks = { ...hooks, PreToolUse: preToolUse };
+  settings.hooks = { ...hooks, SessionStart: sessionStart, PreToolUse: preToolUse };
   await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf8");
   return { path: settingsPath, warnings: [] };
 }
+function buildClaudeHookScript() {
+  return `#!/usr/bin/env node
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+${markerStateSnippet("claude").trim()}
+
+async function readInput() {
+  let body = "";
+  for await (const chunk of process.stdin) {
+    body += chunk;
+  }
+  if (!body.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    return {};
+  }
+}
+
+function emit(value) {
+  process.stdout.write(\`\${JSON.stringify(value)}\\n\`);
+}
+
+const mode = process.argv[2] ?? "";
+const input = await readInput();
+const cwd = resolveInputCwd(input);
+const reportNote = "SwarmVault graph report exists at wiki/graph/report.md. Read it before broad grep/glob searching.";
+
+if (!(await hasReport(cwd))) {
+  emit({});
+  process.exit(0);
+}
+
+if (mode === "session-start") {
+  await resetSession(cwd);
+  emit({
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: reportNote
+    }
+  });
+  process.exit(0);
+}
+
+const toolName = resolveToolName(input);
+if (collectCandidatePaths(input).some((value) => isReportPath(value, cwd))) {
+  await markReportRead(cwd);
+  emit({});
+  process.exit(0);
+}
+
+if (isBroadSearchTool(toolName) && !(await hasSeenReport(cwd))) {
+  emit({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: reportNote
+    }
+  });
+  process.exit(0);
+}
+
+emit({});
+`;
+}
 function markerStateSnippet(agentKey) {
   return `
 function markerState(cwd) {
@@ -237,7 +320,9 @@ function collectCandidatePaths(node, acc = []) {
   for (const [key, value] of Object.entries(node)) {
     if (["path", "filePath", "file_path", "paths", "target", "targets"].includes(key)) {
       collectCandidatePaths(value, acc);
+      continue;
     }
+    collectCandidatePaths(value, acc);
   }
   return acc;
 }
@@ -663,32 +748,151 @@ async function installConfiguredAgents(rootDir) {
 // src/graph-export.ts
 import fs2 from "fs/promises";
 import path2 from "path";
-var NODE_COLORS = {
-  source: "#f59e0b",
-  module: "#fb7185",
-  symbol: "#8b5cf6",
-  rationale: "#14b8a6",
-  concept: "#0ea5e9",
-  entity: "#22c55e"
-};
-function xmlEscape(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function cypherEscape(value) {
-  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+
+// src/graph-interchange.ts
+function exportHyperedgeNodeId(hyperedge) {
+  return `hyperedge:${hyperedge.id}`;
 }
 function relationType(relation) {
   const normalized = relation.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   return normalized || "RELATED_TO";
 }
+function cypherStringLiteral(value) {
+  let escaped = "";
+  for (const char of value) {
+    switch (char) {
+      case "\\":
+        escaped += "\\\\";
+        break;
+      case "'":
+        escaped += "\\'";
+        break;
+      case "\n":
+        escaped += "\\n";
+        break;
+      case "\r":
+        escaped += "\\r";
+        break;
+      case "	":
+        escaped += "\\t";
+        break;
+      case "\b":
+        escaped += "\\b";
+        break;
+      case "\f":
+        escaped += "\\f";
+        break;
+      default: {
+        const code = char.codePointAt(0) ?? 0;
+        escaped += code < 32 || code === 8232 || code === 8233 ? `\\u${code.toString(16).padStart(4, "0")}` : char;
+      }
+    }
+  }
+  return `'${escaped}'`;
+}
 function graphPageById(graph) {
   return new Map(graph.pages.map((page) => [page.id, page]));
 }
 function graphNodeById(graph) {
   return new Map(graph.nodes.map((node) => [node.id, node]));
 }
-function exportHyperedgeNodeId(hyperedge) {
-  return `hyperedge:${hyperedge.id}`;
+function normalizeSwarmNodeProps(node, page) {
+  return {
+    id: node.id,
+    label: node.label,
+    type: node.type,
+    sourceIds: JSON.stringify(node.sourceIds),
+    projectIds: JSON.stringify(node.projectIds),
+    ...node.pageId ? { pageId: node.pageId } : {},
+    ...page?.path ? { pagePath: page.path } : {},
+    ...node.sourceClass ? { sourceClass: node.sourceClass } : {},
+    ...node.language ? { language: node.language } : {},
+    ...node.moduleId ? { moduleId: node.moduleId } : {},
+    ...node.symbolKind ? { symbolKind: node.symbolKind } : {},
+    ...node.communityId ? { communityId: node.communityId } : {},
+    ...node.freshness ? { freshness: node.freshness } : {},
+    ...node.confidence !== void 0 ? { confidence: node.confidence } : {},
+    ...node.degree !== void 0 ? { degree: node.degree } : {},
+    ...node.bridgeScore !== void 0 ? { bridgeScore: node.bridgeScore } : {},
+    ...node.isGodNode !== void 0 ? { isGodNode: node.isGodNode } : {}
+  };
+}
+function normalizeHyperedgeNodeProps(hyperedge) {
+  return {
+    id: exportHyperedgeNodeId(hyperedge),
+    label: hyperedge.label,
+    type: "hyperedge",
+    relation: hyperedge.relation,
+    evidenceClass: hyperedge.evidenceClass,
+    confidence: hyperedge.confidence,
+    sourcePageIds: JSON.stringify(hyperedge.sourcePageIds),
+    why: hyperedge.why
+  };
+}
+function normalizeEdgeProps(edge) {
+  return {
+    id: edge.id,
+    relation: edge.relation,
+    status: edge.status,
+    evidenceClass: edge.evidenceClass,
+    confidence: edge.confidence,
+    provenance: JSON.stringify(edge.provenance),
+    ...edge.similarityReasons?.length ? { similarityReasons: JSON.stringify(edge.similarityReasons) } : {},
+    ...edge.similarityBasis ? { similarityBasis: edge.similarityBasis } : {}
+  };
+}
+function normalizeGroupMemberProps(hyperedge, nodeId) {
+  return {
+    id: `member:${hyperedge.id}:${nodeId}`,
+    relation: "group_member",
+    status: "inferred",
+    evidenceClass: hyperedge.evidenceClass,
+    confidence: hyperedge.confidence,
+    provenance: JSON.stringify(hyperedge.sourcePageIds)
+  };
+}
+function filterGraphBySourceClasses(graph, includeClasses) {
+  const allowed = new Set(includeClasses);
+  const nodeIds = new Set(graph.nodes.filter((node) => node.sourceClass && allowed.has(node.sourceClass)).map((node) => node.id));
+  const pageIds = new Set(graph.pages.filter((page) => page.sourceClass && allowed.has(page.sourceClass)).map((page) => page.id));
+  return {
+    ...graph,
+    nodes: graph.nodes.filter((node) => nodeIds.has(node.id)),
+    edges: graph.edges.filter((edge) => nodeIds.has(edge.source) && nodeIds.has(edge.target)),
+    hyperedges: graph.hyperedges.map((hyperedge) => ({
+      ...hyperedge,
+      nodeIds: hyperedge.nodeIds.filter((nodeId) => nodeIds.has(nodeId))
+    })).filter((hyperedge) => hyperedge.nodeIds.length >= 2),
+    communities: (graph.communities ?? []).map((community) => ({
+      ...community,
+      nodeIds: community.nodeIds.filter((nodeId) => nodeIds.has(nodeId))
+    })).filter((community) => community.nodeIds.length > 0),
+    sources: graph.sources.filter((source) => source.sourceClass && allowed.has(source.sourceClass)),
+    pages: graph.pages.filter((page) => pageIds.has(page.id))
+  };
+}
+function graphCounts(graph) {
+  return {
+    sources: graph.sources.length,
+    pages: graph.pages.length,
+    nodes: graph.nodes.length,
+    relationships: graph.edges.length,
+    hyperedges: graph.hyperedges.length,
+    groupMembers: graph.hyperedges.reduce((total, hyperedge) => total + hyperedge.nodeIds.length, 0)
+  };
+}
+
+// src/graph-export.ts
+var NODE_COLORS = {
+  source: "#f59e0b",
+  module: "#fb7185",
+  symbol: "#8b5cf6",
+  rationale: "#14b8a6",
+  concept: "#0ea5e9",
+  entity: "#22c55e"
+};
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function sortedCommunities(graph) {
   const known = (graph.communities ?? []).map((community) => ({
@@ -950,35 +1154,14 @@ function renderCypher(graph) {
   const lines = ["// Neo4j Cypher import generated by SwarmVault", ""];
   for (const node of [...graph.nodes].sort((left, right) => left.id.localeCompare(right.id))) {
     const page = node.pageId ? pageById2.get(node.pageId) : void 0;
-    const props = [
-      `id: '${cypherEscape(node.id)}'`,
-      `label: '${cypherEscape(node.label)}'`,
-      `type: '${cypherEscape(node.type)}'`,
-      `sourceIds: '${cypherEscape(JSON.stringify(node.sourceIds))}'`,
-      `projectIds: '${cypherEscape(JSON.stringify(node.projectIds))}'`,
-      node.pageId ? `pageId: '${cypherEscape(node.pageId)}'` : "",
-      page?.path ? `pagePath: '${cypherEscape(page.path)}'` : "",
-      node.language ? `language: '${cypherEscape(node.language)}'` : "",
-      node.symbolKind ? `symbolKind: '${cypherEscape(node.symbolKind)}'` : "",
-      node.communityId ? `communityId: '${cypherEscape(node.communityId)}'` : "",
-      node.degree !== void 0 ? `degree: ${node.degree}` : "",
-      node.bridgeScore !== void 0 ? `bridgeScore: ${node.bridgeScore}` : "",
-      node.isGodNode !== void 0 ? `isGodNode: ${node.isGodNode}` : ""
-    ].filter(Boolean).join(", ");
-    lines.push(`MERGE (n:SwarmNode {id: '${cypherEscape(node.id)}'}) SET n += { ${props} };`);
+    const props = Object.entries(normalizeSwarmNodeProps(node, page)).map(([key, value]) => `${key}: ${typeof value === "string" ? cypherStringLiteral(value) : value}`).filter(Boolean).join(", ");
+    lines.push(`MERGE (n:SwarmNode {id: ${cypherStringLiteral(node.id)}}) SET n += { ${props} };`);
   }
   lines.push("");
   for (const hyperedge of [...graph.hyperedges ?? []].sort((left, right) => left.id.localeCompare(right.id))) {
     const hyperedgeNodeId = exportHyperedgeNodeId(hyperedge);
-    lines.push(
-      `MERGE (h:SwarmNode {id: '${cypherEscape(hyperedgeNodeId)}'}) SET h += { id: '${cypherEscape(hyperedgeNodeId)}', label: '${cypherEscape(
-        hyperedge.label
-      )}', type: 'hyperedge', relation: '${cypherEscape(hyperedge.relation)}', evidenceClass: '${cypherEscape(
-        hyperedge.evidenceClass
-      )}', confidence: ${hyperedge.confidence}, sourcePageIds: '${cypherEscape(JSON.stringify(hyperedge.sourcePageIds))}', why: '${cypherEscape(
-        hyperedge.why
-      )}' };`
-    );
+    const props = Object.entries(normalizeHyperedgeNodeProps(hyperedge)).map(([key, value]) => `${key}: ${typeof value === "string" ? cypherStringLiteral(value) : value}`).join(", ");
+    lines.push(`MERGE (h:SwarmNode {id: ${cypherStringLiteral(hyperedgeNodeId)}}) SET h += { ${props} };`);
   }
   if ((graph.hyperedges ?? []).length) {
     lines.push("");
@@ -986,23 +1169,21 @@ function renderCypher(graph) {
   for (const hyperedge of [...graph.hyperedges ?? []].sort((left, right) => left.id.localeCompare(right.id))) {
     const hyperedgeNodeId = exportHyperedgeNodeId(hyperedge);
     for (const nodeId of hyperedge.nodeIds) {
+      const props = Object.entries(normalizeGroupMemberProps(hyperedge, nodeId)).map(([key, value]) => `${key}: ${typeof value === "string" ? cypherStringLiteral(value) : value}`).join(", ");
       lines.push(
-        `MATCH (h:SwarmNode {id: '${cypherEscape(hyperedgeNodeId)}'}), (n:SwarmNode {id: '${cypherEscape(nodeId)}'})`,
-        `MERGE (h)-[r:GROUP_MEMBER {id: '${cypherEscape(`member:${hyperedge.id}:${nodeId}`)}'}]->(n)`,
-        `SET r += { relation: 'group_member', status: 'inferred', evidenceClass: '${cypherEscape(
-          hyperedge.evidenceClass
-        )}', confidence: ${hyperedge.confidence}, provenance: '${cypherEscape(JSON.stringify(hyperedge.sourcePageIds))}' };`
+        `MATCH (h:SwarmNode {id: ${cypherStringLiteral(hyperedgeNodeId)}}), (n:SwarmNode {id: ${cypherStringLiteral(nodeId)}})`,
+        `MERGE (h)-[r:GROUP_MEMBER {id: ${cypherStringLiteral(`member:${hyperedge.id}:${nodeId}`)}}]->(n)`,
+        `SET r += { ${props} };`
       );
     }
   }
   lines.push("");
   for (const edge of [...graph.edges].sort((left, right) => left.id.localeCompare(right.id))) {
+    const props = Object.entries(normalizeEdgeProps(edge)).map(([key, value]) => `${key}: ${typeof value === "string" ? cypherStringLiteral(value) : value}`).join(", ");
     lines.push(
-      `MATCH (a:SwarmNode {id: '${cypherEscape(edge.source)}'}), (b:SwarmNode {id: '${cypherEscape(edge.target)}'})`,
-      `MERGE (a)-[r:${relationType(edge.relation)} {id: '${cypherEscape(edge.id)}'}]->(b)`,
-      `SET r += { relation: '${cypherEscape(edge.relation)}', status: '${cypherEscape(edge.status)}', evidenceClass: '${cypherEscape(
-        edge.evidenceClass
-      )}', confidence: ${edge.confidence}, provenance: '${cypherEscape(JSON.stringify(edge.provenance))}'${edge.similarityReasons?.length ? `, similarityReasons: '${cypherEscape(JSON.stringify(edge.similarityReasons))}'` : ""} };`
+      `MATCH (a:SwarmNode {id: ${cypherStringLiteral(edge.source)}}), (b:SwarmNode {id: ${cypherStringLiteral(edge.target)}})`,
+      `MERGE (a)-[r:${relationType(edge.relation)} {id: ${cypherStringLiteral(edge.id)}}]->(b)`,
+      `SET r += { ${props} };`
     );
   }
   lines.push("");
@@ -1028,104 +1209,477 @@ async function exportGraphFormat(rootDir, format, outputPath) {
   return { format, outputPath: resolvedPath };
 }
 
-// src/hooks.ts
+// src/graph-push.ts
 import fs3 from "fs/promises";
 import path3 from "path";
-import process2 from "process";
-var hookStart = "# >>> swarmvault hook >>>";
-var hookEnd = "# <<< swarmvault hook <<<";
-async function findNearestGitRoot(startPath) {
-  let current = path3.resolve(startPath);
-  try {
-    const stat = await fs3.stat(current);
-    if (!stat.isDirectory()) {
-      current = path3.dirname(current);
-    }
-  } catch {
-    current = path3.dirname(current);
-  }
-  while (true) {
-    if (await fileExists(path3.join(current, ".git"))) {
-      return current;
-    }
-    const parent = path3.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function shellQuote(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function resolveSwarmvaultExecutableCandidate() {
-  const argvPath = process2.argv[1];
-  if (typeof argvPath === "string" && argvPath.trim() && (argvPath.includes(`${path3.sep}@swarmvaultai${path3.sep}cli${path3.sep}`) || argvPath.includes(`${path3.sep}packages${path3.sep}cli${path3.sep}`))) {
-    return path3.resolve(argvPath);
-  }
-  return "swarmvault";
-}
-function managedHookBlock(vaultRoot) {
-  const resolvedExecutable = resolveSwarmvaultExecutableCandidate();
-  return [
-    hookStart,
-    `cd ${shellQuote(vaultRoot)} || exit 0`,
-    `swarmvault_bin=${shellQuote(resolvedExecutable)}`,
-    '[ ! -x "$swarmvault_bin" ] && swarmvault_bin=$(command -v swarmvault 2>/dev/null || true)',
-    'if [ -n "$swarmvault_bin" ] && [ -x "$swarmvault_bin" ]; then',
-    `  "$swarmvault_bin" watch --repo --once >/dev/null 2>&1 || printf '[swarmvault hook] refresh failed\\n' >&2`,
-    "fi",
-    hookEnd,
-    ""
-  ].join("\n");
+import neo4j from "neo4j-driver";
+
+// src/benchmark.ts
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_BENCHMARK_QUESTIONS = [
+  "How does this vault connect the main concepts?",
+  "Which pages bridge the biggest communities?",
+  "What are the core abstractions in this vault?",
+  "Where are the biggest knowledge gaps?",
+  "What evidence should I read first?"
+];
+var RESEARCH_BENCHMARK_QUESTION = "Which research sources should I read first, and why?";
+function nodeMap(graph) {
+  return new Map(graph.nodes.map((node) => [node.id, node]));
 }
-function hookPath(repoRoot, hookName) {
-  return path3.join(repoRoot, ".git", "hooks", hookName);
+function pageMap(graph) {
+  return new Map(graph.pages.map((page) => [page.id, page]));
 }
-async function readHookStatus(filePath) {
-  if (!await fileExists(filePath)) {
-    return "not_installed";
-  }
-  const content = await fs3.readFile(filePath, "utf8");
-  return content.includes(hookStart) && content.includes(hookEnd) ? "installed" : "other_content";
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));
 }
-async function upsertHookFile(filePath, block) {
-  const existing = await fileExists(filePath) ? await fs3.readFile(filePath, "utf8") : "";
-  let next;
-  const startIndex = existing.indexOf(hookStart);
-  const endIndex = existing.indexOf(hookEnd);
-  if (startIndex !== -1 && endIndex !== -1) {
-    next = `${existing.slice(0, startIndex)}${block}${existing.slice(endIndex + hookEnd.length)}`.trimEnd();
-  } else if (existing.trim().length > 0) {
-    next = `${existing.trimEnd()}
-
-${block}`.trimEnd();
-  } else {
-    next = `#!/bin/sh
-${block}`.trimEnd();
-  }
-  await ensureDir(path3.dirname(filePath));
-  await fs3.writeFile(filePath, `${next}
-`, { mode: 493, encoding: "utf8" });
-  await fs3.chmod(filePath, 493);
+function estimateCorpusWords(texts) {
+  return texts.reduce((total, text) => total + normalizeWhitespace(text).split(/\s+/).filter(Boolean).length, 0);
 }
-async function removeHookBlock(filePath) {
-  if (!await fileExists(filePath)) {
-    return;
+function benchmarkQueryTokens(graph, queryResult, pageContentsById) {
+  const nodesById = nodeMap(graph);
+  const pagesById = pageMap(graph);
+  const edgeIds = new Set(queryResult.visitedEdgeIds);
+  const lines = [];
+  for (const pageId of queryResult.pageIds) {
+    const page = pagesById.get(pageId);
+    if (!page) {
+      continue;
+    }
+    const content = normalizeWhitespace(pageContentsById.get(pageId) ?? "").slice(0, 280);
+    lines.push(`PAGE ${page.title} path=${page.path} kind=${page.kind}`);
+    if (content) {
+      lines.push(`PAGE_BODY ${content}`);
+    }
   }
-  const existing = await fs3.readFile(filePath, "utf8");
-  const startIndex = existing.indexOf(hookStart);
-  const endIndex = existing.indexOf(hookEnd);
-  if (startIndex === -1 || endIndex === -1) {
-    return;
+  for (const nodeId of queryResult.visitedNodeIds) {
+    const node = nodesById.get(nodeId);
+    if (!node) {
+      continue;
+    }
+    lines.push(`NODE ${node.label} type=${node.type} community=${node.communityId ?? "unassigned"} page=${node.pageId ?? "none"}`);
   }
-  const next = `${existing.slice(0, startIndex)}${existing.slice(endIndex + hookEnd.length)}`.trim();
-  if (!next || next === "#!/bin/sh") {
-    await fs3.rm(filePath, { force: true });
-    return;
+  for (const edge of graph.edges) {
+    if (!edgeIds.has(edge.id)) {
+      continue;
+    }
+    const source = nodesById.get(edge.source)?.label ?? edge.source;
+    const target = nodesById.get(edge.target)?.label ?? edge.target;
+    lines.push(`EDGE ${source} --${edge.relation}/${edge.evidenceClass}/${edge.confidence.toFixed(2)}--> ${target}`);
   }
-  await fs3.writeFile(filePath, `${next}
-`, "utf8");
+  const queryTokens = estimateTokens(lines.join("\n"));
+  return {
+    question: queryResult.question,
+    queryTokens,
+    reduction: 0,
+    visitedNodeIds: queryResult.visitedNodeIds,
+    visitedEdgeIds: queryResult.visitedEdgeIds,
+    pageIds: queryResult.pageIds
+  };
+}
+function graphHash(graph) {
+  const hashedPages = graph.pages.filter((page) => page.kind !== "graph_report" && page.kind !== "community_summary");
+  const normalized = JSON.stringify(
+    {
+      nodes: [...graph.nodes].map((node) => ({
+        id: node.id,
+        type: node.type,
+        label: node.label,
+        pageId: node.pageId ?? null,
+        sourceClass: node.sourceClass ?? null,
+        communityId: node.communityId ?? null,
+        degree: node.degree ?? null,
+        bridgeScore: node.bridgeScore ?? null,
+        isGodNode: node.isGodNode ?? false,
+        sourceIds: [...node.sourceIds].sort(),
+        projectIds: [...node.projectIds].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id)),
+      edges: [...graph.edges].map((edge) => ({
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+        relation: edge.relation,
+        status: edge.status,
+        evidenceClass: edge.evidenceClass,
+        similarityBasis: edge.similarityBasis ?? null,
+        confidence: edge.confidence,
+        provenance: [...edge.provenance].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id)),
+      pages: [...hashedPages].map((page) => ({
+        id: page.id,
+        path: page.path,
+        kind: page.kind,
+        status: page.status,
+        sourceType: page.sourceType ?? null,
+        sourceClass: page.sourceClass ?? null,
+        sourceIds: [...page.sourceIds].sort(),
+        projectIds: [...page.projectIds].sort(),
+        nodeIds: [...page.nodeIds].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id)),
+      communities: [...graph.communities ?? []].map((community) => ({
+        id: community.id,
+        label: community.label,
+        nodeIds: [...community.nodeIds].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id))
+    },
+    null,
+    0
+  );
+  return sha256(normalized);
+}
+function hasResearchSources(pages) {
+  return pages.some((page) => page.kind === "source" && Boolean(page.sourceType) && page.sourceType !== "url");
+}
+function defaultBenchmarkQuestionsForGraph(graph, maxQuestions = 3) {
+  const normalizedLimit = Math.max(1, Math.min(maxQuestions, DEFAULT_BENCHMARK_QUESTIONS.length));
+  const questions = [...DEFAULT_BENCHMARK_QUESTIONS];
+  if (hasResearchSources(graph.pages)) {
+    questions.unshift(RESEARCH_BENCHMARK_QUESTION);
+  }
+  return uniqueBy(questions, (item) => item).slice(0, normalizedLimit);
+}
+function buildBenchmarkArtifact(input) {
+  const corpusTokens = Math.max(1, Math.round(input.corpusWords * (100 / 75)));
+  const perQuestion = input.perQuestion.filter((entry) => entry.queryTokens > 0).map((entry) => ({
+    ...entry,
+    reduction: Number(Math.max(0, 1 - entry.queryTokens / Math.max(1, corpusTokens)).toFixed(3))
+  }));
+  const avgQueryTokens = perQuestion.length ? Math.max(1, Math.round(perQuestion.reduce((total, entry) => total + entry.queryTokens, 0) / perQuestion.length)) : 0;
+  const reductionRatio = avgQueryTokens ? Number(Math.max(0, 1 - avgQueryTokens / Math.max(1, corpusTokens)).toFixed(3)) : 0;
+  const uniqueVisitedNodes = new Set(perQuestion.flatMap((entry) => entry.visitedNodeIds)).size;
+  const summary = {
+    questionCount: input.questions.length,
+    uniqueVisitedNodes,
+    finalContextTokens: avgQueryTokens,
+    naiveCorpusTokens: corpusTokens,
+    avgReduction: reductionRatio,
+    reductionRatio
+  };
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    graphHash: graphHash(input.graph),
+    corpusWords: input.corpusWords,
+    corpusTokens,
+    nodes: input.graph.nodes.length,
+    edges: input.graph.edges.length,
+    avgQueryTokens,
+    reductionRatio,
+    sampleQuestions: input.questions,
+    perQuestion,
+    questionResults: perQuestion,
+    summary
+  };
+}
+
+// src/graph-push.ts
+var DEFAULT_NEO4J_BATCH_SIZE = 500;
+var DEFAULT_NEO4J_DATABASE = "neo4j";
+function requireConfigValue(value, name) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  throw new Error(`Neo4j push requires ${name}. Configure \`graphSinks.neo4j.${name}\` or pass the matching CLI flag.`);
+}
+async function deriveVaultId(rootDir) {
+  const realRoot = await fs3.realpath(rootDir).catch(() => path3.resolve(rootDir));
+  const label = slugify(path3.basename(realRoot));
+  return `${label}-${sha256(realRoot).slice(0, 12)}`;
+}
+async function resolveNeo4jPushConfig(rootDir, options) {
+  const { config } = await loadVaultConfig(rootDir);
+  const sink = config.graphSinks?.neo4j;
+  const includeClasses = normalizeIncludedClasses(options.includeClasses ?? sink?.includeClasses ?? ["first_party"]);
+  return {
+    uri: requireConfigValue(options.uri ?? sink?.uri, "uri"),
+    username: requireConfigValue(options.username ?? sink?.username, "username"),
+    passwordEnv: requireConfigValue(options.passwordEnv ?? sink?.passwordEnv, "passwordEnv"),
+    database: options.database?.trim() || sink?.database?.trim() || DEFAULT_NEO4J_DATABASE,
+    vaultId: options.vaultId?.trim() || sink?.vaultId?.trim() || await deriveVaultId(rootDir),
+    includeClasses,
+    batchSize: normalizeBatchSize(options.batchSize ?? sink?.batchSize)
+  };
+}
+function normalizeIncludedClasses(values) {
+  const allowed = ["first_party", "third_party", "resource", "generated"];
+  const unique = [...new Set(values)].filter((value) => allowed.includes(value));
+  return unique.length ? unique : ["first_party"];
+}
+function normalizeBatchSize(value) {
+  if (!Number.isFinite(value) || !value || value <= 0) {
+    return DEFAULT_NEO4J_BATCH_SIZE;
+  }
+  return Math.max(1, Math.floor(value));
+}
+async function loadGraph2(rootDir) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const raw = JSON.parse(await fs3.readFile(paths.graphPath, "utf8"));
+  return raw;
+}
+function buildResult(input) {
+  const counts = graphCounts(input.filteredGraph);
+  const fullCounts = graphCounts(input.fullGraph);
+  return {
+    sink: "neo4j",
+    uri: input.resolved.uri,
+    database: input.resolved.database,
+    vaultId: input.resolved.vaultId,
+    dryRun: input.dryRun,
+    graphHash: graphHash(input.fullGraph),
+    includedSourceClasses: input.resolved.includeClasses,
+    counts,
+    skipped: {
+      sources: Math.max(0, fullCounts.sources - counts.sources),
+      pages: Math.max(0, fullCounts.pages - counts.pages),
+      nodes: Math.max(0, fullCounts.nodes - counts.nodes),
+      relationships: Math.max(0, fullCounts.relationships - counts.relationships),
+      hyperedges: Math.max(0, fullCounts.hyperedges - counts.hyperedges),
+      groupMembers: Math.max(0, fullCounts.groupMembers - counts.groupMembers)
+    },
+    warnings: input.warnings ?? []
+  };
+}
+function createDriver(uri, username, password) {
+  return neo4j.driver(uri, neo4j.auth.basic(username, password));
+}
+async function ensureNeo4jConstraints(session) {
+  await session.run("CREATE CONSTRAINT swarmvault_node_identity IF NOT EXISTS FOR (n:SwarmNode) REQUIRE (n.vaultId, n.id) IS UNIQUE");
+  await session.run("CREATE CONSTRAINT swarmvault_sync_identity IF NOT EXISTS FOR (s:SwarmVaultSync) REQUIRE s.vaultId IS UNIQUE");
+}
+function chunkRows(rows, batchSize) {
+  const chunks = [];
+  for (let index = 0; index < rows.length; index += batchSize) {
+    chunks.push(rows.slice(index, index + batchSize));
+  }
+  return chunks;
+}
+async function writeNodeRows(session, vaultId, rows, batchSize) {
+  for (const chunk of chunkRows(rows, batchSize)) {
+    await session.executeWrite(
+      (tx) => tx.run(["UNWIND $rows AS row", "MERGE (n:SwarmNode { vaultId: $vaultId, id: row.id })", "SET n += row.props"].join("\n"), {
+        vaultId,
+        rows: chunk
+      })
+    );
+  }
+}
+async function writeEdgeRows(session, vaultId, rows, batchSize, relation) {
+  const neoRelation = relationType(relation);
+  const query = [
+    "UNWIND $rows AS row",
+    "MATCH (a:SwarmNode { vaultId: $vaultId, id: row.source })",
+    "MATCH (b:SwarmNode { vaultId: $vaultId, id: row.target })",
+    `MERGE (a)-[r:${neoRelation} { vaultId: $vaultId, id: row.id }]->(b)`,
+    "SET r += row.props"
+  ].join("\n");
+  for (const chunk of chunkRows(rows, batchSize)) {
+    await session.executeWrite((tx) => tx.run(query, { vaultId, rows: chunk }));
+  }
+}
+async function writeSyncNode(session, input) {
+  await session.executeWrite(
+    (tx) => tx.run(
+      [
+        "MERGE (s:SwarmVaultSync { vaultId: $vaultId })",
+        "SET s += {",
+        "  vaultId: $vaultId,",
+        "  rootDir: $rootDir,",
+        "  graphGeneratedAt: $graphGeneratedAt,",
+        "  graphHash: $graphHash,",
+        "  pushedAt: $pushedAt,",
+        "  includedSourceClasses: $includedSourceClasses,",
+        "  sources: $sources,",
+        "  pages: $pages,",
+        "  nodes: $nodes,",
+        "  relationships: $relationships,",
+        "  hyperedges: $hyperedges,",
+        "  groupMembers: $groupMembers",
+        "}"
+      ].join("\n"),
+      {
+        vaultId: input.vaultId,
+        rootDir: path3.resolve(input.rootDir),
+        graphGeneratedAt: input.graph.generatedAt,
+        graphHash: graphHash(input.graph),
+        pushedAt: input.pushedAt,
+        includedSourceClasses: input.includedSourceClasses,
+        ...input.counts
+      }
+    )
+  );
+}
+async function pushGraphNeo4j(rootDir, options = {}) {
+  const graph = await loadGraph2(rootDir);
+  const resolved = await resolveNeo4jPushConfig(rootDir, options);
+  const filteredGraph = filterGraphBySourceClasses(graph, resolved.includeClasses);
+  const warnings = filteredGraph.nodes.length || filteredGraph.hyperedges.length || filteredGraph.edges.length ? [] : [`No graph records matched the included source classes: ${resolved.includeClasses.join(", ")}`];
+  const result = buildResult({
+    resolved,
+    filteredGraph,
+    fullGraph: graph,
+    dryRun: options.dryRun ?? false,
+    warnings
+  });
+  if (options.dryRun) {
+    return result;
+  }
+  const password = process.env[resolved.passwordEnv];
+  if (!password) {
+    throw new Error(`Environment variable ${resolved.passwordEnv} is required for Neo4j push.`);
+  }
+  const driver = (options.driverFactory ?? createDriver)(resolved.uri, resolved.username, password);
+  const session = driver.session({ database: resolved.database });
+  try {
+    await ensureNeo4jConstraints(session);
+    const pageById2 = graphPageById(filteredGraph);
+    const nodeRows = [
+      ...filteredGraph.nodes.sort((left, right) => left.id.localeCompare(right.id)).map((node) => ({
+        id: node.id,
+        props: normalizeSwarmNodeProps(node, node.pageId ? pageById2.get(node.pageId) : void 0)
+      })),
+      ...filteredGraph.hyperedges.sort((left, right) => left.id.localeCompare(right.id)).map((hyperedge) => ({
+        id: normalizeHyperedgeNodeProps(hyperedge).id,
+        props: normalizeHyperedgeNodeProps(hyperedge)
+      }))
+    ];
+    await writeNodeRows(session, resolved.vaultId, nodeRows, resolved.batchSize);
+    const edgeGroups = /* @__PURE__ */ new Map();
+    for (const edge of [...filteredGraph.edges].sort((left, right) => left.id.localeCompare(right.id))) {
+      const rows = edgeGroups.get(edge.relation) ?? [];
+      rows.push({
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+        props: normalizeEdgeProps(edge)
+      });
+      edgeGroups.set(edge.relation, rows);
+    }
+    for (const [relation, rows] of [...edgeGroups.entries()].sort((left, right) => left[0].localeCompare(right[0]))) {
+      await writeEdgeRows(session, resolved.vaultId, rows, resolved.batchSize, relation);
+    }
+    const memberRows = filteredGraph.hyperedges.flatMap(
+      (hyperedge) => hyperedge.nodeIds.map((nodeId) => ({
+        id: `member:${hyperedge.id}:${nodeId}`,
+        source: normalizeHyperedgeNodeProps(hyperedge).id,
+        target: nodeId,
+        props: normalizeGroupMemberProps(hyperedge, nodeId)
+      }))
+    );
+    if (memberRows.length) {
+      await writeEdgeRows(session, resolved.vaultId, memberRows, resolved.batchSize, "group_member");
+    }
+    await writeSyncNode(session, {
+      vaultId: resolved.vaultId,
+      rootDir,
+      graph,
+      pushedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      includedSourceClasses: resolved.includeClasses,
+      counts: result.counts
+    });
+    return result;
+  } finally {
+    await session.close();
+    await driver.close();
+  }
+}
+
+// src/hooks.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import process2 from "process";
+var hookStart = "# >>> swarmvault hook >>>";
+var hookEnd = "# <<< swarmvault hook <<<";
+async function findNearestGitRoot(startPath) {
+  let current = path4.resolve(startPath);
+  try {
+    const stat = await fs4.stat(current);
+    if (!stat.isDirectory()) {
+      current = path4.dirname(current);
+    }
+  } catch {
+    current = path4.dirname(current);
+  }
+  while (true) {
+    if (await fileExists(path4.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function resolveSwarmvaultExecutableCandidate() {
+  const argvPath = process2.argv[1];
+  if (typeof argvPath === "string" && argvPath.trim() && (argvPath.includes(`${path4.sep}@swarmvaultai${path4.sep}cli${path4.sep}`) || argvPath.includes(`${path4.sep}packages${path4.sep}cli${path4.sep}`))) {
+    return path4.resolve(argvPath);
+  }
+  return "swarmvault";
+}
+function managedHookBlock(vaultRoot) {
+  const resolvedExecutable = resolveSwarmvaultExecutableCandidate();
+  return [
+    hookStart,
+    `cd ${shellQuote(vaultRoot)} || exit 0`,
+    `swarmvault_bin=${shellQuote(resolvedExecutable)}`,
+    '[ ! -x "$swarmvault_bin" ] && swarmvault_bin=$(command -v swarmvault 2>/dev/null || true)',
+    'if [ -n "$swarmvault_bin" ] && [ -x "$swarmvault_bin" ]; then',
+    `  "$swarmvault_bin" watch --repo --once >/dev/null 2>&1 || printf '[swarmvault hook] refresh failed\\n' >&2`,
+    "fi",
+    hookEnd,
+    ""
+  ].join("\n");
+}
+function hookPath(repoRoot, hookName) {
+  return path4.join(repoRoot, ".git", "hooks", hookName);
+}
+async function readHookStatus(filePath) {
+  if (!await fileExists(filePath)) {
+    return "not_installed";
+  }
+  const content = await fs4.readFile(filePath, "utf8");
+  return content.includes(hookStart) && content.includes(hookEnd) ? "installed" : "other_content";
+}
+async function upsertHookFile(filePath, block) {
+  const existing = await fileExists(filePath) ? await fs4.readFile(filePath, "utf8") : "";
+  let next;
+  const startIndex = existing.indexOf(hookStart);
+  const endIndex = existing.indexOf(hookEnd);
+  if (startIndex !== -1 && endIndex !== -1) {
+    next = `${existing.slice(0, startIndex)}${block}${existing.slice(endIndex + hookEnd.length)}`.trimEnd();
+  } else if (existing.trim().length > 0) {
+    next = `${existing.trimEnd()}
+
+${block}`.trimEnd();
+  } else {
+    next = `#!/bin/sh
+${block}`.trimEnd();
+  }
+  await ensureDir(path4.dirname(filePath));
+  await fs4.writeFile(filePath, `${next}
+`, { mode: 493, encoding: "utf8" });
+  await fs4.chmod(filePath, 493);
+}
+async function removeHookBlock(filePath) {
+  if (!await fileExists(filePath)) {
+    return;
+  }
+  const existing = await fs4.readFile(filePath, "utf8");
+  const startIndex = existing.indexOf(hookStart);
+  const endIndex = existing.indexOf(hookEnd);
+  if (startIndex === -1 || endIndex === -1) {
+    return;
+  }
+  const next = `${existing.slice(0, startIndex)}${existing.slice(endIndex + hookEnd.length)}`.trim();
+  if (!next || next === "#!/bin/sh") {
+    await fs4.rm(filePath, { force: true });
+    return;
+  }
+  await fs4.writeFile(filePath, `${next}
+`, "utf8");
 }
 async function getGitHookStatus(rootDir) {
   const repoRoot = await findNearestGitRoot(rootDir);
@@ -1147,7 +1701,7 @@ async function installGitHooks(rootDir) {
   if (!repoRoot) {
     throw new Error("No git repository found above the current vault.");
   }
-  const block = managedHookBlock(path3.resolve(rootDir));
+  const block = managedHookBlock(path4.resolve(rootDir));
   await upsertHookFile(hookPath(repoRoot, "post-commit"), block);
   await upsertHookFile(hookPath(repoRoot, "post-checkout"), block);
   return getGitHookStatus(rootDir);
@@ -1167,27 +1721,27 @@ async function uninstallGitHooks(rootDir) {
 }
 
 // src/ingest.ts
-import fs9 from "fs/promises";
-import path10 from "path";
+import fs10 from "fs/promises";
+import path11 from "path";
 import { pathToFileURL } from "url";
 import { Readability } from "@mozilla/readability";
 import matter3 from "gray-matter";
 import ignore from "ignore";
-import { JSDOM } from "jsdom";
+import { JSDOM as JSDOM2 } from "jsdom";
 import mime from "mime-types";
 import TurndownService from "turndown";
 
 // src/code-analysis.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 import ts from "typescript";
 
 // src/code-tree-sitter.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import { createRequire } from "module";
-import path4 from "path";
+import path5 from "path";
 var require2 = createRequire(import.meta.url);
-var TREE_SITTER_PACKAGE_ROOT = path4.dirname(path4.dirname(require2.resolve("@vscode/tree-sitter-wasm")));
+var TREE_SITTER_PACKAGE_ROOT = path5.dirname(path5.dirname(require2.resolve("@vscode/tree-sitter-wasm")));
 var RATIONALE_MARKERS = ["NOTE:", "IMPORTANT:", "HACK:", "WHY:", "RATIONALE:"];
 function stripKnownCommentPrefix(line) {
   let next = line.trim();
@@ -1224,7 +1778,7 @@ async function getTreeSitterModule() {
 async function ensureTreeSitterInit(module) {
   if (!treeSitterInitPromise) {
     treeSitterInitPromise = module.Parser.init({
-      locateFile: () => path4.join(TREE_SITTER_PACKAGE_ROOT, "wasm", "tree-sitter.wasm")
+      locateFile: () => path5.join(TREE_SITTER_PACKAGE_ROOT, "wasm", "tree-sitter.wasm")
     });
   }
   return treeSitterInitPromise;
@@ -1237,7 +1791,7 @@ async function loadLanguage(language) {
   const loader = (async () => {
     const module = await getTreeSitterModule();
     await ensureTreeSitterInit(module);
-    const bytes = await fs4.readFile(path4.join(TREE_SITTER_PACKAGE_ROOT, "wasm", grammarFileByLanguage[language]));
+    const bytes = await fs5.readFile(path5.join(TREE_SITTER_PACKAGE_ROOT, "wasm", grammarFileByLanguage[language]));
     return module.Language.load(bytes);
   })();
   languageCache.set(language, loader);
@@ -1254,16 +1808,16 @@ function stripCodeExtension(filePath) {
   return filePath.replace(/\.(?:[cm]?jsx?|tsx?|mts|cts|py|go|rs|java|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i, "");
 }
 function manifestModuleName(manifest, language) {
-  const repoPath = manifest.repoRelativePath ?? path4.basename(manifest.originalPath ?? manifest.storedPath);
+  const repoPath = manifest.repoRelativePath ?? path5.basename(manifest.originalPath ?? manifest.storedPath);
   const normalized = toPosix(stripCodeExtension(repoPath)).replace(/^\.\/+/, "");
   if (!normalized) {
     return void 0;
   }
   if (language === "python") {
     const dotted = normalized.replace(/\/__init__$/i, "").replace(/\//g, ".").replace(/^src\./, "");
-    return dotted || path4.posix.basename(normalized);
+    return dotted || path5.posix.basename(normalized);
   }
-  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path4.posix.basename(normalized) : normalized;
+  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path5.posix.basename(normalized) : normalized;
 }
 function singleLineSignature(value) {
   return truncate(
@@ -1298,6 +1852,55 @@ function collectCallNamesFromText(text, availableNames, selfName) {
   }
   return uniqueBy(names, (name) => name);
 }
+function goReceiverBinding(node) {
+  if (!node) {
+    return {};
+  }
+  const names = uniqueBy(
+    node.descendantsOfType(["identifier", "type_identifier"]).filter((item) => item !== null).map((item) => normalizeSymbolReference(item.text)).filter(Boolean),
+    (item) => item
+  );
+  if (names.length === 0) {
+    return {};
+  }
+  if (names.length === 1) {
+    return { typeName: names[0] };
+  }
+  return {
+    variableName: names[0],
+    typeName: names.at(-1)
+  };
+}
+function goCalledSymbolName(node, receiver) {
+  if (!node) {
+    return void 0;
+  }
+  if (node.type === "selector_expression") {
+    const targetName = normalizeSymbolReference(
+      extractIdentifier(node.childForFieldName("operand") ?? node.childForFieldName("object") ?? node.namedChildren.at(0) ?? null) ?? ""
+    );
+    const fieldName = normalizeSymbolReference(
+      extractIdentifier(node.childForFieldName("field") ?? findNamedChild(node, "field_identifier") ?? node.namedChildren.at(-1) ?? null) ?? ""
+    );
+    if (!fieldName) {
+      return void 0;
+    }
+    if (receiver.variableName && receiver.typeName && targetName === receiver.variableName) {
+      return `${receiver.typeName}.${fieldName}`;
+    }
+    return fieldName;
+  }
+  return normalizeSymbolReference(extractIdentifier(node) ?? "");
+}
+function goCallNamesFromBody(bodyNode, receiver) {
+  if (!bodyNode) {
+    return [];
+  }
+  return uniqueBy(
+    bodyNode.descendantsOfType("call_expression").filter((item) => item !== null).map((callNode) => goCalledSymbolName(callNode.childForFieldName("function") ?? callNode.namedChildren.at(0) ?? null, receiver)).filter((name) => Boolean(name)),
+    (name) => name
+  );
+}
 function finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics, metadata) {
   const topLevelNames = new Set(draftSymbols.map((symbol) => symbol.name));
   for (const symbol of draftSymbols) {
@@ -1784,7 +2387,9 @@ function goCodeAnalysis(manifest, rootNode, diagnostics) {
       if (!name) {
         continue;
       }
-      const receiverType = child.type === "method_declaration" ? normalizeSymbolReference(nodeText(child.childForFieldName("receiver")).replace(/[()]/g, " ").split(/\s+/).at(-1) ?? "") : "";
+      const receiver = child.type === "method_declaration" ? goReceiverBinding(child.childForFieldName("receiver")) : {};
+      const receiverType = receiver.typeName ?? "";
+      const bodyNode = child.childForFieldName("body");
       const symbolName = receiverType ? `${receiverType}.${name}` : name;
       const exported = exportedByCapitalization(name);
       draftSymbols.push({
@@ -1792,10 +2397,10 @@ function goCodeAnalysis(manifest, rootNode, diagnostics) {
         kind: "function",
         signature: singleLineSignature(child.text),
         exported,
-        callNames: [],
+        callNames: goCallNamesFromBody(bodyNode, receiver),
         extendsNames: [],
         implementsNames: [],
-        bodyText: nodeText(child.childForFieldName("body"))
+        bodyText: nodeText(bodyNode)
       });
       if (exported) {
         exportLabels.push(symbolName);
@@ -2473,11 +3078,11 @@ function isNodeExported(node) {
     )
   );
 }
-function makeSymbolId2(sourceId, name, seen) {
+function makeSymbolId2(scope, name, seen) {
   const base = slugify(name);
   const count = (seen.get(base) ?? 0) + 1;
   seen.set(base, count);
-  return `symbol:${sourceId}:${count === 1 ? base : `${base}-${count}`}`;
+  return `symbol:${scope}:${count === 1 ? base : `${base}-${count}`}`;
 }
 function summarizeModule(manifest, code) {
   const localImports = code.imports.filter((item) => !item.isExternal && !item.reExport).length;
@@ -2617,16 +3222,16 @@ function stripCodeExtension2(filePath) {
   return filePath.replace(/\.(?:[cm]?jsx?|tsx?|mts|cts|py|go|rs|java|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i, "");
 }
 function manifestModuleName2(manifest, language) {
-  const repoPath = manifest.repoRelativePath ?? path5.basename(manifest.originalPath ?? manifest.storedPath);
+  const repoPath = manifest.repoRelativePath ?? path6.basename(manifest.originalPath ?? manifest.storedPath);
   const normalized = toPosix(stripCodeExtension2(repoPath)).replace(/^\.\/+/, "");
   if (!normalized) {
     return void 0;
   }
   if (language === "python") {
     const dotted = normalized.replace(/\/__init__$/i, "").replace(/\//g, ".").replace(/^src\./, "");
-    return dotted || path5.posix.basename(normalized);
+    return dotted || path6.posix.basename(normalized);
   }
-  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path5.posix.basename(normalized) : normalized;
+  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path6.posix.basename(normalized) : normalized;
 }
 function finalizeCodeAnalysis2(manifest, language, imports, draftSymbols, exportLabels, diagnostics, metadata) {
   const topLevelNames = new Set(draftSymbols.map((symbol) => symbol.name));
@@ -2636,8 +3241,9 @@ function finalizeCodeAnalysis2(manifest, language, imports, draftSymbols, export
     }
   }
   const seenSymbolIds = /* @__PURE__ */ new Map();
+  const symbolScope = metadata?.namespace ? `ns:${slugify(metadata.namespace)}` : manifest.sourceId;
   const symbols = draftSymbols.map((symbol) => ({
-    id: makeSymbolId2(manifest.sourceId, symbol.name, seenSymbolIds),
+    id: makeSymbolId2(symbolScope, symbol.name, seenSymbolIds),
     name: symbol.name,
     kind: symbol.kind,
     signature: symbol.signature,
@@ -2919,7 +3525,7 @@ function analyzeTypeScriptLikeCode(manifest, content) {
   };
 }
 function inferCodeLanguage(filePath, mimeType = "") {
-  const extension = path5.extname(filePath).toLowerCase();
+  const extension = path6.extname(filePath).toLowerCase();
   if (extension === ".ts" || extension === ".mts" || extension === ".cts") {
     return "typescript";
   }
@@ -2968,12 +3574,12 @@ function modulePageTitle(manifest) {
   return `${manifest.title} module`;
 }
 function importResolutionCandidates(basePath, specifier, extensions) {
-  const resolved = path5.posix.normalize(path5.posix.join(path5.posix.dirname(basePath), specifier));
-  if (path5.posix.extname(resolved)) {
+  const resolved = path6.posix.normalize(path6.posix.join(path6.posix.dirname(basePath), specifier));
+  if (path6.posix.extname(resolved)) {
     return [resolved];
   }
-  const direct = extensions.map((extension) => path5.posix.normalize(`${resolved}${extension}`));
-  const indexFiles = extensions.map((extension) => path5.posix.normalize(path5.posix.join(resolved, `index${extension}`)));
+  const direct = extensions.map((extension) => path6.posix.normalize(`${resolved}${extension}`));
+  const indexFiles = extensions.map((extension) => path6.posix.normalize(path6.posix.join(resolved, `index${extension}`)));
   return uniqueBy([resolved, ...direct, ...indexFiles], (candidate) => candidate);
 }
 function normalizeAlias(value) {
@@ -2992,32 +3598,32 @@ function recordAlias(target, value) {
 }
 function manifestBasenameWithoutExtension(manifest) {
   const target = manifest.repoRelativePath ?? manifest.originalPath ?? manifest.storedPath;
-  return path5.posix.basename(stripCodeExtension2(normalizeAlias(target)));
+  return path6.posix.basename(stripCodeExtension2(normalizeAlias(target)));
 }
 async function readNearestGoModulePath(startPath, cache) {
-  let current = path5.resolve(startPath);
+  let current = path6.resolve(startPath);
   try {
-    const stat = await fs5.stat(current);
+    const stat = await fs6.stat(current);
     if (!stat.isDirectory()) {
-      current = path5.dirname(current);
+      current = path6.dirname(current);
     }
   } catch {
-    current = path5.dirname(current);
+    current = path6.dirname(current);
   }
   while (true) {
     if (cache.has(current)) {
       const cached = cache.get(current);
       return cached === null ? void 0 : cached;
     }
-    const goModPath = path5.join(current, "go.mod");
-    if (await fs5.access(goModPath).then(() => true).catch(() => false)) {
-      const content = await fs5.readFile(goModPath, "utf8");
+    const goModPath = path6.join(current, "go.mod");
+    if (await fs6.access(goModPath).then(() => true).catch(() => false)) {
+      const content = await fs6.readFile(goModPath, "utf8");
       const match = content.match(/^\s*module\s+(\S+)/m);
       const modulePath = match?.[1]?.trim() ?? null;
       cache.set(current, modulePath);
       return modulePath ?? void 0;
     }
-    const parent = path5.dirname(current);
+    const parent = path6.dirname(current);
     if (parent === current) {
       cache.set(current, null);
       return void 0;
@@ -3098,10 +3704,10 @@ async function buildCodeIndex(rootDir, manifests, analyses) {
         if (normalizedNamespace) {
           recordAlias(aliases, normalizedNamespace);
         }
-        const originalPath = manifest.originalPath ? path5.resolve(manifest.originalPath) : path5.resolve(rootDir, manifest.storedPath);
+        const originalPath = manifest.originalPath ? path6.resolve(manifest.originalPath) : path6.resolve(rootDir, manifest.storedPath);
         const goModulePath = await readNearestGoModulePath(originalPath, goModuleCache);
         if (goModulePath && repoRelativePath) {
-          const dir = path5.posix.dirname(repoRelativePath);
+          const dir = path6.posix.dirname(repoRelativePath);
           const packageAlias = dir === "." ? goModulePath : `${goModulePath}/${dir}`;
           recordAlias(aliases, packageAlias);
         }
@@ -3177,10 +3783,10 @@ function resolvePythonRelativeAliases(repoRelativePath, specifier) {
   const dotMatch = specifier.match(/^\.+/);
   const depth = dotMatch ? dotMatch[0].length : 0;
   const relativeModule = specifier.slice(depth).replace(/\./g, "/");
-  const baseDir = path5.posix.dirname(repoRelativePath);
-  const parentDir = path5.posix.normalize(path5.posix.join(baseDir, ...Array(Math.max(depth - 1, 0)).fill("..")));
-  const moduleBase = relativeModule ? path5.posix.join(parentDir, relativeModule) : parentDir;
-  return uniqueBy([`${moduleBase}.py`, path5.posix.join(moduleBase, "__init__.py")], (item) => item);
+  const baseDir = path6.posix.dirname(repoRelativePath);
+  const parentDir = path6.posix.normalize(path6.posix.join(baseDir, ...Array(Math.max(depth - 1, 0)).fill("..")));
+  const moduleBase = relativeModule ? path6.posix.join(parentDir, relativeModule) : parentDir;
+  return uniqueBy([`${moduleBase}.py`, path6.posix.join(moduleBase, "__init__.py")], (item) => item);
 }
 function resolveRustAliases(manifest, specifier) {
   const repoRelativePath = manifest.repoRelativePath ? normalizeAlias(manifest.repoRelativePath) : "";
@@ -3322,9 +3928,11 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
 }
 
 // src/extraction.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import os from "os";
-import path6 from "path";
+import path7 from "path";
+import { strFromU8, unzipSync } from "fflate";
+import { JSDOM } from "jsdom";
 import { z } from "zod";
 var imageVisionExtractionSchema = z.object({
   title: z.string().min(1).nullable().optional(),
@@ -3404,14 +4012,14 @@ async function materializeAttachmentPath(input) {
   if (!input.bytes) {
     throw new Error("Image extraction requires a file path or bytes.");
   }
-  const tempDir = await fs6.mkdtemp(path6.join(os.tmpdir(), "swarmvault-image-extract-"));
+  const tempDir = await fs7.mkdtemp(path7.join(os.tmpdir(), "swarmvault-image-extract-"));
   const extension = input.mimeType.split("/")[1]?.split("+")[0] ?? "bin";
-  const tempPath = path6.join(tempDir, `source.${extension}`);
-  await fs6.writeFile(tempPath, input.bytes);
+  const tempPath = path7.join(tempDir, `source.${extension}`);
+  await fs7.writeFile(tempPath, input.bytes);
   return {
     filePath: tempPath,
     cleanup: async () => {
-      await fs6.rm(tempDir, { recursive: true, force: true });
+      await fs7.rm(tempDir, { recursive: true, force: true });
     }
   };
 }
@@ -3501,6 +4109,49 @@ function normalizePdfMetadata(raw) {
   }
   return Object.keys(metadata).length ? metadata : void 0;
 }
+function normalizeDocumentText(raw) {
+  return raw.replace(/\r\n/g, "\n").split(/\n{2,}/).map((section) => normalizeWhitespace(section)).filter(Boolean).join("\n\n").trim();
+}
+function parseDocxCoreMetadata(bytes) {
+  try {
+    const archive = unzipSync(new Uint8Array(bytes));
+    const coreXml = archive["docProps/core.xml"];
+    if (!coreXml) {
+      return void 0;
+    }
+    const dom = new JSDOM(strFromU8(coreXml), { contentType: "text/xml" });
+    const document = dom.window.document;
+    const valuesByLocalName = /* @__PURE__ */ new Map();
+    for (const node of Array.from(document.getElementsByTagName("*"))) {
+      const localName = node.localName?.trim().toLowerCase();
+      const text = normalizeWhitespace(node.textContent ?? "");
+      if (!localName || !text || valuesByLocalName.has(localName)) {
+        continue;
+      }
+      valuesByLocalName.set(localName, text);
+    }
+    const metadata = {};
+    const mappings = [
+      ["title", "title"],
+      ["author", "creator"],
+      ["subject", "subject"],
+      ["description", "description"],
+      ["keywords", "keywords"],
+      ["last_modified_by", "lastmodifiedby"],
+      ["created", "created"],
+      ["modified", "modified"]
+    ];
+    for (const [targetKey, sourceKey] of mappings) {
+      const value = valuesByLocalName.get(sourceKey);
+      if (value) {
+        metadata[targetKey] = value;
+      }
+    }
+    return Object.keys(metadata).length ? metadata : void 0;
+  } catch {
+    return void 0;
+  }
+}
 async function extractPdfText(input) {
   try {
     const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
@@ -3548,20 +4199,49 @@ async function extractPdfText(input) {
     };
   }
 }
+async function extractDocxText(input) {
+  try {
+    const mammoth = await import("mammoth");
+    const result = await mammoth.extractRawText({
+      buffer: input.bytes
+    });
+    const extractedText = normalizeDocumentText(result.value);
+    const warnings = result.messages.map((message) => normalizeWhitespace(message.message)).filter(Boolean).map((message) => truncate(message, 240));
+    const artifact = {
+      ...extractionMetadata("docx", input.mimeType, "docx_text"),
+      metadata: parseDocxCoreMetadata(input.bytes),
+      warnings: warnings.length ? warnings : void 0
+    };
+    if (!extractedText) {
+      artifact.warnings = [...artifact.warnings ?? [], "DOCX text extraction completed but produced no extractable text."];
+    }
+    return {
+      extractedText: extractedText || void 0,
+      artifact
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("docx", input.mimeType, "docx_text"),
+        warnings: [`DOCX text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
 
 // src/logs.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import matter from "gray-matter";
 async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.sessionsDir);
   const timestamp = startedAt.replace(/[:.]/g, "-");
   const baseName = `${timestamp}-${operation}-${slugify(title)}`;
-  let candidate = path7.join(paths.sessionsDir, `${baseName}.md`);
+  let candidate = path8.join(paths.sessionsDir, `${baseName}.md`);
   let counter = 2;
   while (await fileExists(candidate)) {
-    candidate = path7.join(paths.sessionsDir, `${baseName}-${counter}.md`);
+    candidate = path8.join(paths.sessionsDir, `${baseName}-${counter}.md`);
     counter++;
   }
   return candidate;
@@ -3569,11 +4249,11 @@ async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
 async function appendLogEntry(rootDir, action, title, lines = []) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.wikiDir);
-  const logPath = path7.join(paths.wikiDir, "log.md");
+  const logPath = path8.join(paths.wikiDir, "log.md");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
   const entry = [`## [${timestamp}] ${action} | ${title}`, ...lines.map((line) => `- ${line}`), ""].join("\n");
-  const existing = await fileExists(logPath) ? await fs7.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs7.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs8.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs8.writeFile(logPath, `${existing}${entry}
 `, "utf8");
 }
 async function recordSession(rootDir, input) {
@@ -3583,8 +4263,8 @@ async function recordSession(rootDir, input) {
   const finishedAtIso = new Date(input.finishedAt ?? input.startedAt).toISOString();
   const durationMs = Math.max(0, new Date(finishedAtIso).getTime() - new Date(startedAtIso).getTime());
   const sessionPath = await resolveUniqueSessionPath(rootDir, input.operation, input.title, startedAtIso);
-  const sessionId = path7.basename(sessionPath, ".md");
-  const relativeSessionPath = path7.relative(rootDir, sessionPath).split(path7.sep).join(path7.posix.sep);
+  const sessionId = path8.basename(sessionPath, ".md");
+  const relativeSessionPath = path8.relative(rootDir, sessionPath).split(path8.sep).join(path8.posix.sep);
   const frontmatter = Object.fromEntries(
     Object.entries({
       session_id: sessionId,
@@ -3632,7 +4312,7 @@ async function recordSession(rootDir, input) {
     frontmatter
   );
   await writeFileIfChanged(sessionPath, content);
-  const logPath = path7.join(paths.wikiDir, "log.md");
+  const logPath = path8.join(paths.wikiDir, "log.md");
   const timestamp = startedAtIso.slice(0, 19).replace("T", " ");
   const entry = [
     `## [${timestamp}] ${input.operation} | ${input.title}`,
@@ -3640,8 +4320,8 @@ async function recordSession(rootDir, input) {
     ...(input.lines ?? []).map((line) => `- ${line}`),
     ""
   ].join("\n");
-  const existing = await fileExists(logPath) ? await fs7.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs7.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs8.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs8.writeFile(logPath, `${existing}${entry}
 `, "utf8");
   return { sessionPath, sessionId };
 }
@@ -3651,13 +4331,13 @@ async function appendWatchRun(rootDir, run) {
 }
 
 // src/source-classification.ts
-import path8 from "path";
+import path9 from "path";
 var ALL_SOURCE_CLASSES = ["first_party", "third_party", "resource", "generated"];
 var THIRD_PARTY_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "vendor", "Pods"]);
 var GENERATED_SEGMENTS = /* @__PURE__ */ new Set(["dist", "build", ".next", "coverage", "DerivedData", "target"]);
 function matchesAnyGlob(relativePath, patterns) {
   return patterns.some(
-    (pattern) => path8.matchesGlob(relativePath, pattern) || path8.matchesGlob(path8.posix.basename(relativePath), pattern)
+    (pattern) => path9.matchesGlob(relativePath, pattern) || path9.matchesGlob(path9.posix.basename(relativePath), pattern)
   );
 }
 function classifyRepoPath(relativePath, repoAnalysis) {
@@ -3710,8 +4390,8 @@ function aggregateManifestSourceClass(manifests, sourceIds) {
 }
 
 // src/watch-state.ts
-import fs8 from "fs/promises";
-import path9 from "path";
+import fs9 from "fs/promises";
+import path10 from "path";
 import matter2 from "gray-matter";
 function pendingEntryKey(entry) {
   return entry.path;
@@ -3725,7 +4405,7 @@ function normalizeRelativePath(rootDir, filePath) {
   if (!filePath) {
     return void 0;
   }
-  return toPosix(path9.relative(rootDir, path9.resolve(filePath)));
+  return toPosix(path10.relative(rootDir, path10.resolve(filePath)));
 }
 async function readPendingSemanticRefresh(rootDir) {
   const { paths } = await initWorkspace(rootDir);
@@ -3819,11 +4499,11 @@ async function markPagesStaleForSources(rootDir, sourceIds) {
     if (page.freshness !== "stale" || !page.sourceIds.some((sourceId) => affectedSourceIds.has(sourceId))) {
       continue;
     }
-    const absolutePath = path9.join(paths.wikiDir, page.path);
+    const absolutePath = path10.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const raw = await fs8.readFile(absolutePath, "utf8");
+    const raw = await fs9.readFile(absolutePath, "utf8");
     const parsed = matter2(raw);
     if (parsed.data.freshness === "stale") {
       continue;
@@ -3858,6 +4538,9 @@ function inferKind(mimeType, filePath) {
   if (mimeType === "application/pdf" || filePath.toLowerCase().endsWith(".pdf")) {
     return "pdf";
   }
+  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || filePath.toLowerCase().endsWith(".docx")) {
+    return "docx";
+  }
   if (mimeType.startsWith("image/")) {
     return "image";
   }
@@ -3874,7 +4557,7 @@ function normalizeIngestOptions(options) {
   return {
     includeAssets: options?.includeAssets ?? true,
     maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE)),
-    repoRoot: options?.repoRoot ? path10.resolve(options.repoRoot) : void 0,
+    repoRoot: options?.repoRoot ? path11.resolve(options.repoRoot) : void 0,
     include: (options?.include ?? []).map((pattern) => pattern.trim()).filter(Boolean),
     exclude: (options?.exclude ?? []).map((pattern) => pattern.trim()).filter(Boolean),
     maxFiles: Math.max(1, Math.floor(options?.maxFiles ?? DEFAULT_MAX_DIRECTORY_FILES)),
@@ -3894,27 +4577,27 @@ async function resolveRepoIngestOptions(rootDir, options) {
 }
 function matchesAnyGlob2(relativePath, patterns) {
   return patterns.some(
-    (pattern) => path10.matchesGlob(relativePath, pattern) || path10.matchesGlob(path10.posix.basename(relativePath), pattern)
+    (pattern) => path11.matchesGlob(relativePath, pattern) || path11.matchesGlob(path11.posix.basename(relativePath), pattern)
   );
 }
 function supportedDirectoryKind(sourceKind) {
   return sourceKind !== "binary";
 }
 async function findNearestGitRoot2(startPath) {
-  let current = path10.resolve(startPath);
+  let current = path11.resolve(startPath);
   try {
-    const stat = await fs9.stat(current);
+    const stat = await fs10.stat(current);
     if (!stat.isDirectory()) {
-      current = path10.dirname(current);
+      current = path11.dirname(current);
     }
   } catch {
-    current = path10.dirname(current);
+    current = path11.dirname(current);
   }
   while (true) {
-    if (await fileExists(path10.join(current, ".git"))) {
+    if (await fileExists(path11.join(current, ".git"))) {
       return current;
     }
-    const parent = path10.dirname(current);
+    const parent = path11.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -3922,26 +4605,26 @@ async function findNearestGitRoot2(startPath) {
   }
 }
 function withinRoot(rootPath, targetPath) {
-  const relative = path10.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path10.isAbsolute(relative);
+  const relative = path11.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path11.isAbsolute(relative);
 }
 function repoRootFromManifest(manifest) {
   if (manifest.originType !== "file" || !manifest.originalPath || !manifest.repoRelativePath) {
     return null;
   }
-  const repoDir = path10.posix.dirname(manifest.repoRelativePath);
-  const fileDir = path10.dirname(path10.resolve(manifest.originalPath));
+  const repoDir = path11.posix.dirname(manifest.repoRelativePath);
+  const fileDir = path11.dirname(path11.resolve(manifest.originalPath));
   if (repoDir === "." || !repoDir) {
     return fileDir;
   }
   const segments = repoDir.split("/").filter(Boolean);
-  return path10.resolve(fileDir, ...segments.map(() => ".."));
+  return path11.resolve(fileDir, ...segments.map(() => ".."));
 }
 function repoRelativePathFor(absolutePath, repoRoot) {
   if (!repoRoot || !withinRoot(repoRoot, absolutePath)) {
     return void 0;
   }
-  const relative = toPosix(path10.relative(repoRoot, absolutePath));
+  const relative = toPosix(path11.relative(repoRoot, absolutePath));
   return relative && !relative.startsWith("..") ? relative : void 0;
 }
 function normalizeOriginUrl(input) {
@@ -4017,7 +4700,41 @@ function prepareCapturedMarkdownInput(input) {
     logDetails: input.logDetails
   };
 }
+function isPrivateIp(ip) {
+  if (ip === "::1" || ip.startsWith("fc") || ip.startsWith("fd")) return true;
+  const parts = ip.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((p) => Number.isNaN(p))) return false;
+  return parts[0] === 0 || parts[0] === 127 || parts[0] === 10 || parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31 || parts[0] === 192 && parts[1] === 168 || parts[0] === 169 && parts[1] === 254;
+}
+function allowPrivateUrlsForProcess() {
+  return process.env.SWARMVAULT_ALLOW_PRIVATE_URLS === "1";
+}
+function isReservedTestHostname(hostname) {
+  const lower = hostname.toLowerCase();
+  return lower.endsWith(".test") || lower.endsWith(".example") || lower.endsWith(".invalid");
+}
+async function validateUrlSafety(url) {
+  const parsed = new URL(url);
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`Blocked protocol: ${parsed.protocol}`);
+  }
+  if (allowPrivateUrlsForProcess() || isReservedTestHostname(parsed.hostname)) {
+    return;
+  }
+  let address;
+  try {
+    const { lookup } = await import("dns/promises");
+    const result = await lookup(parsed.hostname);
+    address = result.address;
+  } catch {
+    return;
+  }
+  if (isPrivateIp(address)) {
+    throw new Error(`Blocked private/reserved IP ${address} (resolved from ${parsed.hostname})`);
+  }
+}
 async function fetchText(url) {
+  await validateUrlSafety(url);
   const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
@@ -4025,6 +4742,7 @@ async function fetchText(url) {
   return response.text();
 }
 async function fetchResolvedText(url) {
+  await validateUrlSafety(url);
   const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
@@ -4036,7 +4754,7 @@ async function fetchResolvedText(url) {
   };
 }
 function domTextFromHtml(html, baseUrl) {
-  const dom = new JSDOM(`<body>${html}</body>`, { url: baseUrl });
+  const dom = new JSDOM2(`<body>${html}</body>`, { url: baseUrl });
   return normalizeWhitespace(dom.window.document.body.textContent ?? "");
 }
 async function captureArxivMarkdown(input, options) {
@@ -4046,7 +4764,7 @@ async function captureArxivMarkdown(input, options) {
   }
   const normalizedUrl = `https://arxiv.org/abs/${arxivId}`;
   const html = await fetchText(normalizedUrl);
-  const dom = new JSDOM(html, { url: normalizedUrl });
+  const dom = new JSDOM2(html, { url: normalizedUrl });
   const document = dom.window.document;
   const metaTitle = document.querySelector('meta[name="citation_title"]')?.getAttribute("content")?.trim();
   const headingTitle = document.querySelector("h1.title")?.textContent?.trim();
@@ -4155,7 +4873,7 @@ async function captureArticleMarkdown(rootDir, input, options, extra = { sourceT
   if (!resolved.contentType.includes("html")) {
     throw new Error(`Unsupported article content type: ${resolved.contentType}`);
   }
-  const dom = new JSDOM(resolved.text, { url: resolved.finalUrl });
+  const dom = new JSDOM2(resolved.text, { url: resolved.finalUrl });
   const document = dom.window.document;
   const canonicalHref = document.querySelector('link[rel="canonical"]')?.getAttribute("href")?.trim();
   const canonicalUrl = canonicalHref ? normalizeOriginUrl(new URL(canonicalHref, resolved.finalUrl).toString()) : resolved.finalUrl;
@@ -4238,7 +4956,7 @@ function buildCompositeHash(payloadBytes, attachments = []) {
   return sha256(`${sha256(payloadBytes)}|${attachmentSignature}`);
 }
 function sanitizeAssetRelativePath(value) {
-  const normalized = path10.posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = path11.posix.normalize(value.replace(/\\/g, "/"));
   const segments = normalized.split("/").filter(Boolean).map((segment) => {
     if (segment === ".") {
       return "";
@@ -4258,7 +4976,7 @@ function normalizeLocalReference(value) {
     return null;
   }
   const lowered = candidate.toLowerCase();
-  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path10.isAbsolute(candidate)) {
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path11.isAbsolute(candidate)) {
     return null;
   }
   return candidate.replace(/\\/g, "/");
@@ -4274,6 +4992,22 @@ function extractMarkdownReferences(content) {
   }
   return references;
 }
+function extractHtmlLocalReferences(html, baseUrl) {
+  const dom = new JSDOM2(html, { url: baseUrl });
+  const document = dom.window.document;
+  const references = [];
+  for (const image of [...document.querySelectorAll("img[src]")]) {
+    const src = image.getAttribute("src");
+    if (!src) {
+      continue;
+    }
+    const normalized = normalizeLocalReference(src);
+    if (normalized) {
+      references.push(normalized);
+    }
+  }
+  return references;
+}
 function normalizeRemoteReference(value, baseUrl) {
   const trimmed = value.trim().replace(/^<|>$/g, "");
   const [withoutTitle] = trimmed.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/, 1);
@@ -4309,7 +5043,7 @@ function extractMarkdownImageReferences(content, baseUrl) {
   return references;
 }
 async function convertHtmlToMarkdown(html, url) {
-  const dom = new JSDOM(html, { url });
+  const dom = new JSDOM2(html, { url });
   const article = new Readability(dom.window.document).parse();
   const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
   const body = article?.content ?? dom.window.document.body.innerHTML;
@@ -4320,12 +5054,12 @@ async function convertHtmlToMarkdown(html, url) {
   };
 }
 async function readManifestByHash(manifestsDir, contentHash) {
-  const entries = await fs9.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs10.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path10.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path11.join(manifestsDir, entry.name));
     if (manifest?.contentHash === contentHash) {
       return manifest;
     }
@@ -4333,12 +5067,12 @@ async function readManifestByHash(manifestsDir, contentHash) {
   return null;
 }
 async function readManifestByOrigin(manifestsDir, prepared) {
-  const entries = await fs9.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs10.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path10.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path11.join(manifestsDir, entry.name));
     if (manifest && manifestMatchesOrigin(manifest, prepared)) {
       return manifest;
     }
@@ -4349,12 +5083,12 @@ async function loadGitignoreMatcher(repoRoot, enabled) {
   if (!enabled) {
     return null;
   }
-  const gitignorePath = path10.join(repoRoot, ".gitignore");
+  const gitignorePath = path11.join(repoRoot, ".gitignore");
   if (!await fileExists(gitignorePath)) {
     return null;
   }
   const matcher = ignore();
-  matcher.add(await fs9.readFile(gitignorePath, "utf8"));
+  matcher.add(await fs10.readFile(gitignorePath, "utf8"));
   return matcher;
 }
 function builtInIgnoreReason(relativePath) {
@@ -4378,23 +5112,23 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
     if (!currentDir) {
       continue;
     }
-    const entries = await fs9.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs10.readdir(currentDir, { withFileTypes: true });
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const absolutePath = path10.join(currentDir, entry.name);
-      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(inputDir, absolutePath));
+      const absolutePath = path11.join(currentDir, entry.name);
+      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(inputDir, absolutePath));
       const relativePath = relativeToRepo || entry.name;
       const builtInReason = builtInIgnoreReason(relativePath);
       if (builtInReason) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: builtInReason });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: builtInReason });
         continue;
       }
       if (matcher?.ignores(relativePath)) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "gitignore" });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "gitignore" });
         continue;
       }
       if (matchesAnyGlob2(relativePath, options.exclude)) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "exclude_glob" });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "exclude_glob" });
         continue;
       }
       if (entry.isDirectory()) {
@@ -4402,26 +5136,26 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
         continue;
       }
       if (!entry.isFile()) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
         continue;
       }
       if (options.include.length > 0 && !matchesAnyGlob2(relativePath, options.include)) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "include_glob" });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "include_glob" });
         continue;
       }
       const mimeType = guessMimeType(absolutePath);
       const sourceKind = inferKind(mimeType, absolutePath);
       const sourceClass = sourceClassForRelativePath(relativePath, options);
       if (!supportedDirectoryKind(sourceKind)) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
         continue;
       }
       if (!options.extractClasses.includes(sourceClass)) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: `source_class:${sourceClass}` });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: `source_class:${sourceClass}` });
         continue;
       }
       if (files.length >= options.maxFiles) {
-        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "max_files" });
+        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "max_files" });
         continue;
       }
       files.push(absolutePath);
@@ -4443,12 +5177,12 @@ function resolveUrlMimeType(input, response) {
 function buildRemoteAssetRelativePath(assetUrl, mimeType) {
   const url = new URL(assetUrl);
   const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
-  const extension = path10.posix.extname(normalized);
-  const directory = path10.posix.dirname(normalized);
-  const basename = extension ? path10.posix.basename(normalized, extension) : path10.posix.basename(normalized);
+  const extension = path11.posix.extname(normalized);
+  const directory = path11.posix.dirname(normalized);
+  const basename = extension ? path11.posix.basename(normalized, extension) : path11.posix.basename(normalized);
   const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
   const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
-  return directory === "." ? hashedName : path10.posix.join(directory, hashedName);
+  return directory === "." ? hashedName : path11.posix.join(directory, hashedName);
 }
 async function readResponseBytesWithinLimit(response, maxBytes) {
   const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
@@ -4480,6 +5214,7 @@ async function readResponseBytesWithinLimit(response, maxBytes) {
   return Buffer.concat(chunks);
 }
 async function fetchRemoteImageAttachment(assetUrl, maxAssetSize) {
+  await validateUrlSafety(assetUrl);
   const response = await fetch(assetUrl);
   if (!response.ok) {
     throw new Error(`failed with ${response.status} ${response.statusText}`);
@@ -4512,7 +5247,7 @@ async function collectRemoteImageAttachments(assetUrls, options) {
   return { attachments, skippedCount };
 }
 function extractHtmlImageReferences(html, baseUrl) {
-  const dom = new JSDOM(html, { url: baseUrl });
+  const dom = new JSDOM2(html, { url: baseUrl });
   const document = dom.window.document;
   const references = [];
   for (const image of [...document.querySelectorAll("img[src]")]) {
@@ -4528,7 +5263,7 @@ function extractHtmlImageReferences(html, baseUrl) {
   return references;
 }
 function rewriteHtmlImageReferences(html, baseUrl, replacements) {
-  const dom = new JSDOM(html, { url: baseUrl });
+  const dom = new JSDOM2(html, { url: baseUrl });
   const document = dom.window.document;
   for (const image of [...document.querySelectorAll("img[src]")]) {
     const src = image.getAttribute("src");
@@ -4543,6 +5278,22 @@ function rewriteHtmlImageReferences(html, baseUrl, replacements) {
   }
   return dom.serialize();
 }
+function rewriteHtmlLocalReferences(html, baseUrl, replacements) {
+  const dom = new JSDOM2(html, { url: baseUrl });
+  const document = dom.window.document;
+  for (const image of [...document.querySelectorAll("img[src]")]) {
+    const src = image.getAttribute("src");
+    if (!src) {
+      continue;
+    }
+    const normalized = normalizeLocalReference(src);
+    const replacement = normalized ? replacements.get(normalized) : void 0;
+    if (replacement) {
+      image.setAttribute("src", replacement);
+    }
+  }
+  return dom.serialize();
+}
 function rewriteMarkdownImageReferences(content, baseUrl, replacements) {
   return content.replace(/(!\[[^\]]*]\()([^)]+)(\))/g, (fullMatch, prefix, target, suffix) => {
     const normalized = normalizeRemoteReference(target, baseUrl);
@@ -4584,34 +5335,34 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   const previous = existingByOrigin ?? void 0;
   const sourceId = previous?.sourceId ?? `${slugify(prepared.title)}-${contentHash.slice(0, 8)}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const storedPath = path10.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
-  const extractedTextPath = prepared.extractedText ? path10.join(paths.extractsDir, `${sourceId}.md`) : void 0;
-  const extractedMetadataPath = prepared.extractionArtifact ? path10.join(paths.extractsDir, `${sourceId}.json`) : void 0;
-  const attachmentsDir = path10.join(paths.rawAssetsDir, sourceId);
+  const storedPath = path11.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
+  const extractedTextPath = prepared.extractedText ? path11.join(paths.extractsDir, `${sourceId}.md`) : void 0;
+  const extractedMetadataPath = prepared.extractionArtifact ? path11.join(paths.extractsDir, `${sourceId}.json`) : void 0;
+  const attachmentsDir = path11.join(paths.rawAssetsDir, sourceId);
   if (previous?.storedPath) {
-    await fs9.rm(path10.resolve(rootDir, previous.storedPath), { force: true });
+    await fs10.rm(path11.resolve(rootDir, previous.storedPath), { force: true });
   }
   if (previous?.extractedTextPath) {
-    await fs9.rm(path10.resolve(rootDir, previous.extractedTextPath), { force: true });
+    await fs10.rm(path11.resolve(rootDir, previous.extractedTextPath), { force: true });
   }
   if (previous?.extractedMetadataPath) {
-    await fs9.rm(path10.resolve(rootDir, previous.extractedMetadataPath), { force: true });
+    await fs10.rm(path11.resolve(rootDir, previous.extractedMetadataPath), { force: true });
   }
-  await fs9.rm(attachmentsDir, { recursive: true, force: true });
-  await fs9.writeFile(storedPath, prepared.payloadBytes);
+  await fs10.rm(attachmentsDir, { recursive: true, force: true });
+  await fs10.writeFile(storedPath, prepared.payloadBytes);
   if (prepared.extractedText && extractedTextPath) {
-    await fs9.writeFile(extractedTextPath, prepared.extractedText, "utf8");
+    await fs10.writeFile(extractedTextPath, prepared.extractedText, "utf8");
   }
   if (prepared.extractionArtifact && extractedMetadataPath) {
     await writeJsonFile(extractedMetadataPath, prepared.extractionArtifact);
   }
   const manifestAttachments = [];
   for (const attachment of attachments) {
-    const absoluteAttachmentPath = path10.join(attachmentsDir, attachment.relativePath);
-    await ensureDir(path10.dirname(absoluteAttachmentPath));
-    await fs9.writeFile(absoluteAttachmentPath, attachment.bytes);
+    const absoluteAttachmentPath = path11.join(attachmentsDir, attachment.relativePath);
+    await ensureDir(path11.dirname(absoluteAttachmentPath));
+    await fs10.writeFile(absoluteAttachmentPath, attachment.bytes);
     manifestAttachments.push({
-      path: toPosix(path10.relative(rootDir, absoluteAttachmentPath)),
+      path: toPosix(path11.relative(rootDir, absoluteAttachmentPath)),
       mimeType: attachment.mimeType,
       originalPath: attachment.originalPath
     });
@@ -4627,9 +5378,9 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     originalPath: prepared.originalPath,
     repoRelativePath: prepared.repoRelativePath,
     url: prepared.url,
-    storedPath: toPosix(path10.relative(rootDir, storedPath)),
-    extractedTextPath: extractedTextPath ? toPosix(path10.relative(rootDir, extractedTextPath)) : void 0,
-    extractedMetadataPath: extractedMetadataPath ? toPosix(path10.relative(rootDir, extractedMetadataPath)) : void 0,
+    storedPath: toPosix(path11.relative(rootDir, storedPath)),
+    extractedTextPath: extractedTextPath ? toPosix(path11.relative(rootDir, extractedTextPath)) : void 0,
+    extractedMetadataPath: extractedMetadataPath ? toPosix(path11.relative(rootDir, extractedMetadataPath)) : void 0,
     extractionHash,
     mimeType: prepared.mimeType,
     contentHash,
@@ -4637,7 +5388,7 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
   };
-  await writeJsonFile(path10.join(paths.manifestsDir, `${sourceId}.json`), manifest);
+  await writeJsonFile(path11.join(paths.manifestsDir, `${sourceId}.json`), manifest);
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
@@ -4655,16 +5406,16 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   return { manifest, isNew: !previous, wasUpdated: Boolean(previous) };
 }
 async function removeManifestArtifacts(rootDir, manifest, paths) {
-  await fs9.rm(path10.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
-  await fs9.rm(path10.resolve(rootDir, manifest.storedPath), { force: true });
+  await fs10.rm(path11.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
+  await fs10.rm(path11.resolve(rootDir, manifest.storedPath), { force: true });
   if (manifest.extractedTextPath) {
-    await fs9.rm(path10.resolve(rootDir, manifest.extractedTextPath), { force: true });
+    await fs10.rm(path11.resolve(rootDir, manifest.extractedTextPath), { force: true });
   }
   if (manifest.extractedMetadataPath) {
-    await fs9.rm(path10.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
+    await fs10.rm(path11.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
   }
-  await fs9.rm(path10.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
-  await fs9.rm(path10.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
+  await fs10.rm(path11.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
+  await fs10.rm(path11.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
 }
 function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
   const candidates = [
@@ -4673,17 +5424,17 @@ function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path10.join(rootDir, ".claude"),
-    path10.join(rootDir, ".cursor"),
-    path10.join(rootDir, ".obsidian")
+    path11.join(rootDir, ".claude"),
+    path11.join(rootDir, ".cursor"),
+    path11.join(rootDir, ".obsidian")
   ];
-  return candidates.map((candidate) => path10.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
+  return candidates.map((candidate) => path11.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
 }
 function preparedMatchesManifest(manifest, prepared, contentHash) {
   return manifest.contentHash === contentHash && manifest.extractionHash === (prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact)) && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.sourceType === prepared.sourceType && manifest.sourceClass === prepared.sourceClass && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
 }
 function shouldDeferWatchSemanticRefresh(sourceKind) {
-  return sourceKind === "markdown" || sourceKind === "text" || sourceKind === "html" || sourceKind === "pdf" || sourceKind === "image";
+  return sourceKind === "markdown" || sourceKind === "text" || sourceKind === "html" || sourceKind === "pdf" || sourceKind === "docx" || sourceKind === "image";
 }
 function pendingSemanticRefreshId(changeType, repoRoot, relativePath) {
   return `pending:${changeType}:${sha256(`${toPosix(repoRoot)}:${relativePath}`).slice(0, 12)}`;
@@ -4699,16 +5450,16 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
   const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path10.resolve(item)
+    (item) => path11.resolve(item)
   );
   const uniqueRoots = [...new Set(trackedRoots)].sort((left, right) => left.localeCompare(right));
   const manifestsByRepoRoot = /* @__PURE__ */ new Map();
   for (const manifest of manifests) {
     const repoRoot = repoRootFromManifest(manifest);
-    if (!repoRoot || !uniqueRoots.includes(path10.resolve(repoRoot))) {
+    if (!repoRoot || !uniqueRoots.includes(path11.resolve(repoRoot))) {
       continue;
     }
-    const key = path10.resolve(repoRoot);
+    const key = path11.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -4733,14 +5484,14 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     skipped.push(
       ...collected.skipped,
       ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
-        path: toPosix(path10.relative(rootDir, absolutePath)),
+        path: toPosix(path11.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
-    const currentPaths = new Set(files.map((absolutePath) => path10.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path11.resolve(absolutePath)));
     for (const absolutePath of files) {
-      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(repoRoot, absolutePath));
+      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(repoRoot, absolutePath));
       const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
       const result = await persistPreparedInput(rootDir, prepared, paths);
       if (result.isNew) {
@@ -4750,7 +5501,7 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
       }
     }
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path10.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path11.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         await removeManifestArtifacts(rootDir, manifest, paths);
         removed.push(manifest);
@@ -4758,7 +5509,7 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     }
   }
   if (uniqueRoots.length > 0) {
-    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path10.relative(rootDir, repoRoot)) || ".").join(","), [
+    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path11.relative(rootDir, repoRoot)) || ".").join(","), [
       `repo_roots=${uniqueRoots.length}`,
       `scanned=${scannedCount}`,
       `imported=${imported.length}`,
@@ -4781,16 +5532,16 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path10.resolve(item)
+    (item) => path11.resolve(item)
   );
   const uniqueRoots = [...new Set(trackedRoots)].sort((left, right) => left.localeCompare(right));
   const manifestsByRepoRoot = /* @__PURE__ */ new Map();
   for (const manifest of manifests) {
     const repoRoot = repoRootFromManifest(manifest);
-    if (!repoRoot || !uniqueRoots.includes(path10.resolve(repoRoot))) {
+    if (!repoRoot || !uniqueRoots.includes(path11.resolve(repoRoot))) {
       continue;
     }
-    const key = path10.resolve(repoRoot);
+    const key = path11.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -4805,7 +5556,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   for (const repoRoot of uniqueRoots) {
     const repoManifests = manifestsByRepoRoot.get(repoRoot) ?? [];
     const manifestsByOriginalPath = new Map(
-      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path10.resolve(manifest.originalPath), manifest])
+      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path11.resolve(manifest.originalPath), manifest])
     );
     if (!await fileExists(repoRoot)) {
       for (const manifest of repoManifests) {
@@ -4813,7 +5564,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
           pendingSemanticRefresh.push({
             id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? manifest.storedPath),
             repoRoot,
-            path: toPosix(path10.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
+            path: toPosix(path11.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -4833,17 +5584,17 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     skipped.push(
       ...collected.skipped,
       ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
-        path: toPosix(path10.relative(rootDir, absolutePath)),
+        path: toPosix(path11.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
-    const currentPaths = new Set(files.map((absolutePath) => path10.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path11.resolve(absolutePath)));
     for (const absolutePath of files) {
-      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(repoRoot, absolutePath));
+      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(repoRoot, absolutePath));
       const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
       if (shouldDeferWatchSemanticRefresh(prepared.sourceKind)) {
-        const existing = manifestsByOriginalPath.get(path10.resolve(absolutePath));
+        const existing = manifestsByOriginalPath.get(path11.resolve(absolutePath));
         const contentHash = buildCompositeHash(prepared.payloadBytes, prepared.attachments);
         const changed = !existing || !preparedMatchesManifest(existing, prepared, contentHash);
         if (changed) {
@@ -4851,10 +5602,10 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
             id: pendingSemanticRefreshId(
               existing ? "modified" : "added",
               repoRoot,
-              prepared.repoRelativePath ?? toPosix(path10.relative(repoRoot, absolutePath))
+              prepared.repoRelativePath ?? toPosix(path11.relative(repoRoot, absolutePath))
             ),
             repoRoot,
-            path: toPosix(path10.relative(rootDir, absolutePath)),
+            path: toPosix(path11.relative(rootDir, absolutePath)),
             changeType: existing ? "modified" : "added",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: existing?.sourceId,
@@ -4874,13 +5625,13 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
       }
     }
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path10.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path11.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         if (shouldDeferWatchSemanticRefresh(manifest.sourceKind)) {
           pendingSemanticRefresh.push({
-            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path10.relative(repoRoot, originalPath))),
+            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path11.relative(repoRoot, originalPath))),
             repoRoot,
-            path: toPosix(path10.relative(rootDir, originalPath)),
+            path: toPosix(path11.relative(rootDir, originalPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -4898,7 +5649,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     await appendLogEntry(
       rootDir,
       "sync_repo_watch",
-      uniqueRoots.map((repoRoot) => toPosix(path10.relative(rootDir, repoRoot)) || ".").join(","),
+      uniqueRoots.map((repoRoot) => toPosix(path11.relative(rootDir, repoRoot)) || ".").join(","),
       [
         `repo_roots=${uniqueRoots.length}`,
         `scanned=${scannedCount}`,
@@ -4924,17 +5675,17 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   };
 }
 async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
-  const payloadBytes = await fs9.readFile(absoluteInput);
+  const payloadBytes = await fs10.readFile(absoluteInput);
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
   const language = inferCodeLanguage(absoluteInput, mimeType);
-  const storedExtension = path10.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
+  const storedExtension = path11.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
   let title;
   let extractedText;
   let extractionArtifact;
   if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
     extractedText = payloadBytes.toString("utf8");
-    title = titleFromText(path10.basename(absoluteInput, path10.extname(absoluteInput)), extractedText);
+    title = titleFromText(path11.basename(absoluteInput, path11.extname(absoluteInput)), extractedText);
     extractionArtifact = createPlainTextExtractionArtifact(sourceKind, mimeType);
   } else if (sourceKind === "html") {
     const html = payloadBytes.toString("utf8");
@@ -4943,12 +5694,18 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
     extractedText = converted.markdown;
     extractionArtifact = createHtmlReadabilityExtractionArtifact(sourceKind, mimeType);
   } else if (sourceKind === "pdf") {
-    title = path10.basename(absoluteInput, path10.extname(absoluteInput));
+    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
     const extracted = await extractPdfText({ mimeType, bytes: payloadBytes });
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "docx") {
+    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
+    const extracted = await extractDocxText({ mimeType, bytes: payloadBytes });
+    title = extracted.artifact.metadata?.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
   } else if (sourceKind === "image") {
-    title = path10.basename(absoluteInput, path10.extname(absoluteInput));
+    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
     const extracted = await extractImageWithVision(rootDir, {
       title,
       mimeType,
@@ -4958,7 +5715,7 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
   } else {
-    title = path10.basename(absoluteInput, path10.extname(absoluteInput));
+    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
   }
   return {
     title,
@@ -4977,6 +5734,7 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
   };
 }
 async function prepareUrlInput(rootDir, input, options) {
+  await validateUrlSafety(input);
   const response = await fetch(input);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${input}: ${response.status} ${response.statusText}`);
@@ -5034,7 +5792,7 @@ async function prepareUrlInput(rootDir, input, options) {
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path10.extname(inputUrl.pathname);
+    const extension = path11.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = payloadBytes.toString("utf8");
@@ -5064,6 +5822,11 @@ async function prepareUrlInput(rootDir, input, options) {
       const extracted = await extractPdfText({ mimeType, bytes: payloadBytes });
       extractedText = extracted.extractedText;
       extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "docx") {
+      const extracted = await extractDocxText({ mimeType, bytes: payloadBytes });
+      title = extracted.artifact.metadata?.title?.trim() || title;
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
     } else if (sourceKind === "image") {
       const extracted = await extractImageWithVision(rootDir, {
         title,
@@ -5097,17 +5860,17 @@ async function collectInboxAttachmentRefs(inputDir, files) {
   for (const absolutePath of files) {
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
-    if (sourceKind !== "markdown") {
+    if (sourceKind !== "markdown" && sourceKind !== "html") {
       continue;
     }
-    const content = await fs9.readFile(absolutePath, "utf8");
-    const refs = extractMarkdownReferences(content);
+    const content = await fs10.readFile(absolutePath, "utf8");
+    const refs = sourceKind === "html" ? extractHtmlLocalReferences(content, pathToFileURL(absolutePath).toString()) : extractMarkdownReferences(content);
     if (!refs.length) {
       continue;
     }
     const sourceRefs = [];
     for (const ref of refs) {
-      const resolved = path10.resolve(path10.dirname(absolutePath), ref);
+      const resolved = path11.resolve(path11.dirname(absolutePath), ref);
       if (!resolved.startsWith(inputDir) || !await fileExists(resolved)) {
         continue;
       }
@@ -5140,13 +5903,52 @@ function rewriteMarkdownReferences(content, replacements) {
     return `${prefix}${replacement}${suffix}`;
   });
 }
-async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs9.readFile(absolutePath);
-  const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path10.basename(absolutePath, path10.extname(absolutePath)), originalText);
+async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
+  const originalBytes = await fs10.readFile(absolutePath);
+  const originalText = originalBytes.toString("utf8");
+  const title = titleFromText(path11.basename(absolutePath, path11.extname(absolutePath)), originalText);
+  const attachments = [];
+  for (const attachmentRef of attachmentRefs) {
+    const bytes = await fs10.readFile(attachmentRef.absolutePath);
+    attachments.push({
+      relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
+      mimeType: guessMimeType(attachmentRef.absolutePath),
+      originalPath: toPosix(attachmentRef.absolutePath),
+      bytes
+    });
+  }
+  const contentHash = buildCompositeHash(originalBytes, attachments);
+  const sourceId = `${slugify(title)}-${contentHash.slice(0, 8)}`;
+  const replacements = new Map(
+    attachmentRefs.map((attachmentRef) => [
+      attachmentRef.relativeRef.replace(/\\/g, "/"),
+      `../assets/${sourceId}/${sanitizeAssetRelativePath(attachmentRef.relativeRef)}`
+    ])
+  );
+  const rewrittenText = rewriteMarkdownReferences(originalText, replacements);
+  const extractionArtifact = createPlainTextExtractionArtifact("markdown", "text/markdown");
+  return {
+    title,
+    originType: "file",
+    sourceKind: "markdown",
+    originalPath: toPosix(absolutePath),
+    mimeType: "text/markdown",
+    storedExtension: path11.extname(absolutePath) || ".md",
+    payloadBytes: Buffer.from(rewrittenText, "utf8"),
+    extractedText: rewrittenText,
+    extractionArtifact,
+    extractionHash: buildExtractionHash(rewrittenText, extractionArtifact),
+    attachments,
+    contentHash
+  };
+}
+async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
+  const originalBytes = await fs10.readFile(absolutePath);
+  const originalHtml = originalBytes.toString("utf8");
+  const initialConversion = await convertHtmlToMarkdown(originalHtml, pathToFileURL(absolutePath).toString());
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
-    const bytes = await fs9.readFile(attachmentRef.absolutePath);
+    const bytes = await fs10.readFile(attachmentRef.absolutePath);
     attachments.push({
       relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
       mimeType: guessMimeType(attachmentRef.absolutePath),
@@ -5155,6 +5957,8 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     });
   }
   const contentHash = buildCompositeHash(originalBytes, attachments);
+  const fallbackTitle = path11.basename(absolutePath, path11.extname(absolutePath));
+  const title = initialConversion.title || fallbackTitle;
   const sourceId = `${slugify(title)}-${contentHash.slice(0, 8)}`;
   const replacements = new Map(
     attachmentRefs.map((attachmentRef) => [
@@ -5162,31 +5966,32 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
       `../assets/${sourceId}/${sanitizeAssetRelativePath(attachmentRef.relativeRef)}`
     ])
   );
-  const rewrittenText = rewriteMarkdownReferences(originalText, replacements);
-  const extractionArtifact = createPlainTextExtractionArtifact("markdown", "text/markdown");
+  const rewrittenHtml = rewriteHtmlLocalReferences(originalHtml, pathToFileURL(absolutePath).toString(), replacements);
+  const converted = rewrittenHtml === originalHtml ? initialConversion : await convertHtmlToMarkdown(rewrittenHtml, pathToFileURL(absolutePath).toString());
+  const extractionArtifact = createHtmlReadabilityExtractionArtifact("html", "text/html");
   return {
-    title,
+    title: converted.title || title,
     originType: "file",
-    sourceKind: "markdown",
+    sourceKind: "html",
     originalPath: toPosix(absolutePath),
-    mimeType: "text/markdown",
-    storedExtension: path10.extname(absolutePath) || ".md",
-    payloadBytes: Buffer.from(rewrittenText, "utf8"),
-    extractedText: rewrittenText,
+    mimeType: "text/html",
+    storedExtension: path11.extname(absolutePath) || ".html",
+    payloadBytes: Buffer.from(rewrittenHtml, "utf8"),
+    extractedText: converted.markdown,
     extractionArtifact,
-    extractionHash: buildExtractionHash(rewrittenText, extractionArtifact),
+    extractionHash: buildExtractionHash(converted.markdown, extractionArtifact),
     attachments,
     contentHash
   };
 }
 function isSupportedInboxKind(sourceKind) {
-  return ["markdown", "text", "html", "pdf", "image"].includes(sourceKind);
+  return ["markdown", "text", "html", "pdf", "docx", "image"].includes(sourceKind);
 }
 async function ingestInput(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInput = path10.resolve(rootDir, input);
-  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path10.dirname(absoluteInput));
+  const absoluteInput = path11.resolve(rootDir, input);
+  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path11.dirname(absoluteInput));
   const prepared = isHttpUrl(input) ? await prepareUrlInput(rootDir, input, normalizedOptions) : await prepareFileInput(rootDir, absoluteInput, repoRoot);
   const result = await persistPreparedInput(rootDir, prepared, paths);
   return result.manifest;
@@ -5276,7 +6081,7 @@ async function addInput(rootDir, input, options = {}) {
 async function ingestDirectory(rootDir, inputDir, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
-  const absoluteInputDir = path10.resolve(rootDir, inputDir);
+  const absoluteInputDir = path11.resolve(rootDir, inputDir);
   const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot2(absoluteInputDir) ?? absoluteInputDir;
   if (!await fileExists(absoluteInputDir)) {
     throw new Error(`Directory not found: ${absoluteInputDir}`);
@@ -5285,7 +6090,7 @@ async function ingestDirectory(rootDir, inputDir, options) {
   const imported = [];
   const updated = [];
   for (const absolutePath of files) {
-    const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(repoRoot, absolutePath));
+    const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(repoRoot, absolutePath));
     const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (result.isNew) {
@@ -5293,11 +6098,11 @@ async function ingestDirectory(rootDir, inputDir, options) {
     } else if (result.wasUpdated) {
       updated.push(result.manifest);
     } else {
-      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "duplicate_content" });
     }
   }
-  await appendLogEntry(rootDir, "ingest_directory", toPosix(path10.relative(rootDir, absoluteInputDir)) || ".", [
-    `repo_root=${toPosix(path10.relative(rootDir, repoRoot)) || "."}`,
+  await appendLogEntry(rootDir, "ingest_directory", toPosix(path11.relative(rootDir, absoluteInputDir)) || ".", [
+    `repo_root=${toPosix(path11.relative(rootDir, repoRoot)) || "."}`,
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `updated=${updated.length}`,
@@ -5314,7 +6119,7 @@ async function ingestDirectory(rootDir, inputDir, options) {
 }
 async function importInbox(rootDir, inputDir) {
   const { paths } = await initWorkspace(rootDir);
-  const effectiveInputDir = path10.resolve(rootDir, inputDir ?? paths.inboxDir);
+  const effectiveInputDir = path11.resolve(rootDir, inputDir ?? paths.inboxDir);
   if (!await fileExists(effectiveInputDir)) {
     throw new Error(`Inbox directory not found: ${effectiveInputDir}`);
   }
@@ -5325,31 +6130,31 @@ async function importInbox(rootDir, inputDir) {
   const skipped = [];
   let attachmentCount = 0;
   for (const absolutePath of files) {
-    const basename = path10.basename(absolutePath);
+    const basename = path11.basename(absolutePath);
     if (basename.startsWith(".")) {
-      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "hidden_file" });
+      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "hidden_file" });
       continue;
     }
     if (claimedAttachments.has(absolutePath)) {
-      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
+      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
     if (!isSupportedInboxKind(sourceKind)) {
-      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
       continue;
     }
-    const prepared = sourceKind === "markdown" && refsBySource.has(absolutePath) ? await prepareInboxMarkdownInput(absolutePath, refsBySource.get(absolutePath) ?? []) : await prepareFileInput(rootDir, absolutePath);
+    const prepared = sourceKind === "markdown" && refsBySource.has(absolutePath) ? await prepareInboxMarkdownInput(absolutePath, refsBySource.get(absolutePath) ?? []) : sourceKind === "html" && refsBySource.has(absolutePath) ? await prepareInboxHtmlInput(absolutePath, refsBySource.get(absolutePath) ?? []) : await prepareFileInput(rootDir, absolutePath);
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (!result.isNew) {
-      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
     attachmentCount += result.manifest.attachments?.length ?? 0;
     imported.push(result.manifest);
   }
-  await appendLogEntry(rootDir, "inbox_import", toPosix(path10.relative(rootDir, effectiveInputDir)) || ".", [
+  await appendLogEntry(rootDir, "inbox_import", toPosix(path11.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `attachments=${attachmentCount}`,
@@ -5368,9 +6173,9 @@ async function listManifests(rootDir) {
   if (!await fileExists(paths.manifestsDir)) {
     return [];
   }
-  const entries = await fs9.readdir(paths.manifestsDir);
+  const entries = await fs10.readdir(paths.manifestsDir);
   const manifests = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path10.join(paths.manifestsDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path11.join(paths.manifestsDir, entry)))
   );
   return manifests.filter((manifest) => Boolean(manifest));
 }
@@ -5378,17 +6183,17 @@ async function readExtractedText(rootDir, manifest) {
   if (!manifest.extractedTextPath) {
     return void 0;
   }
-  const absolutePath = path10.resolve(rootDir, manifest.extractedTextPath);
+  const absolutePath = path11.resolve(rootDir, manifest.extractedTextPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
-  return fs9.readFile(absolutePath, "utf8");
+  return fs10.readFile(absolutePath, "utf8");
 }
 async function readExtractionArtifact(rootDir, manifest) {
   if (!manifest.extractedMetadataPath) {
     return void 0;
   }
-  const absolutePath = path10.resolve(rootDir, manifest.extractedMetadataPath);
+  const absolutePath = path11.resolve(rootDir, manifest.extractedMetadataPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
@@ -5396,20 +6201,20 @@ async function readExtractionArtifact(rootDir, manifest) {
 }
 
 // src/mcp.ts
-import fs17 from "fs/promises";
-import path21 from "path";
+import fs18 from "fs/promises";
+import path22 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z8 } from "zod";
 
 // src/schema.ts
-import fs10 from "fs/promises";
-import path11 from "path";
+import fs11 from "fs/promises";
+import path12 from "path";
 function normalizeSchemaContent(content) {
   return content.trim() ? content.trim() : defaultVaultSchema().trim();
 }
 async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
-  const content = await fileExists(schemaPath) ? await fs10.readFile(schemaPath, "utf8") : fallback;
+  const content = await fileExists(schemaPath) ? await fs11.readFile(schemaPath, "utf8") : fallback;
   const normalized = normalizeSchemaContent(content);
   return {
     path: schemaPath,
@@ -5418,7 +6223,7 @@ async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
   };
 }
 function resolveProjectSchemaPath(rootDir, schemaPath) {
-  return path11.resolve(rootDir, schemaPath);
+  return path12.resolve(rootDir, schemaPath);
 }
 function composeVaultSchema(root, projectSchemas = []) {
   if (!projectSchemas.length) {
@@ -5434,7 +6239,7 @@ function composeVaultSchema(root, projectSchemas = []) {
       (schema) => [
         `## Project Schema`,
         "",
-        `Path: ${toPosix(path11.relative(path11.dirname(root.path), schema.path) || schema.path)}`,
+        `Path: ${toPosix(path12.relative(path12.dirname(root.path), schema.path) || schema.path)}`,
         "",
         schema.content
       ].join("\n")
@@ -5510,13 +6315,13 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs16 from "fs/promises";
-import path20 from "path";
+import fs17 from "fs/promises";
+import path21 from "path";
 import matter9 from "gray-matter";
 import { z as z7 } from "zod";
 
 // src/analysis.ts
-import path12 from "path";
+import path13 from "path";
 import { z as z2 } from "zod";
 var ANALYSIS_FORMAT_VERSION = 5;
 var sourceAnalysisSchema = z2.object({
@@ -5696,276 +6501,119 @@ ${truncate(text, 18e3)}`
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function analysisFromVisionExtraction(manifest, extraction, schemaHash) {
-  if (!extraction.vision) {
-    return null;
-  }
-  return {
-    analysisVersion: ANALYSIS_FORMAT_VERSION,
-    sourceId: manifest.sourceId,
-    sourceHash: manifest.contentHash,
-    extractionHash: manifest.extractionHash,
-    schemaHash,
-    title: extraction.vision.title?.trim() || manifest.title,
-    summary: extraction.vision.summary,
-    concepts: extraction.vision.concepts.map((term) => ({
-      id: `concept:${slugify(term.name)}`,
-      name: term.name,
-      description: term.description
-    })),
-    entities: extraction.vision.entities.map((term) => ({
-      id: `entity:${slugify(term.name)}`,
-      name: term.name,
-      description: term.description
-    })),
-    claims: extraction.vision.claims.map((claim, index) => ({
-      id: `claim:${manifest.sourceId}:${index + 1}`,
-      text: claim.text,
-      confidence: claim.confidence,
-      status: "extracted",
-      polarity: claim.polarity,
-      citation: manifest.sourceId
-    })),
-    questions: extraction.vision.questions,
-    rationales: [],
-    producedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function extractionWarningSummary(manifest, extraction) {
-  const warning = extraction?.warnings?.find(Boolean);
-  if (warning) {
-    return `Imported ${manifest.sourceKind} source. ${warning}`;
-  }
-  return `Imported ${manifest.sourceKind} source. Text extraction is not yet available for this source.`;
-}
-async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path12.join(paths.analysesDir, `${manifest.sourceId}.json`);
-  const cached = await readJsonFile(cachePath);
-  if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && cached.sourceHash === manifest.contentHash && cached.extractionHash === manifest.extractionHash && cached.schemaHash === schema.hash) {
-    return cached;
-  }
-  const extraction = await readExtractionArtifact(paths.rootDir, manifest);
-  const content = normalizeWhitespace(extractedText ?? "");
-  let analysis;
-  if (manifest.sourceKind === "code" && content) {
-    analysis = await analyzeCodeSource(manifest, extractedText ?? "", schema.hash);
-  } else if (manifest.sourceKind === "image") {
-    const visionAnalysis = extraction ? analysisFromVisionExtraction(manifest, extraction, schema.hash) : null;
-    if (visionAnalysis) {
-      analysis = visionAnalysis;
-    } else if (!content) {
-      analysis = {
-        analysisVersion: ANALYSIS_FORMAT_VERSION,
-        sourceId: manifest.sourceId,
-        sourceHash: manifest.contentHash,
-        extractionHash: manifest.extractionHash,
-        schemaHash: schema.hash,
-        title: manifest.title,
-        summary: extractionWarningSummary(manifest, extraction),
-        concepts: [],
-        entities: [],
-        claims: [],
-        questions: [],
-        rationales: [],
-        producedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    } else if (provider.type === "heuristic") {
-      analysis = heuristicAnalysis(manifest, content, schema.hash);
-    } else {
-      try {
-        analysis = await providerAnalysis(manifest, content, provider, schema);
-      } catch {
-        analysis = heuristicAnalysis(manifest, content, schema.hash);
-      }
-    }
-  } else if (!content) {
-    analysis = {
-      analysisVersion: ANALYSIS_FORMAT_VERSION,
-      sourceId: manifest.sourceId,
-      sourceHash: manifest.contentHash,
-      extractionHash: manifest.extractionHash,
-      schemaHash: schema.hash,
-      title: manifest.title,
-      summary: extractionWarningSummary(manifest, extraction),
-      concepts: [],
-      entities: [],
-      claims: [],
-      questions: [],
-      rationales: [],
-      producedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } else if (provider.type === "heuristic") {
-    analysis = heuristicAnalysis(manifest, content, schema.hash);
-  } else {
-    try {
-      analysis = await providerAnalysis(manifest, content, provider, schema);
-    } catch {
-      analysis = heuristicAnalysis(manifest, content, schema.hash);
-    }
-  }
-  await writeJsonFile(cachePath, analysis);
-  return analysis;
-}
-function analysisSignature(analysis) {
-  return sha256(JSON.stringify(analysis));
-}
-
-// src/benchmark.ts
-var CHARS_PER_TOKEN = 4;
-var DEFAULT_BENCHMARK_QUESTIONS = [
-  "How does this vault connect the main concepts?",
-  "Which pages bridge the biggest communities?",
-  "What are the core abstractions in this vault?",
-  "Where are the biggest knowledge gaps?",
-  "What evidence should I read first?"
-];
-var RESEARCH_BENCHMARK_QUESTION = "Which research sources should I read first, and why?";
-function nodeMap(graph) {
-  return new Map(graph.nodes.map((node) => [node.id, node]));
-}
-function pageMap(graph) {
-  return new Map(graph.pages.map((page) => [page.id, page]));
-}
-function estimateTokens(text) {
-  return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));
-}
-function estimateCorpusWords(texts) {
-  return texts.reduce((total, text) => total + normalizeWhitespace(text).split(/\s+/).filter(Boolean).length, 0);
-}
-function benchmarkQueryTokens(graph, queryResult, pageContentsById) {
-  const nodesById = nodeMap(graph);
-  const pagesById = pageMap(graph);
-  const edgeIds = new Set(queryResult.visitedEdgeIds);
-  const lines = [];
-  for (const pageId of queryResult.pageIds) {
-    const page = pagesById.get(pageId);
-    if (!page) {
-      continue;
-    }
-    const content = normalizeWhitespace(pageContentsById.get(pageId) ?? "").slice(0, 280);
-    lines.push(`PAGE ${page.title} path=${page.path} kind=${page.kind}`);
-    if (content) {
-      lines.push(`PAGE_BODY ${content}`);
-    }
-  }
-  for (const nodeId of queryResult.visitedNodeIds) {
-    const node = nodesById.get(nodeId);
-    if (!node) {
-      continue;
-    }
-    lines.push(`NODE ${node.label} type=${node.type} community=${node.communityId ?? "unassigned"} page=${node.pageId ?? "none"}`);
-  }
-  for (const edge of graph.edges) {
-    if (!edgeIds.has(edge.id)) {
-      continue;
-    }
-    const source = nodesById.get(edge.source)?.label ?? edge.source;
-    const target = nodesById.get(edge.target)?.label ?? edge.target;
-    lines.push(`EDGE ${source} --${edge.relation}/${edge.evidenceClass}/${edge.confidence.toFixed(2)}--> ${target}`);
-  }
-  const queryTokens = estimateTokens(lines.join("\n"));
-  return {
-    question: queryResult.question,
-    queryTokens,
-    reduction: 0,
-    visitedNodeIds: queryResult.visitedNodeIds,
-    visitedEdgeIds: queryResult.visitedEdgeIds,
-    pageIds: queryResult.pageIds
-  };
-}
-function graphHash(graph) {
-  const hashedPages = graph.pages.filter((page) => page.kind !== "graph_report" && page.kind !== "community_summary");
-  const normalized = JSON.stringify(
-    {
-      nodes: [...graph.nodes].map((node) => ({
-        id: node.id,
-        type: node.type,
-        label: node.label,
-        pageId: node.pageId ?? null,
-        sourceClass: node.sourceClass ?? null,
-        communityId: node.communityId ?? null,
-        degree: node.degree ?? null,
-        bridgeScore: node.bridgeScore ?? null,
-        isGodNode: node.isGodNode ?? false,
-        sourceIds: [...node.sourceIds].sort(),
-        projectIds: [...node.projectIds].sort()
-      })).sort((left, right) => left.id.localeCompare(right.id)),
-      edges: [...graph.edges].map((edge) => ({
-        id: edge.id,
-        source: edge.source,
-        target: edge.target,
-        relation: edge.relation,
-        status: edge.status,
-        evidenceClass: edge.evidenceClass,
-        similarityBasis: edge.similarityBasis ?? null,
-        confidence: edge.confidence,
-        provenance: [...edge.provenance].sort()
-      })).sort((left, right) => left.id.localeCompare(right.id)),
-      pages: [...hashedPages].map((page) => ({
-        id: page.id,
-        path: page.path,
-        kind: page.kind,
-        status: page.status,
-        sourceType: page.sourceType ?? null,
-        sourceClass: page.sourceClass ?? null,
-        sourceIds: [...page.sourceIds].sort(),
-        projectIds: [...page.projectIds].sort(),
-        nodeIds: [...page.nodeIds].sort()
-      })).sort((left, right) => left.id.localeCompare(right.id)),
-      communities: [...graph.communities ?? []].map((community) => ({
-        id: community.id,
-        label: community.label,
-        nodeIds: [...community.nodeIds].sort()
-      })).sort((left, right) => left.id.localeCompare(right.id))
-    },
-    null,
-    0
-  );
-  return sha256(normalized);
-}
-function hasResearchSources(pages) {
-  return pages.some((page) => page.kind === "source" && Boolean(page.sourceType) && page.sourceType !== "url");
-}
-function defaultBenchmarkQuestionsForGraph(graph, maxQuestions = 3) {
-  const normalizedLimit = Math.max(1, Math.min(maxQuestions, DEFAULT_BENCHMARK_QUESTIONS.length));
-  const questions = [...DEFAULT_BENCHMARK_QUESTIONS];
-  if (hasResearchSources(graph.pages)) {
-    questions.unshift(RESEARCH_BENCHMARK_QUESTION);
+function analysisFromVisionExtraction(manifest, extraction, schemaHash) {
+  if (!extraction.vision) {
+    return null;
   }
-  return uniqueBy(questions, (item) => item).slice(0, normalizedLimit);
-}
-function buildBenchmarkArtifact(input) {
-  const corpusTokens = Math.max(1, Math.round(input.corpusWords * (100 / 75)));
-  const perQuestion = input.perQuestion.filter((entry) => entry.queryTokens > 0).map((entry) => ({
-    ...entry,
-    reduction: Number(Math.max(0, 1 - entry.queryTokens / Math.max(1, corpusTokens)).toFixed(3))
-  }));
-  const avgQueryTokens = perQuestion.length ? Math.max(1, Math.round(perQuestion.reduce((total, entry) => total + entry.queryTokens, 0) / perQuestion.length)) : 0;
-  const reductionRatio = avgQueryTokens ? Number(Math.max(0, 1 - avgQueryTokens / Math.max(1, corpusTokens)).toFixed(3)) : 0;
-  const uniqueVisitedNodes = new Set(perQuestion.flatMap((entry) => entry.visitedNodeIds)).size;
-  const summary = {
-    questionCount: input.questions.length,
-    uniqueVisitedNodes,
-    finalContextTokens: avgQueryTokens,
-    naiveCorpusTokens: corpusTokens,
-    avgReduction: reductionRatio,
-    reductionRatio
-  };
   return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    graphHash: graphHash(input.graph),
-    corpusWords: input.corpusWords,
-    corpusTokens,
-    nodes: input.graph.nodes.length,
-    edges: input.graph.edges.length,
-    avgQueryTokens,
-    reductionRatio,
-    sampleQuestions: input.questions,
-    perQuestion,
-    questionResults: perQuestion,
-    summary
+    analysisVersion: ANALYSIS_FORMAT_VERSION,
+    sourceId: manifest.sourceId,
+    sourceHash: manifest.contentHash,
+    extractionHash: manifest.extractionHash,
+    schemaHash,
+    title: extraction.vision.title?.trim() || manifest.title,
+    summary: extraction.vision.summary,
+    concepts: extraction.vision.concepts.map((term) => ({
+      id: `concept:${slugify(term.name)}`,
+      name: term.name,
+      description: term.description
+    })),
+    entities: extraction.vision.entities.map((term) => ({
+      id: `entity:${slugify(term.name)}`,
+      name: term.name,
+      description: term.description
+    })),
+    claims: extraction.vision.claims.map((claim, index) => ({
+      id: `claim:${manifest.sourceId}:${index + 1}`,
+      text: claim.text,
+      confidence: claim.confidence,
+      status: "extracted",
+      polarity: claim.polarity,
+      citation: manifest.sourceId
+    })),
+    questions: extraction.vision.questions,
+    rationales: [],
+    producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function extractionWarningSummary(manifest, extraction) {
+  const warning = extraction?.warnings?.find(Boolean);
+  if (warning) {
+    return `Imported ${manifest.sourceKind} source. ${warning}`;
+  }
+  return `Imported ${manifest.sourceKind} source. Text extraction is not yet available for this source.`;
+}
+async function analyzeSource(manifest, extractedText, provider, paths, schema) {
+  const cachePath = path13.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cached = await readJsonFile(cachePath);
+  if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && cached.sourceHash === manifest.contentHash && cached.extractionHash === manifest.extractionHash && cached.schemaHash === schema.hash) {
+    return cached;
+  }
+  const extraction = await readExtractionArtifact(paths.rootDir, manifest);
+  const content = normalizeWhitespace(extractedText ?? "");
+  let analysis;
+  if (manifest.sourceKind === "code" && content) {
+    analysis = await analyzeCodeSource(manifest, extractedText ?? "", schema.hash);
+  } else if (manifest.sourceKind === "image") {
+    const visionAnalysis = extraction ? analysisFromVisionExtraction(manifest, extraction, schema.hash) : null;
+    if (visionAnalysis) {
+      analysis = visionAnalysis;
+    } else if (!content) {
+      analysis = {
+        analysisVersion: ANALYSIS_FORMAT_VERSION,
+        sourceId: manifest.sourceId,
+        sourceHash: manifest.contentHash,
+        extractionHash: manifest.extractionHash,
+        schemaHash: schema.hash,
+        title: manifest.title,
+        summary: extractionWarningSummary(manifest, extraction),
+        concepts: [],
+        entities: [],
+        claims: [],
+        questions: [],
+        rationales: [],
+        producedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } else if (provider.type === "heuristic") {
+      analysis = heuristicAnalysis(manifest, content, schema.hash);
+    } else {
+      try {
+        analysis = await providerAnalysis(manifest, content, provider, schema);
+      } catch {
+        analysis = heuristicAnalysis(manifest, content, schema.hash);
+      }
+    }
+  } else if (!content) {
+    analysis = {
+      analysisVersion: ANALYSIS_FORMAT_VERSION,
+      sourceId: manifest.sourceId,
+      sourceHash: manifest.contentHash,
+      extractionHash: manifest.extractionHash,
+      schemaHash: schema.hash,
+      title: manifest.title,
+      summary: extractionWarningSummary(manifest, extraction),
+      concepts: [],
+      entities: [],
+      claims: [],
+      questions: [],
+      rationales: [],
+      producedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } else if (provider.type === "heuristic") {
+    analysis = heuristicAnalysis(manifest, content, schema.hash);
+  } else {
+    try {
+      analysis = await providerAnalysis(manifest, content, provider, schema);
+    } catch {
+      analysis = heuristicAnalysis(manifest, content, schema.hash);
+    }
+  }
+  await writeJsonFile(cachePath, analysis);
+  return analysis;
+}
+function analysisSignature(analysis) {
+  return sha256(JSON.stringify(analysis));
+}
 
 // src/confidence.ts
 function nodeConfidence(sourceCount) {
@@ -5984,8 +6632,8 @@ function conflictConfidence(claimA, claimB) {
 }
 
 // src/deep-lint.ts
-import fs11 from "fs/promises";
-import path15 from "path";
+import fs12 from "fs/promises";
+import path16 from "path";
 import matter4 from "gray-matter";
 import { z as z5 } from "zod";
 
@@ -6006,7 +6654,7 @@ function normalizeFindingSeverity(value) {
 
 // src/orchestration.ts
 import { spawn } from "child_process";
-import path13 from "path";
+import path14 from "path";
 import { z as z3 } from "zod";
 var orchestrationRoleResultSchema = z3.object({
   summary: z3.string().optional(),
@@ -6099,7 +6747,7 @@ async function runProviderRole(rootDir, role, roleConfig, input) {
 }
 async function runCommandRole(rootDir, role, executor, input) {
   const [command, ...args] = executor.command;
-  const cwd = executor.cwd ? path13.resolve(rootDir, executor.cwd) : rootDir;
+  const cwd = executor.cwd ? path14.resolve(rootDir, executor.cwd) : rootDir;
   const child = spawn(command, args, {
     cwd,
     env: {
@@ -6193,7 +6841,7 @@ function summarizeRoleQuestions(results) {
 }
 
 // src/web-search/registry.ts
-import path14 from "path";
+import path15 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { z as z4 } from "zod";
 
@@ -6291,7 +6939,7 @@ async function createWebSearchAdapter(id, config, rootDir) {
       if (!config.module) {
         throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
       }
-      const resolvedModule = path14.isAbsolute(config.module) ? config.module : path14.resolve(rootDir, config.module);
+      const resolvedModule = path15.isAbsolute(config.module) ? config.module : path15.resolve(rootDir, config.module);
       const loaded = await import(pathToFileURL2(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
@@ -6351,8 +6999,8 @@ async function loadContextPages(rootDir, graph) {
   );
   return Promise.all(
     contextPages.slice(0, 18).map(async (page) => {
-      const absolutePath = path15.join(paths.wikiDir, page.path);
-      const raw = await fs11.readFile(absolutePath, "utf8").catch(() => "");
+      const absolutePath = path16.join(paths.wikiDir, page.path);
+      const raw = await fs12.readFile(absolutePath, "utf8").catch(() => "");
       const parsed = matter4(raw);
       return {
         id: page.id,
@@ -6400,7 +7048,7 @@ function heuristicDeepFindings(contextPages, structuralFindings, graph) {
       code: "missing_citation",
       message: finding.message,
       pagePath: finding.pagePath,
-      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path15.basename(finding.pagePath, ".md")}?` : void 0
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path16.basename(finding.pagePath, ".md")}?` : void 0
     });
   }
   for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
@@ -6578,8 +7226,8 @@ async function runDeepLint(rootDir, structuralFindings, options = {}) {
 }
 
 // src/embeddings.ts
-import fs12 from "fs/promises";
-import path16 from "path";
+import fs13 from "fs/promises";
+import path17 from "path";
 var MAX_EMBEDDING_BATCH = 32;
 var MAX_SIMILARITY_NODES = 240;
 function cosineSimilarity(left, right) {
@@ -6613,9 +7261,15 @@ async function loadPageContents(rootDir, graph) {
   const contents = /* @__PURE__ */ new Map();
   await Promise.all(
     graph.pages.map(async (page) => {
-      const absolutePath = path16.join(paths.wikiDir, page.path);
-      const content = await fs12.readFile(absolutePath, "utf8").catch(() => "");
-      contents.set(page.id, content);
+      const absolutePath = path17.join(paths.wikiDir, page.path);
+      const content = await fs13.readFile(absolutePath, "utf8").catch(() => {
+        process.stderr.write(`[swarmvault] Warning: could not read page ${page.path} for embedding
+`);
+        return "";
+      });
+      if (content) {
+        contents.set(page.id, content);
+      }
     })
   );
   return contents;
@@ -8110,15 +8764,15 @@ function sourceTypeForNode(node, pagesById) {
   return pagesById.get(node.pageId)?.sourceType;
 }
 function supportingPathDetails(graph, edge) {
-  const path25 = shortestGraphPath(graph, edge.source, edge.target);
+  const path26 = shortestGraphPath(graph, edge.source, edge.target);
   const edgesById = new Map(graph.edges.map((item) => [item.id, item]));
-  const pathEdges = path25.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
+  const pathEdges = path26.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
   return {
-    pathNodeIds: path25.nodeIds,
-    pathEdgeIds: path25.edgeIds,
+    pathNodeIds: path26.nodeIds,
+    pathEdgeIds: path26.edgeIds,
     pathRelations: pathEdges.map((item) => item.relation),
     pathEvidenceClasses: pathEdges.map((item) => item.evidenceClass),
-    pathSummary: path25.summary
+    pathSummary: path26.summary
   };
 }
 function surpriseScore(edge, graph, pagesById, hyperedgesByNodeId) {
@@ -8187,7 +8841,7 @@ function topSurprisingConnections(graph, pagesById) {
     }).map((edge) => {
       const source = nodesById.get(edge.source);
       const target = nodesById.get(edge.target);
-      const path25 = supportingPathDetails(graph, edge);
+      const path26 = supportingPathDetails(graph, edge);
       const scored = surpriseScore(edge, graph, pagesById, hyperedgesByNodeId);
       return {
         id: edge.id,
@@ -8198,11 +8852,11 @@ function topSurprisingConnections(graph, pagesById) {
         relation: edge.relation,
         evidenceClass: edge.evidenceClass,
         confidence: edge.confidence,
-        pathNodeIds: path25.pathNodeIds,
-        pathEdgeIds: path25.pathEdgeIds,
-        pathRelations: path25.pathRelations,
-        pathEvidenceClasses: path25.pathEvidenceClasses,
-        pathSummary: path25.pathSummary,
+        pathNodeIds: path26.pathNodeIds,
+        pathEdgeIds: path26.pathEdgeIds,
+        pathRelations: path26.pathRelations,
+        pathEvidenceClasses: path26.pathEvidenceClasses,
+        pathSummary: path26.pathSummary,
         why: scored.why,
         explanation: scored.explanation,
         surpriseScore: scored.score
@@ -9087,13 +9741,13 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
-import fs14 from "fs/promises";
-import path18 from "path";
+import fs15 from "fs/promises";
+import path19 from "path";
 import matter7 from "gray-matter";
 
 // src/pages.ts
-import fs13 from "fs/promises";
-import path17 from "path";
+import fs14 from "fs/promises";
+import path18 from "path";
 import matter6 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -9171,7 +9825,7 @@ async function loadExistingManagedPageState(absolutePath, defaults = {}) {
       updatedAt: updatedFallback
     };
   }
-  const content = await fs13.readFile(absolutePath, "utf8");
+  const content = await fs14.readFile(absolutePath, "utf8");
   const parsed = matter6(content);
   return {
     status: normalizePageStatus(parsed.data.status, defaults.status ?? "active"),
@@ -9210,7 +9864,7 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const fallbackCreatedAt = defaults.createdAt ?? now;
   const fallbackUpdatedAt = defaults.updatedAt ?? fallbackCreatedAt;
-  const title = typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(relativePath, ".md");
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path18.basename(relativePath, ".md");
   const kind = inferPageKind(relativePath, parsed.data.kind);
   const sourceIds = normalizeStringArray(parsed.data.source_ids);
   const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -9251,18 +9905,18 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   };
 }
 async function loadInsightPages(wikiDir) {
-  const insightsDir = path17.join(wikiDir, "insights");
+  const insightsDir = path18.join(wikiDir, "insights");
   if (!await fileExists(insightsDir)) {
     return [];
   }
-  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path17.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
+  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path18.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
   const insights = [];
   for (const absolutePath of files) {
-    const relativePath = toPosix(path17.relative(wikiDir, absolutePath));
-    const content = await fs13.readFile(absolutePath, "utf8");
+    const relativePath = toPosix(path18.relative(wikiDir, absolutePath));
+    const content = await fs14.readFile(absolutePath, "utf8");
     const parsed = matter6(content);
-    const stats = await fs13.stat(absolutePath);
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(absolutePath, ".md");
+    const stats = await fs14.stat(absolutePath);
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path18.basename(absolutePath, ".md");
     const sourceIds = normalizeStringArray(parsed.data.source_ids);
     const projectIds = normalizeProjectIds(parsed.data.project_ids);
     const nodeIds = normalizeStringArray(parsed.data.node_ids);
@@ -9325,27 +9979,27 @@ function relatedOutputsForPage(targetPage, outputPages) {
   return outputPages.map((page) => ({ page, rank: relationRank(page, targetPage) })).filter((item) => item.rank > 0).sort((left, right) => right.rank - left.rank || left.page.title.localeCompare(right.page.title)).map((item) => item.page);
 }
 async function resolveUniqueOutputSlug(wikiDir, baseSlug) {
-  const outputsDir = path18.join(wikiDir, "outputs");
+  const outputsDir = path19.join(wikiDir, "outputs");
   const root = baseSlug || "output";
   let candidate = root;
   let counter = 2;
-  while (await fileExists(path18.join(outputsDir, `${candidate}.md`))) {
+  while (await fileExists(path19.join(outputsDir, `${candidate}.md`))) {
     candidate = `${root}-${counter}`;
     counter++;
   }
   return candidate;
 }
 async function loadSavedOutputPages(wikiDir) {
-  const outputsDir = path18.join(wikiDir, "outputs");
-  const entries = await fs14.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
+  const outputsDir = path19.join(wikiDir, "outputs");
+  const entries = await fs15.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
   const outputs = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") {
       continue;
     }
-    const relativePath = path18.posix.join("outputs", entry.name);
-    const absolutePath = path18.join(outputsDir, entry.name);
-    const content = await fs14.readFile(absolutePath, "utf8");
+    const relativePath = path19.posix.join("outputs", entry.name);
+    const absolutePath = path19.join(outputsDir, entry.name);
+    const content = await fs15.readFile(absolutePath, "utf8");
     const parsed = matter7(content);
     const slug = entry.name.replace(/\.md$/, "");
     const title = typeof parsed.data.title === "string" ? parsed.data.title : slug;
@@ -9358,7 +10012,7 @@ async function loadSavedOutputPages(wikiDir) {
     const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
     const backlinks = normalizeStringArray(parsed.data.backlinks);
     const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
-    const stats = await fs14.stat(absolutePath);
+    const stats = await fs15.stat(absolutePath);
     const createdAt = typeof parsed.data.created_at === "string" ? parsed.data.created_at : stats.birthtimeMs > 0 ? stats.birthtime.toISOString() : stats.mtime.toISOString();
     const updatedAt = typeof parsed.data.updated_at === "string" ? parsed.data.updated_at : stats.mtime.toISOString();
     outputs.push({
@@ -9396,8 +10050,8 @@ async function loadSavedOutputPages(wikiDir) {
 }
 
 // src/search.ts
-import fs15 from "fs/promises";
-import path19 from "path";
+import fs16 from "fs/promises";
+import path20 from "path";
 import matter8 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
@@ -9423,7 +10077,7 @@ function normalizeSourceClass2(value) {
   return value === "first_party" || value === "third_party" || value === "resource" || value === "generated" ? value : void 0;
 }
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path19.dirname(dbPath));
+  await ensureDir(path20.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -9455,8 +10109,8 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
     "INSERT INTO pages (id, path, title, body, kind, status, source_type, source_class, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
   );
   for (const page of pages) {
-    const absolutePath = path19.join(wikiDir, page.path);
-    const content = await fs15.readFile(absolutePath, "utf8");
+    const absolutePath = path20.join(wikiDir, page.path);
+    const content = await fs16.readFile(absolutePath, "utf8");
     const parsed = matter8(content);
     insertPage.run(
       page.id,
@@ -9573,7 +10227,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path20.join("outputs", "assets", slug, fileName));
+  return toPosix(path21.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -9713,7 +10367,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-KLO5YIHP.js");
+  const { createProvider: createProvider2 } = await import("./registry-G7NSRYCO.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -9911,7 +10565,7 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path20.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path21.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
@@ -9937,10 +10591,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path20.isAbsolute(rawPath)) {
+  if (!path21.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path20.relative(rootDir, rawPath));
+  const relative = toPosix(path21.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -10114,7 +10768,7 @@ function pageHashes(pages) {
   return Object.fromEntries(pages.map((page) => [page.page.id, page.contentHash]));
 }
 async function buildManagedGraphPage(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs16.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs17.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -10152,7 +10806,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs16.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs17.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -10274,8 +10928,64 @@ function deriveGraphMetrics(nodes, edges) {
 function resetGraphNodeMetrics(nodes) {
   return nodes.map(({ communityId: _communityId, degree: _degree, bridgeScore: _bridgeScore, isGodNode: _isGodNode, ...node }) => node);
 }
+function manifestRepoPath(manifest) {
+  return toPosix(manifest.repoRelativePath ?? path21.basename(manifest.originalPath ?? manifest.storedPath));
+}
+function goPackageScopeKey(manifest, analysis) {
+  if (analysis.code?.language !== "go") {
+    return null;
+  }
+  const packageName = analysis.code.namespace?.trim();
+  if (!packageName) {
+    return null;
+  }
+  return `${packageName}:${path21.posix.dirname(manifestRepoPath(manifest))}`;
+}
+function buildGoPackageSymbolLookups(analyses, manifestsById) {
+  const lookups = /* @__PURE__ */ new Map();
+  for (const analysis of analyses) {
+    if (analysis.code?.language !== "go") {
+      continue;
+    }
+    const manifest = manifestsById.get(analysis.sourceId);
+    if (!manifest) {
+      continue;
+    }
+    const scopeKey = goPackageScopeKey(manifest, analysis);
+    if (!scopeKey) {
+      continue;
+    }
+    const current = lookups.get(scopeKey) ?? {
+      byName: /* @__PURE__ */ new Map(),
+      methodIdsByShortName: /* @__PURE__ */ new Map()
+    };
+    for (const symbol of analysis.code.symbols) {
+      current.byName.set(symbol.name, symbol.id);
+      const separator = symbol.name.lastIndexOf(".");
+      if (separator > 0) {
+        const shortName = symbol.name.slice(separator + 1);
+        const matches = current.methodIdsByShortName.get(shortName) ?? /* @__PURE__ */ new Set();
+        matches.add(symbol.id);
+        current.methodIdsByShortName.set(shortName, matches);
+      }
+    }
+    lookups.set(scopeKey, current);
+  }
+  return new Map(
+    [...lookups.entries()].map(([scopeKey, value]) => [
+      scopeKey,
+      {
+        byName: value.byName,
+        uniqueMethodIdsByShortName: new Map(
+          [...value.methodIdsByShortName.entries()].filter(([, ids]) => ids.size === 1).map(([shortName, ids]) => [shortName, [...ids][0]])
+        )
+      }
+    ])
+  );
+}
 function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
   const manifestsById = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
+  const goPackageSymbolLookups = buildGoPackageSymbolLookups(analyses, manifestsById);
   const sourceNodes = manifests.map((manifest) => ({
     id: `source:${manifest.sourceId}`,
     type: "source",
@@ -10422,6 +11132,10 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
         }
       }
       const symbolIdsByName = new Map(analysis.code.symbols.map((symbol) => [symbol.name, symbol.id]));
+      const goPackageLookup = analysis.code.language === "go" ? goPackageSymbolLookups.get(goPackageScopeKey(manifest, analysis) ?? "") : void 0;
+      const localSymbolIdsByName = goPackageLookup?.byName ?? symbolIdsByName;
+      const localGoMethodIdsByShortName = goPackageLookup?.uniqueMethodIdsByShortName ?? /* @__PURE__ */ new Map();
+      const resolveLocalSymbolId = (targetName) => localSymbolIdsByName.get(targetName) ?? (analysis.code?.language === "go" ? localGoMethodIdsByShortName.get(targetName) : void 0);
       for (const rationale of analysis.rationales) {
         const targetSymbolId = rationale.symbolName ? symbolIdsByName.get(rationale.symbolName) : void 0;
         const targetId = targetSymbolId ?? moduleId;
@@ -10474,9 +11188,31 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
           }
         }
       }
+      if (analysis.code.language === "go") {
+        for (const symbol of analysis.code.symbols) {
+          const separator = symbol.name.lastIndexOf(".");
+          if (separator <= 0) {
+            continue;
+          }
+          const receiverTypeId = localSymbolIdsByName.get(symbol.name.slice(0, separator));
+          if (!receiverTypeId || receiverTypeId === symbol.id) {
+            continue;
+          }
+          pushEdge({
+            id: `${receiverTypeId}->${symbol.id}:defines:receiver`,
+            source: receiverTypeId,
+            target: symbol.id,
+            relation: "defines",
+            status: "extracted",
+            evidenceClass: "extracted",
+            confidence: 1,
+            provenance: [analysis.sourceId]
+          });
+        }
+      }
       for (const symbol of analysis.code.symbols) {
         for (const targetName of symbol.calls) {
-          const targetId = symbolIdsByName.get(targetName);
+          const targetId = resolveLocalSymbolId(targetName);
           if (!targetId || targetId === symbol.id) {
             continue;
           }
@@ -10492,7 +11228,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
           });
         }
         for (const targetName of symbol.extends) {
-          const targetId = symbolIdsByName.get(targetName) ?? importedSymbolIdsByName.get(targetName);
+          const targetId = resolveLocalSymbolId(targetName) ?? importedSymbolIdsByName.get(targetName);
           if (!targetId) {
             continue;
           }
@@ -10508,7 +11244,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
           });
         }
         for (const targetName of symbol.implements) {
-          const targetId = symbolIdsByName.get(targetName) ?? importedSymbolIdsByName.get(targetName);
+          const targetId = resolveLocalSymbolId(targetName) ?? importedSymbolIdsByName.get(targetName);
           if (!targetId) {
             continue;
           }
@@ -10630,7 +11366,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
-    const absolutePath = path20.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
+    const absolutePath = path21.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
     communityRecords.push(
       await buildManagedGraphPage(
         absolutePath,
@@ -10658,7 +11394,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     recentResearchSources: recentResearchSourcePages(graph, previousCompiledAt),
     graphHash: graphHash(graph)
   });
-  const reportAbsolutePath = path20.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path21.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -10679,7 +11415,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path20.resolve(wikiDir, relativePath);
+  const absolutePath = path21.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -10742,29 +11478,29 @@ async function requiredCompileArtifactsExist(paths) {
     paths.graphPath,
     paths.codeIndexPath,
     paths.searchDbPath,
-    path20.join(paths.wikiDir, "index.md"),
-    path20.join(paths.wikiDir, "sources", "index.md"),
-    path20.join(paths.wikiDir, "code", "index.md"),
-    path20.join(paths.wikiDir, "concepts", "index.md"),
-    path20.join(paths.wikiDir, "entities", "index.md"),
-    path20.join(paths.wikiDir, "outputs", "index.md"),
-    path20.join(paths.wikiDir, "projects", "index.md"),
-    path20.join(paths.wikiDir, "candidates", "index.md")
+    path21.join(paths.wikiDir, "index.md"),
+    path21.join(paths.wikiDir, "sources", "index.md"),
+    path21.join(paths.wikiDir, "code", "index.md"),
+    path21.join(paths.wikiDir, "concepts", "index.md"),
+    path21.join(paths.wikiDir, "entities", "index.md"),
+    path21.join(paths.wikiDir, "outputs", "index.md"),
+    path21.join(paths.wikiDir, "projects", "index.md"),
+    path21.join(paths.wikiDir, "candidates", "index.md")
   ];
   const checks = await Promise.all(requiredPaths.map((filePath) => fileExists(filePath)));
   return checks.every(Boolean);
 }
 async function loadAvailableCachedAnalyses(paths, manifests) {
   const analyses = await Promise.all(
-    manifests.map(async (manifest) => readJsonFile(path20.join(paths.analysesDir, `${manifest.sourceId}.json`)))
+    manifests.map(async (manifest) => readJsonFile(path21.join(paths.analysesDir, `${manifest.sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis));
 }
 function approvalManifestPath(paths, approvalId) {
-  return path20.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path21.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path20.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path21.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
@@ -10774,7 +11510,7 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs16.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs17.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph) {
@@ -10789,7 +11525,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path20.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path21.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -10822,7 +11558,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path20.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path21.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
@@ -10834,16 +11570,16 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
 }
 async function stageApprovalBundle(paths, changedFiles, deletedPaths, previousGraph, graph) {
   const approvalId = `compile-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path20.join(paths.approvalsDir, approvalId);
+  const approvalDir = path21.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path20.join(approvalDir, "wiki"));
-  await ensureDir(path20.join(approvalDir, "state"));
+  await ensureDir(path21.join(approvalDir, "wiki"));
+  await ensureDir(path21.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path20.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path20.dirname(targetPath));
-    await fs16.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path21.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path21.dirname(targetPath));
+    await fs17.writeFile(targetPath, file.content, "utf8");
   }
-  await fs16.writeFile(path20.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs17.writeFile(path21.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10905,7 +11641,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path20.join(paths.wikiDir, preview.path),
+      path21.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -10951,7 +11687,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path20.join(paths.wikiDir, modulePreview.path),
+          path21.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -10985,8 +11721,8 @@ async function syncVaultArtifacts(rootDir, input) {
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const aggregateSourceClass2 = aggregateManifestSourceClass(input.manifests, sourceIds);
       const fallbackPaths = [
-        path20.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path20.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path21.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path21.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -11004,7 +11740,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path20.join(paths.wikiDir, relativePath),
+        path21.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -11099,7 +11835,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path20.join(paths.wikiDir, "projects", "index.md"),
+      path21.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -11123,7 +11859,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path20.join(paths.wikiDir, projectIndexRef.path),
+        path21.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -11151,7 +11887,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path20.join(paths.wikiDir, "index.md"),
+      path21.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -11182,7 +11918,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path20.join(paths.wikiDir, relativePath),
+        path21.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -11193,12 +11929,12 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const nextPagePaths = new Set(records.map((record) => record.page.path));
   const obsoleteGraphPaths = (previousGraph?.pages ?? []).filter((page) => page.kind !== "output" && page.kind !== "insight").map((page) => page.path).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path20.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path21.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
   const obsoletePaths = uniqueStrings3([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path20.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs16.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path21.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs17.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -11223,10 +11959,10 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs16.rm(path20.join(paths.wikiDir, relativePath), { force: true });
+    await fs17.rm(path21.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
-  await writeJsonFile(path20.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+  await writeJsonFile(path21.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   await writeJsonFile(paths.codeIndexPath, input.codeIndex);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
@@ -11297,17 +12033,17 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path20.join(paths.wikiDir, "sources")),
-    ensureDir(path20.join(paths.wikiDir, "code")),
-    ensureDir(path20.join(paths.wikiDir, "concepts")),
-    ensureDir(path20.join(paths.wikiDir, "entities")),
-    ensureDir(path20.join(paths.wikiDir, "outputs")),
-    ensureDir(path20.join(paths.wikiDir, "graph")),
-    ensureDir(path20.join(paths.wikiDir, "graph", "communities")),
-    ensureDir(path20.join(paths.wikiDir, "projects")),
-    ensureDir(path20.join(paths.wikiDir, "candidates"))
+    ensureDir(path21.join(paths.wikiDir, "sources")),
+    ensureDir(path21.join(paths.wikiDir, "code")),
+    ensureDir(path21.join(paths.wikiDir, "concepts")),
+    ensureDir(path21.join(paths.wikiDir, "entities")),
+    ensureDir(path21.join(paths.wikiDir, "outputs")),
+    ensureDir(path21.join(paths.wikiDir, "graph")),
+    ensureDir(path21.join(paths.wikiDir, "graph", "communities")),
+    ensureDir(path21.join(paths.wikiDir, "projects")),
+    ensureDir(path21.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path20.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path21.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -11328,7 +12064,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       outputs: pages.filter((page) => page.kind === "output" && page.projectIds.includes(project.id)),
       candidates: pages.filter((page) => page.status === "candidate" && page.projectIds.includes(project.id))
     };
-    const absolutePath = path20.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path21.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -11346,7 +12082,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path20.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path21.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -11367,7 +12103,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ["candidates/index.md", "candidates", pagesWithGraph.filter((page) => page.status === "candidate")],
     ["graph/index.md", "graph", pagesWithGraph.filter((page) => page.kind === "graph_report" || page.kind === "community_summary")]
   ]) {
-    const absolutePath = path20.join(paths.wikiDir, relativePath);
+    const absolutePath = path21.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -11381,23 +12117,23 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     );
   }
   for (const record of graphOrientation.records) {
-    await writeFileIfChanged(path20.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path21.join(paths.wikiDir, record.page.path), record.content);
   }
   if (graphOrientation.report) {
-    await writeJsonFile(path20.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+    await writeJsonFile(path21.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path20.relative(paths.wikiDir, absolutePath)));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path21.relative(paths.wikiDir, absolutePath)));
   const allowedProjectIndexPaths = /* @__PURE__ */ new Set([
     "projects/index.md",
     ...configuredProjects.map((project) => `projects/${project.id}/index.md`)
   ]);
   await Promise.all(
-    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs16.rm(path20.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs17.rm(path21.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingGraphPages = (await listFilesRecursive(path20.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path20.relative(paths.wikiDir, absolutePath)));
+  const existingGraphPages = (await listFilesRecursive(path21.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path21.relative(paths.wikiDir, absolutePath)));
   const allowedGraphPages = /* @__PURE__ */ new Set(["graph/index.md", ...graphOrientation.records.map((record) => record.page.path)]);
   await Promise.all(
-    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs16.rm(path20.join(paths.wikiDir, relativePath), { force: true }))
+    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs17.rm(path21.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
@@ -11417,7 +12153,7 @@ async function prepareOutputPageSave(rootDir, input) {
       confidence: 0.74
     }
   });
-  const absolutePath = path20.join(paths.wikiDir, output.page.path);
+  const absolutePath = path21.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -11429,15 +12165,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path20.dirname(prepared.savedPath));
-  await fs16.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path21.dirname(prepared.savedPath));
+  await fs17.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path20.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path20.dirname(assetPath));
+    const assetPath = path21.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path21.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs16.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs17.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs16.writeFile(assetPath, assetFile.content);
+      await fs17.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -11458,7 +12194,7 @@ async function prepareExploreHubSave(rootDir, input) {
       confidence: 0.76
     }
   });
-  const absolutePath = path20.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path21.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -11470,15 +12206,15 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path20.dirname(prepared.savedPath));
-  await fs16.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path21.dirname(prepared.savedPath));
+  await fs17.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path20.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path20.dirname(assetPath));
+    const assetPath = path21.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path21.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs16.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs17.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs16.writeFile(assetPath, assetFile.content);
+      await fs17.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -11495,17 +12231,17 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     }))
   ]);
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path20.join(paths.approvalsDir, approvalId);
+  const approvalDir = path21.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path20.join(approvalDir, "wiki"));
-  await ensureDir(path20.join(approvalDir, "state"));
+  await ensureDir(path21.join(approvalDir, "wiki"));
+  await ensureDir(path21.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path20.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path20.dirname(targetPath));
+    const targetPath = path21.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path21.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs16.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs17.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs16.writeFile(targetPath, file.content, "utf8");
+      await fs17.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -11520,7 +12256,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs16.writeFile(path20.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs17.writeFile(path21.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11549,9 +12285,9 @@ async function executeQuery(rootDir, question, format) {
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path20.join(paths.wikiDir, result.path);
+      const absolutePath = path21.join(paths.wikiDir, result.path);
       try {
-        const content = await fs16.readFile(absolutePath, "utf8");
+        const content = await fs17.readFile(absolutePath, "utf8");
         const parsed = matter9(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
@@ -11733,7 +12469,7 @@ function sortGraphPages(pages) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs16.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs17.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -11749,8 +12485,8 @@ async function readApproval(rootDir, approvalId) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs16.readFile(path20.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs16.readFile(path20.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs17.readFile(path21.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs17.readFile(path21.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       return {
         ...entry,
         currentContent,
@@ -11778,26 +12514,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path20.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs16.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path20.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path20.dirname(targetAbsolutePath));
-      await fs16.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path21.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs17.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path21.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path21.dirname(targetAbsolutePath));
+      await fs17.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs16.rm(path20.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs17.rm(path21.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       const nextPage = bundleGraph?.pages.find((page) => page.id === entry.pageId && page.path === entry.nextPath) ?? parseStoredPage(entry.nextPath, stagedContent);
       if (nextPage.kind === "output" && nextPage.outputAssets?.length) {
-        const outputAssetDir = path20.join(paths.wikiDir, "outputs", "assets", path20.basename(nextPage.path, ".md"));
-        await fs16.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path21.join(paths.wikiDir, "outputs", "assets", path21.basename(nextPage.path, ".md"));
+        await fs17.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path20.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path21.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path20.join(paths.wikiDir, asset.path);
-          await ensureDir(path20.dirname(targetAssetPath));
-          await fs16.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path21.join(paths.wikiDir, asset.path);
+          await ensureDir(path21.dirname(targetAssetPath));
+          await fs17.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -11808,10 +12544,10 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
     } else {
       const deletedPage = nextPages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? bundleGraph?.pages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? null;
       if (entry.previousPath) {
-        await fs16.rm(path20.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs17.rm(path21.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs16.rm(path20.join(paths.wikiDir, "outputs", "assets", path20.basename(deletedPage.path, ".md")), {
+        await fs17.rm(path21.join(paths.wikiDir, "outputs", "assets", path21.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -11902,7 +12638,7 @@ async function promoteCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  const raw = await fs16.readFile(path20.join(paths.wikiDir, candidate.path), "utf8");
+  const raw = await fs17.readFile(path21.join(paths.wikiDir, candidate.path), "utf8");
   const parsed = matter9(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const nextContent = matter9.stringify(parsed.content, {
@@ -11914,10 +12650,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path20.join(paths.wikiDir, nextPath);
-  await ensureDir(path20.dirname(nextAbsolutePath));
-  await fs16.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs16.rm(path20.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path21.join(paths.wikiDir, nextPath);
+  await ensureDir(path21.dirname(nextAbsolutePath));
+  await fs17.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs17.rm(path21.join(paths.wikiDir, candidate.path), { force: true });
   const nextPage = parseStoredPage(nextPath, nextContent, { createdAt: candidate.createdAt, updatedAt: nextUpdatedAt });
   const nextPages = sortGraphPages(
     (graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path).concat(nextPage)
@@ -11962,7 +12698,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs16.rm(path20.join(paths.wikiDir, candidate.path), { force: true });
+  await fs17.rm(path21.join(paths.wikiDir, candidate.path), { force: true });
   const nextPages = sortGraphPages((graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path));
   const nextGraph = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12001,18 +12737,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path20.join(rootDir, ".obsidian");
+  const obsidianDir = path21.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path20.join(obsidianDir, "app.json"), {
+    writeJsonFile(path21.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path20.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path21.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -12022,7 +12758,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path20.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path21.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -12034,7 +12770,7 @@ async function ensureObsidianWorkspace(rootDir) {
       })),
       localJumps: false
     }),
-    writeJsonFile(path20.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path21.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -12049,7 +12785,7 @@ async function ensureObsidianWorkspace(rootDir) {
 async function initVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path20.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path21.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
@@ -12085,7 +12821,7 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path20.join(paths.wikiDir, "projects", "index.md"),
+    path21.join(paths.wikiDir, "projects", "index.md"),
     matter9.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
@@ -12107,7 +12843,7 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path20.join(paths.wikiDir, "candidates", "index.md"),
+    path21.join(paths.wikiDir, "candidates", "index.md"),
     matter9.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
@@ -12243,7 +12979,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path20.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path21.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           return cached;
         }
@@ -12267,22 +13003,22 @@ async function compileVault(rootDir, options = {}) {
       }
       const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
       if (analysisSignature(enriched) !== analysisSignature(analysis)) {
-        await writeJsonFile(path20.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+        await writeJsonFile(path21.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
       }
       return enriched;
     })
   );
   await Promise.all([
-    ensureDir(path20.join(paths.wikiDir, "sources")),
-    ensureDir(path20.join(paths.wikiDir, "code")),
-    ensureDir(path20.join(paths.wikiDir, "concepts")),
-    ensureDir(path20.join(paths.wikiDir, "entities")),
-    ensureDir(path20.join(paths.wikiDir, "outputs")),
-    ensureDir(path20.join(paths.wikiDir, "projects")),
-    ensureDir(path20.join(paths.wikiDir, "insights")),
-    ensureDir(path20.join(paths.wikiDir, "candidates")),
-    ensureDir(path20.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path20.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path21.join(paths.wikiDir, "sources")),
+    ensureDir(path21.join(paths.wikiDir, "code")),
+    ensureDir(path21.join(paths.wikiDir, "concepts")),
+    ensureDir(path21.join(paths.wikiDir, "entities")),
+    ensureDir(path21.join(paths.wikiDir, "outputs")),
+    ensureDir(path21.join(paths.wikiDir, "projects")),
+    ensureDir(path21.join(paths.wikiDir, "insights")),
+    ensureDir(path21.join(paths.wikiDir, "candidates")),
+    ensureDir(path21.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path21.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
@@ -12429,7 +13165,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path20.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path21.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -12685,9 +13421,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path20.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path21.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path20.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path21.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -12774,11 +13510,11 @@ async function benchmarkVault(rootDir, options = {}) {
     }
   }
   for (const page of graph.pages) {
-    const absolutePath = path20.join(paths.wikiDir, page.path);
+    const absolutePath = path21.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const parsed = matter9(await fs16.readFile(absolutePath, "utf8"));
+    const parsed = matter9(await fs17.readFile(absolutePath, "utf8"));
     pageContentsById.set(page.id, parsed.content);
   }
   const configuredQuestions = (config.benchmark?.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
@@ -12823,7 +13559,7 @@ async function listGraphHyperedges(rootDir, target, limit = 25) {
 }
 async function readGraphReport(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
-  return readJsonFile(path20.join(paths.wikiDir, "graph", "report.json"));
+  return readJsonFile(path21.join(paths.wikiDir, "graph", "report.json"));
 }
 async function listGodNodes(rootDir, limit = 10) {
   const graph = await ensureCompiledGraph(rootDir);
@@ -12836,15 +13572,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path20.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path21.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs16.readFile(absolutePath, "utf8");
+  const raw = await fs17.readFile(absolutePath, "utf8");
   const parsed = matter9(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path20.basename(relativePath, path20.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path21.basename(relativePath, path21.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -12880,7 +13616,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "warning",
           code: "stale_page",
           message: `Page ${page.title} is stale because the vault schema changed.`,
-          pagePath: path20.join(paths.wikiDir, page.path),
+          pagePath: path21.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -12891,7 +13627,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
             severity: "warning",
             code: "stale_page",
             message: `Page ${page.title} is stale because source ${sourceId} changed.`,
-            pagePath: path20.join(paths.wikiDir, page.path),
+            pagePath: path21.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -12902,13 +13638,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path20.join(paths.wikiDir, page.path),
+          pagePath: path21.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path20.join(paths.wikiDir, page.path);
+      const absolutePath = path21.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs16.readFile(absolutePath, "utf8");
+        const content = await fs17.readFile(absolutePath, "utf8");
         if (content.includes("## Claims")) {
           const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
           if (uncited.length) {
@@ -12988,7 +13724,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.28";
+var SERVER_VERSION = "0.1.30";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -13259,7 +13995,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(path21.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path22.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -13292,8 +14028,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path21.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs17.readFile(absolutePath, "utf8"));
+      const absolutePath = path22.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs18.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -13301,11 +14037,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(path21.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path22.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path21.basename(relativePath, ".md"),
+            name: path22.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -13322,11 +14058,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path21.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path22.resolve(paths.sessionsDir, relativePath);
       if (!absolutePath.startsWith(paths.sessionsDir) || !await fileExists(absolutePath)) {
         return asTextResource(`swarmvault://sessions/${encodedPath}`, `Session not found: ${relativePath}`);
       }
-      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs17.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs18.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -13374,13 +14110,13 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs18 from "fs/promises";
-import path22 from "path";
+import fs19 from "fs/promises";
+import path23 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path22.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path23.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path22.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path23.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -13483,13 +14219,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs18.open(leasePath, "wx");
+  const handle = await fs19.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs18.rm(leasePath, { force: true });
+    await fs19.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -13637,15 +14373,15 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/viewer.ts
 import { execFile } from "child_process";
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 import http from "http";
-import path24 from "path";
+import path25 from "path";
 import { promisify } from "util";
 import matter10 from "gray-matter";
 import mime2 from "mime-types";
 
 // src/watch.ts
-import path23 from "path";
+import path24 from "path";
 import process3 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
@@ -13653,15 +14389,15 @@ var BACKOFF_THRESHOLD = 3;
 var CRITICAL_THRESHOLD = 10;
 var REPO_WATCH_IGNORES = /* @__PURE__ */ new Set([".git", ".venv"]);
 function withinRoot2(rootPath, targetPath) {
-  const relative = path23.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path23.isAbsolute(relative);
+  const relative = path24.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative);
 }
 function hasIgnoredRepoSegment(baseDir, targetPath) {
-  const relativePath = path23.relative(baseDir, targetPath);
+  const relativePath = path24.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath.split(path23.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+  return relativePath.split(path24.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
 }
 function workspaceIgnoreRoots(rootDir, paths) {
   return [
@@ -13670,16 +14406,16 @@ function workspaceIgnoreRoots(rootDir, paths) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path23.join(rootDir, ".claude"),
-    path23.join(rootDir, ".cursor"),
-    path23.join(rootDir, ".obsidian")
-  ].map((candidate) => path23.resolve(candidate));
+    path24.join(rootDir, ".claude"),
+    path24.join(rootDir, ".cursor"),
+    path24.join(rootDir, ".obsidian")
+  ].map((candidate) => path24.resolve(candidate));
 }
 async function resolveWatchTargets(rootDir, paths, options) {
-  const targets = /* @__PURE__ */ new Set([path23.resolve(paths.inboxDir)]);
+  const targets = /* @__PURE__ */ new Set([path24.resolve(paths.inboxDir)]);
   if (options.repo) {
     for (const repoRoot of await listTrackedRepoRoots(rootDir)) {
-      targets.add(path23.resolve(repoRoot));
+      targets.add(path24.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
@@ -13809,7 +14545,7 @@ async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   const baseDebounceMs = options.debounceMs ?? 900;
   const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
-  const inboxWatchRoot = path23.resolve(paths.inboxDir);
+  const inboxWatchRoot = path24.resolve(paths.inboxDir);
   let watchTargets = await resolveWatchTargets(rootDir, paths, options);
   let timer;
   let running = false;
@@ -13823,7 +14559,7 @@ async function watchVault(rootDir, options = {}) {
     usePolling: true,
     interval: 100,
     ignored: (targetPath) => {
-      const absolutePath = path23.resolve(targetPath);
+      const absolutePath = path24.resolve(targetPath);
       const primaryTarget = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
@@ -13922,51 +14658,33 @@ async function watchVault(rootDir, options = {}) {
       }
     } finally {
       const finishedAt = /* @__PURE__ */ new Date();
-      await recordSession(rootDir, {
-        operation: "watch",
-        title: `Watch cycle for ${paths.inboxDir}${options.repo ? " and tracked repos" : ""}`,
-        startedAt: startedAt.toISOString(),
-        finishedAt: finishedAt.toISOString(),
-        success,
-        error,
-        changedPages,
-        lintFindingCount,
-        lines: [
-          `reasons=${runReasons.join(",") || "none"}`,
-          `imported=${importedCount}`,
-          `scanned=${scannedCount}`,
-          `attachments=${attachmentCount}`,
-          `repo_scanned=${repoScannedCount}`,
-          `repo_imported=${repoImportedCount}`,
-          `repo_updated=${repoUpdatedCount}`,
-          `repo_removed=${repoRemovedCount}`,
-          `lint=${lintFindingCount ?? 0}`
-        ]
-      });
-      await appendWatchRun(rootDir, {
-        startedAt: startedAt.toISOString(),
-        finishedAt: finishedAt.toISOString(),
-        durationMs: finishedAt.getTime() - startedAt.getTime(),
-        inputDir: paths.inboxDir,
-        reasons: runReasons,
-        importedCount: importedCount + repoImportedCount + repoUpdatedCount,
-        scannedCount: scannedCount + repoScannedCount,
-        attachmentCount,
-        changedPages,
-        repoImportedCount,
-        repoUpdatedCount,
-        repoRemovedCount,
-        repoScannedCount,
-        pendingSemanticRefreshCount,
-        pendingSemanticRefreshPaths,
-        lintFindingCount,
-        success,
-        error
-      });
-      await writeWatchStatusArtifact(rootDir, {
-        generatedAt: finishedAt.toISOString(),
-        watchedRepoRoots,
-        lastRun: {
+      try {
+        await recordSession(rootDir, {
+          operation: "watch",
+          title: `Watch cycle for ${paths.inboxDir}${options.repo ? " and tracked repos" : ""}`,
+          startedAt: startedAt.toISOString(),
+          finishedAt: finishedAt.toISOString(),
+          success,
+          error,
+          changedPages,
+          lintFindingCount,
+          lines: [
+            `reasons=${runReasons.join(",") || "none"}`,
+            `imported=${importedCount}`,
+            `scanned=${scannedCount}`,
+            `attachments=${attachmentCount}`,
+            `repo_scanned=${repoScannedCount}`,
+            `repo_imported=${repoImportedCount}`,
+            `repo_updated=${repoUpdatedCount}`,
+            `repo_removed=${repoRemovedCount}`,
+            `lint=${lintFindingCount ?? 0}`
+          ]
+        });
+      } catch {
+        process3.stderr.write("[swarmvault watch] Failed to record session log.\n");
+      }
+      try {
+        await appendWatchRun(rootDir, {
           startedAt: startedAt.toISOString(),
           finishedAt: finishedAt.toISOString(),
           durationMs: finishedAt.getTime() - startedAt.getTime(),
@@ -13985,9 +14703,39 @@ async function watchVault(rootDir, options = {}) {
           lintFindingCount,
           success,
           error
-        },
-        pendingSemanticRefresh: await readPendingSemanticRefresh(rootDir)
-      });
+        });
+      } catch {
+        process3.stderr.write("[swarmvault watch] Failed to append watch run.\n");
+      }
+      try {
+        await writeWatchStatusArtifact(rootDir, {
+          generatedAt: finishedAt.toISOString(),
+          watchedRepoRoots,
+          lastRun: {
+            startedAt: startedAt.toISOString(),
+            finishedAt: finishedAt.toISOString(),
+            durationMs: finishedAt.getTime() - startedAt.getTime(),
+            inputDir: paths.inboxDir,
+            reasons: runReasons,
+            importedCount: importedCount + repoImportedCount + repoUpdatedCount,
+            scannedCount: scannedCount + repoScannedCount,
+            attachmentCount,
+            changedPages,
+            repoImportedCount,
+            repoUpdatedCount,
+            repoRemovedCount,
+            repoScannedCount,
+            pendingSemanticRefreshCount,
+            pendingSemanticRefreshPaths,
+            lintFindingCount,
+            success,
+            error
+          },
+          pendingSemanticRefresh: await readPendingSemanticRefresh(rootDir)
+        });
+      } catch {
+        process3.stderr.write("[swarmvault watch] Failed to write watch status artifact.\n");
+      }
       running = false;
       if (pending && !closed) {
         schedule("queued");
@@ -13995,8 +14743,8 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path23.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
-    return path23.relative(baseDir, targetPath) || ".";
+    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path24.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path24.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) => {
@@ -14037,15 +14785,15 @@ async function getWatchStatus(rootDir) {
 var execFileAsync = promisify(execFile);
 async function readViewerPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path24.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path25.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs19.readFile(absolutePath, "utf8");
+  const raw = await fs20.readFile(absolutePath, "utf8");
   const parsed = matter10(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path24.basename(relativePath, path24.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path25.basename(relativePath, path25.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -14053,12 +14801,12 @@ async function readViewerPage(rootDir, relativePath) {
 }
 async function readViewerAsset(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path24.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path25.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs19.readFile(absolutePath),
+    buffer: await fs20.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -14081,12 +14829,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path24.join(viewerDistDir, "index.html");
+  const indexPath = path25.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path24.dirname(viewerDistDir);
-  if (await fileExists(path24.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path25.dirname(viewerDistDir);
+  if (await fileExists(path25.join(viewerProjectDir, "package.json"))) {
     await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -14103,7 +14851,7 @@ async function startGraphServer(rootDir, port) {
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs19.readFile(paths.graphPath, "utf8"));
+      response.end(await fs20.readFile(paths.graphPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/graph/query") {
@@ -14160,14 +14908,14 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     if (url.pathname === "/api/graph-report") {
-      const reportPath = path24.join(paths.wikiDir, "graph", "report.json");
+      const reportPath = path25.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;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs19.readFile(reportPath, "utf8"));
+      response.end(await fs20.readFile(reportPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/watch-status") {
@@ -14250,8 +14998,8 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path24.join(paths.viewerDistDir, relativePath);
-    const fallback = path24.join(paths.viewerDistDir, "index.html");
+    const target = path25.join(paths.viewerDistDir, relativePath);
+    const fallback = path25.join(paths.viewerDistDir, "index.html");
     const filePath = await fileExists(target) ? target : fallback;
     if (!await fileExists(filePath)) {
       response.writeHead(503, { "content-type": "text/plain" });
@@ -14259,7 +15007,7 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs19.readFile(filePath));
+    response.end(await fs20.readFile(filePath));
   });
   await new Promise((resolve) => {
     server.listen(effectivePort, resolve);
@@ -14286,7 +15034,7 @@ async function exportGraphHtml(rootDir, outputPath) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path24.join(paths.viewerDistDir, "index.html");
+  const indexPath = path25.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -14312,17 +15060,17 @@ async function exportGraphHtml(rootDir, outputPath) {
       } : null;
     })
   );
-  const rawHtml = await fs19.readFile(indexPath, "utf8");
+  const rawHtml = await fs20.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] ? path24.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path24.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path25.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path25.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 fs19.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs19.readFile(stylePath, "utf8") : "";
-  const report = await readJsonFile(path24.join(paths.wikiDir, "graph", "report.json"));
+  const script = await fs20.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs20.readFile(stylePath, "utf8") : "";
+  const report = await readJsonFile(path25.join(paths.wikiDir, "graph", "report.json"));
   const embeddedData = JSON.stringify({ graph, pages: pages.filter(Boolean), report }, null, 2).replace(/</g, "\\u003c");
   const html = [
     "<!doctype html>",
@@ -14341,9 +15089,9 @@ async function exportGraphHtml(rootDir, outputPath) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs19.mkdir(path24.dirname(outputPath), { recursive: true });
-  await fs19.writeFile(outputPath, html, "utf8");
-  return path24.resolve(outputPath);
+  await fs20.mkdir(path25.dirname(outputPath), { recursive: true });
+  await fs20.writeFile(outputPath, html, "utf8");
+  return path25.resolve(outputPath);
 }
 export {
   acceptApproval,
@@ -14389,6 +15137,7 @@ export {
   loadVaultSchemas,
   pathGraphVault,
   promoteCandidate,
+  pushGraphNeo4j,
   queryGraphVault,
   queryVault,
   readApproval,