@swarmvaultai/engine 0.1.29 → 0.1.31

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-IHMJCCXR.js";
+} from "./chunk-IAEYFTUS.js";
 
 // src/agents.ts
 import crypto from "crypto";
@@ -748,16 +748,14 @@ 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;");
+
+// 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 = "";
@@ -792,18 +790,109 @@ function cypherStringLiteral(value) {
   }
   return `'${escaped}'`;
 }
-function relationType(relation) {
-  const normalized = relation.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-  return normalized || "RELATED_TO";
-}
 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) => ({
@@ -1065,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: ${cypherStringLiteral(node.id)}`,
-      `label: ${cypherStringLiteral(node.label)}`,
-      `type: ${cypherStringLiteral(node.type)}`,
-      `sourceIds: ${cypherStringLiteral(JSON.stringify(node.sourceIds))}`,
-      `projectIds: ${cypherStringLiteral(JSON.stringify(node.projectIds))}`,
-      node.pageId ? `pageId: ${cypherStringLiteral(node.pageId)}` : "",
-      page?.path ? `pagePath: ${cypherStringLiteral(page.path)}` : "",
-      node.language ? `language: ${cypherStringLiteral(node.language)}` : "",
-      node.symbolKind ? `symbolKind: ${cypherStringLiteral(node.symbolKind)}` : "",
-      node.communityId ? `communityId: ${cypherStringLiteral(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(", ");
+    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: ${cypherStringLiteral(hyperedgeNodeId)}}) SET h += { id: ${cypherStringLiteral(hyperedgeNodeId)}, label: ${cypherStringLiteral(
-        hyperedge.label
-      )}, type: ${cypherStringLiteral("hyperedge")}, relation: ${cypherStringLiteral(hyperedge.relation)}, evidenceClass: ${cypherStringLiteral(
-        hyperedge.evidenceClass
-      )}, confidence: ${hyperedge.confidence}, sourcePageIds: ${cypherStringLiteral(JSON.stringify(hyperedge.sourcePageIds))}, why: ${cypherStringLiteral(
-        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("");
@@ -1101,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: ${cypherStringLiteral(hyperedgeNodeId)}}), (n:SwarmNode {id: ${cypherStringLiteral(nodeId)}})`,
         `MERGE (h)-[r:GROUP_MEMBER {id: ${cypherStringLiteral(`member:${hyperedge.id}:${nodeId}`)}}]->(n)`,
-        `SET r += { relation: ${cypherStringLiteral("group_member")}, status: ${cypherStringLiteral("inferred")}, evidenceClass: ${cypherStringLiteral(
-          hyperedge.evidenceClass
-        )}, confidence: ${hyperedge.confidence}, provenance: ${cypherStringLiteral(JSON.stringify(hyperedge.sourcePageIds))} };`
+        `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: ${cypherStringLiteral(edge.source)}}), (b:SwarmNode {id: ${cypherStringLiteral(edge.target)}})`,
       `MERGE (a)-[r:${relationType(edge.relation)} {id: ${cypherStringLiteral(edge.id)}}]->(b)`,
-      `SET r += { relation: ${cypherStringLiteral(edge.relation)}, status: ${cypherStringLiteral(edge.status)}, evidenceClass: ${cypherStringLiteral(
-        edge.evidenceClass
-      )}, confidence: ${edge.confidence}, provenance: ${cypherStringLiteral(JSON.stringify(edge.provenance))}${edge.similarityReasons?.length ? `, similarityReasons: ${cypherStringLiteral(JSON.stringify(edge.similarityReasons))}` : ""} };`
+      `SET r += { ${props} };`
     );
   }
   lines.push("");
@@ -1143,27 +1209,400 @@ 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 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 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);
+  }
+  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 = path3.resolve(startPath);
+  let current = path4.resolve(startPath);
   try {
-    const stat = await fs3.stat(current);
+    const stat = await fs4.stat(current);
     if (!stat.isDirectory()) {
-      current = path3.dirname(current);
+      current = path4.dirname(current);
     }
   } catch {
-    current = path3.dirname(current);
+    current = path4.dirname(current);
   }
   while (true) {
-    if (await fileExists(path3.join(current, ".git"))) {
+    if (await fileExists(path4.join(current, ".git"))) {
       return current;
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -1175,8 +1614,8 @@ function shellQuote(value) {
 }
 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);
+  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";
 }
@@ -1195,17 +1634,17 @@ function managedHookBlock(vaultRoot) {
   ].join("\n");
 }
 function hookPath(repoRoot, hookName) {
-  return path3.join(repoRoot, ".git", "hooks", hookName);
+  return path4.join(repoRoot, ".git", "hooks", hookName);
 }
 async function readHookStatus(filePath) {
   if (!await fileExists(filePath)) {
     return "not_installed";
   }
-  const content = await fs3.readFile(filePath, "utf8");
+  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 fs3.readFile(filePath, "utf8") : "";
+  const existing = await fileExists(filePath) ? await fs4.readFile(filePath, "utf8") : "";
   let next;
   const startIndex = existing.indexOf(hookStart);
   const endIndex = existing.indexOf(hookEnd);
@@ -1219,16 +1658,16 @@ ${block}`.trimEnd();
     next = `#!/bin/sh
 ${block}`.trimEnd();
   }
-  await ensureDir(path3.dirname(filePath));
-  await fs3.writeFile(filePath, `${next}
+  await ensureDir(path4.dirname(filePath));
+  await fs4.writeFile(filePath, `${next}
 `, { mode: 493, encoding: "utf8" });
-  await fs3.chmod(filePath, 493);
+  await fs4.chmod(filePath, 493);
 }
 async function removeHookBlock(filePath) {
   if (!await fileExists(filePath)) {
     return;
   }
-  const existing = await fs3.readFile(filePath, "utf8");
+  const existing = await fs4.readFile(filePath, "utf8");
   const startIndex = existing.indexOf(hookStart);
   const endIndex = existing.indexOf(hookEnd);
   if (startIndex === -1 || endIndex === -1) {
@@ -1236,10 +1675,10 @@ async function removeHookBlock(filePath) {
   }
   const next = `${existing.slice(0, startIndex)}${existing.slice(endIndex + hookEnd.length)}`.trim();
   if (!next || next === "#!/bin/sh") {
-    await fs3.rm(filePath, { force: true });
+    await fs4.rm(filePath, { force: true });
     return;
   }
-  await fs3.writeFile(filePath, `${next}
+  await fs4.writeFile(filePath, `${next}
 `, "utf8");
 }
 async function getGitHookStatus(rootDir) {
@@ -1262,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);
@@ -1282,8 +1721,8 @@ 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";
@@ -1293,16 +1732,16 @@ 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();
@@ -1339,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;
@@ -1352,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);
@@ -1369,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(
@@ -2639,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;
@@ -2783,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));
@@ -2802,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,
@@ -3085,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";
   }
@@ -3134,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) {
@@ -3158,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;
@@ -3264,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);
         }
@@ -3343,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) : "";
@@ -3470,7 +3910,7 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType) ?? "typescript";
   const { code, rationales } = language === "javascript" || language === "jsx" || language === "typescript" || language === "tsx" ? analyzeTypeScriptLikeCode(manifest, extractedText) : await analyzeTreeSitterCode(manifest, extractedText, language);
   return {
-    analysisVersion: 5,
+    analysisVersion: 6,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
     extractionHash: manifest.extractionHash,
@@ -3481,6 +3921,7 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
     entities: [],
     claims: codeClaims(manifest, code),
     questions: codeQuestions(manifest, code),
+    tags: [],
     rationales,
     code,
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3488,9 +3929,9 @@ 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";
@@ -3572,14 +4013,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 });
     }
   };
 }
@@ -3790,18 +4231,18 @@ async function extractDocxText(input) {
 }
 
 // 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;
@@ -3809,11 +4250,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) {
@@ -3823,8 +4264,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,
@@ -3872,7 +4313,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}`,
@@ -3880,8 +4321,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 };
 }
@@ -3891,13 +4332,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) {
@@ -3950,8 +4391,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;
@@ -3965,7 +4406,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);
@@ -4059,11 +4500,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;
@@ -4117,7 +4558,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)),
@@ -4137,27 +4578,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;
     }
@@ -4165,26 +4606,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) {
@@ -4260,7 +4701,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}`);
@@ -4268,6 +4743,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}`);
@@ -4481,7 +4957,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 "";
@@ -4501,7 +4977,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, "/");
@@ -4579,12 +5055,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;
     }
@@ -4592,12 +5068,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;
     }
@@ -4608,12 +5084,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) {
@@ -4637,23 +5113,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()) {
@@ -4661,26 +5137,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);
@@ -4702,12 +5178,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);
@@ -4739,6 +5215,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}`);
@@ -4859,34 +5336,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
     });
@@ -4902,9 +5379,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,
@@ -4912,7 +5389,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}`,
@@ -4930,16 +5407,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 = [
@@ -4948,11 +5425,11 @@ 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;
@@ -4974,16 +5451,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);
@@ -5008,14 +5485,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) {
@@ -5025,7 +5502,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);
@@ -5033,7 +5510,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}`,
@@ -5056,16 +5533,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);
@@ -5080,7 +5557,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) {
@@ -5088,7 +5565,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,
@@ -5108,17 +5585,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) {
@@ -5126,10 +5603,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,
@@ -5149,13 +5626,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,
@@ -5173,7 +5650,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}`,
@@ -5199,17 +5676,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");
@@ -5218,18 +5695,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 = path10.basename(absoluteInput, path10.extname(absoluteInput));
+    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,
@@ -5239,7 +5716,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,
@@ -5258,6 +5735,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}`);
@@ -5315,7 +5793,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");
@@ -5386,14 +5864,14 @@ async function collectInboxAttachmentRefs(inputDir, files) {
     if (sourceKind !== "markdown" && sourceKind !== "html") {
       continue;
     }
-    const content = await fs9.readFile(absolutePath, "utf8");
+    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;
       }
@@ -5427,12 +5905,12 @@ function rewriteMarkdownReferences(content, replacements) {
   });
 }
 async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs9.readFile(absolutePath);
+  const originalBytes = await fs10.readFile(absolutePath);
   const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path10.basename(absolutePath, path10.extname(absolutePath)), originalText);
+  const title = titleFromText(path11.basename(absolutePath, path11.extname(absolutePath)), originalText);
   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),
@@ -5456,7 +5934,7 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     sourceKind: "markdown",
     originalPath: toPosix(absolutePath),
     mimeType: "text/markdown",
-    storedExtension: path10.extname(absolutePath) || ".md",
+    storedExtension: path11.extname(absolutePath) || ".md",
     payloadBytes: Buffer.from(rewrittenText, "utf8"),
     extractedText: rewrittenText,
     extractionArtifact,
@@ -5466,12 +5944,12 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
   };
 }
 async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs9.readFile(absolutePath);
+  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),
@@ -5480,7 +5958,7 @@ async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
     });
   }
   const contentHash = buildCompositeHash(originalBytes, attachments);
-  const fallbackTitle = path10.basename(absolutePath, path10.extname(absolutePath));
+  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(
@@ -5498,7 +5976,7 @@ async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
     sourceKind: "html",
     originalPath: toPosix(absolutePath),
     mimeType: "text/html",
-    storedExtension: path10.extname(absolutePath) || ".html",
+    storedExtension: path11.extname(absolutePath) || ".html",
     payloadBytes: Buffer.from(rewrittenHtml, "utf8"),
     extractedText: converted.markdown,
     extractionArtifact,
@@ -5513,8 +5991,8 @@ function isSupportedInboxKind(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;
@@ -5604,7 +6082,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}`);
@@ -5613,7 +6091,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) {
@@ -5621,11 +6099,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}`,
@@ -5642,7 +6120,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}`);
   }
@@ -5653,31 +6131,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) ?? []) : 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}`,
@@ -5696,9 +6174,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));
 }
@@ -5706,17 +6184,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;
   }
@@ -5724,20 +6202,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,
@@ -5746,7 +6224,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) {
@@ -5762,7 +6240,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")
@@ -5838,15 +6316,15 @@ 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 ANALYSIS_FORMAT_VERSION = 6;
 var sourceAnalysisSchema = z2.object({
   title: z2.string().min(1),
   summary: z2.string().min(1),
@@ -5861,7 +6339,8 @@ var sourceAnalysisSchema = z2.object({
       citation: z2.string().min(1)
     })
   ).max(8).default([]),
-  questions: z2.array(z2.string()).max(6).default([])
+  questions: z2.array(z2.string()).max(6).default([]),
+  tags: z2.array(z2.string()).max(5).default([])
 });
 var STOPWORDS = /* @__PURE__ */ new Set([
   "about",
@@ -5965,6 +6444,7 @@ function heuristicAnalysis(manifest, text, schemaHash) {
       citation: manifest.sourceId
     })),
     questions: concepts.slice(0, 3).map((term) => `How does ${term.name} relate to ${manifest.title}?`),
+    tags: [],
     rationales: [],
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -5977,6 +6457,8 @@ async function providerAnalysis(manifest, text, provider, schema) {
         "",
         "Follow the vault schema when choosing titles, categories, relationships, and summaries.",
         "",
+        "Return up to 5 broad domain tags that categorize this source. Tags should be lowercase kebab-case (e.g., cryptography, distributed-systems, machine-learning). These are broader categories, not specific concepts or entity names.",
+        "",
         `Vault schema path: ${schema.path}`,
         "",
         "Vault schema instructions:",
@@ -6020,6 +6502,7 @@ ${truncate(text, 18e3)}`
       citation: claim.citation
     })),
     questions: parsed.questions,
+    tags: parsed.tags,
     rationales: [],
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -6055,6 +6538,7 @@ function analysisFromVisionExtraction(manifest, extraction, schemaHash) {
       citation: manifest.sourceId
     })),
     questions: extraction.vision.questions,
+    tags: [],
     rationales: [],
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -6067,7 +6551,7 @@ function extractionWarningSummary(manifest, extraction) {
   return `Imported ${manifest.sourceKind} source. Text extraction is not yet available for this source.`;
 }
 async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path12.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  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;
@@ -6094,6 +6578,7 @@ async function analyzeSource(manifest, extractedText, provider, paths, schema) {
         entities: [],
         claims: [],
         questions: [],
+        tags: [],
         rationales: [],
         producedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -6119,6 +6604,7 @@ async function analyzeSource(manifest, extractedText, provider, paths, schema) {
       entities: [],
       claims: [],
       questions: [],
+      tags: [],
       rationales: [],
       producedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -6138,163 +6624,6 @@ 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);
-  }
-  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/confidence.ts
 function nodeConfidence(sourceCount) {
   return Math.min(0.5 + sourceCount * 0.15, 0.95);
@@ -6312,8 +6641,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";
 
@@ -6334,7 +6663,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(),
@@ -6427,7 +6756,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: {
@@ -6521,7 +6850,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";
 
@@ -6619,7 +6948,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);
@@ -6647,7 +6976,14 @@ var deepLintResponseSchema = z5.object({
   findings: z5.array(
     z5.object({
       severity: z5.string().optional().default("info"),
-      code: z5.enum(["coverage_gap", "contradiction_candidate", "missing_citation", "candidate_page", "follow_up_question"]),
+      code: z5.enum([
+        "coverage_gap",
+        "contradiction_candidate",
+        "contradiction",
+        "missing_citation",
+        "candidate_page",
+        "follow_up_question"
+      ]),
       message: z5.string().min(1),
       relatedSourceIds: z5.array(z5.string()).default([]),
       relatedPageIds: z5.array(z5.string()).default([]),
@@ -6679,8 +7015,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,
@@ -6728,7 +7064,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)) {
@@ -6780,6 +7116,7 @@ async function runDeepLint(rootDir, structuralFindings, options = {}) {
         system: "You are an auditor for a local-first LLM knowledge vault. Return advisory findings only. Do not propose direct file edits.",
         prompt: [
           "Review this SwarmVault state and return high-signal advisory findings.",
+          "Look for claims that contradict each other across different sources. When you find a genuine contradiction, use code 'contradiction' and include both source IDs in relatedSourceIds.",
           "",
           "Schema:",
           schema.content,
@@ -6906,8 +7243,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) {
@@ -6941,8 +7278,8 @@ 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(() => {
+      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 "";
@@ -8444,15 +8781,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) {
@@ -8521,7 +8858,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,
@@ -8532,11 +8869,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
@@ -8642,6 +8979,13 @@ function buildGraphReportArtifact(input) {
       title: page.title,
       sourceType: page.sourceType,
       updatedAt: page.updatedAt
+    })),
+    contradictions: (input.contradictions ?? []).map((c) => ({
+      sourceIdA: c.sourceIdA,
+      sourceIdB: c.sourceIdB,
+      claimA: c.claimA.text,
+      claimB: c.claimB.text,
+      confidenceDelta: Math.abs(c.claimA.confidence - c.claimB.confidence)
     }))
   };
 }
@@ -8761,6 +9105,12 @@ function buildGraphReportPage(input) {
       return `- ${sourceLabel} ${connection.relation} ${targetLabel} (${connection.evidenceClass}, ${connection.confidence.toFixed(2)}). Why: ${connection.why}. ${connection.explanation} Path: ${connection.pathSummary}.`;
     }) : ["- No cross-community links detected."],
     "",
+    "## Contradictions",
+    "",
+    ...input.report.contradictions.length ? input.report.contradictions.map(
+      (c) => `- **${c.claimA}** vs **${c.claimB}** (sources: \`${c.sourceIdA}\`, \`${c.sourceIdB}\`, confidence delta: ${c.confidenceDelta.toFixed(2)})`
+    ) : ["- No contradictions detected."],
+    "",
     "## Group Patterns",
     "",
     ...input.report.groupPatterns.length ? input.report.groupPatterns.map((hyperedge) => {
@@ -9421,13 +9771,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") : [];
@@ -9505,7 +9855,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"),
@@ -9544,7 +9894,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);
@@ -9585,18 +9935,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);
@@ -9659,27 +10009,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;
@@ -9692,7 +10042,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({
@@ -9730,8 +10080,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");
@@ -9757,7 +10107,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;");
@@ -9789,8 +10139,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,
@@ -9907,7 +10257,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}`;
@@ -10047,7 +10397,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-5SYH3Y3U.js");
+  const { createProvider: createProvider2 } = await import("./registry-G7NSRYCO.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -10245,7 +10595,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) {
@@ -10271,10 +10621,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) {
@@ -10448,7 +10798,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
@@ -10486,7 +10836,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
@@ -10609,7 +10959,7 @@ function resetGraphNodeMetrics(nodes) {
   return nodes.map(({ communityId: _communityId, degree: _degree, bridgeScore: _bridgeScore, isGodNode: _isGodNode, ...node }) => node);
 }
 function manifestRepoPath(manifest) {
-  return toPosix(manifest.repoRelativePath ?? path20.basename(manifest.originalPath ?? manifest.storedPath));
+  return toPosix(manifest.repoRelativePath ?? path21.basename(manifest.originalPath ?? manifest.storedPath));
 }
 function goPackageScopeKey(manifest, analysis) {
   if (analysis.code?.language !== "go") {
@@ -10619,7 +10969,7 @@ function goPackageScopeKey(manifest, analysis) {
   if (!packageName) {
     return null;
   }
-  return `${packageName}:${path20.posix.dirname(manifestRepoPath(manifest))}`;
+  return `${packageName}:${path21.posix.dirname(manifestRepoPath(manifest))}`;
 }
 function buildGoPackageSymbolLookups(analyses, manifestsById) {
   const lookups = /* @__PURE__ */ new Map();
@@ -10663,21 +11013,64 @@ function buildGoPackageSymbolLookups(analyses, manifestsById) {
     ])
   );
 }
+function claimTokens(text) {
+  return new Set(
+    text.toLowerCase().match(/[a-z][a-z0-9-]{2,}/g)?.filter((t) => !(/* @__PURE__ */ new Set(["the", "and", "for", "that", "this", "with", "are", "was", "from", "has", "not", "all", "but"])).has(t)) ?? []
+  );
+}
+function claimJaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection++;
+  }
+  return intersection / (a.size + b.size - intersection);
+}
+function detectContradictions(analyses) {
+  const contradictions = [];
+  const claimsWithTokens = analyses.flatMap(
+    (analysis) => analysis.claims.filter((c) => c.polarity === "positive" || c.polarity === "negative").map((c) => ({ sourceId: analysis.sourceId, claim: c, tokens: claimTokens(c.text) }))
+  );
+  for (let i = 0; i < claimsWithTokens.length; i++) {
+    for (let j = i + 1; j < claimsWithTokens.length; j++) {
+      const a = claimsWithTokens[i];
+      const b = claimsWithTokens[j];
+      if (a.sourceId === b.sourceId) continue;
+      if (a.claim.polarity === b.claim.polarity) continue;
+      const similarity = claimJaccardSimilarity(a.tokens, b.tokens);
+      if (similarity >= 0.3) {
+        contradictions.push({
+          sourceIdA: a.sourceId,
+          sourceIdB: b.sourceId,
+          claimA: { text: a.claim.text, confidence: a.claim.confidence },
+          claimB: { text: b.claim.text, confidence: b.claim.confidence },
+          similarity
+        });
+      }
+    }
+  }
+  return contradictions;
+}
 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",
-    label: manifest.title,
-    pageId: `source:${manifest.sourceId}`,
-    freshness: "fresh",
-    confidence: 1,
-    sourceIds: [manifest.sourceId],
-    projectIds: scopedProjectIdsFromSources([manifest.sourceId], sourceProjects),
-    sourceClass: manifest.sourceClass,
-    language: manifest.language
-  }));
+  const analysesBySourceId = new Map(analyses.map((analysis) => [analysis.sourceId, analysis]));
+  const sourceNodes = manifests.map((manifest) => {
+    const analysis = analysesBySourceId.get(manifest.sourceId);
+    return {
+      id: `source:${manifest.sourceId}`,
+      type: "source",
+      label: manifest.title,
+      pageId: `source:${manifest.sourceId}`,
+      freshness: "fresh",
+      confidence: 1,
+      sourceIds: [manifest.sourceId],
+      projectIds: scopedProjectIdsFromSources([manifest.sourceId], sourceProjects),
+      sourceClass: manifest.sourceClass,
+      language: manifest.language,
+      tags: analysis?.tags ?? []
+    };
+  });
   const conceptMap = /* @__PURE__ */ new Map();
   const entityMap = /* @__PURE__ */ new Map();
   const moduleMap = /* @__PURE__ */ new Map();
@@ -10692,7 +11085,6 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
     edgesById.add(edge.id);
     edges.push(edge);
   };
-  const analysesBySourceId = new Map(analyses.map((analysis) => [analysis.sourceId, analysis]));
   for (const analysis of analyses) {
     for (const concept of analysis.concepts) {
       const existing = conceptMap.get(concept.id);
@@ -11042,11 +11434,11 @@ function recentResearchSourcePages(graph, previousCompiledAt) {
     sourceType: page.sourceType
   }));
 }
-async function buildGraphOrientationPages(graph, paths, schemaHash, previousCompiledAt) {
+async function buildGraphOrientationPages(graph, paths, schemaHash, previousCompiledAt, contradictions = []) {
   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,
@@ -11072,9 +11464,10 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     benchmark,
     benchmarkStale: benchmark ? benchmark.graphHash !== graphHash(graph) : false,
     recentResearchSources: recentResearchSourcePages(graph, previousCompiledAt),
-    graphHash: graphHash(graph)
+    graphHash: graphHash(graph),
+    contradictions
   });
-  const reportAbsolutePath = path20.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path21.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -11095,7 +11488,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);
@@ -11158,29 +11551,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));
@@ -11190,7 +11583,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) {
@@ -11205,7 +11598,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,
@@ -11238,7 +11631,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",
@@ -11250,16 +11643,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(),
@@ -11321,7 +11714,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,
@@ -11336,7 +11729,7 @@ async function syncVaultArtifacts(rootDir, input) {
         modulePreview ?? void 0,
         {
           projectIds: sourceProjectIds,
-          extraTags: sourceCategoryTags,
+          extraTags: [...sourceCategoryTags, ...analysis.tags ?? []],
           sourceClass: manifest.sourceClass
         }
       )
@@ -11367,7 +11760,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,
@@ -11382,7 +11775,7 @@ async function syncVaultArtifacts(rootDir, input) {
             localModules,
             relatedOutputs: relatedOutputsForPage(modulePreview, input.outputPages),
             projectIds: sourceProjectIds,
-            extraTags: sourceCategoryTags
+            extraTags: [...sourceCategoryTags, ...analysis.tags ?? []]
           })
         )
       );
@@ -11401,8 +11794,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({
@@ -11420,7 +11813,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",
@@ -11462,6 +11855,22 @@ async function syncVaultArtifacts(rootDir, input) {
   const compiledPages = records.map((record) => record.page);
   const basePages = [...compiledPages, ...input.outputPages, ...input.insightPages];
   const structuralGraph = buildGraph(input.manifests, input.analyses, basePages, input.sourceProjects, input.codeIndex);
+  const contradictions = detectContradictions(input.analyses);
+  for (const contradiction of contradictions) {
+    const edgeId = `contradiction:${contradiction.sourceIdA}->${contradiction.sourceIdB}`;
+    if (!structuralGraph.edges.some((e) => e.id === edgeId)) {
+      structuralGraph.edges.push({
+        id: edgeId,
+        source: `source:${contradiction.sourceIdA}`,
+        target: `source:${contradiction.sourceIdB}`,
+        relation: "contradicts",
+        status: "conflicted",
+        evidenceClass: "ambiguous",
+        confidence: Math.abs(contradiction.claimA.confidence - contradiction.claimB.confidence),
+        provenance: [contradiction.sourceIdA, contradiction.sourceIdB]
+      });
+    }
+  }
   const embeddingEdges = await embeddingSimilarityEdges(rootDir, structuralGraph).catch(() => []);
   const baseGraph = embeddingEdges.length > 0 ? (() => {
     const edges = uniqueBy([...structuralGraph.edges, ...embeddingEdges], (edge) => edge.id).sort(
@@ -11475,7 +11884,13 @@ async function syncVaultArtifacts(rootDir, input) {
       communities: metrics.communities
     };
   })() : structuralGraph;
-  const graphOrientation = await buildGraphOrientationPages(baseGraph, paths, globalSchemaHash, input.previousState?.generatedAt);
+  const graphOrientation = await buildGraphOrientationPages(
+    baseGraph,
+    paths,
+    globalSchemaHash,
+    input.previousState?.generatedAt,
+    contradictions
+  );
   records.push(...graphOrientation.records);
   const allPages = [...basePages, ...graphOrientation.records.map((record) => record.page)];
   const graph = {
@@ -11515,7 +11930,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)
@@ -11539,7 +11954,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())
@@ -11567,7 +11982,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)
@@ -11598,7 +12013,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)
@@ -11609,12 +12024,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 });
@@ -11639,10 +12054,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,
@@ -11713,17 +12128,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(
@@ -11744,7 +12159,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(
@@ -11762,7 +12177,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(
@@ -11783,7 +12198,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(
@@ -11797,23 +12212,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);
 }
@@ -11833,7 +12248,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,
@@ -11845,15 +12260,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 };
@@ -11874,7 +12289,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,
@@ -11886,15 +12301,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 };
@@ -11911,17 +12326,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([
@@ -11936,7 +12351,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(),
@@ -11965,9 +12380,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)}`;
@@ -12146,10 +12561,62 @@ function updateCandidateHistory(compileState, page, deleted = false) {
 function sortGraphPages(pages) {
   return [...pages].sort((left, right) => left.path.localeCompare(right.path) || left.title.localeCompare(right.title));
 }
+function computeUnifiedDiff(current, staged, label) {
+  const currentLines = current.split("\n");
+  const stagedLines = staged.split("\n");
+  const output = [`--- a/${label}`, `+++ b/${label}`];
+  const n = currentLines.length;
+  const m = stagedLines.length;
+  const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = currentLines[i2] === stagedLines[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  let i = 0;
+  let j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && currentLines[i] === stagedLines[j]) {
+      output.push(` ${currentLines[i]}`);
+      i++;
+      j++;
+    } else if (j < m && (i >= n || dp[i][j + 1] >= dp[i + 1][j])) {
+      output.push(`+${stagedLines[j]}`);
+      j++;
+    } else {
+      output.push(`-${currentLines[i]}`);
+      i++;
+    }
+  }
+  return output.join("\n");
+}
+function computeChangeSummary(current, staged, changeType) {
+  if (changeType === "create") return "New page";
+  if (changeType === "delete") return "Removed page";
+  if (changeType === "promote") return "Promoted from candidate";
+  if (!current || !staged) return "Updated page";
+  const currentParsed = matter9(current);
+  const stagedParsed = matter9(staged);
+  const changes = [];
+  const currentTags = currentParsed.data.tags ?? [];
+  const stagedTags = stagedParsed.data.tags ?? [];
+  const addedTags = stagedTags.filter((t) => !currentTags.includes(t));
+  const removedTags = currentTags.filter((t) => !stagedTags.includes(t));
+  if (addedTags.length) changes.push(`added ${addedTags.length} tag(s)`);
+  if (removedTags.length) changes.push(`removed ${removedTags.length} tag(s)`);
+  if (currentParsed.data.title !== stagedParsed.data.title) changes.push("updated title");
+  const currentLines = currentParsed.content.trim().split("\n").length;
+  const stagedLines = stagedParsed.content.trim().split("\n").length;
+  const lineDelta = stagedLines - currentLines;
+  if (lineDelta > 0) changes.push(`added ${lineDelta} line(s)`);
+  else if (lineDelta < 0) changes.push(`removed ${Math.abs(lineDelta)} line(s)`);
+  else if (currentParsed.content !== stagedParsed.content) changes.push("modified content");
+  return changes.length ? changes.join(", ") : "no visible changes";
+}
 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 {
@@ -12159,19 +12626,24 @@ async function listApprovals(rootDir) {
   );
   return manifests.filter((manifest) => Boolean(manifest)).map(approvalSummary).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
-async function readApproval(rootDir, approvalId) {
+async function readApproval(rootDir, approvalId, options) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifest = await readApprovalManifest(paths, 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;
-      return {
+      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;
+      const detail = {
         ...entry,
         currentContent,
         stagedContent
       };
+      detail.changeSummary = computeChangeSummary(detail.currentContent, detail.stagedContent, detail.changeType);
+      if (options?.diff && detail.currentContent && detail.stagedContent) {
+        detail.diff = computeUnifiedDiff(detail.currentContent, detail.stagedContent, detail.nextPath ?? detail.pageId);
+      }
+      return detail;
     })
   );
   return {
@@ -12194,26 +12666,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(
@@ -12224,10 +12696,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
         });
@@ -12318,7 +12790,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, {
@@ -12330,10 +12802,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)
@@ -12378,7 +12850,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(),
@@ -12417,18 +12889,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",
@@ -12438,7 +12910,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,
@@ -12450,7 +12922,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: {
@@ -12465,7 +12937,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,
@@ -12501,7 +12973,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",
@@ -12523,7 +12995,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",
@@ -12659,7 +13131,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;
         }
@@ -12683,22 +13155,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,
@@ -12845,7 +13317,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;
@@ -13101,9 +13573,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);
   }
@@ -13190,11 +13662,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);
@@ -13239,7 +13711,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);
@@ -13252,15 +13724,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
   };
@@ -13296,7 +13768,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]
         });
       }
@@ -13307,7 +13779,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]
           });
@@ -13318,13 +13790,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) {
@@ -13367,11 +13839,43 @@ async function lintVault(rootDir, options = {}) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       success: true,
       lintFindingCount: findings2.length,
-      lines: [`findings=${findings2.length}`, `deep=${Boolean(options.deep)}`, `web=${Boolean(options.web)}`]
+      lines: [
+        `findings=${findings2.length}`,
+        `deep=${Boolean(options.deep)}`,
+        `web=${Boolean(options.web)}`,
+        `conflicts=${Boolean(options.conflicts)}`
+      ]
     });
     return findings2;
   }
+  const contradictionFindings = options.conflicts ? graph.edges.filter((edge) => edge.relation === "contradicts").map((edge) => {
+    const sourceIdA = edge.provenance[0] ?? edge.source.replace(/^source:/, "");
+    const sourceIdB = edge.provenance[1] ?? edge.target.replace(/^source:/, "");
+    return {
+      severity: "warning",
+      code: "contradiction",
+      message: `Contradicting claims detected between source "${sourceIdA}" and source "${sourceIdB}".`,
+      relatedSourceIds: [sourceIdA, sourceIdB]
+    };
+  }) : [];
+  if (options.conflicts && !options.deep) {
+    await recordSession(rootDir, {
+      operation: "lint",
+      title: `Linted ${graph.pages.length} page(s)`,
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      success: true,
+      relatedPageIds: graph.pages.map((page) => page.id),
+      relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
+      lintFindingCount: contradictionFindings.length,
+      lines: [`findings=${contradictionFindings.length}`, `deep=false`, `web=false`, `conflicts=true`]
+    });
+    return contradictionFindings;
+  }
   const findings = await structuralLintFindings(rootDir, paths, graph, schemas, manifests, sourceProjects);
+  if (options.conflicts) {
+    findings.push(...contradictionFindings);
+  }
   if (options.deep) {
     findings.push(...await runDeepLint(rootDir, findings, { web: options.web }));
   }
@@ -13386,7 +13890,12 @@ async function lintVault(rootDir, options = {}) {
     relatedPageIds: graph.pages.map((page) => page.id),
     relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
     lintFindingCount: findings.length,
-    lines: [`findings=${findings.length}`, `deep=${Boolean(options.deep)}`, `web=${Boolean(options.web)}`]
+    lines: [
+      `findings=${findings.length}`,
+      `deep=${Boolean(options.deep)}`,
+      `web=${Boolean(options.web)}`,
+      `conflicts=${Boolean(options.conflicts)}`
+    ]
   });
   return findings;
 }
@@ -13404,7 +13913,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.29";
+var SERVER_VERSION = "0.1.31";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -13675,7 +14184,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));
     }
   );
@@ -13708,8 +14217,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(
@@ -13717,11 +14226,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"
@@ -13738,11 +14247,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;
@@ -13790,13 +14299,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);
@@ -13899,13 +14408,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) {
@@ -14053,15 +14562,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;
@@ -14069,15 +14578,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 [
@@ -14086,16 +14595,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));
@@ -14225,7 +14734,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;
@@ -14239,7 +14748,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;
@@ -14423,8 +14932,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) => {
@@ -14465,15 +14974,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)
@@ -14481,12 +14990,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"
   };
 }
@@ -14509,12 +15018,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 });
   }
 }
@@ -14531,7 +15040,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") {
@@ -14588,14 +15097,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") {
@@ -14678,8 +15187,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" });
@@ -14687,7 +15196,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);
@@ -14714,7 +15223,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.");
   }
@@ -14740,17 +15249,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>",
@@ -14769,9 +15278,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,
@@ -14817,6 +15326,7 @@ export {
   loadVaultSchemas,
   pathGraphVault,
   promoteCandidate,
+  pushGraphNeo4j,
   queryGraphVault,
   queryVault,
   readApproval,