@swarmvaultai/engine 0.10.0 → 0.11.0

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-G2TH6ZTA.js";
+} from "./chunk-4MSSM2GH.js";
 import {
   estimatePageTokens,
   estimateTokens,
@@ -727,7 +727,7 @@ function renderPromotionSessionMarkdown(decisions, promotedPageIds, options) {
 
 // src/consolidate.ts
 import fs7 from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 import matter4 from "gray-matter";
 
 // src/logs.ts
@@ -5625,7 +5625,9 @@ function candidateExtensionsFor(language) {
     case "jsx":
     case "typescript":
     case "tsx":
-      return [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+      return [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs", ".vue"];
+    case "vue":
+      return [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs", ".vue"];
     case "bash":
       return [".sh", ".bash", ".zsh"];
     case "python":
@@ -6017,6 +6019,7 @@ function findImportCandidates(manifest, codeImport, lookup) {
     case "jsx":
     case "typescript":
     case "tsx":
+    case "vue":
       return repoRelativePath && isRelativeSpecifier(codeImport.specifier) ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
     case "python":
       if (repoRelativePath && codeImport.specifier.startsWith(".")) {
@@ -6084,6 +6087,7 @@ function importLooksLocal(manifest, codeImport, candidates) {
     case "jsx":
     case "typescript":
     case "tsx":
+    case "vue":
       return isRelativeSpecifier(codeImport.specifier);
     case "python":
       return codeImport.specifier.startsWith(".");
@@ -6142,9 +6146,128 @@ function enrichResolvedCodeImports(manifest, analysis, artifact) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+var VUE_SCRIPT_BLOCK_REGEX = /<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi;
+function vueScriptLanguageFromAttributes(attributes) {
+  const langMatch = attributes.match(/\blang\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i);
+  const lang = (langMatch?.[1] ?? langMatch?.[2] ?? langMatch?.[3] ?? "").trim().toLowerCase();
+  const hasJsx = /\bjsx\b/.test(attributes) || lang === "tsx" || lang === "jsx";
+  if (lang === "ts" || lang === "typescript" || lang === "tsx") {
+    return hasJsx ? "tsx" : "typescript";
+  }
+  if (lang === "js" || lang === "javascript" || lang === "jsx") {
+    return hasJsx ? "jsx" : "javascript";
+  }
+  return "typescript";
+}
+function extractVueScriptBlocks(source) {
+  const blocks = [];
+  VUE_SCRIPT_BLOCK_REGEX.lastIndex = 0;
+  let match = VUE_SCRIPT_BLOCK_REGEX.exec(source);
+  while (match !== null) {
+    const attributes = match[1] ?? "";
+    const content = match[2] ?? "";
+    const openTagEnd = match.index + match[0].indexOf(">") + 1;
+    const lineOffset = source.slice(0, openTagEnd).split("\n").length - 1;
+    const setup = /\bsetup\b/.test(attributes);
+    blocks.push({
+      content,
+      lineOffset,
+      language: vueScriptLanguageFromAttributes(attributes),
+      setup
+    });
+    match = VUE_SCRIPT_BLOCK_REGEX.exec(source);
+  }
+  return blocks;
+}
+function mergeVueScriptAnalyses(outer, inners) {
+  if (inners.length === 0) {
+    return outer;
+  }
+  const mergedImports = [...outer.code.imports];
+  const seenImportKeys = new Set(
+    mergedImports.map((imp) => `${imp.specifier}\0${imp.reExport ? "re" : "im"}\0${imp.isTypeOnly ? "t" : "v"}`)
+  );
+  const mergedSymbols = [...outer.code.symbols];
+  const seenSymbolKeys = new Set(mergedSymbols.map((symbol) => `${symbol.name}\0${symbol.kind}`));
+  const mergedExports = [...outer.code.exports];
+  const seenExports = new Set(mergedExports);
+  const mergedDiagnostics = [...outer.code.diagnostics];
+  const mergedDependencies = new Set(outer.code.dependencies);
+  const mergedRationales = [...outer.rationales];
+  const seenRationaleKeys = new Set(mergedRationales.map((r) => `${r.symbolName ?? ""}:${r.text.toLowerCase()}`));
+  for (const inner of inners) {
+    for (const imp of inner.code.imports) {
+      const key = `${imp.specifier}\0${imp.reExport ? "re" : "im"}\0${imp.isTypeOnly ? "t" : "v"}`;
+      if (!seenImportKeys.has(key)) {
+        mergedImports.push(imp);
+        seenImportKeys.add(key);
+      }
+    }
+    for (const symbol of inner.code.symbols) {
+      const key = `${symbol.name}\0${symbol.kind}`;
+      if (!seenSymbolKeys.has(key)) {
+        mergedSymbols.push(symbol);
+        seenSymbolKeys.add(key);
+      }
+    }
+    for (const label of inner.code.exports) {
+      if (!seenExports.has(label)) {
+        mergedExports.push(label);
+        seenExports.add(label);
+      }
+    }
+    for (const diag of inner.code.diagnostics) {
+      mergedDiagnostics.push({
+        ...diag,
+        line: diag.line + inner.lineOffset
+      });
+    }
+    for (const dep of inner.code.dependencies) {
+      mergedDependencies.add(dep);
+    }
+    for (const rationale of inner.rationales) {
+      const key = `${rationale.symbolName ?? ""}:${rationale.text.toLowerCase()}`;
+      if (!seenRationaleKeys.has(key)) {
+        mergedRationales.push(rationale);
+        seenRationaleKeys.add(key);
+      }
+    }
+  }
+  return {
+    code: {
+      ...outer.code,
+      imports: mergedImports,
+      dependencies: Array.from(mergedDependencies),
+      symbols: mergedSymbols,
+      exports: mergedExports,
+      diagnostics: mergedDiagnostics
+    },
+    rationales: mergedRationales
+  };
+}
+async function analyzeVueSource(manifest, extractedText) {
+  const outer = await analyzeTreeSitterCode(manifest, extractedText, "vue");
+  const scriptBlocks = extractVueScriptBlocks(extractedText);
+  if (scriptBlocks.length === 0) {
+    return outer;
+  }
+  const innerResults = [];
+  for (const block of scriptBlocks) {
+    if (!block.content.trim()) {
+      continue;
+    }
+    const innerManifest = {
+      ...manifest,
+      language: block.language
+    };
+    const analyzed = analyzeTypeScriptLikeCode(innerManifest, block.content);
+    innerResults.push({ code: analyzed.code, rationales: analyzed.rationales, lineOffset: block.lineOffset });
+  }
+  return mergeVueScriptAnalyses(outer, innerResults);
+}
 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);
+  const { code, rationales } = language === "javascript" || language === "jsx" || language === "typescript" || language === "tsx" ? analyzeTypeScriptLikeCode(manifest, extractedText) : language === "vue" ? await analyzeVueSource(manifest, extractedText) : await analyzeTreeSitterCode(manifest, extractedText, language);
   return {
     analysisVersion: 7,
     sourceId: manifest.sourceId,
@@ -6548,6 +6671,7 @@ function filterGraphBySourceClass(graph, sourceClass) {
 }
 
 // src/graph-enrichment.ts
+var DEFAULT_SIMILARITY_IDF_FLOOR = 0.5;
 var STOPWORDS = /* @__PURE__ */ new Set([
   "about",
   "after",
@@ -6629,21 +6753,70 @@ function hasDistinctScope(left, right) {
   const rightOnly = [...rightSources].some((sourceId) => !leftSources.has(sourceId));
   return leftOnly || rightOnly;
 }
-function supportCount(values) {
-  return values?.size ?? 0;
-}
-function similarityScore(reasons) {
-  const concept = supportCount(reasons.get("shared_concept"));
-  const entity = supportCount(reasons.get("shared_entity"));
-  const symbol = supportCount(reasons.get("shared_symbol"));
-  const rationale = supportCount(reasons.get("shared_rationale_theme"));
-  const sourceType = supportCount(reasons.get("shared_source_type"));
-  const tag = supportCount(reasons.get("shared_tag"));
-  const categoryCount = [...reasons.keys()].length;
-  const weighted = (concept ? 0.46 + Math.min(0.12, (concept - 1) * 0.04) : 0) + (entity ? 0.34 + Math.min(0.1, (entity - 1) * 0.03) : 0) + (symbol ? 0.24 + Math.min(0.08, (symbol - 1) * 0.02) : 0) + (rationale ? 0.18 + Math.min(0.08, (rationale - 1) * 0.03) : 0) + (sourceType ? 0.1 : 0) + (tag ? 0.12 + Math.min(0.04, (tag - 1) * 0.02) : 0);
-  const categoryBonus = categoryCount >= 3 ? 0.08 : categoryCount === 2 ? 0.04 : 0;
+var CATEGORY_BASE_WEIGHT = {
+  shared_concept: 0.46,
+  shared_entity: 0.34,
+  shared_symbol: 0.24,
+  shared_rationale_theme: 0.18,
+  shared_source_type: 0.1,
+  shared_tag: 0.12
+};
+function buildIdfTable(featureDocFrequency, documentCount) {
+  const idf = /* @__PURE__ */ new Map();
+  const safeDocCount = Math.max(1, documentCount);
+  for (const [reason, values] of featureDocFrequency.entries()) {
+    const inner = /* @__PURE__ */ new Map();
+    for (const [value, df] of values.entries()) {
+      inner.set(value, Math.log((safeDocCount + 1) / (df + 1)) + 1);
+    }
+    idf.set(reason, inner);
+  }
+  return idf;
+}
+function similarityScore(reasons, idfTable, floor) {
+  let weighted = 0;
+  let activeCategories = 0;
+  for (const [reason, values] of reasons.entries()) {
+    const idfByValue = idfTable.get(reason);
+    let categoryContribution = 0;
+    let hitCount = 0;
+    for (const value of values) {
+      const idfValue = idfByValue?.get(value) ?? 0;
+      if (idfValue < floor) {
+        continue;
+      }
+      hitCount++;
+      const base = CATEGORY_BASE_WEIGHT[reason] ?? 0.1;
+      if (hitCount === 1) {
+        categoryContribution += Math.min(base * 2, base * idfValue);
+      } else {
+        categoryContribution += Math.min(0.12, 0.04 * idfValue);
+      }
+    }
+    if (categoryContribution > 0) {
+      weighted += categoryContribution;
+      activeCategories++;
+    }
+  }
+  const categoryBonus = activeCategories >= 3 ? 0.08 : activeCategories === 2 ? 0.04 : 0;
   return Math.min(0.96, weighted + categoryBonus);
 }
+function pruneReasonsByIdf(reasons, idfTable, floor) {
+  const pruned = /* @__PURE__ */ new Map();
+  for (const [reason, values] of reasons.entries()) {
+    const idfByValue = idfTable.get(reason);
+    const keep = /* @__PURE__ */ new Set();
+    for (const value of values) {
+      if ((idfByValue?.get(value) ?? 0) >= floor) {
+        keep.add(value);
+      }
+    }
+    if (keep.size > 0) {
+      pruned.set(reason, keep);
+    }
+  }
+  return pruned;
+}
 function describeSimilarityReasons(reasons) {
   if (!reasons?.length) {
     return "This link is inferred from multiple shared graph features.";
@@ -6702,11 +6875,27 @@ function nodeContexts(nodes, manifests, analyses) {
     return { node, featureValues: features };
   }).filter((context) => context.featureValues.size > 0);
 }
-function buildSemanticSimilarityEdges(nodes, edges, manifests, analyses) {
+function buildSemanticSimilarityEdges(nodes, edges, manifests, analyses, options) {
+  const idfFloor = options?.similarityIdfFloor ?? DEFAULT_SIMILARITY_IDF_FLOOR;
+  const similarityEdgeCap = Math.max(0, options?.similarityEdgeCap ?? Number.POSITIVE_INFINITY);
   const contexts = nodeContexts(nodes, manifests, analyses);
   const contextsById = new Map(contexts.map((context) => [context.node.id, context]));
   const directPairs = new Set(edges.map((edge) => pairKey(edge.source, edge.target)));
   const pairReasons = /* @__PURE__ */ new Map();
+  const featureDocFrequency = /* @__PURE__ */ new Map();
+  for (const context of contexts) {
+    for (const [reason, values] of context.featureValues.entries()) {
+      let inner = featureDocFrequency.get(reason);
+      if (!inner) {
+        inner = /* @__PURE__ */ new Map();
+        featureDocFrequency.set(reason, inner);
+      }
+      for (const value of values) {
+        inner.set(value, (inner.get(value) ?? 0) + 1);
+      }
+    }
+  }
+  const idfTable = buildIdfTable(featureDocFrequency, contexts.length);
   for (const reason of ["shared_concept", "shared_entity", "shared_symbol", "shared_rationale_theme", "shared_source_type"]) {
     const buckets = /* @__PURE__ */ new Map();
     for (const context of contexts) {
@@ -6749,20 +6938,24 @@ function buildSemanticSimilarityEdges(nodes, edges, manifests, analyses) {
       }
     }
   }
-  return [...pairReasons.entries()].flatMap(([key, reasons]) => {
+  const candidates = [...pairReasons.entries()].flatMap(([key, reasons]) => {
     const [leftId, rightId] = key.split("|");
     const left = contextsById.get(leftId)?.node;
     const right = contextsById.get(rightId)?.node;
     if (!left || !right) {
       return [];
     }
-    const confidence = similarityScore(reasons);
+    const prunedReasons = pruneReasonsByIdf(reasons, idfTable, idfFloor);
+    if (prunedReasons.size === 0) {
+      return [];
+    }
+    const confidence = similarityScore(prunedReasons, idfTable, idfFloor);
     if (confidence < 0.5) {
       return [];
     }
     return [
       {
-        id: `similar:${sha256(`${left.id}|${right.id}|${[...reasons.keys()].sort().join(",")}`).slice(0, 16)}`,
+        id: `similar:${sha256(`${left.id}|${right.id}|${[...prunedReasons.keys()].sort().join(",")}`).slice(0, 16)}`,
         source: left.id,
         target: right.id,
         relation: "semantically_similar_to",
@@ -6773,11 +6966,15 @@ function buildSemanticSimilarityEdges(nodes, edges, manifests, analyses) {
           [...left.sourceIds, ...right.sourceIds].sort((a, b) => a.localeCompare(b)),
           (value) => value
         ),
-        similarityReasons: [...reasons.keys()].sort((a, b) => a.localeCompare(b)),
+        similarityReasons: [...prunedReasons.keys()].sort((a, b) => a.localeCompare(b)),
         similarityBasis: "feature_overlap"
       }
     ];
   }).sort((left, right) => right.confidence - left.confidence || left.id.localeCompare(right.id));
+  if (candidates.length > similarityEdgeCap) {
+    return candidates.slice(0, similarityEdgeCap);
+  }
+  return candidates;
 }
 function buildTopicHyperedges(graph) {
   const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
@@ -6857,8 +7054,8 @@ function buildModuleFormHyperedges(graph) {
     ];
   });
 }
-function enrichGraph(graph, manifests, analyses, extraSimilarityEdges = []) {
-  const similarityEdges = buildSemanticSimilarityEdges(graph.nodes, graph.edges, manifests, analyses);
+function enrichGraph(graph, manifests, analyses, extraSimilarityEdges = [], options) {
+  const similarityEdges = buildSemanticSimilarityEdges(graph.nodes, graph.edges, manifests, analyses, options);
   const enrichedEdges = uniqueBy([...graph.edges, ...similarityEdges, ...extraSimilarityEdges], (edge) => edge.id).sort(
     (left, right) => left.id.localeCompare(right.id)
   );
@@ -6875,12 +7072,213 @@ function enrichGraph(graph, manifests, analyses, extraSimilarityEdges = []) {
   };
 }
 
-// src/graph-tools.ts
+// src/graph-query-core.ts
+var NODE_TYPE_PRIORITY = {
+  concept: 6,
+  entity: 5,
+  source: 4,
+  module: 3,
+  symbol: 2,
+  rationale: 1
+};
 function normalizeTarget(value) {
+  return value.replace(/\s+/g, " ").trim().normalize("NFKD").replace(/\p{Mn}+/gu, "").toLowerCase();
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (!value) continue;
+    if (seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+function scoreMatch(query, candidate) {
+  const q = normalizeTarget(query);
+  const c = normalizeTarget(candidate);
+  if (!q || !c) return 0;
+  if (c === q) return 100;
+  if (c.startsWith(q)) return 80;
+  if (c.includes(q)) return 60;
+  const qTokens = q.split(/\s+/).filter(Boolean);
+  const cTokens = new Set(c.split(/\s+/).filter(Boolean));
+  const overlap = qTokens.filter((token) => cTokens.has(token)).length;
+  return overlap ? overlap * 10 : 0;
+}
+function buildAdjacency(graph) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const push = (nodeId, item) => {
+    const list = adjacency.get(nodeId);
+    if (list) {
+      list.push(item);
+    } else {
+      adjacency.set(nodeId, [item]);
+    }
+  };
+  for (const edge of graph.edges) {
+    push(edge.source, { edge, nodeId: edge.target, direction: "outgoing" });
+    push(edge.target, { edge, nodeId: edge.source, direction: "incoming" });
+  }
+  for (const [nodeId, items] of adjacency.entries()) {
+    items.sort((left, right) => right.edge.confidence - left.edge.confidence || left.edge.relation.localeCompare(right.edge.relation));
+    adjacency.set(nodeId, items);
+  }
+  return adjacency;
+}
+function compareLabelCandidates(left, right) {
+  const priorityDelta = (NODE_TYPE_PRIORITY[right.type] ?? 0) - (NODE_TYPE_PRIORITY[left.type] ?? 0);
+  if (priorityDelta !== 0) return priorityDelta;
+  const degreeDelta = (right.degree ?? 0) - (left.degree ?? 0);
+  if (degreeDelta !== 0) return degreeDelta;
+  return left.id.localeCompare(right.id);
+}
+function resolveCoreNode(graph, target) {
+  const byId = new Map(graph.nodes.map((node) => [node.id, node]));
+  if (byId.has(target)) return byId.get(target);
+  const normalized = normalizeTarget(target);
+  const labelMatches = graph.nodes.filter((node) => normalizeTarget(node.label) === normalized || normalizeTarget(node.id) === normalized);
+  if (labelMatches.length) {
+    return labelMatches.slice().sort(compareLabelCandidates)[0];
+  }
+  const pages = graph.pages ?? [];
+  const pageHit = pages.map((page) => ({
+    page,
+    score: Math.max(scoreMatch(target, page.title), scoreMatch(target, page.path))
+  })).filter((item) => item.score > 0).sort((left, right) => right.score - left.score || left.page.title.localeCompare(right.page.title))[0];
+  if (pageHit) {
+    const primary = graph.nodes.find((node) => node.pageId === pageHit.page.id);
+    if (primary) return primary;
+  }
+  const fuzzy = graph.nodes.map((node) => ({ node, score: Math.max(scoreMatch(target, node.label), scoreMatch(target, node.id)) })).filter((item) => item.score > 0).sort((left, right) => right.score - left.score || compareLabelCandidates(left.node, right.node))[0];
+  return fuzzy?.node;
+}
+function runCoreGraphPath(graph, from, to) {
+  const start = resolveCoreNode(graph, from);
+  const end = resolveCoreNode(graph, to);
+  if (!start || !end) {
+    return {
+      from,
+      to,
+      resolvedFromNodeId: start?.id,
+      resolvedToNodeId: end?.id,
+      found: false,
+      nodeIds: [],
+      edgeIds: [],
+      pageIds: [],
+      summary: "Could not resolve one or both graph targets."
+    };
+  }
+  const adjacency = buildAdjacency(graph);
+  const queue = [start.id];
+  const visited = /* @__PURE__ */ new Set([start.id]);
+  const previous = /* @__PURE__ */ new Map();
+  while (queue.length) {
+    const current2 = queue.shift();
+    if (current2 === end.id) break;
+    for (const neighbor of adjacency.get(current2) ?? []) {
+      if (visited.has(neighbor.nodeId)) continue;
+      visited.add(neighbor.nodeId);
+      previous.set(neighbor.nodeId, { nodeId: current2, edgeId: neighbor.edge.id });
+      queue.push(neighbor.nodeId);
+    }
+  }
+  if (!visited.has(end.id)) {
+    return {
+      from,
+      to,
+      resolvedFromNodeId: start.id,
+      resolvedToNodeId: end.id,
+      found: false,
+      nodeIds: [],
+      edgeIds: [],
+      pageIds: [],
+      summary: `No path found between ${start.label} and ${end.label}.`
+    };
+  }
+  const nodeIds = [];
+  const edgeIds = [];
+  let current = end.id;
+  while (current !== start.id) {
+    nodeIds.push(current);
+    const prev = previous.get(current);
+    if (!prev) break;
+    edgeIds.push(prev.edgeId);
+    current = prev.nodeId;
+  }
+  nodeIds.push(start.id);
+  nodeIds.reverse();
+  edgeIds.reverse();
+  const nodeById2 = new Map(graph.nodes.map((node) => [node.id, node]));
+  const pageIds = uniqueStrings(
+    nodeIds.flatMap((nodeId) => {
+      const node = nodeById2.get(nodeId);
+      return node?.pageId ? [node.pageId] : [];
+    })
+  );
+  return {
+    from,
+    to,
+    resolvedFromNodeId: start.id,
+    resolvedToNodeId: end.id,
+    found: true,
+    nodeIds,
+    edgeIds,
+    pageIds,
+    summary: nodeIds.map((nodeId) => nodeById2.get(nodeId)?.label ?? nodeId).join(" -> ")
+  };
+}
+function runCoreGraphExplain(graph, target) {
+  const node = resolveCoreNode(graph, target);
+  if (!node) return void 0;
+  const adjacency = buildAdjacency(graph);
+  const nodeById2 = new Map(graph.nodes.map((candidate) => [candidate.id, candidate]));
+  const neighbors = [];
+  for (const neighbor of adjacency.get(node.id) ?? []) {
+    const targetNode = nodeById2.get(neighbor.nodeId);
+    if (!targetNode) continue;
+    neighbors.push({
+      nodeId: targetNode.id,
+      label: targetNode.label,
+      type: targetNode.type,
+      pageId: targetNode.pageId,
+      relation: neighbor.edge.relation,
+      direction: neighbor.direction,
+      confidence: neighbor.edge.confidence,
+      evidenceClass: neighbor.edge.evidenceClass
+    });
+  }
+  neighbors.sort((left, right) => right.confidence - left.confidence || left.label.localeCompare(right.label));
+  const pagesById = new Map((graph.pages ?? []).map((page2) => [page2.id, page2]));
+  const page = node.pageId ? pagesById.get(node.pageId) : void 0;
+  const community = node.communityId ? graph.communities?.find((candidate) => candidate.id === node.communityId) : void 0;
+  const hyperedges = (graph.hyperedges ?? []).filter((hyperedge) => hyperedge.nodeIds.includes(node.id)).slice().sort((left, right) => right.confidence - left.confidence || left.label.localeCompare(right.label));
+  const summary = [
+    `Node: ${node.label}`,
+    `Type: ${node.type}`,
+    `Community: ${node.communityId ?? "none"}`,
+    `Neighbors: ${neighbors.length}`,
+    `Group patterns: ${hyperedges.length}`,
+    `Page: ${page?.path ?? "none"}`
+  ].join("\n");
+  return {
+    target,
+    node,
+    page,
+    community: community ? { id: community.id, label: community.label } : void 0,
+    neighbors,
+    hyperedges,
+    summary
+  };
+}
+
+// src/graph-tools.ts
+function normalizeTarget2(value) {
   return normalizeWhitespace(value).normalize("NFKD").replace(/\p{Mn}+/gu, "").toLowerCase();
 }
 function computeNormLabel(label) {
-  return normalizeTarget(label);
+  return normalizeTarget2(label);
 }
 function nodeById(graph) {
   return new Map(graph.nodes.map((node) => [node.id, node]));
@@ -6891,9 +7289,9 @@ function pageById(graph) {
 function hyperedgesForNode(graph, nodeId) {
   return (graph.hyperedges ?? []).filter((hyperedge) => hyperedge.nodeIds.includes(nodeId)).sort((left, right) => right.confidence - left.confidence || left.label.localeCompare(right.label));
 }
-function scoreMatch(query, candidate) {
-  const normalizedQuery = normalizeTarget(query);
-  const normalizedCandidate = normalizeTarget(candidate);
+function scoreMatch2(query, candidate) {
+  const normalizedQuery = normalizeTarget2(query);
+  const normalizedCandidate = normalizeTarget2(candidate);
   if (!normalizedQuery || !normalizedCandidate) {
     return 0;
   }
@@ -6919,7 +7317,7 @@ function pageSearchMatches(graph, question, searchResults) {
   const pages = pageById(graph);
   return searchResults.map((result) => {
     const page = pages.get(result.pageId);
-    const score = Math.max(scoreMatch(question, result.title), scoreMatch(question, result.path));
+    const score = Math.max(scoreMatch2(question, result.title), scoreMatch2(question, result.path));
     if (!page || score <= 0) {
       return null;
     }
@@ -6936,7 +7334,7 @@ function nodeMatches(graph, query) {
     type: "node",
     id: node.id,
     label: node.label,
-    score: Math.max(scoreMatch(query, node.label), scoreMatch(query, node.id))
+    score: Math.max(scoreMatch2(query, node.label), scoreMatch2(query, node.id))
   })).filter((match) => match.score > 0).sort((left, right) => right.score - left.score || left.label.localeCompare(right.label));
 }
 function hyperedgeMatches(graph, query) {
@@ -6944,7 +7342,7 @@ function hyperedgeMatches(graph, query) {
     type: "hyperedge",
     id: hyperedge.id,
     label: hyperedge.label,
-    score: Math.max(scoreMatch(query, hyperedge.label), scoreMatch(query, hyperedge.why), scoreMatch(query, hyperedge.relation))
+    score: Math.max(scoreMatch2(query, hyperedge.label), scoreMatch2(query, hyperedge.why), scoreMatch2(query, hyperedge.relation))
   })).filter((match) => match.score > 0).sort((left, right) => right.score - left.score || left.label.localeCompare(right.label));
 }
 function graphAdjacency(graph) {
@@ -6965,7 +7363,7 @@ function graphAdjacency(graph) {
   }
   return adjacency;
 }
-var NODE_TYPE_PRIORITY = {
+var NODE_TYPE_PRIORITY2 = {
   concept: 6,
   entity: 5,
   source: 4,
@@ -6974,9 +7372,9 @@ var NODE_TYPE_PRIORITY = {
   rationale: 1
 };
 function nodeTypePriority(type) {
-  return NODE_TYPE_PRIORITY[type] ?? 0;
+  return NODE_TYPE_PRIORITY2[type] ?? 0;
 }
-function compareLabelCandidates(left, right) {
+function compareLabelCandidates2(left, right) {
   const priorityDelta = nodeTypePriority(right.type) - nodeTypePriority(left.type);
   if (priorityDelta !== 0) {
     return priorityDelta;
@@ -6988,30 +7386,23 @@ function compareLabelCandidates(left, right) {
   return left.id.localeCompare(right.id);
 }
 function resolveNode(graph, target) {
-  const normalized = normalizeTarget(target);
+  const normalized = normalizeTarget2(target);
   const byId = nodeById(graph);
   if (byId.has(target)) {
     return byId.get(target);
   }
-  const labelMatches = graph.nodes.filter((node) => normalizeTarget(node.label) === normalized || normalizeTarget(node.id) === normalized);
+  const labelMatches = graph.nodes.filter((node) => normalizeTarget2(node.label) === normalized || normalizeTarget2(node.id) === normalized);
   if (labelMatches.length) {
-    return labelMatches.sort(compareLabelCandidates)[0];
+    return labelMatches.sort(compareLabelCandidates2)[0];
   }
   const pages = graph.pages.map((page) => ({
     page,
-    score: Math.max(scoreMatch(target, page.title), scoreMatch(target, page.path))
+    score: Math.max(scoreMatch2(target, page.title), scoreMatch2(target, page.path))
   })).filter((item) => item.score > 0).sort((left, right) => right.score - left.score || left.page.title.localeCompare(right.page.title));
   if (pages[0]) {
     return primaryNodeForPage(graph, pages[0].page);
   }
-  return graph.nodes.map((node) => ({ node, score: Math.max(scoreMatch(target, node.label), scoreMatch(target, node.id)) })).filter((item) => item.score > 0).sort((left, right) => right.score - left.score || compareLabelCandidates(left.node, right.node))[0]?.node;
-}
-function communityLabel(graph, communityId) {
-  if (!communityId) {
-    return void 0;
-  }
-  const community = graph.communities?.find((item) => item.id === communityId);
-  return community ? { id: community.id, label: community.label } : void 0;
+  return graph.nodes.map((node) => ({ node, score: Math.max(scoreMatch2(target, node.label), scoreMatch2(target, node.id)) })).filter((item) => item.score > 0).sort((left, right) => right.score - left.score || compareLabelCandidates2(left.node, right.node))[0]?.node;
 }
 function queryGraph(graph, question, searchResults, options) {
   const traversal = options?.traversal ?? "bfs";
@@ -7102,128 +7493,29 @@ function queryGraph(graph, question, searchResults, options) {
   };
 }
 function shortestGraphPath(graph, from, to) {
-  const start = resolveNode(graph, from);
-  const end = resolveNode(graph, to);
-  if (!start || !end) {
-    return {
-      from,
-      to,
-      resolvedFromNodeId: start?.id,
-      resolvedToNodeId: end?.id,
-      found: false,
-      nodeIds: [],
-      edgeIds: [],
-      pageIds: [],
-      summary: "Could not resolve one or both graph targets."
-    };
-  }
-  const adjacency = graphAdjacency(graph);
-  const queue = [start.id];
-  const visited = /* @__PURE__ */ new Set([start.id]);
-  const previous = /* @__PURE__ */ new Map();
-  while (queue.length) {
-    const current2 = queue.shift();
-    if (current2 === end.id) {
-      break;
-    }
-    for (const neighbor of adjacency.get(current2) ?? []) {
-      if (visited.has(neighbor.nodeId)) {
-        continue;
-      }
-      visited.add(neighbor.nodeId);
-      previous.set(neighbor.nodeId, { nodeId: current2, edgeId: neighbor.edge.id });
-      queue.push(neighbor.nodeId);
-    }
-  }
-  if (!visited.has(end.id)) {
-    return {
-      from,
-      to,
-      resolvedFromNodeId: start.id,
-      resolvedToNodeId: end.id,
-      found: false,
-      nodeIds: [],
-      edgeIds: [],
-      pageIds: [],
-      summary: `No path found between ${start.label} and ${end.label}.`
-    };
-  }
-  const nodeIds = [];
-  const edgeIds = [];
-  let current = end.id;
-  while (current !== start.id) {
-    nodeIds.push(current);
-    const prev = previous.get(current);
-    if (!prev) {
-      break;
-    }
-    edgeIds.push(prev.edgeId);
-    current = prev.nodeId;
+  return runCoreGraphPath(graph, from, to);
+}
+function explainGraphTarget(graph, target) {
+  const result = runCoreGraphExplain(graph, target);
+  if (!result) {
+    throw new Error(`Could not resolve graph target: ${target}`);
   }
-  nodeIds.push(start.id);
-  nodeIds.reverse();
-  edgeIds.reverse();
   const nodes = nodeById(graph);
-  const pageIds = uniqueBy(
-    nodeIds.flatMap((nodeId) => {
-      const node = nodes.get(nodeId);
-      return node?.pageId ? [node.pageId] : [];
-    }),
-    (item) => item
-  );
-  return {
-    from,
-    to,
-    resolvedFromNodeId: start.id,
-    resolvedToNodeId: end.id,
-    found: true,
-    nodeIds,
-    edgeIds,
-    pageIds,
-    summary: nodeIds.map((nodeId) => nodes.get(nodeId)?.label ?? nodeId).join(" -> ")
-  };
-}
-function explainGraphTarget(graph, target) {
-  const node = resolveNode(graph, target);
-  if (!node) {
-    throw new Error(`Could not resolve graph target: ${target}`);
-  }
-  const pages = pageById(graph);
-  const page = node.pageId ? pages.get(node.pageId) : void 0;
-  const neighbors = [];
-  const nodes = nodeById(graph);
-  for (const neighbor of graphAdjacency(graph).get(node.id) ?? []) {
-    const targetNode = nodes.get(neighbor.nodeId);
-    if (!targetNode) {
-      continue;
-    }
-    neighbors.push({
-      nodeId: targetNode.id,
-      label: targetNode.label,
-      type: targetNode.type,
-      pageId: targetNode.pageId,
-      relation: neighbor.edge.relation,
-      direction: neighbor.direction,
-      confidence: neighbor.edge.confidence,
-      evidenceClass: neighbor.edge.evidenceClass
-    });
-  }
-  neighbors.sort((left, right) => right.confidence - left.confidence || left.label.localeCompare(right.label));
+  const node = nodes.get(result.node.id) ?? result.node;
+  const page = node.pageId ? pageById(graph).get(node.pageId) : void 0;
+  const neighbors = result.neighbors.map((neighbor) => ({
+    ...neighbor,
+    type: nodes.get(neighbor.nodeId)?.type ?? neighbor.type,
+    evidenceClass: neighbor.evidenceClass
+  }));
   return {
     target,
     node,
     page,
-    community: communityLabel(graph, node.communityId),
+    community: result.community,
     neighbors,
     hyperedges: hyperedgesForNode(graph, node.id),
-    summary: [
-      `Node: ${node.label}`,
-      `Type: ${node.type}`,
-      `Community: ${node.communityId ?? "none"}`,
-      `Neighbors: ${neighbors.length}`,
-      `Group patterns: ${hyperedgesForNode(graph, node.id).length}`,
-      `Page: ${page?.path ?? "none"}`
-    ].join("\n")
+    summary: result.summary
   };
 }
 function topGodNodes(graph, limit = 10) {
@@ -7237,7 +7529,7 @@ function listHyperedges(graph, target, limit = 25) {
   if (node) {
     return hyperedgesForNode(graph, node.id).slice(0, limit);
   }
-  const page = graph.pages.find((candidate) => normalizeTarget(candidate.path) === normalizeTarget(target) || candidate.id === target);
+  const page = graph.pages.find((candidate) => normalizeTarget2(candidate.path) === normalizeTarget2(target) || candidate.id === target);
   if (!page) {
     return [];
   }
@@ -7283,8 +7575,8 @@ function blastRadius(graph, target, options) {
   const resolved = resolveNode(graph, target);
   const moduleNode = resolved?.type === "module" ? resolved : resolved?.moduleId ? graph.nodes.find((n) => n.id === resolved.moduleId) : void 0;
   if (!moduleNode) {
-    const normalizedTarget = normalizeTarget(target);
-    const candidate = graph.nodes.filter((n) => n.type === "module").find((n) => normalizeTarget(n.label).includes(normalizedTarget) || normalizeTarget(n.id).includes(normalizedTarget));
+    const normalizedTarget = normalizeTarget2(target);
+    const candidate = graph.nodes.filter((n) => n.type === "module").find((n) => normalizeTarget2(n.label).includes(normalizedTarget) || normalizeTarget2(n.id).includes(normalizedTarget));
     if (!candidate) {
       return {
         target,
@@ -7340,6 +7632,105 @@ function blastRadius(graph, target, options) {
   };
 }
 
+// src/large-repo-defaults.ts
+var LARGE_REPO_NODE_THRESHOLD = 1e3;
+var DEFAULT_SMALL_GOD_NODE_LIMIT = 20;
+var DEFAULT_LARGE_GOD_NODE_LIMIT = 10;
+var DEFAULT_SIMILARITY_IDF_FLOOR2 = 0.5;
+var SIMILARITY_EDGE_CAP_MAX = 2e4;
+var SIMILARITY_EDGE_CAP_PER_NODE = 5;
+var MIN_FOLD_BELOW = 3;
+function clampPositiveInteger(value, fallback) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function clampNonNegativeNumber(value, fallback) {
+  if (!Number.isFinite(value) || value < 0) {
+    return fallback;
+  }
+  return value;
+}
+function resolveLargeRepoDefaults(input) {
+  const nodeCount = Math.max(0, Math.floor(input.nodeCount));
+  const totalCommunities = Math.max(0, Math.floor(input.totalCommunities ?? 0));
+  const graphConfig = input.config?.graph;
+  const isLargeRepo = nodeCount > LARGE_REPO_NODE_THRESHOLD;
+  const defaultGodNodeLimit = isLargeRepo ? DEFAULT_LARGE_GOD_NODE_LIMIT : DEFAULT_SMALL_GOD_NODE_LIMIT;
+  const godNodeLimit = graphConfig?.godNodeLimit !== void 0 ? clampPositiveInteger(graphConfig.godNodeLimit, defaultGodNodeLimit) : defaultGodNodeLimit;
+  const defaultSimilarityEdgeCap = Math.min(SIMILARITY_EDGE_CAP_MAX, Math.max(0, SIMILARITY_EDGE_CAP_PER_NODE * nodeCount));
+  const similarityEdgeCap = graphConfig?.similarityEdgeCap !== void 0 ? clampPositiveInteger(graphConfig.similarityEdgeCap, defaultSimilarityEdgeCap) : defaultSimilarityEdgeCap;
+  const similarityIdfFloor = graphConfig?.similarityIdfFloor !== void 0 ? clampNonNegativeNumber(graphConfig.similarityIdfFloor, DEFAULT_SIMILARITY_IDF_FLOOR2) : DEFAULT_SIMILARITY_IDF_FLOOR2;
+  const defaultFoldBelow = Math.max(MIN_FOLD_BELOW, Math.ceil(totalCommunities / 50));
+  const foldCommunitiesBelow = graphConfig?.foldCommunitiesBelow !== void 0 ? clampPositiveInteger(graphConfig.foldCommunitiesBelow, defaultFoldBelow) : defaultFoldBelow;
+  return {
+    godNodeLimit,
+    foldCommunitiesBelow,
+    similarityEdgeCap,
+    similarityIdfFloor
+  };
+}
+
+// src/source-classification.ts
+import path6 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) => path6.matchesGlob(relativePath, pattern) || path6.matchesGlob(path6.posix.basename(relativePath), pattern)
+  );
+}
+function classifyRepoPath(relativePath, repoAnalysis) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  const custom = repoAnalysis?.classifyGlobs;
+  if (custom?.first_party?.length && matchesAnyGlob(normalized, custom.first_party)) {
+    return "first_party";
+  }
+  for (const sourceClass of ["third_party", "resource", "generated"]) {
+    const patterns = custom?.[sourceClass];
+    if (patterns?.length && matchesAnyGlob(normalized, patterns)) {
+      return sourceClass;
+    }
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.some((segment) => THIRD_PARTY_SEGMENTS.has(segment))) {
+    return "third_party";
+  }
+  if (segments.some((segment) => GENERATED_SEGMENTS.has(segment))) {
+    return "generated";
+  }
+  if (segments.some((segment) => segment.endsWith(".xcassets") || segment.endsWith(".imageset"))) {
+    return "resource";
+  }
+  return "first_party";
+}
+function normalizeExtractClasses(repoAnalysis, extra = []) {
+  const configured = repoAnalysis?.extractClasses?.length ? repoAnalysis.extractClasses : ["first_party"];
+  return ALL_SOURCE_CLASSES.filter((sourceClass) => (/* @__PURE__ */ new Set([...configured, ...extra])).has(sourceClass));
+}
+function aggregateSourceClass(values) {
+  const available = ALL_SOURCE_CLASSES.filter((sourceClass) => values.includes(sourceClass));
+  if (!available.length) {
+    return void 0;
+  }
+  if (available.includes("first_party")) {
+    return "first_party";
+  }
+  if (available.includes("resource")) {
+    return "resource";
+  }
+  if (available.includes("third_party")) {
+    return "third_party";
+  }
+  return "generated";
+}
+function aggregateManifestSourceClass(manifests, sourceIds) {
+  const byId = new Map(manifests.map((manifest) => [manifest.sourceId, manifest.sourceClass]));
+  return aggregateSourceClass(sourceIds.map((sourceId) => byId.get(sourceId)));
+}
+
 // src/markdown.ts
 function tierFrontmatterFragment(tier) {
   if (!tier) {
@@ -7357,7 +7748,7 @@ function tierFrontmatterFragment(tier) {
   }
   return fragment;
 }
-function uniqueStrings(values) {
+function uniqueStrings2(values) {
   return uniqueBy(values.filter(Boolean), (value) => value);
 }
 var GUIDED_SOURCE_MARKER_PREFIX = "<!-- swarmvault-guided-source:";
@@ -7388,7 +7779,7 @@ function extractGuidedSourceBlocks(content) {
     blocks.push(content.slice(startIndex, blockEnd).trim());
     cursor = blockEnd;
   }
-  return uniqueStrings(blocks);
+  return uniqueStrings2(blocks);
 }
 function appendGuidedSourceBlocks(body, existingContent) {
   const blocks = extractGuidedSourceBlocks(existingContent);
@@ -7416,12 +7807,29 @@ function cssclassesFor(kind) {
   return ["swarmvault", `sv-${kind.replace(/_/g, "-")}`];
 }
 function decoratedTags(baseTags, decorations) {
-  return uniqueStrings([
+  return uniqueStrings2([
     ...baseTags,
     ...(decorations?.projectIds ?? []).map((projectId) => `project/${projectId}`),
     ...decorations?.extraTags ?? []
   ]);
 }
+function sortDerivedTags(tags, leaders) {
+  const deduped = uniqueStrings2(tags);
+  const pinned = [];
+  const rest = [];
+  for (const tag of deduped) {
+    if (leaders.includes(tag)) continue;
+    rest.push(tag);
+  }
+  for (const leader of leaders) {
+    if (deduped.includes(leader)) pinned.push(leader);
+  }
+  rest.sort((left, right) => left.localeCompare(right));
+  return [...pinned, ...rest];
+}
+function inheritedSourceTags(sourceAnalyses) {
+  return uniqueStrings2(sourceAnalyses.flatMap((analysis) => analysis.tags ?? []));
+}
 function pagePathFor(kind, slug) {
   switch (kind) {
     case "source":
@@ -7630,7 +8038,7 @@ function buildModulePage(input) {
   const nodeIds = [code.moduleId, ...code.symbols.map((symbol) => symbol.id)];
   const localModuleBacklinks = input.localModules.map((moduleRef) => moduleRef.page.id);
   const relatedOutputs = input.relatedOutputs ?? [];
-  const backlinks = uniqueStrings([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]);
+  const backlinks = uniqueStrings2([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]);
   const { sourceHashes, sourceSemanticHashes } = sourceHashesForManifest(manifest);
   const importsSection = code.imports.length ? code.imports.map((item) => {
     const localModule = item.resolvedSourceId ? input.localModules.find((moduleRef) => moduleRef.sourceId === item.resolvedSourceId && moduleRef.reExport === item.reExport) : void 0;
@@ -7677,9 +8085,9 @@ function buildModulePage(input) {
     backlinks,
     schema_hash: schemaHash,
     ...sourceHashFrontmatter(sourceHashes, sourceSemanticHashes),
-    related_page_ids: uniqueStrings([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
+    related_page_ids: uniqueStrings2([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
     related_node_ids: [],
-    related_source_ids: uniqueStrings([
+    related_source_ids: uniqueStrings2([
       manifest.sourceId,
       ...input.localModules.map((moduleRef) => moduleRef.sourceId),
       ...relatedOutputs.flatMap((page) => page.sourceIds)
@@ -7754,9 +8162,9 @@ function buildModulePage(input) {
       schemaHash,
       sourceHashes,
       sourceSemanticHashes,
-      relatedPageIds: uniqueStrings([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
+      relatedPageIds: uniqueStrings2([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
       relatedNodeIds: [],
-      relatedSourceIds: uniqueStrings([
+      relatedSourceIds: uniqueStrings2([
         manifest.sourceId,
         ...input.localModules.map((moduleRef) => moduleRef.sourceId),
         ...relatedOutputs.flatMap((page) => page.sourceIds)
@@ -7775,13 +8183,16 @@ function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHash
   const sourceIds = sourceAnalyses.map((item) => item.sourceId);
   const otherPages = [...sourceAnalyses.map((item) => `source:${item.sourceId}`), ...relatedOutputs.map((page) => page.id)];
   const summary = descriptions.find(Boolean) ?? `${kind} aggregated from ${sourceIds.length} source(s).`;
+  const leaderTags = metadata.status === "candidate" ? [kind, "candidate"] : [kind];
+  const inheritedTags = inheritedSourceTags(sourceAnalyses);
+  const derivedTags = sortDerivedTags([...decoratedTags(leaderTags, decorations), ...inheritedTags], leaderTags);
   const frontmatter = {
     page_id: pageId,
     kind,
     cssclasses: cssclassesFor(kind),
     title: name,
     ...decorations?.sourceClass ? { source_class: decorations.sourceClass } : {},
-    tags: decoratedTags(metadata.status === "candidate" ? [kind, "candidate"] : [kind], decorations),
+    tags: derivedTags,
     source_ids: sourceIds,
     project_ids: decorations?.projectIds ?? [],
     node_ids: [pageId],
@@ -8076,8 +8487,8 @@ function topGroupPatterns(graph) {
     (left, right) => right.confidence - left.confidence || right.nodeIds.length - left.nodeIds.length || left.label.localeCompare(right.label)
   ).slice(0, 8);
 }
-function fragmentedCommunityPresentation(graph, communityPages) {
-  const thinCommunities = (graph.communities ?? []).filter((community) => community.nodeIds.length <= 2).sort((left, right) => right.nodeIds.length - left.nodeIds.length || left.label.localeCompare(right.label));
+function fragmentedCommunityPresentation(graph, communityPages, foldBelow = 3) {
+  const thinCommunities = (graph.communities ?? []).filter((community) => community.nodeIds.length < foldBelow).sort((left, right) => right.nodeIds.length - left.nodeIds.length || left.label.localeCompare(right.label));
   const visibleCommunities = thinCommunities.slice(0, 6).map((community) => {
     const page = communityPages.find((candidate) => candidate.id === `graph:${community.id}`);
     return {
@@ -8126,7 +8537,7 @@ function suggestedGraphQuestions(graph) {
     }
   }
   const isolatedNodeQuestions = graph.nodes.filter((node) => (node.degree ?? 0) <= 1 && node.type !== "source").slice(0, 3).map((node) => `What connects ${node.label} to the rest of the vault?`);
-  return uniqueStrings([
+  return uniqueStrings2([
     ...thinCommunities.map((community) => `What sources would strengthen community ${community.label}?`),
     ...bridgeNodes.map((node) => `Why does ${node.label} connect multiple communities in the vault?`),
     ...ambiguousEdgeQuestions,
@@ -8174,13 +8585,44 @@ function buildKnowledgeGaps(graph) {
   }
   return { isolatedNodes, thinCommunityCount, ambiguousEdgeRatio, warnings };
 }
+var SOURCE_CLASS_LABELS = {
+  first_party: "First-party",
+  third_party: "Third-party",
+  resource: "Resource",
+  generated: "Generated"
+};
+function benchmarkByClassTableLines(byClass) {
+  if (!byClass) {
+    return [];
+  }
+  const lines = [
+    "### Benchmark By Source Class",
+    "",
+    "| Class | Sources | Pages | Nodes | God Nodes | Naive Tokens | Guided Tokens | Reduction |",
+    "| ----- | ------- | ----- | ----- | --------- | ------------ | ------------- | --------- |"
+  ];
+  for (const sourceClass of ALL_SOURCE_CLASSES) {
+    const entry = byClass[sourceClass];
+    const reductionPct = (entry.reductionRatio * 100).toFixed(1);
+    lines.push(
+      `| ${SOURCE_CLASS_LABELS[sourceClass]} | ${entry.sourceCount} | ${entry.pageCount} | ${entry.nodeCount} | ${entry.godNodeCount} | ${entry.naiveCorpusTokens} | ${entry.finalContextTokens} | ${reductionPct}% |`
+    );
+  }
+  lines.push("");
+  return lines;
+}
 function buildGraphReportArtifact(input) {
   const firstPartyGraph = filterGraphBySourceClass(input.graph, "first_party");
   const reportGraph = firstPartyGraph.nodes.length ? firstPartyGraph : input.graph;
   const pagesById = new Map(reportGraph.pages.map((page) => [page.id, page]));
-  const godNodes = reportGraph.nodes.filter((node) => node.isGodNode).sort((left, right) => (right.degree ?? 0) - (left.degree ?? 0)).slice(0, 8);
+  const repoDefaults = resolveLargeRepoDefaults({
+    nodeCount: input.graph.nodes.length,
+    totalCommunities: input.graph.communities?.length ?? 0,
+    config: input.config
+  });
+  const godNodes = reportGraph.nodes.filter((node) => node.isGodNode).sort((left, right) => (right.degree ?? 0) - (left.degree ?? 0)).slice(0, repoDefaults.godNodeLimit);
   const bridgeNodes = reportGraph.nodes.filter((node) => (node.bridgeScore ?? 0) > 0).sort((left, right) => (right.bridgeScore ?? 0) - (left.bridgeScore ?? 0)).slice(0, 8);
-  const communityPresentation = fragmentedCommunityPresentation(reportGraph, input.communityPages);
+  const communityPresentation = fragmentedCommunityPresentation(reportGraph, input.communityPages, repoDefaults.foldCommunitiesBelow);
   const surprisingConnections = topSurprisingConnections(reportGraph, pagesById);
   const groupPatterns = topGroupPatterns(reportGraph);
   const breakdown = sourceClassBreakdown(input.graph);
@@ -8220,14 +8662,32 @@ function buildGraphReportArtifact(input) {
       generatedAt: input.benchmark.generatedAt,
       stale: input.benchmarkStale ?? false,
       summary: input.benchmark.summary,
-      questionCount: input.benchmark.sampleQuestions.length
+      questionCount: input.benchmark.sampleQuestions.length,
+      byClass: input.benchmark.byClass ? Object.fromEntries(
+        ALL_SOURCE_CLASSES.map((sourceClass) => {
+          const entry = input.benchmark?.byClass?.[sourceClass];
+          return [
+            sourceClass,
+            {
+              sourceCount: entry?.sourceCount ?? 0,
+              pageCount: entry?.pageCount ?? 0,
+              nodeCount: entry?.nodeCount ?? 0,
+              godNodeCount: entry?.godNodeCount ?? 0,
+              finalContextTokens: entry?.finalContextTokens ?? 0,
+              naiveCorpusTokens: entry?.corpusTokens ?? 0,
+              reductionRatio: entry?.reductionRatio ?? 0
+            }
+          ];
+        })
+      ) : void 0
     } : void 0,
     godNodes: godNodes.map((node) => ({
       nodeId: node.id,
       label: node.label,
       pageId: node.pageId,
       degree: node.degree,
-      bridgeScore: node.bridgeScore
+      bridgeScore: node.bridgeScore,
+      ...node.surpriseReason ? { surpriseReason: node.surpriseReason } : {}
     })),
     bridgeNodes: bridgeNodes.map((node) => ({
       nodeId: node.id,
@@ -8277,7 +8737,7 @@ function buildGraphReportPage(input) {
   const pathValue = pagePathFor("graph_report", "report");
   const pagesById = new Map(input.graph.pages.map((page) => [page.id, page]));
   const nodesById = new Map(input.graph.nodes.map((node) => [node.id, node]));
-  const relatedNodeIds = uniqueStrings([
+  const relatedNodeIds = uniqueStrings2([
     ...input.report.godNodes.map((node) => node.nodeId),
     ...input.report.bridgeNodes.map((node) => node.nodeId),
     ...input.report.surprisingConnections.flatMap((connection) => [
@@ -8287,14 +8747,14 @@ function buildGraphReportPage(input) {
     ]),
     ...input.report.groupPatterns.flatMap((hyperedge) => hyperedge.nodeIds)
   ]);
-  const relatedPageIds = uniqueStrings([
+  const relatedPageIds = uniqueStrings2([
     ...input.report.godNodes.map((node) => node.pageId ?? ""),
     ...input.report.bridgeNodes.map((node) => node.pageId ?? ""),
     ...input.report.communityPages.map((page) => page.id),
     ...input.report.recentResearchSources.map((page) => page.pageId),
     ...input.report.groupPatterns.flatMap((hyperedge) => hyperedge.sourcePageIds)
   ]);
-  const relatedSourceIds = uniqueStrings([
+  const relatedSourceIds = uniqueStrings2([
     ...relatedNodeIds.flatMap((nodeId) => nodesById.get(nodeId)?.sourceIds ?? []),
     ...input.report.recentResearchSources.flatMap((page) => pagesById.get(page.pageId)?.sourceIds ?? [])
   ]);
@@ -8354,7 +8814,8 @@ function buildGraphReportPage(input) {
       `- Unique Nodes Considered: ${input.report.benchmark.summary.uniqueVisitedNodes}`,
       `- Reduction Ratio: ${(input.report.benchmark.summary.reductionRatio * 100).toFixed(1)}%`,
       `- Questions: ${input.report.benchmark.questionCount}`,
-      ""
+      "",
+      ...benchmarkByClassTableLines(input.report.benchmark.byClass)
     ] : ["- No benchmark results yet.", ""],
     "## Top God Nodes",
     "",
@@ -8451,14 +8912,14 @@ function buildCommunitySummaryPage(input) {
   const nodesById = new Map(input.graph.nodes.map((node) => [node.id, node]));
   const pagesById = new Map(input.graph.pages.map((page) => [page.id, page]));
   const communityNodes = input.community.nodeIds.map((nodeId) => nodesById.get(nodeId)).filter((node) => Boolean(node));
-  const communityPageIds = uniqueStrings(communityNodes.map((node) => node.pageId ?? ""));
+  const communityPageIds = uniqueStrings2(communityNodes.map((node) => node.pageId ?? ""));
   const communityPages = communityPageIds.map((id) => pagesById.get(id)).filter((page) => Boolean(page));
   const externalEdges = input.graph.edges.filter((edge) => {
     const source = nodesById.get(edge.source);
     const target = nodesById.get(edge.target);
     return source?.communityId === input.community.id && target?.communityId && target.communityId !== input.community.id;
   }).slice(0, 8);
-  const relatedSourceIds = uniqueStrings(communityNodes.flatMap((node) => node.sourceIds));
+  const relatedSourceIds = uniqueStrings2(communityNodes.flatMap((node) => node.sourceIds));
   const frontmatter = {
     page_id: pageId,
     kind: "community_summary",
@@ -8479,7 +8940,7 @@ function buildCommunitySummaryPage(input) {
     schema_hash: input.schemaHash,
     source_hashes: {},
     source_semantic_hashes: {},
-    related_page_ids: uniqueStrings(["graph:report", ...communityPageIds]),
+    related_page_ids: uniqueStrings2(["graph:report", ...communityPageIds]),
     related_node_ids: input.community.nodeIds,
     related_source_ids: relatedSourceIds
   };
@@ -8519,7 +8980,7 @@ function buildCommunitySummaryPage(input) {
       schemaHash: input.schemaHash,
       sourceHashes: {},
       sourceSemanticHashes: {},
-      relatedPageIds: uniqueStrings(["graph:report", ...communityPageIds]),
+      relatedPageIds: uniqueStrings2(["graph:report", ...communityPageIds]),
       relatedNodeIds: input.community.nodeIds,
       relatedSourceIds,
       createdAt: input.metadata.createdAt,
@@ -8882,7 +9343,7 @@ function buildExploreHubPage(input) {
 
 // src/pages.ts
 import fs6 from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 import matter3 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -9027,7 +9488,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 : path6.basename(relativePath, ".md");
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path7.basename(relativePath, ".md");
   const kind = inferPageKind(relativePath, parsed.data.kind);
   const sourceIds = normalizeStringArray(parsed.data.source_ids);
   const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -9075,18 +9536,18 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   };
 }
 async function loadInsightPages(wikiDir) {
-  const insightsDir = path6.join(wikiDir, "insights");
+  const insightsDir = path7.join(wikiDir, "insights");
   if (!await fileExists(insightsDir)) {
     return [];
   }
-  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path6.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
+  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path7.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
   const insights = [];
   for (const absolutePath of files) {
-    const relativePath = toPosix(path6.relative(wikiDir, absolutePath));
+    const relativePath = toPosix(path7.relative(wikiDir, absolutePath));
     const content = await fs6.readFile(absolutePath, "utf8");
     const parsed = matter3(content);
     const stats = await fs6.stat(absolutePath);
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : path6.basename(absolutePath, ".md");
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path7.basename(absolutePath, ".md");
     const sourceIds = normalizeStringArray(parsed.data.source_ids);
     const projectIds = normalizeProjectIds(parsed.data.project_ids);
     const nodeIds = normalizeStringArray(parsed.data.node_ids);
@@ -9313,6 +9774,36 @@ async function heuristicProceduralTitle(workflow, stepTitles, provider) {
 function insightPagePath(tier, slugSource) {
   return `insights/${tier}/${slugify(slugSource)}.md`;
 }
+function extractStoredPageTags(stored) {
+  try {
+    const parsed = matter4(stored.content);
+    const raw = parsed.data?.tags;
+    if (!Array.isArray(raw)) return [];
+    return raw.filter((value) => typeof value === "string" && value.length > 0);
+  } catch {
+    return [];
+  }
+}
+function sortDerivedTagsForInsight(tags, leaders) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const tag of tags) {
+    if (!tag || seen.has(tag)) continue;
+    seen.add(tag);
+    deduped.push(tag);
+  }
+  const pinned = [];
+  const rest = [];
+  for (const tag of deduped) {
+    if (leaders.includes(tag)) continue;
+    rest.push(tag);
+  }
+  for (const leader of leaders) {
+    if (seen.has(leader)) pinned.push(leader);
+  }
+  rest.sort((left, right) => left.localeCompare(right));
+  return [...pinned, ...rest];
+}
 function buildConsolidatedPage(input) {
   const { tier, title, summary, relativePath, sourcePages, confidence, now } = input;
   const pageId = `insight:${slugify(`${tier}-${relativePath.replace(/^insights\//, "").replace(/\.md$/, "")}`)}`;
@@ -9322,11 +9813,16 @@ function buildConsolidatedPage(input) {
   const relatedPageIds = sourcePages.map((page2) => page2.id);
   const consolidatedFromPageIds = sourcePages.map((page2) => page2.id);
   const createdAt = now.toISOString();
+  const leaderTags = ["insight", tier];
+  const projectTags = projectIds.map((projectId) => `project/${projectId}`);
+  const inheritedTags = (input.inheritedTags ?? []).filter((tag) => typeof tag === "string" && tag.length > 0);
+  const tags = sortDerivedTagsForInsight([...leaderTags, ...projectTags, ...inheritedTags], leaderTags);
   const frontmatter = {
     page_id: pageId,
     title,
     kind: "insight",
     tier,
+    tags,
     consolidated_from_page_ids: consolidatedFromPageIds,
     consolidation_confidence: Math.max(0, Math.min(1, confidence)),
     source_ids: sourceIds,
@@ -9389,7 +9885,7 @@ function buildConsolidatedPage(input) {
 async function markSourcePagesSuperseded(wikiDir, sourcePages, newPageId) {
   const updatedPaths = [];
   for (const stored of sourcePages) {
-    const absolutePath = path7.join(wikiDir, stored.page.path);
+    const absolutePath = path8.join(wikiDir, stored.page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
@@ -9405,8 +9901,8 @@ async function markSourcePagesSuperseded(wikiDir, sourcePages, newPageId) {
   return updatedPaths;
 }
 async function writeConsolidatedPage(wikiDir, relativePath, content) {
-  const absolutePath = path7.join(wikiDir, relativePath);
-  await ensureDir(path7.dirname(absolutePath));
+  const absolutePath = path8.join(wikiDir, relativePath);
+  await ensureDir(path8.dirname(absolutePath));
   return writeFileIfChanged(absolutePath, content);
 }
 async function runConsolidation(rootDir, config = {}, provider, options = {}) {
@@ -9458,6 +9954,7 @@ async function runConsolidation(rootDir, config = {}, provider, options = {}) {
       summary: titleSummary.summary,
       relativePath,
       sourcePages: groupPages,
+      inheritedTags: group.pages.flatMap((stored) => extractStoredPageTags(stored)),
       confidence,
       now
     });
@@ -9496,10 +9993,11 @@ async function runConsolidation(rootDir, config = {}, provider, options = {}) {
       summary: titleSummary.summary,
       relativePath,
       sourcePages: pages.map((stored) => stored.page),
+      inheritedTags: pages.flatMap((stored) => extractStoredPageTags(stored)),
       confidence,
       now
     });
-    const existingPath = path7.join(wikiDir, relativePath);
+    const existingPath = path8.join(wikiDir, relativePath);
     if (await fileExists(existingPath)) {
       decisions.push(`  skip: semantic page already exists for node ${nodeId}`);
       continue;
@@ -9548,10 +10046,11 @@ async function runConsolidation(rootDir, config = {}, provider, options = {}) {
       summary: titleSummary.summary,
       relativePath,
       sourcePages: ordered.map((stored) => stored.page),
+      inheritedTags: ordered.flatMap((stored) => extractStoredPageTags(stored)),
       confidence,
       now
     });
-    const existingPath = path7.join(wikiDir, relativePath);
+    const existingPath = path8.join(wikiDir, relativePath);
     if (await fileExists(existingPath)) {
       decisions.push(`  skip: procedural page already exists for workflow ${workflow}`);
       continue;
@@ -9588,7 +10087,7 @@ async function runConsolidation(rootDir, config = {}, provider, options = {}) {
 
 // src/freshness.ts
 import fs8 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 import matter5 from "gray-matter";
 var DEFAULT_HALF_LIFE_DAYS = 365;
 var DEFAULT_STALE_THRESHOLD = 0.3;
@@ -9729,7 +10228,7 @@ async function persistDecayFrontmatter(wikiDir, pages) {
     if (page.managedBy === "human") {
       continue;
     }
-    const absolutePath = path8.join(wikiDir, page.path);
+    const absolutePath = path9.join(wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
@@ -9775,7 +10274,7 @@ async function runDecayPass(input) {
 import { readFileSync } from "fs";
 import fs9 from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import path9 from "path";
+import path10 from "path";
 import matter6 from "gray-matter";
 
 // src/graph-interchange.ts
@@ -9843,7 +10342,8 @@ function normalizeSwarmNodeProps(node, page) {
     ...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 } : {}
+    ...node.isGodNode !== void 0 ? { isGodNode: node.isGodNode } : {},
+    ...node.surpriseReason ? { surpriseReason: node.surpriseReason } : {}
   };
 }
 function normalizeHyperedgeNodeProps(hyperedge) {
@@ -9915,6 +10415,30 @@ function graphCounts(graph) {
 function htmlEscape(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
+var SOURCE_CLASS_LABELS2 = {
+  first_party: "First-party",
+  third_party: "Third-party",
+  resource: "Resource",
+  generated: "Generated"
+};
+function renderBenchmarkByClassSection(report) {
+  const byClass = report?.benchmark?.byClass;
+  if (!byClass) {
+    return "";
+  }
+  const rows = ALL_SOURCE_CLASSES.map((sourceClass) => {
+    const entry = byClass[sourceClass];
+    const reductionPct = (entry.reductionRatio * 100).toFixed(1);
+    return `<tr><td>${htmlEscape(SOURCE_CLASS_LABELS2[sourceClass])}</td><td>${entry.sourceCount}</td><td>${entry.pageCount}</td><td>${entry.nodeCount}</td><td>${entry.godNodeCount}</td><td>${entry.naiveCorpusTokens}</td><td>${entry.finalContextTokens}</td><td>${reductionPct}%</td></tr>`;
+  }).join("\n");
+  return `<h2>Benchmark By Source Class</h2>
+<table>
+<thead><tr><th>Class</th><th>Sources</th><th>Pages</th><th>Nodes</th><th>God Nodes</th><th>Naive Tokens</th><th>Guided Tokens</th><th>Reduction</th></tr></thead>
+<tbody>
+${rows}
+</tbody>
+</table>`;
+}
 function nodeTypeColor(type) {
   const colors = {
     source: "#f59e0b",
@@ -10188,6 +10712,8 @@ ${warnings.length ? `<h2>Warnings</h2>
 ${warnings.map((w) => `<li>${htmlEscape(w)}</li>`).join("\n")}
 </ul>` : ""}
 
+${renderBenchmarkByClassSection(report)}
+
 <h2>Pages</h2>
 <input type="text" id="page-filter" placeholder="Filter pages..." />
 <div id="pages-container">
@@ -10226,11 +10752,43 @@ var _visNetworkJs;
 function loadVisNetworkJs() {
   if (!_visNetworkJs) {
     const require3 = createRequire2(import.meta.url);
-    const pkgDir = path9.dirname(require3.resolve("vis-network/package.json"));
-    _visNetworkJs = readFileSync(path9.join(pkgDir, "standalone/umd/vis-network.min.js"), "utf8");
+    const pkgDir = path10.dirname(require3.resolve("vis-network/package.json"));
+    _visNetworkJs = readFileSync(path10.join(pkgDir, "standalone/umd/vis-network.min.js"), "utf8");
   }
   return _visNetworkJs;
 }
+function synthesizeHyperedgeHubs(hyperedges, nodes) {
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  const hubNodes = [];
+  const hubEdges = [];
+  for (const hyperedge of hyperedges) {
+    const participantIds = hyperedge.nodeIds.filter((nodeId) => nodeIds.has(nodeId));
+    if (participantIds.length < 2) continue;
+    const hubId = `hyper:${hyperedge.id}`;
+    hubNodes.push({
+      id: hubId,
+      hyperedgeId: hyperedge.id,
+      label: hyperedge.relation,
+      relation: hyperedge.relation,
+      participantIds,
+      confidence: hyperedge.confidence ?? 0,
+      evidenceClass: hyperedge.evidenceClass ?? "inferred",
+      why: hyperedge.why ?? ""
+    });
+    for (const participantId of participantIds) {
+      hubEdges.push({
+        id: `hyper-edge:${hyperedge.id}:${participantId}`,
+        hyperedgeId: hyperedge.id,
+        source: hubId,
+        target: participantId,
+        relation: hyperedge.relation,
+        confidence: hyperedge.confidence ?? 0,
+        evidenceClass: hyperedge.evidenceClass ?? "inferred"
+      });
+    }
+  }
+  return { hubNodes, hubEdges };
+}
 function hexToObsidianColor(hex) {
   return { a: 1, rgb: Number.parseInt(hex.replace("#", ""), 16) };
 }
@@ -10637,7 +11195,8 @@ function renderHtmlStandalone(graph) {
     bridgeScore: node.bridgeScore ?? null,
     confidence: node.confidence ?? null,
     sourceClass: node.sourceClass ?? null,
-    tags: node.tags ?? []
+    tags: node.tags ?? [],
+    pageId: node.pageId ?? null
   }));
   const edgesData = cappedEdges.map((edge) => ({
     id: edge.id,
@@ -10652,10 +11211,67 @@ function renderHtmlStandalone(graph) {
     label: c.label,
     nodeIds: c.nodeIds
   }));
+  const corePagesData = graph.pages.filter((page) => page.nodeIds.some((nodeId) => cappedNodeIds.has(nodeId))).map((page) => ({ id: page.id, path: page.path, title: page.title }));
+  const coreHyperedgesData = (graph.hyperedges ?? []).filter((hyperedge) => hyperedge.nodeIds.some((nodeId) => cappedNodeIds.has(nodeId))).map((hyperedge) => ({
+    id: hyperedge.id,
+    label: hyperedge.label,
+    relation: hyperedge.relation,
+    nodeIds: hyperedge.nodeIds,
+    confidence: hyperedge.confidence,
+    evidenceClass: hyperedge.evidenceClass,
+    why: hyperedge.why
+  }));
+  const coreNodesData = cappedNodes.map((node) => ({
+    id: node.id,
+    label: node.label,
+    type: node.type,
+    pageId: node.pageId ?? null,
+    communityId: node.communityId ?? null,
+    degree: node.degree ?? 0,
+    confidence: node.confidence ?? null
+  }));
+  const coreEdgesData = cappedEdges.map((edge) => ({
+    id: edge.id,
+    source: edge.source,
+    target: edge.target,
+    relation: edge.relation,
+    evidenceClass: edge.evidenceClass,
+    confidence: edge.confidence
+  }));
+  const { hubNodes, hubEdges } = synthesizeHyperedgeHubs(graph.hyperedges ?? [], cappedNodes);
+  const hubNodesData = hubNodes.map((hub) => ({
+    id: hub.id,
+    label: hub.label,
+    type: "hyperedge",
+    isHub: true,
+    hyperedgeId: hub.hyperedgeId,
+    relation: hub.relation,
+    confidence: hub.confidence,
+    evidenceClass: hub.evidenceClass
+  }));
+  const hubEdgesData = hubEdges.map((edge) => ({
+    id: edge.id,
+    from: edge.source,
+    to: edge.target,
+    relation: edge.relation,
+    evidenceClass: edge.evidenceClass,
+    confidence: edge.confidence,
+    isHubEdge: true,
+    hyperedgeId: edge.hyperedgeId
+  }));
   const graphJson = JSON.stringify({
-    nodes: nodesData,
-    edges: edgesData,
-    communities: communitiesData
+    nodes: [...nodesData, ...hubNodesData],
+    edges: [...edgesData, ...hubEdgesData],
+    communities: communitiesData,
+    // Core payload for the inline query/path/explain runtime. Kept separate
+    // from the vis.js payload so hub scaffolding never leaks into traversal.
+    core: {
+      nodes: coreNodesData,
+      edges: coreEdgesData,
+      pages: corePagesData,
+      hyperedges: coreHyperedgesData,
+      communities: communitiesData
+    }
   });
   return `<!doctype html>
 <html lang="en">
@@ -10681,6 +11297,21 @@ function renderHtmlStandalone(graph) {
     #legend .item { display: flex; align-items: center; gap: 6px; font-size: 12px; margin: 3px 0; }
     #legend .dot { width: 10px; height: 10px; border-radius: 50%; }
     #stats { position: absolute; top: 12px; right: 340px; z-index: 10; background: #1e293b; padding: 8px 12px; border-radius: 6px; font-size: 12px; color: #94a3b8; border: 1px solid #334155; }
+    #tools { position: absolute; top: 52px; left: 12px; z-index: 10; width: 300px; background: #1e293b; padding: 12px; border-radius: 8px; border: 1px solid #334155; max-height: calc(100vh - 80px); overflow-y: auto; }
+    #tools h3 { font-size: 13px; color: #f8fafc; margin-bottom: 6px; font-weight: 600; letter-spacing: 0.04em; text-transform: uppercase; }
+    #tools .panel { border-top: 1px solid #334155; padding-top: 10px; margin-top: 10px; }
+    #tools .panel:first-of-type { border-top: none; margin-top: 0; padding-top: 0; }
+    #tools .row { display: flex; gap: 6px; margin-bottom: 6px; }
+    #tools .row.radio { gap: 12px; font-size: 12px; color: #cbd5e1; }
+    #tools input[type=text] { flex: 1; padding: 6px 8px; border-radius: 4px; border: 1px solid #475569; background: #0f172a; color: #e2e8f0; font-size: 12px; }
+    #tools button { padding: 6px 10px; border-radius: 4px; border: 1px solid #475569; background: #334155; color: #e2e8f0; font-size: 12px; cursor: pointer; }
+    #tools button:hover { background: #475569; }
+    #tools .result { font-size: 12px; color: #cbd5e1; margin-top: 6px; line-height: 1.4; white-space: pre-wrap; }
+    #tools .result .hdr { color: #f8fafc; font-weight: 600; margin-top: 6px; }
+    #tools .result ol, #tools .result ul { padding-left: 18px; margin: 4px 0; }
+    #tools .result .item { color: #38bdf8; cursor: pointer; text-decoration: underline; }
+    #tools .result .relation { color: #94a3b8; font-size: 11px; }
+    #tools .result .error { color: #f87171; }
   </style>
 </head>
 <body>
@@ -10692,6 +11323,41 @@ function renderHtmlStandalone(graph) {
     <div id="sidebarFields"></div>
     <div class="neighbors" id="sidebarNeighbors"></div>
   </div>
+  <div id="tools" data-testid="graph-tools">
+    <section class="panel" data-testid="graph-query-panel">
+      <h3>Query</h3>
+      <div class="row">
+        <input type="text" id="queryInput" data-testid="graph-query-input" placeholder="Ask a question about the graph..." />
+        <button type="button" id="queryRun" data-testid="graph-query-run">Run</button>
+      </div>
+      <div class="row radio">
+        <label><input type="radio" name="queryTraversal" value="bfs" checked /> BFS</label>
+        <label><input type="radio" name="queryTraversal" value="dfs" /> DFS</label>
+      </div>
+      <div class="result" id="queryResult" data-testid="graph-query-result"></div>
+    </section>
+    <section class="panel" data-testid="graph-path-panel">
+      <h3>Path</h3>
+      <div class="row">
+        <input type="text" id="pathFrom" data-testid="graph-path-from" placeholder="From node id or label..." />
+      </div>
+      <div class="row">
+        <input type="text" id="pathTo" data-testid="graph-path-to" placeholder="To node id or label..." />
+      </div>
+      <div class="row">
+        <button type="button" id="pathFind" data-testid="graph-path-find">Find</button>
+      </div>
+      <div class="result" id="pathResult" data-testid="graph-path-result"></div>
+    </section>
+    <section class="panel" data-testid="graph-explain-panel">
+      <h3>Explain</h3>
+      <div class="row">
+        <input type="text" id="explainInput" data-testid="graph-explain-input" placeholder="Node id or label..." />
+        <button type="button" id="explainRun" data-testid="graph-explain-run">Explain</button>
+      </div>
+      <div class="result" id="explainResult" data-testid="graph-explain-result"></div>
+    </section>
+  </div>
   <div id="legend"></div>
   <script>
     var GRAPH_DATA = ${graphJson};
@@ -10722,6 +11388,22 @@ function renderHtmlStandalone(graph) {
     GRAPH_DATA.nodes.forEach(function(n) { nodeMap[n.id] = n; });
 
     var visNodes = new vis.DataSet(GRAPH_DATA.nodes.map(function(n) {
+      if (n.isHub) {
+        // Hub nodes are viewer-only scaffolding \u2014 keep them small, dashed,
+        // and painted with a secondary accent so they read as grouping
+        // glue rather than first-class entities.
+        return {
+          id: n.id,
+          label: n.label,
+          shape: "dot",
+          color: { background: "#0f172a", border: "#a78bfa" },
+          size: 10,
+          font: { color: "#c4b5fd", size: 10 },
+          borderWidth: 2,
+          borderWidthSelected: 3,
+          shapeProperties: { borderDashes: [4, 3] }
+        };
+      }
       var size = 8 + Math.min(32, n.degree * 2);
       return {
         id: n.id,
@@ -10734,6 +11416,17 @@ function renderHtmlStandalone(graph) {
     }));
 
     var visEdges = new vis.DataSet(GRAPH_DATA.edges.map(function(e) {
+      if (e.isHubEdge) {
+        return {
+          id: e.id,
+          from: e.from,
+          to: e.to,
+          color: { color: "#a78bfa", opacity: 0.5 },
+          width: 1,
+          dashes: [4, 3],
+          arrows: { to: { enabled: false } }
+        };
+      }
       var dashed = (e.evidenceClass === "inferred" || e.evidenceClass === "ambiguous");
       return {
         id: e.id,
@@ -10833,44 +11526,555 @@ function renderHtmlStandalone(graph) {
           link.textContent = nbLabel + " (" + nb.relation + ")";
           sidebarNeighbors.appendChild(link);
         });
-      } else {
-        renderField(sidebarNeighbors, "Neighbors", "none");
+      } else {
+        renderField(sidebarNeighbors, "Neighbors", "none");
+      }
+
+      sidebar.classList.add("open");
+    });
+
+    sidebarNeighbors.addEventListener("click", function(e) {
+      var target = e.target;
+      while (target && target !== sidebarNeighbors) {
+        if (target.dataset && target.dataset.nodeId) {
+          var nid = target.dataset.nodeId;
+          network.selectNodes([nid]);
+          network.focus(nid, { scale: 1.2, animation: { duration: 400 } });
+          network.body.emitter.emit("click", { nodes: [nid] });
+          return;
+        }
+        target = target.parentElement;
+      }
+    });
+
+    document.getElementById("searchInput").addEventListener("input", function() {
+      var query = this.value.toLowerCase().trim();
+      if (!query) {
+        visNodes.forEach(function(n) {
+          visNodes.update({ id: n.id, opacity: 1.0, font: { color: "#e2e8f0", size: 11 } });
+        });
+        return;
+      }
+      visNodes.forEach(function(n) {
+        var match = n.label.toLowerCase().indexOf(query) !== -1;
+        visNodes.update({
+          id: n.id,
+          opacity: match ? 1.0 : 0.15,
+          font: { color: match ? "#f8fafc" : "#475569", size: match ? 13 : 9 }
+        });
+      });
+    });
+
+    // ---------------------------------------------------------------------
+    // Embedded graph query/path/explain runtime.
+    //
+    // Dependency-free port of the graph-query-core helpers that the live
+    // graph serve / MCP surface uses. Operates only on the GRAPH_DATA.core
+    // payload (real nodes/edges/pages/hyperedges/communities) so viewer-only
+    // hub scaffolding never leaks into traversal. No network calls; no
+    // provider-backed features.
+    // ---------------------------------------------------------------------
+    var CORE = GRAPH_DATA.core;
+    var CORE_NODE_TYPE_PRIORITY = { concept: 6, entity: 5, source: 4, module: 3, symbol: 2, rationale: 1 };
+
+    function coreNormalize(value) {
+      if (value == null) return "";
+      return String(value).replace(/\\s+/g, " ").trim().normalize("NFKD").replace(/[\\u0300-\\u036f]+/g, "").toLowerCase();
+    }
+
+    function coreScore(query, candidate) {
+      var q = coreNormalize(query);
+      var c = coreNormalize(candidate);
+      if (!q || !c) return 0;
+      if (c === q) return 100;
+      if (c.indexOf(q) === 0) return 80;
+      if (c.indexOf(q) !== -1) return 60;
+      var qTokens = q.split(/\\s+/).filter(Boolean);
+      var cTokens = {};
+      c.split(/\\s+/).filter(Boolean).forEach(function(tok) { cTokens[tok] = true; });
+      var overlap = 0;
+      qTokens.forEach(function(tok) { if (cTokens[tok]) overlap++; });
+      return overlap ? overlap * 10 : 0;
+    }
+
+    function coreUnique(values) {
+      var seen = {};
+      var out = [];
+      for (var i = 0; i < values.length; i++) {
+        var v = values[i];
+        if (!v) continue;
+        if (seen[v]) continue;
+        seen[v] = true;
+        out.push(v);
+      }
+      return out;
+    }
+
+    function coreBuildAdjacency() {
+      var adj = {};
+      function push(id, item) {
+        if (!adj[id]) adj[id] = [];
+        adj[id].push(item);
+      }
+      for (var i = 0; i < CORE.edges.length; i++) {
+        var edge = CORE.edges[i];
+        push(edge.source, { edge: edge, nodeId: edge.target, direction: "outgoing" });
+        push(edge.target, { edge: edge, nodeId: edge.source, direction: "incoming" });
+      }
+      Object.keys(adj).forEach(function(nid) {
+        adj[nid].sort(function(a, b) {
+          return (b.edge.confidence - a.edge.confidence) || a.edge.relation.localeCompare(b.edge.relation);
+        });
+      });
+      return adj;
+    }
+
+    var CORE_ADJ = coreBuildAdjacency();
+    var CORE_NODE_BY_ID = {};
+    CORE.nodes.forEach(function(n) { CORE_NODE_BY_ID[n.id] = n; });
+    var CORE_PAGE_BY_ID = {};
+    (CORE.pages || []).forEach(function(p) { CORE_PAGE_BY_ID[p.id] = p; });
+    var CORE_COMM_BY_ID = {};
+    (CORE.communities || []).forEach(function(c) { CORE_COMM_BY_ID[c.id] = c; });
+
+    function coreCompareLabel(a, b) {
+      var pa = CORE_NODE_TYPE_PRIORITY[a.type] || 0;
+      var pb = CORE_NODE_TYPE_PRIORITY[b.type] || 0;
+      if (pb !== pa) return pb - pa;
+      var da = a.degree || 0;
+      var db = b.degree || 0;
+      if (db !== da) return db - da;
+      return a.id.localeCompare(b.id);
+    }
+
+    function coreResolveNode(target) {
+      if (CORE_NODE_BY_ID[target]) return CORE_NODE_BY_ID[target];
+      var normalized = coreNormalize(target);
+      var labelMatches = CORE.nodes.filter(function(n) {
+        return coreNormalize(n.label) === normalized || coreNormalize(n.id) === normalized;
+      });
+      if (labelMatches.length) {
+        return labelMatches.slice().sort(coreCompareLabel)[0];
+      }
+      var pageHit = (CORE.pages || [])
+        .map(function(p) {
+          return { page: p, score: Math.max(coreScore(target, p.title), coreScore(target, p.path)) };
+        })
+        .filter(function(item) { return item.score > 0; })
+        .sort(function(left, right) {
+          return (right.score - left.score) || left.page.title.localeCompare(right.page.title);
+        })[0];
+      if (pageHit) {
+        var primary = CORE.nodes.filter(function(n) { return n.pageId === pageHit.page.id; })[0];
+        if (primary) return primary;
+      }
+      var fuzzy = CORE.nodes
+        .map(function(n) { return { node: n, score: Math.max(coreScore(target, n.label), coreScore(target, n.id)) }; })
+        .filter(function(item) { return item.score > 0; })
+        .sort(function(left, right) {
+          return (right.score - left.score) || coreCompareLabel(left.node, right.node);
+        })[0];
+      return fuzzy ? fuzzy.node : undefined;
+    }
+
+    function coreUniqueMatches(matches) {
+      var seen = {};
+      var out = [];
+      for (var i = 0; i < matches.length; i++) {
+        var m = matches[i];
+        var key = m.type + ":" + m.id;
+        if (seen[key]) continue;
+        seen[key] = true;
+        out.push(m);
+      }
+      return out;
+    }
+
+    function runGraphQuery(question, traversalOpt, budgetOpt) {
+      var traversal = traversalOpt === "dfs" ? "dfs" : "bfs";
+      var budget = Math.max(3, Math.min((budgetOpt != null ? budgetOpt : 12), 50));
+      var pageMatches = (CORE.pages || [])
+        .map(function(p) { return { type: "page", id: p.id, label: p.title, score: Math.max(coreScore(question, p.title), coreScore(question, p.path)) }; })
+        .filter(function(m) { return m.score > 0; });
+      var nodeMatches = CORE.nodes
+        .map(function(n) { return { type: "node", id: n.id, label: n.label, score: Math.max(coreScore(question, n.label), coreScore(question, n.id)) }; })
+        .filter(function(m) { return m.score > 0; });
+      var hyperMatches = (CORE.hyperedges || [])
+        .map(function(h) { return { type: "hyperedge", id: h.id, label: h.label, score: Math.max(coreScore(question, h.label), coreScore(question, h.why || ""), coreScore(question, h.relation)) }; })
+        .filter(function(m) { return m.score > 0; });
+      var matches = coreUniqueMatches(pageMatches.concat(nodeMatches).concat(hyperMatches))
+        .sort(function(a, b) { return (b.score - a.score) || a.label.localeCompare(b.label); })
+        .slice(0, 12);
+
+      var nodesByPageId = {};
+      CORE.nodes.forEach(function(n) {
+        if (!n.pageId) return;
+        if (!nodesByPageId[n.pageId]) nodesByPageId[n.pageId] = [];
+        nodesByPageId[n.pageId].push(n.id);
+      });
+
+      var seedList = [];
+      matches.forEach(function(m) {
+        if (m.type === "page") {
+          (nodesByPageId[m.id] || []).forEach(function(id) { seedList.push(id); });
+        } else if (m.type === "node") {
+          seedList.push(m.id);
+        } else if (m.type === "hyperedge") {
+          var hy = (CORE.hyperedges || []).filter(function(h) { return h.id === m.id; })[0];
+          if (hy) hy.nodeIds.forEach(function(id) { seedList.push(id); });
+        }
+      });
+      var seeds = coreUnique(seedList);
+
+      var visitedNodeIds = [];
+      var visitedEdgeIds = {};
+      var seen = {};
+      var frontier = seeds.slice();
+      while (frontier.length && visitedNodeIds.length < budget) {
+        var current = traversal === "dfs" ? frontier.pop() : frontier.shift();
+        if (!current || seen[current]) continue;
+        seen[current] = true;
+        visitedNodeIds.push(current);
+        var adj = CORE_ADJ[current] || [];
+        for (var i = 0; i < adj.length; i++) {
+          var nb = adj[i];
+          visitedEdgeIds[nb.edge.id] = true;
+          if (!seen[nb.nodeId]) frontier.push(nb.nodeId);
+          if (visitedNodeIds.length + frontier.length >= budget * 2) break;
+        }
+      }
+
+      var pageIdsList = [];
+      matches.forEach(function(m) { if (m.type === "page") pageIdsList.push(m.id); });
+      visitedNodeIds.forEach(function(nid) {
+        var n = CORE_NODE_BY_ID[nid];
+        if (n && n.pageId) pageIdsList.push(n.pageId);
+      });
+      var pageIds = coreUnique(pageIdsList);
+      var communities = coreUnique(
+        visitedNodeIds.map(function(nid) { return CORE_NODE_BY_ID[nid] && CORE_NODE_BY_ID[nid].communityId; }).filter(Boolean)
+      );
+      var hyperedgeIds = coreUnique(
+        (CORE.hyperedges || [])
+          .filter(function(h) { return h.nodeIds.some(function(nid) { return visitedNodeIds.indexOf(nid) !== -1; }); })
+          .map(function(h) { return h.id; })
+      );
+      var seedPageIds = coreUnique(matches.filter(function(m) { return m.type === "page"; }).map(function(m) { return m.id; }));
+      var visitedEdgeIdList = Object.keys(visitedEdgeIds);
+
+      var summary = [
+        "Seeds: " + (seeds.join(", ") || "none"),
+        "Visited nodes: " + visitedNodeIds.length,
+        "Visited edges: " + visitedEdgeIdList.length,
+        "Touched group patterns: " + hyperedgeIds.length,
+        "Communities: " + (communities.join(", ") || "none"),
+        "Pages: " + (pageIds.join(", ") || "none")
+      ].join("\\n");
+
+      return {
+        question: question,
+        traversal: traversal,
+        seedNodeIds: seeds,
+        seedPageIds: seedPageIds,
+        visitedNodeIds: visitedNodeIds,
+        visitedEdgeIds: visitedEdgeIdList,
+        hyperedgeIds: hyperedgeIds,
+        pageIds: pageIds,
+        communities: communities,
+        matches: matches,
+        summary: summary
+      };
+    }
+
+    function runGraphPath(from, to) {
+      var start = coreResolveNode(from);
+      var end = coreResolveNode(to);
+      if (!start || !end) {
+        return {
+          from: from,
+          to: to,
+          resolvedFromNodeId: start ? start.id : undefined,
+          resolvedToNodeId: end ? end.id : undefined,
+          found: false,
+          nodeIds: [],
+          edgeIds: [],
+          pageIds: [],
+          summary: "Could not resolve one or both graph targets."
+        };
+      }
+      var queue = [start.id];
+      var visited = {}; visited[start.id] = true;
+      var previous = {};
+      while (queue.length) {
+        var current = queue.shift();
+        if (current === end.id) break;
+        var adj = CORE_ADJ[current] || [];
+        for (var i = 0; i < adj.length; i++) {
+          var nb = adj[i];
+          if (visited[nb.nodeId]) continue;
+          visited[nb.nodeId] = true;
+          previous[nb.nodeId] = { nodeId: current, edgeId: nb.edge.id };
+          queue.push(nb.nodeId);
+        }
+      }
+      if (!visited[end.id]) {
+        return {
+          from: from,
+          to: to,
+          resolvedFromNodeId: start.id,
+          resolvedToNodeId: end.id,
+          found: false,
+          nodeIds: [],
+          edgeIds: [],
+          pageIds: [],
+          summary: "No path found between " + start.label + " and " + end.label + "."
+        };
+      }
+      var nodeIds = [];
+      var edgeIds = [];
+      var cursor = end.id;
+      while (cursor !== start.id) {
+        nodeIds.push(cursor);
+        var prev = previous[cursor];
+        if (!prev) break;
+        edgeIds.push(prev.edgeId);
+        cursor = prev.nodeId;
+      }
+      nodeIds.push(start.id);
+      nodeIds.reverse();
+      edgeIds.reverse();
+      var pageIds = coreUnique(nodeIds.map(function(nid) { return CORE_NODE_BY_ID[nid] && CORE_NODE_BY_ID[nid].pageId; }).filter(Boolean));
+      var summary = nodeIds.map(function(nid) { return (CORE_NODE_BY_ID[nid] && CORE_NODE_BY_ID[nid].label) || nid; }).join(" -> ");
+      return {
+        from: from,
+        to: to,
+        resolvedFromNodeId: start.id,
+        resolvedToNodeId: end.id,
+        found: true,
+        nodeIds: nodeIds,
+        edgeIds: edgeIds,
+        pageIds: pageIds,
+        summary: summary
+      };
+    }
+
+    function runGraphExplain(target) {
+      var node = coreResolveNode(target);
+      if (!node) return undefined;
+      var neighbors = [];
+      var adj = CORE_ADJ[node.id] || [];
+      for (var i = 0; i < adj.length; i++) {
+        var nb = adj[i];
+        var t = CORE_NODE_BY_ID[nb.nodeId];
+        if (!t) continue;
+        neighbors.push({
+          nodeId: t.id,
+          label: t.label,
+          type: t.type,
+          pageId: t.pageId || undefined,
+          relation: nb.edge.relation,
+          direction: nb.direction,
+          confidence: nb.edge.confidence,
+          evidenceClass: nb.edge.evidenceClass
+        });
+      }
+      neighbors.sort(function(a, b) { return (b.confidence - a.confidence) || a.label.localeCompare(b.label); });
+      var page = node.pageId ? CORE_PAGE_BY_ID[node.pageId] : undefined;
+      var community = node.communityId ? CORE_COMM_BY_ID[node.communityId] : undefined;
+      var hyperedges = (CORE.hyperedges || [])
+        .filter(function(h) { return h.nodeIds.indexOf(node.id) !== -1; })
+        .slice()
+        .sort(function(a, b) { return (b.confidence - a.confidence) || a.label.localeCompare(b.label); });
+      var summary = [
+        "Node: " + node.label,
+        "Type: " + node.type,
+        "Community: " + (node.communityId || "none"),
+        "Neighbors: " + neighbors.length,
+        "Group patterns: " + hyperedges.length,
+        "Page: " + (page ? page.path : "none")
+      ].join("\\n");
+      return {
+        target: target,
+        node: node,
+        page: page,
+        community: community ? { id: community.id, label: community.label } : undefined,
+        neighbors: neighbors,
+        hyperedges: hyperedges,
+        summary: summary
+      };
+    }
+
+    // Expose helpers for test harnesses and browser console introspection.
+    window.runGraphQuery = runGraphQuery;
+    window.runGraphPath = runGraphPath;
+    window.runGraphExplain = runGraphExplain;
+
+    function focusNode(nodeId) {
+      try {
+        network.selectNodes([nodeId]);
+        network.focus(nodeId, { scale: 1.2, animation: { duration: 300 } });
+        network.body.emitter.emit("click", { nodes: [nodeId] });
+      } catch (err) {
+        // ignore \u2014 focus is best effort in static exports
+      }
+    }
+
+    function renderList(parent, items, onClick) {
+      items.forEach(function(entry) {
+        var line = document.createElement("div");
+        line.className = "item";
+        line.textContent = entry.text;
+        line.addEventListener("click", function() { if (onClick) onClick(entry.id); });
+        parent.appendChild(line);
+      });
+    }
+
+    function renderQueryPanel(result) {
+      var host = document.getElementById("queryResult");
+      host.textContent = "";
+      if (!result) return;
+      var summaryEl = document.createElement("div");
+      summaryEl.textContent = result.summary;
+      host.appendChild(summaryEl);
+      if (result.visitedNodeIds.length) {
+        var hdr = document.createElement("div");
+        hdr.className = "hdr";
+        hdr.textContent = "Visited (" + result.traversal.toUpperCase() + ")";
+        host.appendChild(hdr);
+        renderList(host, result.visitedNodeIds.map(function(nid, idx) {
+          var n = CORE_NODE_BY_ID[nid];
+          return { id: nid, text: (idx + 1) + ". " + ((n && n.label) || nid) };
+        }), focusNode);
+      }
+    }
+
+    function renderPathPanel(result) {
+      var host = document.getElementById("pathResult");
+      host.textContent = "";
+      if (!result) return;
+      var summaryEl = document.createElement("div");
+      summaryEl.textContent = result.summary;
+      host.appendChild(summaryEl);
+      if (result.found && result.nodeIds.length) {
+        var edgeById = {};
+        CORE.edges.forEach(function(e) { edgeById[e.id] = e; });
+        var ol = document.createElement("ol");
+        for (var i = 0; i < result.nodeIds.length; i++) {
+          var nid = result.nodeIds[i];
+          var n = CORE_NODE_BY_ID[nid];
+          var li = document.createElement("li");
+          var btn = document.createElement("span");
+          btn.className = "item";
+          btn.textContent = (n && n.label) || nid;
+          (function(targetId) { btn.addEventListener("click", function() { focusNode(targetId); }); })(nid);
+          li.appendChild(btn);
+          if (i < result.edgeIds.length) {
+            var edge = edgeById[result.edgeIds[i]];
+            if (edge) {
+              var rel = document.createElement("span");
+              rel.className = "relation";
+              rel.textContent = "  -[" + edge.relation + "]-> ";
+              li.appendChild(rel);
+            }
+          }
+          ol.appendChild(li);
+        }
+        host.appendChild(ol);
+      }
+    }
+
+    function renderExplainPanel(result, target) {
+      var host = document.getElementById("explainResult");
+      host.textContent = "";
+      if (!result) {
+        var err = document.createElement("div");
+        err.className = "error";
+        err.textContent = "Could not resolve graph target: " + target;
+        host.appendChild(err);
+        return;
+      }
+      var summaryEl = document.createElement("div");
+      summaryEl.textContent = result.summary;
+      host.appendChild(summaryEl);
+      if (result.neighbors.length) {
+        var byRel = {};
+        result.neighbors.forEach(function(nb) {
+          if (!byRel[nb.relation]) byRel[nb.relation] = [];
+          byRel[nb.relation].push(nb);
+        });
+        Object.keys(byRel).sort().forEach(function(rel) {
+          var hdr = document.createElement("div");
+          hdr.className = "hdr";
+          hdr.textContent = rel + " (" + byRel[rel].length + ")";
+          host.appendChild(hdr);
+          renderList(host, byRel[rel].map(function(nb) {
+            var arrow = nb.direction === "incoming" ? "<- " : "-> ";
+            return { id: nb.nodeId, text: arrow + nb.label + "  [" + nb.evidenceClass + ", " + nb.confidence.toFixed(2) + "]" };
+          }), focusNode);
+        });
+      }
+      if (result.community) {
+        var ch = document.createElement("div");
+        ch.className = "hdr";
+        ch.textContent = "Community";
+        host.appendChild(ch);
+        var cb = document.createElement("div");
+        cb.textContent = result.community.label;
+        host.appendChild(cb);
+      }
+      if (result.hyperedges && result.hyperedges.length) {
+        var hh = document.createElement("div");
+        hh.className = "hdr";
+        hh.textContent = "Group Patterns (" + result.hyperedges.length + ")";
+        host.appendChild(hh);
+        result.hyperedges.forEach(function(h) {
+          var line = document.createElement("div");
+          line.textContent = h.label + " [" + h.relation + ", " + h.confidence.toFixed(2) + "]";
+          host.appendChild(line);
+        });
       }
+    }
 
-      sidebar.classList.add("open");
-    });
+    function runPanelQuery() {
+      var question = document.getElementById("queryInput").value.trim();
+      if (!question) {
+        renderQueryPanel(null);
+        return;
+      }
+      var radios = document.getElementsByName("queryTraversal");
+      var traversal = "bfs";
+      for (var i = 0; i < radios.length; i++) {
+        if (radios[i].checked) { traversal = radios[i].value; break; }
+      }
+      renderQueryPanel(runGraphQuery(question, traversal));
+    }
 
-    sidebarNeighbors.addEventListener("click", function(e) {
-      var target = e.target;
-      while (target && target !== sidebarNeighbors) {
-        if (target.dataset && target.dataset.nodeId) {
-          var nid = target.dataset.nodeId;
-          network.selectNodes([nid]);
-          network.focus(nid, { scale: 1.2, animation: { duration: 400 } });
-          network.body.emitter.emit("click", { nodes: [nid] });
-          return;
-        }
-        target = target.parentElement;
+    function runPanelPath() {
+      var from = document.getElementById("pathFrom").value.trim();
+      var to = document.getElementById("pathTo").value.trim();
+      if (!from || !to) {
+        renderPathPanel(null);
+        return;
       }
-    });
+      renderPathPanel(runGraphPath(from, to));
+    }
 
-    document.getElementById("searchInput").addEventListener("input", function() {
-      var query = this.value.toLowerCase().trim();
-      if (!query) {
-        visNodes.forEach(function(n) {
-          visNodes.update({ id: n.id, opacity: 1.0, font: { color: "#e2e8f0", size: 11 } });
-        });
+    function runPanelExplain() {
+      var target = document.getElementById("explainInput").value.trim();
+      if (!target) {
+        renderExplainPanel(null, "");
         return;
       }
-      visNodes.forEach(function(n) {
-        var match = n.label.toLowerCase().indexOf(query) !== -1;
-        visNodes.update({
-          id: n.id,
-          opacity: match ? 1.0 : 0.15,
-          font: { color: match ? "#f8fafc" : "#475569", size: match ? 13 : 9 }
-        });
-      });
-    });
+      renderExplainPanel(runGraphExplain(target), target);
+    }
+
+    document.getElementById("queryRun").addEventListener("click", runPanelQuery);
+    document.getElementById("queryInput").addEventListener("keydown", function(e) { if (e.key === "Enter") runPanelQuery(); });
+    document.getElementById("pathFind").addEventListener("click", runPanelPath);
+    document.getElementById("pathFrom").addEventListener("keydown", function(e) { if (e.key === "Enter") runPanelPath(); });
+    document.getElementById("pathTo").addEventListener("keydown", function(e) { if (e.key === "Enter") runPanelPath(); });
+    document.getElementById("explainRun").addEventListener("click", runPanelExplain);
+    document.getElementById("explainInput").addEventListener("keydown", function(e) { if (e.key === "Enter") runPanelExplain(); });
   </script>
 </body>
 </html>`;
@@ -10884,9 +12088,9 @@ async function loadGraph(rootDir) {
   return graph;
 }
 async function writeGraphExport(outputPath, content) {
-  await ensureDir(path9.dirname(outputPath));
+  await ensureDir(path10.dirname(outputPath));
   await fs9.writeFile(outputPath, content, "utf8");
-  return path9.resolve(outputPath);
+  return path10.resolve(outputPath);
 }
 async function exportGraphFormat(rootDir, format, outputPath) {
   const graph = await loadGraph(rootDir);
@@ -10897,7 +12101,7 @@ async function exportGraphFormat(rootDir, format, outputPath) {
 async function exportGraphReportHtml(rootDir, outputPath) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await loadGraph(rootDir);
-  const report = await readJsonFile(path9.join(paths.wikiDir, "graph", "report.json"));
+  const report = await readJsonFile(path10.join(paths.wikiDir, "graph", "report.json"));
   const html = renderGraphReportHtml(graph, report);
   const resolvedPath = await writeGraphExport(outputPath, html);
   return { format: "report", outputPath: resolvedPath };
@@ -10929,11 +12133,11 @@ function typePluralDir(nodeType) {
 function obsidianNodeSlug(node, pageById2) {
   if (node.pageId) {
     const page = pageById2.get(node.pageId);
-    if (page) return path9.basename(page.path, ".md");
+    if (page) return path10.basename(page.path, ".md");
   }
   return slugify(node.label);
 }
-function buildAdjacency(edges) {
+function buildAdjacency2(edges) {
   const adjacency = /* @__PURE__ */ new Map();
   for (const edge of edges) {
     if (!adjacency.has(edge.source)) adjacency.set(edge.source, []);
@@ -10966,7 +12170,7 @@ async function listFilesRecursive2(dir, base = "") {
   for (const entry of entries) {
     const rel = base ? `${base}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      results.push(...await listFilesRecursive2(path9.join(dir, entry.name), rel));
+      results.push(...await listFilesRecursive2(path10.join(dir, entry.name), rel));
     } else {
       results.push(rel);
     }
@@ -11012,12 +12216,12 @@ function typedLinkFrontmatter(nodeIds, adjacency, nodesById, wikilinkTarget) {
 async function exportObsidianVault(rootDir, outputDir) {
   const graph = await loadGraph(rootDir);
   const { paths } = await loadVaultConfig(rootDir);
-  const resolvedOutputDir = path9.resolve(outputDir);
+  const resolvedOutputDir = path10.resolve(outputDir);
   await ensureDir(resolvedOutputDir);
   const nodesById = graphNodeById(graph);
   const pageById2 = graphPageById(graph);
   const communities = sortedCommunities(graph);
-  const adjacency = buildAdjacency(graph.edges);
+  const adjacency = buildAdjacency2(graph.edges);
   const nodesByPageId = /* @__PURE__ */ new Map();
   for (const node of graph.nodes) {
     if (node.pageId && pageById2.has(node.pageId)) {
@@ -11052,9 +12256,9 @@ async function exportObsidianVault(rootDir, outputDir) {
   const pageByPath = new Map(graph.pages.map((p) => [p.path, p]));
   for (const relPath of wikiFiles) {
     if (!relPath.endsWith(".md")) continue;
-    const srcFile = path9.join(paths.wikiDir, relPath);
-    const destFile = path9.join(resolvedOutputDir, relPath);
-    await ensureDir(path9.dirname(destFile));
+    const srcFile = path10.join(paths.wikiDir, relPath);
+    const destFile = path10.join(resolvedOutputDir, relPath);
+    await ensureDir(path10.dirname(destFile));
     let rawContent;
     try {
       rawContent = await fs9.readFile(srcFile, "utf8");
@@ -11112,9 +12316,9 @@ ${connLines.join("\n")}
   }
   for (const node of orphanNodes) {
     const relPath = orphanFilePath.get(node.id);
-    const destFile = path9.join(resolvedOutputDir, relPath);
-    await ensureDir(path9.dirname(destFile));
-    const slug = path9.basename(relPath, ".md");
+    const destFile = path10.join(resolvedOutputDir, relPath);
+    await ensureDir(path10.dirname(destFile));
+    const slug = path10.basename(relPath, ".md");
     const aliases = node.label !== slug ? [node.label] : [];
     const frontmatter = {
       id: node.id,
@@ -11169,8 +12373,8 @@ ${connLines.join("\n")}
       });
     });
     const communitySlug = deduplicateFileName(safeFileName(community.label), usedCommunityFileNames);
-    const destFile = path9.join(resolvedOutputDir, "graph", "communities", `${communitySlug}.md`);
-    await ensureDir(path9.dirname(destFile));
+    const destFile = path10.join(resolvedOutputDir, "graph", "communities", `${communitySlug}.md`);
+    await ensureDir(path10.dirname(destFile));
     const lines = [`# ${community.label}`, "", "## Members", ""];
     for (const member of memberNodes) {
       const target = wikilinkTarget.get(member.id);
@@ -11202,13 +12406,13 @@ ${connLines.join("\n")}
     await fs9.writeFile(destFile, content, "utf8");
     fileCount++;
   }
-  const outputsAssetsDir = path9.join(paths.wikiDir, "outputs", "assets");
+  const outputsAssetsDir = path10.join(paths.wikiDir, "outputs", "assets");
   try {
     const assetFiles = await listFilesRecursive2(outputsAssetsDir);
     for (const relAsset of assetFiles) {
-      const src = path9.join(outputsAssetsDir, relAsset);
-      const dest = path9.join(resolvedOutputDir, "outputs", "assets", relAsset);
-      await ensureDir(path9.dirname(dest));
+      const src = path10.join(outputsAssetsDir, relAsset);
+      const dest = path10.join(resolvedOutputDir, "outputs", "assets", relAsset);
+      await ensureDir(path10.dirname(dest));
       await fs9.copyFile(src, dest);
       fileCount++;
     }
@@ -11217,15 +12421,15 @@ ${connLines.join("\n")}
   try {
     const rawAssetFiles = await listFilesRecursive2(paths.rawAssetsDir);
     for (const relAsset of rawAssetFiles) {
-      const src = path9.join(paths.rawAssetsDir, relAsset);
-      const dest = path9.join(resolvedOutputDir, "raw", "assets", relAsset);
-      await ensureDir(path9.dirname(dest));
+      const src = path10.join(paths.rawAssetsDir, relAsset);
+      const dest = path10.join(resolvedOutputDir, "raw", "assets", relAsset);
+      await ensureDir(path10.dirname(dest));
       await fs9.copyFile(src, dest);
       fileCount++;
     }
   } catch {
   }
-  const obsidianDir = path9.join(resolvedOutputDir, ".obsidian");
+  const obsidianDir = path10.join(resolvedOutputDir, ".obsidian");
   await ensureDir(obsidianDir);
   const projectIds = Object.keys(
     graph.pages.reduce(
@@ -11250,7 +12454,7 @@ ${connLines.join("\n")}
   }));
   const colorGroups = [...nodeTypeGroups, ...projectColorGroups];
   await fs9.writeFile(
-    path9.join(obsidianDir, "app.json"),
+    path10.join(obsidianDir, "app.json"),
     JSON.stringify(
       { newFileLocation: "folder", newFileFolderPath: "outputs", attachmentFolderPath: "raw/assets", useMarkdownLinks: false },
       null,
@@ -11259,12 +12463,12 @@ ${connLines.join("\n")}
     "utf8"
   );
   await fs9.writeFile(
-    path9.join(obsidianDir, "core-plugins.json"),
+    path10.join(obsidianDir, "core-plugins.json"),
     JSON.stringify(["file-explorer", "global-search", "graph", "backlink", "tag-pane", "page-preview", "outline"], null, 2),
     "utf8"
   );
   await fs9.writeFile(
-    path9.join(obsidianDir, "graph.json"),
+    path10.join(obsidianDir, "graph.json"),
     JSON.stringify(
       { colorGroups, "collapse-filter": false, search: "", showTags: true, showAttachments: false, showOrphans: true },
       null,
@@ -11272,9 +12476,9 @@ ${connLines.join("\n")}
     ),
     "utf8"
   );
-  await fs9.writeFile(path9.join(obsidianDir, "types.json"), JSON.stringify({ types: OBSIDIAN_PROPERTY_TYPES }, null, 2), "utf8");
+  await fs9.writeFile(path10.join(obsidianDir, "types.json"), JSON.stringify({ types: OBSIDIAN_PROPERTY_TYPES }, null, 2), "utf8");
   fileCount += 4;
-  const dashboardDir = path9.join(resolvedOutputDir, "graph", "dashboards");
+  const dashboardDir = path10.join(resolvedOutputDir, "graph", "dashboards");
   await ensureDir(dashboardDir);
   const dvPages = [
     {
@@ -11311,7 +12515,7 @@ ${connLines.join("\n")}
 ${dv.query}
 \`\`\`
 `;
-    await fs9.writeFile(path9.join(dashboardDir, `${dv.name}.md`), matter6.stringify(dvBody, dvFrontmatter), "utf8");
+    await fs9.writeFile(path10.join(dashboardDir, `${dv.name}.md`), matter6.stringify(dvBody, dvFrontmatter), "utf8");
     fileCount++;
   }
   return { format: "obsidian", outputPath: resolvedOutputDir, fileCount };
@@ -11393,13 +12597,13 @@ async function exportObsidianCanvas(rootDir, outputPath) {
           color: COLORS[communityIndex % COLORS.length]
         });
       } else {
-        const communityLabel2 = community.id === "community:unassigned" ? "Unassigned" : community.label;
+        const communityLabel = community.id === "community:unassigned" ? "Unassigned" : community.label;
         canvasNodes.push({
           id: canvasId,
           type: "text",
           text: `**${node.label}**
 Type: ${node.type}
-Community: ${communityLabel2}`,
+Community: ${communityLabel}`,
           x: nodeX,
           y: nodeY,
           width: NODE_WIDTH,
@@ -11434,7 +12638,7 @@ Community: ${communityLabel2}`,
 
 // src/graph-push.ts
 import fs10 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 import neo4j from "neo4j-driver";
 
 // src/benchmark.ts
@@ -11561,6 +12765,37 @@ function defaultBenchmarkQuestionsForGraph(graph, maxQuestions = 3) {
   }
   return uniqueBy(questions, (item) => item).slice(0, normalizedLimit);
 }
+function buildBenchmarkByClass(input) {
+  const entries = {};
+  for (const sourceClass of ALL_SOURCE_CLASSES) {
+    const corpusWords = Math.max(0, Math.round(input.perClassCorpusWords[sourceClass] ?? 0));
+    const corpusTokens = corpusWords > 0 ? Math.max(1, Math.round(corpusWords * (100 / 75))) : 0;
+    const sourceCount = input.graph.sources.filter((source) => source.sourceClass === sourceClass).length;
+    const pageCount = input.graph.pages.filter((page) => page.sourceClass === sourceClass).length;
+    const nodeCount = input.graph.nodes.filter((node) => node.sourceClass === sourceClass).length;
+    const godNodeCount = input.graph.nodes.filter((node) => node.sourceClass === sourceClass && Boolean(node.isGodNode)).length;
+    const perQuestionRaw = input.perClassPerQuestion[sourceClass] ?? [];
+    const perQuestion = perQuestionRaw.filter((entry) => entry.queryTokens > 0).map((entry) => ({
+      ...entry,
+      reduction: corpusTokens > 0 ? Number((1 - entry.queryTokens / Math.max(1, corpusTokens)).toFixed(3)) : 0
+    }));
+    const finalContextTokens = perQuestion.length ? Math.max(1, Math.round(perQuestion.reduce((total, entry) => total + entry.queryTokens, 0) / perQuestion.length)) : 0;
+    const reductionRatio = finalContextTokens && corpusTokens > 0 ? Number((1 - finalContextTokens / Math.max(1, corpusTokens)).toFixed(3)) : 0;
+    entries[sourceClass] = {
+      sourceClass,
+      sourceCount,
+      pageCount,
+      nodeCount,
+      godNodeCount,
+      corpusWords,
+      corpusTokens,
+      finalContextTokens,
+      reductionRatio,
+      perQuestion
+    };
+  }
+  return entries;
+}
 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) => ({
@@ -11581,6 +12816,23 @@ function buildBenchmarkArtifact(input) {
     avgReduction: reductionRatio,
     reductionRatio
   };
+  const emptyPerClassWords = {
+    first_party: 0,
+    third_party: 0,
+    resource: 0,
+    generated: 0
+  };
+  const emptyPerClassQuestions = {
+    first_party: [],
+    third_party: [],
+    resource: [],
+    generated: []
+  };
+  const byClass = input.byClass ?? buildBenchmarkByClass({
+    graph: input.graph,
+    perClassCorpusWords: emptyPerClassWords,
+    perClassPerQuestion: emptyPerClassQuestions
+  });
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     graphHash: graphHash(input.graph),
@@ -11592,7 +12844,8 @@ function buildBenchmarkArtifact(input) {
     reductionRatio,
     sampleQuestions: input.questions,
     perQuestion,
-    summary
+    summary,
+    byClass
   };
 }
 
@@ -11606,8 +12859,8 @@ function requireConfigValue(value, name) {
   throw new Error(`Neo4j push requires ${name}. Configure \`graphSinks.neo4j.${name}\` or pass the matching CLI flag.`);
 }
 async function deriveVaultId(rootDir) {
-  const realRoot = await fs10.realpath(rootDir).catch(() => path10.resolve(rootDir));
-  const label = slugify(path10.basename(realRoot));
+  const realRoot = await fs10.realpath(rootDir).catch(() => path11.resolve(rootDir));
+  const label = slugify(path11.basename(realRoot));
   return `${label}-${sha256(realRoot).slice(0, 12)}`;
 }
 async function resolveNeo4jPushConfig(rootDir, options) {
@@ -11722,7 +12975,7 @@ async function writeSyncNode(session, input) {
       ].join("\n"),
       {
         vaultId: input.vaultId,
-        rootDir: path10.resolve(input.rootDir),
+        rootDir: path11.resolve(input.rootDir),
         graphGeneratedAt: input.graph.generatedAt,
         graphHash: graphHash(input.graph),
         pushedAt: input.pushedAt,
@@ -11809,25 +13062,25 @@ async function pushGraphNeo4j(rootDir, options = {}) {
 
 // src/hooks.ts
 import fs11 from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 import process2 from "process";
 var hookStart = "# >>> swarmvault hook >>>";
 var hookEnd = "# <<< swarmvault hook <<<";
 async function findNearestGitRoot(startPath) {
-  let current = path11.resolve(startPath);
+  let current = path12.resolve(startPath);
   try {
     const stat = await fs11.stat(current);
     if (!stat.isDirectory()) {
-      current = path11.dirname(current);
+      current = path12.dirname(current);
     }
   } catch {
-    current = path11.dirname(current);
+    current = path12.dirname(current);
   }
   while (true) {
-    if (await fileExists(path11.join(current, ".git"))) {
+    if (await fileExists(path12.join(current, ".git"))) {
       return current;
     }
-    const parent = path11.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -11839,8 +13092,8 @@ function shellQuote(value) {
 }
 function resolveSwarmvaultExecutableCandidate() {
   const argvPath = process2.argv[1];
-  if (typeof argvPath === "string" && argvPath.trim() && (argvPath.includes(`${path11.sep}@swarmvaultai${path11.sep}cli${path11.sep}`) || argvPath.includes(`${path11.sep}packages${path11.sep}cli${path11.sep}`))) {
-    return path11.resolve(argvPath);
+  if (typeof argvPath === "string" && argvPath.trim() && (argvPath.includes(`${path12.sep}@swarmvaultai${path12.sep}cli${path12.sep}`) || argvPath.includes(`${path12.sep}packages${path12.sep}cli${path12.sep}`))) {
+    return path12.resolve(argvPath);
   }
   return "swarmvault";
 }
@@ -11859,7 +13112,7 @@ function managedHookBlock(vaultRoot) {
   ].join("\n");
 }
 function hookPath(repoRoot, hookName) {
-  return path11.join(repoRoot, ".git", "hooks", hookName);
+  return path12.join(repoRoot, ".git", "hooks", hookName);
 }
 async function readHookStatus(filePath) {
   if (!await fileExists(filePath)) {
@@ -11883,7 +13136,7 @@ ${block}`.trimEnd();
     next = `#!/bin/sh
 ${block}`.trimEnd();
   }
-  await ensureDir(path11.dirname(filePath));
+  await ensureDir(path12.dirname(filePath));
   await fs11.writeFile(filePath, `${next}
 `, { mode: 493, encoding: "utf8" });
   await fs11.chmod(filePath, 493);
@@ -11926,7 +13179,7 @@ async function installGitHooks(rootDir) {
   if (!repoRoot) {
     throw new Error("No git repository found above the current vault.");
   }
-  const block = managedHookBlock(path11.resolve(rootDir));
+  const block = managedHookBlock(path12.resolve(rootDir));
   await upsertHookFile(hookPath(repoRoot, "post-commit"), block);
   await upsertHookFile(hookPath(repoRoot, "post-checkout"), block);
   return getGitHookStatus(rootDir);
@@ -11960,7 +13213,7 @@ import TurndownService2 from "turndown";
 // src/extraction.ts
 import fs12 from "fs/promises";
 import os2 from "os";
-import path12 from "path";
+import path13 from "path";
 import { Readable } from "stream";
 import { parse as parseCsvSync } from "csv-parse/sync";
 import { strFromU8, unzipSync } from "fflate";
@@ -12003,6 +13256,119 @@ function firstMarkdownHeading(text) {
   }
   return void 0;
 }
+var NON_CODE_RATIONALE_MARKERS = ["NOTE", "WHY", "HACK", "IMPORTANT", "RATIONALE", "TODO", "FIXME", "WARNING", "WARN"];
+var NON_CODE_RATIONALE_MARKER_SET = new Set(NON_CODE_RATIONALE_MARKERS);
+function matchFixedPrefix(text) {
+  const stripped = text.replace(/^[\s>*_\-\u2022\u25CB\u25CF]+/, "").trimStart();
+  if (!stripped) {
+    return null;
+  }
+  const match = /^([A-Za-z]+)[:\-\u2013\u2014]\s+(.+)$/s.exec(stripped);
+  if (!match) {
+    return null;
+  }
+  const upper = match[1].toUpperCase();
+  if (!NON_CODE_RATIONALE_MARKER_SET.has(upper)) {
+    return null;
+  }
+  const remainder = normalizeWhitespace(match[2]).trim();
+  if (!remainder) {
+    return null;
+  }
+  return { marker: upper, remainder };
+}
+function extractRationaleFromMarkdown(content, sourceId) {
+  const nodes = parseMarkdownNodes(content);
+  if (!nodes.length) {
+    return [];
+  }
+  const rationales = [];
+  let currentHeading;
+  const recordMatch = (text) => {
+    const match = matchFixedPrefix(text);
+    if (!match) {
+      return;
+    }
+    rationales.push({
+      id: `rationale:${sourceId}:${rationales.length}`,
+      text: truncate(match.remainder, 280),
+      citation: sourceId,
+      kind: match.marker.toLowerCase(),
+      symbolName: currentHeading
+    });
+  };
+  const visitBlock = (node) => {
+    if (node.type === "heading") {
+      const headingText = markdownNodeText(node).trim();
+      if (headingText) {
+        currentHeading = headingText;
+      }
+      return;
+    }
+    if (node.type === "blockquote") {
+      for (const child of node.children ?? []) {
+        if (child.type === "paragraph") {
+          recordMatch(markdownNodeText(child));
+        } else {
+          visitBlock(child);
+        }
+      }
+      return;
+    }
+    if (node.type === "list") {
+      for (const item of node.children ?? []) {
+        if (item.type !== "listItem") {
+          continue;
+        }
+        const itemParagraphs = [];
+        const nestedLists = [];
+        for (const child of item.children ?? []) {
+          if (child.type === "paragraph") {
+            itemParagraphs.push(markdownNodeText(child));
+          } else if (child.type === "list") {
+            nestedLists.push(child);
+          }
+        }
+        const combined = itemParagraphs.join(" ").trim();
+        if (combined) {
+          recordMatch(combined);
+        }
+        for (const nested of nestedLists) {
+          visitBlock(nested);
+        }
+      }
+    }
+  };
+  for (const node of nodes) {
+    visitBlock(node);
+  }
+  return rationales;
+}
+function extractRationaleFromPlainText(content, sourceId, fallbackSymbolName) {
+  if (!content.trim()) {
+    return [];
+  }
+  const paragraphs = content.split(/\r?\n\s*\r?\n+/);
+  const rationales = [];
+  for (const paragraph of paragraphs) {
+    const normalized = normalizeWhitespace(paragraph);
+    if (!normalized) {
+      continue;
+    }
+    const match = matchFixedPrefix(normalized);
+    if (!match) {
+      continue;
+    }
+    rationales.push({
+      id: `rationale:${sourceId}:${rationales.length}`,
+      text: truncate(match.remainder, 280),
+      citation: sourceId,
+      kind: match.marker.toLowerCase(),
+      symbolName: fallbackSymbolName
+    });
+  }
+  return rationales;
+}
 
 // src/extraction.ts
 var imageVisionExtractionSchema = z.object({
@@ -12083,9 +13449,9 @@ async function materializeAttachmentPath(input) {
   if (!input.bytes) {
     throw new Error("Image extraction requires a file path or bytes.");
   }
-  const tempDir = await fs12.mkdtemp(path12.join(os2.tmpdir(), "swarmvault-image-extract-"));
+  const tempDir = await fs12.mkdtemp(path13.join(os2.tmpdir(), "swarmvault-image-extract-"));
   const extension = input.mimeType.split("/")[1]?.split("+")[0] ?? "bin";
-  const tempPath = path12.join(tempDir, `source.${extension}`);
+  const tempPath = path13.join(tempDir, `source.${extension}`);
   await fs12.writeFile(tempPath, input.bytes);
   return {
     filePath: tempPath,
@@ -12421,7 +13787,7 @@ function zipDirname(value) {
   return index === -1 ? "" : value.slice(0, index);
 }
 function resolveZipTarget(basePath, target) {
-  return path12.posix.normalize(path12.posix.join(zipDirname(basePath), target));
+  return path13.posix.normalize(path13.posix.join(zipDirname(basePath), target));
 }
 function relationshipTargets(xml, basePath) {
   const document = parseXmlDocument(xml);
@@ -12606,7 +13972,7 @@ async function extractJupyterNotebook(input) {
       }
     }
     if (!notebookTitle && input.fileName) {
-      notebookTitle = path12.basename(input.fileName, path12.extname(input.fileName));
+      notebookTitle = path13.basename(input.fileName, path13.extname(input.fileName));
     }
     const sections = [];
     let markdownCellCount = 0;
@@ -12695,7 +14061,7 @@ async function extractCsvText(input) {
     const rows = parsed.map((row) => row.map((value) => normalizeTableCell(value)));
     const { headers, bodyRows } = detectHeaderRow(rows);
     const hintLines = columnHints(headers, bodyRows);
-    const title = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0;
+    const title = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0;
     const extractedText = [
       title ? `# ${title}` : null,
       `Format: ${delimiter === "	" ? "TSV" : "CSV"}`,
@@ -12760,7 +14126,7 @@ async function extractSpreadsheetWorkbook(input, sourceKind, extractor) {
       sheetSections.push(...markdownTable(headers, bodyRows));
       sheetSections.push("");
     }
-    const title = normalizeWhitespace(String(workbook.Props?.Title ?? "")) || (input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0);
+    const title = normalizeWhitespace(String(workbook.Props?.Title ?? "")) || (input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0);
     const extractedText = [
       title ? `# ${title}` : null,
       `Sheets: ${allSheetNames.length}`,
@@ -12822,7 +14188,7 @@ async function extractPptxText(input) {
       if (slideTexts.length) {
         slideSections.push(slideTexts.join("\n"));
       }
-      const slideRelsPath = `${zipDirname(slidePath)}/_rels/${path12.posix.basename(slidePath)}.rels`;
+      const slideRelsPath = `${zipDirname(slidePath)}/_rels/${path13.posix.basename(slidePath)}.rels`;
       const slideRelsXml = zipEntryText(archive, slideRelsPath);
       if (slideRelsXml) {
         const slideRels = relationshipTargets(slideRelsXml, slidePath);
@@ -12839,7 +14205,7 @@ async function extractPptxText(input) {
       slideSections.push("");
     }
     const metadata = parseOfficeCoreMetadata(input.bytes);
-    const title = metadata?.title || (input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0);
+    const title = metadata?.title || (input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0);
     const extractedText = [title ? `# ${title}` : null, `Slides: ${slideTargets.length}`, "", ...slideSections].filter((item) => Boolean(item)).join("\n").trim();
     return {
       title,
@@ -12893,7 +14259,7 @@ async function extractEpubChapters(input) {
       ).filter(([id, item]) => Boolean(id && item.href))
     );
     const spineIds = Array.from(packageDocument.getElementsByTagName("*")).filter((node) => node.localName === "itemref").map((node) => node.getAttribute("idref")?.trim()).filter((value) => Boolean(value));
-    const bookTitle = xmlTextNodes(packageXml, "title")[0] || (input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0);
+    const bookTitle = xmlTextNodes(packageXml, "title")[0] || (input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0);
     const author = xmlTextNodes(packageXml, "creator")[0];
     const chapters = [];
     for (const spineId of spineIds) {
@@ -13197,7 +14563,7 @@ async function extractOdtText(input) {
     const textNodes = collectOdfTextNodes(contentXml);
     const headingCount = textNodes.filter((node) => node.heading).length;
     const paragraphCount = textNodes.filter((node) => !node.heading).length;
-    const title = metadata?.title || textNodes.find((node) => node.heading === 1)?.text || (input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0);
+    const title = metadata?.title || textNodes.find((node) => node.heading === 1)?.text || (input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0);
     const body = renderOdfTextNodes(textNodes);
     const extractedText = [title ? `# ${title}` : null, "", body].filter((item) => item !== null).join("\n").trim();
     return {
@@ -13241,7 +14607,7 @@ async function extractOdpText(input) {
       }
       slideSections.push("");
     });
-    const title = metadata?.title || (input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0);
+    const title = metadata?.title || (input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0);
     const extractedText = [title ? `# ${title}` : null, `Slides: ${pages.length}`, "", ...slideSections].filter((item) => Boolean(item)).join("\n").trim();
     const warnings = pages.length > 60 ? ["ODP extraction truncated to the first 60 slides."] : void 0;
     return {
@@ -13424,7 +14790,7 @@ async function extractStructuredData(input) {
     const previewText = decodeTextBytes(input.bytes);
     const previewLines = previewText.split(/\r?\n/).slice(0, 40);
     const truncated = previewText.split(/\r?\n/).length > previewLines.length;
-    const title = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0;
+    const title = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0;
     const extractedText = [
       title ? `# ${title}` : null,
       `Format: ${format.toUpperCase()}`,
@@ -13533,7 +14899,7 @@ async function extractBibTeXText(input) {
     const totalEntries = entries.length;
     const truncated = entries.length > 200;
     const typeSummary = [...citationTypes.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).map(([type, count]) => `${type} (${count})`).join(", ");
-    const title = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : "BibTeX library";
+    const title = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : "BibTeX library";
     const extractedText = [
       `# ${title}`,
       "",
@@ -13593,7 +14959,7 @@ async function extractRtfText(input) {
         paragraphs.push(text);
       }
     }
-    const title = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0;
+    const title = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0;
     const extractedText = [title ? `# ${title}` : null, "", ...paragraphs].filter((item) => item !== null).join("\n\n").trim();
     return {
       title,
@@ -13694,7 +15060,7 @@ async function extractOrgText(input) {
     for (const child of document.children ?? []) {
       renderOrgNode(child, bodyLines);
     }
-    const title = documentTitle.trim() || (input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0);
+    const title = documentTitle.trim() || (input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0);
     const extractedText = [title ? `# ${title}` : null, "", ...bodyLines].filter((item) => item !== null).join("\n").trim();
     return {
       title,
@@ -13726,7 +15092,7 @@ async function extractAsciiDocText(input) {
     const html = processor.convert(source, { safe: "safe", standalone: false });
     const markdown = htmlToMarkdown(html);
     const docTitle = (typeof loaded.getTitle === "function" ? loaded.getTitle() : void 0) ?? void 0;
-    const fileTitle = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0;
+    const fileTitle = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0;
     const title = docTitle?.trim() || fileTitle;
     const extractedText = [title ? `# ${title}` : null, "", markdown].filter((item) => item !== null).join("\n").trim();
     return {
@@ -13758,7 +15124,7 @@ async function extractTranscriptText(input) {
       end: Math.max(0, node.data?.end ?? 0),
       text: normalizeWhitespace((node.data?.text ?? "").replace(/\s*\n+\s*/g, " "))
     })).filter((cue) => cue.text);
-    const title = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : void 0;
+    const title = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : void 0;
     const extractedText = [
       title ? `# ${title}` : null,
       `Format: ${input.fileName?.toLowerCase().endsWith(".vtt") ? "WebVTT" : "SRT"}`,
@@ -13794,7 +15160,7 @@ async function extractTranscriptText(input) {
 async function extractEmailText(input) {
   try {
     const { simpleParser } = await import("mailparser");
-    const fallbackTitle = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : "Email";
+    const fallbackTitle = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : "Email";
     const parsed = await simpleParser(input.bytes);
     const normalized = normalizeParsedEmail(parsed, fallbackTitle);
     return {
@@ -13816,7 +15182,7 @@ async function extractEmailText(input) {
 }
 async function extractMboxMessages(input) {
   try {
-    const title = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : "Mailbox";
+    const title = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : "Mailbox";
     const { simpleParser } = await import("mailparser");
     const messages = await loadZipMessageBuffers(input.bytes);
     const extracted = [];
@@ -13852,7 +15218,7 @@ async function extractMboxMessages(input) {
 async function extractCalendarEvents(input) {
   try {
     const ical = await import("node-ical");
-    const calendarTitle = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : "Calendar";
+    const calendarTitle = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : "Calendar";
     const parsed = ical.default.sync.parseICS(decodeTextBytes(input.bytes));
     const events = [];
     for (const item of Object.values(parsed)) {
@@ -14035,7 +15401,7 @@ async function isSlackExportDirectory(directoryPath) {
     return false;
   }
   for (const entry of entries) {
-    const channelDir = path12.join(directoryPath, entry);
+    const channelDir = path13.join(directoryPath, entry);
     const stat = await fs12.stat(channelDir).catch(() => null);
     if (!stat?.isDirectory()) {
       continue;
@@ -14050,7 +15416,7 @@ async function isSlackExportDirectory(directoryPath) {
 async function extractSlackExportArchive(input) {
   try {
     const archive = unzipSync(new Uint8Array(input.bytes));
-    const title = input.fileName ? path12.basename(input.fileName, path12.extname(input.fileName)) : "Slack Export";
+    const title = input.fileName ? path13.basename(input.fileName, path13.extname(input.fileName)) : "Slack Export";
     return parseSlackExportEntries(archiveEntriesAsText(archive), title);
   } catch (error) {
     return {
@@ -14060,7 +15426,7 @@ async function extractSlackExportArchive(input) {
   }
 }
 async function extractSlackExportDirectory(directoryPath) {
-  const title = path12.basename(directoryPath) || "Slack Export";
+  const title = path13.basename(directoryPath) || "Slack Export";
   try {
     const entries = /* @__PURE__ */ new Map();
     const queue = [directoryPath];
@@ -14068,12 +15434,12 @@ async function extractSlackExportDirectory(directoryPath) {
       const current = queue.shift();
       const children = await fs12.readdir(current, { withFileTypes: true });
       for (const child of children) {
-        const absoluteChild = path12.join(current, child.name);
+        const absoluteChild = path13.join(current, child.name);
         if (child.isDirectory()) {
           queue.push(absoluteChild);
           continue;
         }
-        const relativeChild = path12.posix.relative(directoryPath, absoluteChild.split(path12.sep).join(path12.posix.sep));
+        const relativeChild = path13.posix.relative(directoryPath, absoluteChild.split(path13.sep).join(path13.posix.sep));
         entries.set(relativeChild, await fs12.readFile(absoluteChild, "utf8"));
       }
     }
@@ -14225,65 +15591,6 @@ function buildConfiguredRedactor(config) {
   return buildRedactor(resolved.patterns, resolved.placeholder);
 }
 
-// src/source-classification.ts
-import path13 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) => path13.matchesGlob(relativePath, pattern) || path13.matchesGlob(path13.posix.basename(relativePath), pattern)
-  );
-}
-function classifyRepoPath(relativePath, repoAnalysis) {
-  const normalized = relativePath.replace(/\\/g, "/");
-  const custom = repoAnalysis?.classifyGlobs;
-  if (custom?.first_party?.length && matchesAnyGlob(normalized, custom.first_party)) {
-    return "first_party";
-  }
-  for (const sourceClass of ["third_party", "resource", "generated"]) {
-    const patterns = custom?.[sourceClass];
-    if (patterns?.length && matchesAnyGlob(normalized, patterns)) {
-      return sourceClass;
-    }
-  }
-  const segments = normalized.split("/").filter(Boolean);
-  if (segments.some((segment) => THIRD_PARTY_SEGMENTS.has(segment))) {
-    return "third_party";
-  }
-  if (segments.some((segment) => GENERATED_SEGMENTS.has(segment))) {
-    return "generated";
-  }
-  if (segments.some((segment) => segment.endsWith(".xcassets") || segment.endsWith(".imageset"))) {
-    return "resource";
-  }
-  return "first_party";
-}
-function normalizeExtractClasses(repoAnalysis, extra = []) {
-  const configured = repoAnalysis?.extractClasses?.length ? repoAnalysis.extractClasses : ["first_party"];
-  return ALL_SOURCE_CLASSES.filter((sourceClass) => (/* @__PURE__ */ new Set([...configured, ...extra])).has(sourceClass));
-}
-function aggregateSourceClass(values) {
-  const available = ALL_SOURCE_CLASSES.filter((sourceClass) => values.includes(sourceClass));
-  if (!available.length) {
-    return void 0;
-  }
-  if (available.includes("first_party")) {
-    return "first_party";
-  }
-  if (available.includes("resource")) {
-    return "resource";
-  }
-  if (available.includes("third_party")) {
-    return "third_party";
-  }
-  return "generated";
-}
-function aggregateManifestSourceClass(manifests, sourceIds) {
-  const byId = new Map(manifests.map((manifest) => [manifest.sourceId, manifest.sourceClass]));
-  return aggregateSourceClass(sourceIds.map((sourceId) => byId.get(sourceId)));
-}
-
 // src/source-registry.ts
 import fs13 from "fs/promises";
 import path14 from "path";
@@ -14542,7 +15849,7 @@ var MARKDOWN_SEMANTIC_FRONTMATTER_KEYS = [
   "canonical_url",
   "source_type"
 ];
-function uniqueStrings2(values) {
+function uniqueStrings3(values) {
   return [...new Set(values.filter(Boolean))];
 }
 function ingestRunStatePath(stateDir, runId) {
@@ -14941,7 +16248,7 @@ function normalizeSemanticMarkdownList(value) {
   if (!Array.isArray(value)) {
     return void 0;
   }
-  const items = uniqueStrings2(
+  const items = uniqueStrings3(
     value.flatMap((item) => typeof item === "string" ? [normalizeWhitespace(item.trim())] : []).filter(Boolean)
   );
   return items.length ? items : void 0;
@@ -15273,7 +16580,7 @@ async function captureArxivMarkdown(input, options) {
       canonical_url: normalizedUrl,
       title,
       authors,
-      tags: uniqueStrings2(categories),
+      tags: uniqueStrings3(categories),
       arxiv_id: arxivId,
       author: options.author,
       contributor: options.contributor,
@@ -15349,14 +16656,14 @@ function firstMetaContent(document, selectors) {
   return void 0;
 }
 function metaContents(document, selectors) {
-  return uniqueStrings2(
+  return uniqueStrings3(
     selectors.flatMap(
       (selector) => [...document.querySelectorAll(selector)].map((node) => node.getAttribute("content")?.trim() ?? "").filter(Boolean)
     )
   );
 }
 function splitKeywords(value) {
-  return uniqueStrings2(
+  return uniqueStrings3(
     (value ?? "").split(/[;,]/g).map((item) => item.trim()).filter(Boolean)
   );
 }
@@ -15370,7 +16677,7 @@ async function captureArticleMarkdown(rootDir, input, options, extra = { sourceT
   const canonicalHref = document.querySelector('link[rel="canonical"]')?.getAttribute("href")?.trim();
   const canonicalUrl = canonicalHref ? normalizeOriginUrl(new URL(canonicalHref, resolved.finalUrl).toString()) : resolved.finalUrl;
   const title = firstMetaContent(document, ['meta[name="citation_title"]', 'meta[property="og:title"]', 'meta[name="twitter:title"]']) ?? (document.title.trim() || canonicalUrl);
-  const authors = uniqueStrings2([
+  const authors = uniqueStrings3([
     ...metaContents(document, ['meta[name="citation_author"]']),
     ...metaContents(document, ['meta[name="author"]', 'meta[property="article:author"]'])
   ]);
@@ -15381,7 +16688,7 @@ async function captureArticleMarkdown(rootDir, input, options, extra = { sourceT
     'meta[name="pubdate"]'
   ]);
   const updatedAt = firstMetaContent(document, ['meta[property="article:modified_time"]', 'meta[name="lastmod"]']);
-  const tags = uniqueStrings2([
+  const tags = uniqueStrings3([
     ...metaContents(document, ['meta[property="article:tag"]']),
     ...splitKeywords(firstMetaContent(document, ['meta[name="keywords"]']))
   ]);
@@ -17339,7 +18646,7 @@ async function readExtractionArtifact(rootDir, manifest) {
 }
 
 // src/mcp.ts
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import path27 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -17511,7 +18818,7 @@ function contentTokens(text, minLength = 4) {
 }
 
 // src/analysis.ts
-var ANALYSIS_FORMAT_VERSION = 7;
+var ANALYSIS_FORMAT_VERSION = 8;
 var sourceAnalysisSchema = z2.object({
   title: z2.string().min(1),
   summary: z2.string().min(1),
@@ -17535,6 +18842,42 @@ var HEURISTIC_SECTION_SOURCE_KINDS = /* @__PURE__ */ new Map([
   ["email", "Message"],
   ["calendar", "Description"]
 ]);
+var MARKDOWN_RATIONALE_KINDS = /* @__PURE__ */ new Set([
+  "markdown",
+  "html",
+  "pdf",
+  "docx",
+  "epub",
+  "odt",
+  "rtf",
+  "org",
+  "asciidoc",
+  "jupyter"
+]);
+var PLAIN_TEXT_RATIONALE_KINDS = /* @__PURE__ */ new Set(["text", "transcript", "chat_export", "email", "calendar"]);
+function filenameStemForSource(manifest) {
+  const candidate = manifest.repoRelativePath ?? manifest.originalPath ?? manifest.storedPath;
+  const base = path18.basename(candidate);
+  const stem = base.replace(/\.[^.]+$/, "");
+  return stem || manifest.title;
+}
+function extractNonCodeRationales(manifest, rawText) {
+  if (!rawText.trim()) {
+    return [];
+  }
+  if (MARKDOWN_RATIONALE_KINDS.has(manifest.sourceKind)) {
+    const fallback = filenameStemForSource(manifest);
+    const rationales = extractRationaleFromMarkdown(rawText, manifest.sourceId);
+    return rationales.map((entry) => ({
+      ...entry,
+      symbolName: entry.symbolName ?? fallback
+    }));
+  }
+  if (PLAIN_TEXT_RATIONALE_KINDS.has(manifest.sourceKind)) {
+    return extractRationaleFromPlainText(rawText, manifest.sourceId, filenameStemForSource(manifest));
+  }
+  return [];
+}
 function extractTopTerms(text, count) {
   const frequency = /* @__PURE__ */ new Map();
   for (const token of contentTokens(text)) {
@@ -17866,6 +19209,12 @@ async function analyzeSource(manifest, extractedText, provider, paths, schema) {
       analysis = heuristicAnalysis(manifest, content, schema.hash);
     }
   }
+  if (manifest.sourceKind !== "code" && !analysis.rationales.length) {
+    const extra = extractNonCodeRationales(manifest, extractedText ?? "");
+    if (extra.length) {
+      analysis = { ...analysis, rationales: extra };
+    }
+  }
   const normalized = normalizeSourceAnalysis(manifest, analysis);
   await writeJsonFile(cachePath, normalized);
   return normalized;
@@ -19106,7 +20455,7 @@ async function guidedSourceSessionStatePath(rootDir, sessionId) {
 // src/vault.ts
 var COMPILE_PROGRESS_THRESHOLD = 120;
 var COMPILE_PROGRESS_UPDATE_INTERVAL = 50;
-function uniqueStrings3(values) {
+function uniqueStrings4(values) {
   return uniqueBy(values.filter(Boolean), (value) => value);
 }
 function createCompileProgressReporter(phase, totalItems) {
@@ -19297,7 +20646,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-SUXWCWB4.js");
+  const { createProvider: createProvider2 } = await import("./registry-QAG2ZYH3.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -19501,7 +20850,7 @@ function normalizeProjectRoot(root) {
 function projectEntries(config) {
   return Object.entries(config.projects ?? {}).map(([id, project]) => ({
     id,
-    roots: uniqueStrings3(project.roots.map(normalizeProjectRoot)).filter(Boolean),
+    roots: uniqueStrings4(project.roots.map(normalizeProjectRoot)).filter(Boolean),
     schemaPath: project.schemaPath
   })).sort((left, right) => left.id.localeCompare(right.id));
 }
@@ -19549,11 +20898,11 @@ function resolveSourceProjects(rootDir, manifests, config) {
   return Object.fromEntries(manifests.map((manifest) => [manifest.sourceId, resolveSourceProjectId(rootDir, manifest, config)]));
 }
 function scopedProjectIdsFromSources(sourceIds, sourceProjects) {
-  const projectIds = uniqueStrings3(sourceIds.map((sourceId) => sourceProjects[sourceId] ?? "").filter(Boolean));
+  const projectIds = uniqueStrings4(sourceIds.map((sourceId) => sourceProjects[sourceId] ?? "").filter(Boolean));
   return projectIds.length === 1 ? projectIds : [];
 }
 function schemaProjectIdsFromPages(pageIds, pageMap2) {
-  return uniqueStrings3(
+  return uniqueStrings4(
     pageIds.flatMap((pageId) => pageMap2.get(pageId)?.projectIds ?? []).filter(Boolean).sort((left, right) => left.localeCompare(right))
   );
 }
@@ -19562,7 +20911,7 @@ function categoryTagsForSchema(schema, texts) {
   if (!haystack) {
     return [];
   }
-  return uniqueStrings3(
+  return uniqueStrings4(
     schemaCategoryLabels({ path: "", hash: "", content: schema.content }).filter((label) => haystack.includes(label.toLowerCase())).map((label) => `category/${slugify(label)}`)
   ).slice(0, 3);
 }
@@ -19802,8 +21151,8 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
   const manifestBySourceId = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
   const timelineManifests = manifests.filter((manifest) => manifestDetailValue(manifest, "occurred_at")).sort((left, right) => (manifestDetailValue(right, "occurred_at") ?? "").localeCompare(manifestDetailValue(left, "occurred_at") ?? "")).slice(0, 25);
   const recentSourcePages = [...sourcePages].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, 20);
-  const analyses = await loadAnalysesBySourceIds(paths, uniqueStrings3(sourcePages.flatMap((page) => page.sourceIds)));
-  const openQuestions = uniqueStrings3(
+  const analyses = await loadAnalysesBySourceIds(paths, uniqueStrings4(sourcePages.flatMap((page) => page.sourceIds)));
+  const openQuestions = uniqueStrings4(
     analyses.flatMap((analysis) => analysis.questions.map((question) => `${analysis.title}: ${question}`))
   ).slice(0, 20);
   const sourceSessions = await listGuidedSourceSessions(paths.rootDir);
@@ -20047,7 +21396,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
           kind: "index",
           title: "Source Sessions",
           tags: ["index", "dashboard", "source-sessions"],
-          source_ids: uniqueStrings3([
+          source_ids: uniqueStrings4([
             ...sessionPages.flatMap((page) => page.sourceIds),
             ...sourceSessions.flatMap((session) => session.sourceIds)
           ]),
@@ -20058,7 +21407,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
           confidence: 1,
           created_at: metadata.createdAt,
           updated_at: metadata.updatedAt,
-          compiled_from: uniqueStrings3([
+          compiled_from: uniqueStrings4([
             ...sessionPages.flatMap((page) => page.sourceIds),
             ...sourceSessions.flatMap((session) => session.sourceIds)
           ]),
@@ -20100,7 +21449,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
           kind: "index",
           title: "Source Guides",
           tags: ["index", "dashboard", "source-guides"],
-          source_ids: uniqueStrings3([
+          source_ids: uniqueStrings4([
             ...guidePages.flatMap((page) => page.sourceIds),
             ...stagedGuideBundles.flatMap((bundle) => bundle.entries.flatMap((entry) => entry.sourceIds))
           ]),
@@ -20111,7 +21460,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
           confidence: 1,
           created_at: metadata.createdAt,
           updated_at: metadata.updatedAt,
-          compiled_from: uniqueStrings3([
+          compiled_from: uniqueStrings4([
             ...guidePages.flatMap((page) => page.sourceIds),
             ...stagedGuideBundles.flatMap((bundle) => bundle.entries.flatMap((entry) => entry.sourceIds))
           ]),
@@ -20162,7 +21511,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
           kind: "index",
           title: "Research Map",
           tags: ["index", "dashboard", "research-map"],
-          source_ids: uniqueStrings3([
+          source_ids: uniqueStrings4([
             ...conceptPages.flatMap((page) => page.sourceIds),
             ...entityPages.flatMap((page) => page.sourceIds),
             ...guidePages.flatMap((page) => page.sourceIds)
@@ -20174,7 +21523,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
           confidence: 1,
           created_at: metadata.createdAt,
           updated_at: metadata.updatedAt,
-          compiled_from: uniqueStrings3([
+          compiled_from: uniqueStrings4([
             ...conceptPages.flatMap((page) => page.sourceIds),
             ...entityPages.flatMap((page) => page.sourceIds),
             ...guidePages.flatMap((page) => page.sourceIds)
@@ -20324,7 +21673,7 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
   return records;
 }
 function indexCompiledFrom(pages) {
-  return uniqueStrings3(pages.flatMap((page) => page.sourceIds));
+  return uniqueStrings4(pages.flatMap((page) => page.sourceIds));
 }
 function autoResolution(nodeCount, edgeCount) {
   if (nodeCount <= 20) return 0.5;
@@ -20338,6 +21687,21 @@ function pruneDanglingEdges(nodes, edges) {
 function applyNormLabel(nodes) {
   return nodes.map((node) => node.normLabel ? node : { ...node, normLabel: computeNormLabel(node.label) });
 }
+function describeGodNodeReason(degree, communityCount, degreeMean, degreeStd) {
+  const parts = [`degree ${degree}`];
+  if (communityCount >= 3) {
+    parts.push(`across ${communityCount} communities`);
+  } else if (communityCount === 2) {
+    parts.push("bridges 2 communities");
+  }
+  if (degreeStd > 0) {
+    const sigma = (degree - degreeMean) / degreeStd;
+    if (sigma >= 1.5) {
+      parts.push(`${sigma.toFixed(1)}\u03C3 above mean`);
+    }
+  }
+  return parts.join(", ");
+}
 function deriveGraphMetrics(nodes, edges, options) {
   const adjacency = /* @__PURE__ */ new Map();
   const connect = (left, right) => {
@@ -20406,6 +21770,9 @@ function deriveGraphMetrics(nodes, edges, options) {
   }
   const degreeValues = nodes.filter((node) => node.type !== "source").map((node) => degreeMap.get(node.id) ?? 0).sort((left, right) => right - left);
   const godNodeThreshold = degreeValues[Math.max(0, Math.floor(degreeValues.length * 0.1) - 1)] ?? 0;
+  const degreeMean = degreeValues.length > 0 ? degreeValues.reduce((sum, value) => sum + value, 0) / degreeValues.length : 0;
+  const degreeVariance = degreeValues.length > 0 ? degreeValues.reduce((sum, value) => sum + (value - degreeMean) ** 2, 0) / degreeValues.length : 0;
+  const degreeStd = Math.sqrt(degreeVariance);
   const nextNodes = nodes.map((node) => {
     const neighborCommunities = new Set(
       [...adjacency.get(node.id) ?? []].map((neighborId) => communityMap.get(neighborId) ?? communityMap.get(node.id)).filter((communityId) => Boolean(communityId))
@@ -20413,12 +21780,14 @@ function deriveGraphMetrics(nodes, edges, options) {
     const degree = degreeMap.get(node.id) ?? 0;
     const bridgeScore = node.type === "source" ? neighborCommunities.size : Math.max(0, neighborCommunities.size - 1);
     const inferredCommunityId = communityMap.get(node.id) ?? [...adjacency.get(node.id) ?? []].map((neighborId) => communityMap.get(neighborId)).find((communityId) => Boolean(communityId));
+    const isGodNode = node.type !== "source" && degree >= godNodeThreshold && degree > 0;
     return {
       ...node,
       communityId: inferredCommunityId,
       degree,
       bridgeScore,
-      isGodNode: node.type !== "source" && degree >= godNodeThreshold && degree > 0
+      isGodNode,
+      surpriseReason: isGodNode ? describeGodNodeReason(degree, neighborCommunities.size, degreeMean, degreeStd) : void 0
     };
   });
   return {
@@ -20427,7 +21796,16 @@ function deriveGraphMetrics(nodes, edges, options) {
   };
 }
 function resetGraphNodeMetrics(nodes) {
-  return nodes.map(({ communityId: _communityId, degree: _degree, bridgeScore: _bridgeScore, isGodNode: _isGodNode, ...node }) => node);
+  return nodes.map(
+    ({
+      communityId: _communityId,
+      degree: _degree,
+      bridgeScore: _bridgeScore,
+      isGodNode: _isGodNode,
+      surpriseReason: _surpriseReason,
+      ...node
+    }) => node
+  );
 }
 function manifestRepoPath(manifest) {
   return toPosix(manifest.repoRelativePath ?? path25.basename(manifest.originalPath ?? manifest.storedPath));
@@ -20833,6 +22211,34 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex, opti
           provenance: [analysis.sourceId, targetSourceId]
         });
       }
+    } else if (analysis.rationales.length) {
+      const manifest = manifestsById.get(analysis.sourceId);
+      if (manifest) {
+        const sourceNodeId = `source:${analysis.sourceId}`;
+        for (const rationale of analysis.rationales) {
+          rationaleMap.set(rationale.id, {
+            id: rationale.id,
+            type: "rationale",
+            label: truncate(rationale.text, 80),
+            pageId: sourceNodeId,
+            freshness: "fresh",
+            confidence: 1,
+            sourceIds: [analysis.sourceId],
+            projectIds: scopedProjectIdsFromSources([analysis.sourceId], sourceProjects),
+            sourceClass: manifest.sourceClass
+          });
+          pushEdge({
+            id: `${rationale.id}->${sourceNodeId}:rationale_for`,
+            source: rationale.id,
+            target: sourceNodeId,
+            relation: "rationale_for",
+            status: "extracted",
+            evidenceClass: "extracted",
+            confidence: 1,
+            provenance: [analysis.sourceId]
+          });
+        }
+      }
     }
   }
   const conceptClaims = /* @__PURE__ */ new Map();
@@ -20883,6 +22289,10 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex, opti
     ...conceptMap.values(),
     ...entityMap.values()
   ];
+  const repoDefaults = resolveLargeRepoDefaults({
+    nodeCount: graphNodes.length,
+    config: options?.config
+  });
   const enriched = enrichGraph(
     {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -20893,7 +22303,12 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex, opti
       pages
     },
     manifests,
-    analyses
+    analyses,
+    [],
+    {
+      similarityIdfFloor: repoDefaults.similarityIdfFloor,
+      similarityEdgeCap: repoDefaults.similarityEdgeCap
+    }
   );
   const metrics = deriveGraphMetrics(graphNodes, enriched.edges, { resolution: options?.communityResolution });
   const finalNodes = applyNormLabel(metrics.nodes);
@@ -20924,7 +22339,7 @@ function recentResearchSourcePages(graph, previousCompiledAt) {
     sourceType: page.sourceType
   }));
 }
-async function buildGraphOrientationPages(graph, paths, schemaHash, previousCompiledAt, contradictions = []) {
+async function buildGraphOrientationPages(graph, paths, schemaHash, previousCompiledAt, contradictions = [], config) {
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
@@ -20934,7 +22349,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
         absolutePath,
         {
           managedBy: "system",
-          compiledFrom: uniqueStrings3(
+          compiledFrom: uniqueStrings4(
             community.nodeIds.flatMap((nodeId) => graph.nodes.find((node) => node.id === nodeId)?.sourceIds ?? [])
           ),
           confidence: 1
@@ -20955,14 +22370,15 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     benchmarkStale: benchmark ? benchmark.graphHash !== graphHash(graph) : false,
     recentResearchSources: recentResearchSourcePages(graph, previousCompiledAt),
     graphHash: graphHash(graph),
-    contradictions
+    contradictions,
+    config
   });
   const reportAbsolutePath = path25.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
       managedBy: "system",
-      compiledFrom: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
+      compiledFrom: uniqueStrings4(graph.pages.flatMap((page) => page.sourceIds)),
       confidence: 1
     },
     (metadata) => buildGraphReportPage({
@@ -21298,7 +22714,7 @@ async function syncVaultArtifacts(rootDir, input) {
       const itemKind = kind === "concepts" ? "concept" : "entity";
       const slug = slugify(aggregate.name);
       const pageId = `${itemKind}:${slug}`;
-      const sourceIds = uniqueStrings3(aggregate.sourceAnalyses.map((item) => item.sourceId));
+      const sourceIds = uniqueStrings4(aggregate.sourceAnalyses.map((item) => item.sourceId));
       const projectIds = scopedProjectIdsFromSources(sourceIds, input.sourceProjects);
       const schemaHash = effectiveHashForProject(input.schemas, projectIds[0] ?? null);
       const previousEntry = input.previousState?.candidateHistory?.[pageId];
@@ -21369,7 +22785,8 @@ 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, {
-    communityResolution: config.graph?.communityResolution
+    communityResolution: config.graph?.communityResolution,
+    config
   });
   const contradictions = detectContradictions(input.analyses);
   for (const contradiction of contradictions) {
@@ -21407,7 +22824,8 @@ async function syncVaultArtifacts(rootDir, input) {
     paths,
     globalSchemaHash,
     input.previousState?.generatedAt,
-    contradictions
+    contradictions,
+    config
   );
   const preliminaryPages = [...basePages, ...graphOrientation.records.map((record) => record.page)];
   const dashboardRecords = await buildDashboardRecords(
@@ -21560,7 +22978,7 @@ async function syncVaultArtifacts(rootDir, input) {
   const nextPagePaths = new Set(records.map((record) => record.page.path));
   const obsoleteGraphPaths = (previousGraph?.pages ?? []).filter((page) => page.kind !== "output" && page.kind !== "insight").map((page) => page.path).filter((relativePath) => !nextPagePaths.has(relativePath));
   const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path25.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const obsoletePaths = uniqueStrings3([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
+  const obsoletePaths = uniqueStrings4([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
     const absolutePath = path25.join(paths.wikiDir, record.page.path);
@@ -21619,7 +23037,7 @@ async function syncVaultArtifacts(rootDir, input) {
   return {
     graph,
     allPages,
-    changedPages: uniqueStrings3([...changedPages, ...writeChanges]),
+    changedPages: uniqueStrings4([...changedPages, ...writeChanges]),
     promotedPageIds,
     candidatePageCount: candidatePages.length,
     staged: false
@@ -21648,7 +23066,9 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     },
     paths,
     globalSchemaHash,
-    compileState?.generatedAt
+    compileState?.generatedAt,
+    [],
+    config
   ) : { records: [], report: null };
   const dashboardRecords = currentGraph ? await buildDashboardRecords(
     config,
@@ -21817,7 +23237,7 @@ async function prepareOutputPageSave(rootDir, input) {
       status: "active",
       createdAt: now,
       updatedAt: now,
-      compiledFrom: uniqueStrings3(input.relatedSourceIds ?? input.citations),
+      compiledFrom: uniqueStrings4(input.relatedSourceIds ?? input.citations),
       managedBy: "system",
       confidence: 0.74
     }
@@ -21858,7 +23278,7 @@ async function prepareExploreHubSave(rootDir, input) {
       status: "active",
       createdAt: now,
       updatedAt: now,
-      compiledFrom: uniqueStrings3(input.citations),
+      compiledFrom: uniqueStrings4(input.citations),
       managedBy: "system",
       confidence: 0.76
     }
@@ -22536,7 +23956,7 @@ async function promoteCandidate(rootDir, target) {
     ...parsed.data,
     status: "active",
     updated_at: nextUpdatedAt,
-    tags: uniqueStrings3([candidate.kind, ...Array.isArray(parsed.data.tags) ? parsed.data.tags : []]).filter(
+    tags: uniqueStrings4([candidate.kind, ...Array.isArray(parsed.data.tags) ? parsed.data.tags : []]).filter(
       (tag) => tag !== "candidate"
     )
   });
@@ -23130,7 +24550,7 @@ async function compileVault(rootDir, options = {}) {
   const currentInsightHashes = pageHashes(storedInsightPages);
   const previousState = await readJsonFile(paths.compileStatePath);
   const rootSchemaChanged = !previousState || previousState.rootSchemaHash !== schemas.root.hash;
-  const effectiveSchemaChanged = !previousState || previousGlobalSchemaHash(previousState) !== schemas.effective.global.hash || uniqueStrings3([...Object.keys(previousState?.effectiveSchemaHashes?.projects ?? {}), ...Object.keys(schemas.effective.projects)]).some(
+  const effectiveSchemaChanged = !previousState || previousGlobalSchemaHash(previousState) !== schemas.effective.global.hash || uniqueStrings4([...Object.keys(previousState?.effectiveSchemaHashes?.projects ?? {}), ...Object.keys(schemas.effective.projects)]).some(
     (projectId) => previousProjectSchemaHash(previousState, projectId) !== effectiveHashForProject(schemas, projectId)
   );
   const nextProjectConfigHash = projectConfigHash(config);
@@ -23324,7 +24744,7 @@ async function compileVault(rootDir, options = {}) {
         config: config.freshness
       });
       if (decayResult.updatedPaths.length) {
-        sync.changedPages = uniqueStrings3([...sync.changedPages, ...decayResult.updatedPaths]);
+        sync.changedPages = uniqueStrings4([...sync.changedPages, ...decayResult.updatedPaths]);
       }
     } catch {
     }
@@ -23333,7 +24753,7 @@ async function compileVault(rootDir, options = {}) {
     try {
       const consolidation = await runConsolidation(rootDir, config.consolidation ?? {});
       if (consolidation.newPages.length) {
-        sync.changedPages = uniqueStrings3([...sync.changedPages, ...consolidation.newPages.map((page) => page.path)]);
+        sync.changedPages = uniqueStrings4([...sync.changedPages, ...consolidation.newPages.map((page) => page.path)]);
       }
     } catch {
     }
@@ -23694,7 +25114,7 @@ ${orchestrationNotes.join("\n")}
     citations: allCitations,
     format: outputFormat,
     relatedPageCount: stepPages.length,
-    relatedNodeCount: uniqueStrings3(stepPages.flatMap((page) => page.nodeIds)).length,
+    relatedNodeCount: uniqueStrings4(stepPages.flatMap((page) => page.nodeIds)).length,
     projectId: stepPages[0]?.projectIds[0] ?? null
   });
   const hubInput = {
@@ -23704,7 +25124,7 @@ ${orchestrationNotes.join("\n")}
     citations: allCitations,
     schemaHash: composeVaultSchema(
       schemas.root,
-      uniqueStrings3(stepPages.flatMap((page) => page.projectIds).sort((left, right) => left.localeCompare(right))).map((projectId) => schemas.projects[projectId]).filter((schema) => Boolean(schema?.hash))
+      uniqueStrings4(stepPages.flatMap((page) => page.projectIds).sort((left, right) => left.localeCompare(right))).map((projectId) => schemas.projects[projectId]).filter((schema) => Boolean(schema?.hash))
     ).hash,
     outputFormat,
     outputAssets: hubAssetBundle.outputAssets,
@@ -23764,7 +25184,7 @@ ${orchestrationNotes.join("\n")}
     providerId: provider.id,
     success: true,
     relatedSourceIds: [...relatedSourceIds],
-    relatedPageIds: uniqueStrings3([...relatedPageIds, ...stepPages.map((page) => page.id), hubPage.id]),
+    relatedPageIds: uniqueStrings4([...relatedPageIds, ...stepPages.map((page) => page.id), hubPage.id]),
     relatedNodeIds: [...relatedNodeIds],
     citations: allCitations,
     tokenUsage: tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0 ? {
@@ -23879,10 +25299,19 @@ async function benchmarkVault(rootDir, options = {}) {
   const manifests = await listManifests(rootDir);
   const pageContentsById = /* @__PURE__ */ new Map();
   let corpusWords = 0;
+  const perClassCorpusWords = {
+    first_party: 0,
+    third_party: 0,
+    resource: 0,
+    generated: 0
+  };
   for (const manifest of manifests) {
     const extractedText = await readExtractedText(rootDir, manifest);
     if (extractedText) {
-      corpusWords += estimateCorpusWords([extractedText]);
+      const words = estimateCorpusWords([extractedText]);
+      corpusWords += words;
+      const manifestClass = manifest.sourceClass ?? "first_party";
+      perClassCorpusWords[manifestClass] = (perClassCorpusWords[manifestClass] ?? 0) + words;
     }
   }
   for (const page of graph.pages) {
@@ -23911,11 +25340,51 @@ async function benchmarkVault(rootDir, options = {}) {
       };
     })
   );
+  const perClassPerQuestion = {
+    first_party: [],
+    third_party: [],
+    resource: [],
+    generated: []
+  };
+  for (const sourceClass of ALL_SOURCE_CLASSES) {
+    const filteredGraph = filterGraphBySourceClass(graph, sourceClass);
+    if (!filteredGraph.nodes.length) {
+      continue;
+    }
+    const classPageContents = /* @__PURE__ */ new Map();
+    for (const page of filteredGraph.pages) {
+      const content = pageContentsById.get(page.id);
+      if (content !== void 0) {
+        classPageContents.set(page.id, content);
+      }
+    }
+    const classResults = await Promise.all(
+      sampleQuestions.map(async (question) => {
+        const result = await runResolvedGraphQuery(rootDir, filteredGraph, question, { budget: 12 });
+        const metrics = benchmarkQueryTokens(filteredGraph, result, classPageContents);
+        return {
+          question,
+          queryTokens: metrics.queryTokens,
+          reduction: metrics.reduction,
+          visitedNodeIds: result.visitedNodeIds,
+          visitedEdgeIds: result.visitedEdgeIds,
+          pageIds: result.pageIds
+        };
+      })
+    );
+    perClassPerQuestion[sourceClass] = classResults;
+  }
+  const byClass = buildBenchmarkByClass({
+    graph,
+    perClassCorpusWords,
+    perClassPerQuestion
+  });
   const artifact = buildBenchmarkArtifact({
     graph,
     corpusWords,
     questions: sampleQuestions,
-    perQuestion
+    perQuestion,
+    byClass
   });
   await writeJsonFile(paths.benchmarkPath, artifact);
   await refreshIndexesAndSearch(rootDir, graph.pages);
@@ -23947,9 +25416,15 @@ async function readGraphReport(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   return readJsonFile(path25.join(paths.wikiDir, "graph", "report.json"));
 }
-async function listGodNodes(rootDir, limit = 10) {
+async function listGodNodes(rootDir, limit) {
   const graph = await ensureCompiledGraph(rootDir);
-  return topGodNodes(graph, limit);
+  const { config } = await loadVaultConfig(rootDir);
+  const defaults = resolveLargeRepoDefaults({
+    nodeCount: graph.nodes.length,
+    config
+  });
+  const effectiveLimit = limit ?? defaults.godNodeLimit;
+  return topGodNodes(graph, effectiveLimit);
 }
 async function blastRadiusVault(rootDir, target, options) {
   const graph = await ensureCompiledGraph(rootDir);
@@ -24230,7 +25705,7 @@ async function lintVault(rootDir, options = {}) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       success: true,
       relatedPageIds: graph.pages.map((page) => page.id),
-      relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
+      relatedSourceIds: uniqueStrings4(graph.pages.flatMap((page) => page.sourceIds)),
       lintFindingCount: contradictionFindings.length,
       lines: [`findings=${contradictionFindings.length}`, `deep=false`, `web=false`, `conflicts=true`]
     });
@@ -24245,7 +25720,7 @@ async function lintVault(rootDir, options = {}) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       success: true,
       relatedPageIds: graph.pages.map((page) => page.id),
-      relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
+      relatedSourceIds: uniqueStrings4(graph.pages.flatMap((page) => page.sourceIds)),
       lintFindingCount: decayFindings.length,
       lines: [`findings=${decayFindings.length}`, `deep=false`, `web=false`, `conflicts=false`, `decay=true`]
     });
@@ -24260,7 +25735,7 @@ async function lintVault(rootDir, options = {}) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       success: true,
       relatedPageIds: graph.pages.map((page) => page.id),
-      relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
+      relatedSourceIds: uniqueStrings4(graph.pages.flatMap((page) => page.sourceIds)),
       lintFindingCount: tierFindings.length,
       lines: [`findings=${tierFindings.length}`, `deep=false`, `web=false`, `conflicts=false`, `tiers=true`]
     });
@@ -24284,7 +25759,7 @@ async function lintVault(rootDir, options = {}) {
     providerId: provider?.id,
     success: true,
     relatedPageIds: graph.pages.map((page) => page.id),
-    relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
+    relatedSourceIds: uniqueStrings4(graph.pages.flatMap((page) => page.sourceIds)),
     lintFindingCount: findings.length,
     lines: [
       `findings=${findings.length}`,
@@ -24314,6 +25789,7 @@ async function consolidateVault(rootDir, options = {}) {
 }
 
 // src/watch.ts
+import fs22 from "fs/promises";
 import path26 from "path";
 import process3 from "process";
 import chokidar from "chokidar";
@@ -24417,15 +25893,96 @@ function workspaceIgnoreRoots(rootDir, paths) {
 async function resolveWatchTargets(rootDir, paths, options) {
   const targets = /* @__PURE__ */ new Set([path26.resolve(paths.inboxDir)]);
   if (options.repo) {
-    for (const repoRoot of await listTrackedRepoRoots(rootDir)) {
+    for (const repoRoot of await resolveWatchedRepoRoots(rootDir, { overrideRoots: options.overrideRoots })) {
       targets.add(path26.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
 }
+function resolveRootRelative(rootDir, candidate) {
+  return path26.isAbsolute(candidate) ? path26.resolve(candidate) : path26.resolve(rootDir, candidate);
+}
+async function resolveWatchedRepoRoots(rootDir, options = {}) {
+  const override = options.overrideRoots?.filter(Boolean) ?? [];
+  if (override.length > 0) {
+    return dedupeSorted(override.map((candidate) => resolveRootRelative(rootDir, candidate)));
+  }
+  const config = options.config ?? (await loadVaultConfig(rootDir).catch(() => null))?.config;
+  const watchConfig = config?.watch ?? {};
+  const explicit = watchConfig.repoRoots?.filter(Boolean) ?? [];
+  const baseRoots = explicit.length > 0 ? explicit.map((candidate) => resolveRootRelative(rootDir, candidate)) : await listTrackedRepoRoots(rootDir);
+  const excluded = new Set(
+    (watchConfig.excludeRepoRoots ?? []).filter(Boolean).map((candidate) => resolveRootRelative(rootDir, candidate))
+  );
+  return dedupeSorted(baseRoots.filter((candidate) => !excluded.has(path26.resolve(candidate))));
+}
+async function listWatchedRoots(rootDir, options = {}) {
+  return resolveWatchedRepoRoots(rootDir, options);
+}
+function dedupeSorted(values) {
+  return [...new Set(values.map((value) => path26.resolve(value)))].sort((left, right) => left.localeCompare(right));
+}
+async function readConfigJson(rootDir) {
+  const configPath = path26.join(rootDir, "swarmvault.config.json");
+  const raw = await fs22.readFile(configPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("swarmvault.config.json must contain a JSON object.");
+  }
+  return { path: configPath, content: parsed };
+}
+async function writeConfigJson(configPath, content) {
+  await fs22.writeFile(configPath, `${JSON.stringify(content, null, 2)}
+`, "utf8");
+}
+function getWatchBlock(config) {
+  const block = config.watch;
+  if (block && typeof block === "object" && !Array.isArray(block)) {
+    return block;
+  }
+  return {};
+}
+async function addWatchedRoot(rootDir, candidate) {
+  const resolved = resolveRootRelative(rootDir, candidate);
+  const { path: configPath, content } = await readConfigJson(rootDir);
+  const watchBlock = getWatchBlock(content);
+  const current = Array.isArray(watchBlock.repoRoots) ? watchBlock.repoRoots.filter((value) => typeof value === "string") : [];
+  const resolvedSet = new Set(current.map((value) => resolveRootRelative(rootDir, value)));
+  if (!resolvedSet.has(resolved)) {
+    current.push(resolved);
+  }
+  watchBlock.repoRoots = [...new Set(current.map((value) => resolveRootRelative(rootDir, value)))].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  content.watch = watchBlock;
+  await writeConfigJson(configPath, content);
+  return resolved;
+}
+async function removeWatchedRoot(rootDir, candidate) {
+  const resolved = resolveRootRelative(rootDir, candidate);
+  const { path: configPath, content } = await readConfigJson(rootDir);
+  const watchBlock = getWatchBlock(content);
+  const current = Array.isArray(watchBlock.repoRoots) ? watchBlock.repoRoots.filter((value) => typeof value === "string") : [];
+  const filtered = current.filter((value) => resolveRootRelative(rootDir, value) !== resolved);
+  const removed = filtered.length !== current.length;
+  if (filtered.length > 0) {
+    watchBlock.repoRoots = filtered;
+    content.watch = watchBlock;
+  } else if ("repoRoots" in watchBlock) {
+    delete watchBlock.repoRoots;
+    if (Object.keys(watchBlock).length === 0) {
+      delete content.watch;
+    } else {
+      content.watch = watchBlock;
+    }
+  }
+  await writeConfigJson(configPath, content);
+  return removed;
+}
 async function performWatchCycle(rootDir, paths, options, codeOnly = false) {
   const imported = await importInbox(rootDir, paths.inboxDir);
-  const repoSync = options.repo ? await syncTrackedReposForWatch(rootDir) : null;
+  const repoRoots = options.repo ? await resolveWatchedRepoRoots(rootDir, { overrideRoots: options.overrideRoots }) : void 0;
+  const repoSync = options.repo ? await syncTrackedReposForWatch(rootDir, void 0, repoRoots) : null;
   const compile = await compileVault(rootDir, { codeOnly });
   const pendingSemanticRefresh = repoSync ? await mergePendingSemanticRefresh(rootDir, repoSync.pendingSemanticRefresh) : await readPendingSemanticRefresh(rootDir);
   const stalePagePaths = await markPagesStaleForSources(
@@ -24794,7 +26351,7 @@ async function watchVault(rootDir, options = {}) {
 }
 async function getWatchStatus(rootDir) {
   const persisted = await readWatchStatusArtifact(rootDir);
-  const watchedRepoRoots = await listTrackedRepoRoots(rootDir);
+  const watchedRepoRoots = await resolveWatchedRepoRoots(rootDir);
   const pendingSemanticRefresh = await readPendingSemanticRefresh(rootDir);
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -24805,7 +26362,7 @@ async function getWatchStatus(rootDir) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.10.0";
+var SERVER_VERSION = "0.11.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -25237,7 +26794,7 @@ async function createMcpServer(rootDir) {
       }
       const { paths } = await loadVaultConfig(rootDir);
       const absolutePath = path27.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs22.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs23.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -25270,7 +26827,7 @@ async function createMcpServer(rootDir) {
       if (!isPathWithin(paths.sessionsDir, absolutePath) || !await fileExists(absolutePath)) {
         return asTextResource(`swarmvault://sessions/${encodedPath}`, `Session not found: ${relativePath}`);
       }
-      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs22.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs23.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -25329,7 +26886,7 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 import path28 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
   return path28.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
@@ -25438,13 +26995,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs23.open(leasePath, "wx");
+  const handle = await fs24.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs23.rm(leasePath, { force: true });
+    await fs24.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -25603,7 +27160,7 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/sources.ts
 import { spawn as spawn2 } from "child_process";
-import fs24 from "fs/promises";
+import fs25 from "fs/promises";
 import path29 from "path";
 import matter13 from "gray-matter";
 import { JSDOM as JSDOM3 } from "jsdom";
@@ -25625,7 +27182,7 @@ var DOCS_HINT_SEGMENTS = /* @__PURE__ */ new Set([
   "apis",
   "getting-started"
 ]);
-function uniqueStrings4(values) {
+function uniqueStrings5(values) {
   return uniqueBy(values.filter(Boolean), (value) => value);
 }
 function sourceOutputSchemaHash(schemas, projectIds) {
@@ -25634,7 +27191,7 @@ function sourceOutputSchemaHash(schemas, projectIds) {
   }
   return composeVaultSchema(
     schemas.root,
-    uniqueStrings4([...projectIds].sort((left, right) => left.localeCompare(right))).map((projectId) => schemas.projects[projectId]).filter((schema) => Boolean(schema?.hash))
+    uniqueStrings5([...projectIds].sort((left, right) => left.localeCompare(right))).map((projectId) => schemas.projects[projectId]).filter((schema) => Boolean(schema?.hash))
   ).hash;
 }
 function normalizeManagedStatus(value) {
@@ -25656,7 +27213,7 @@ function withinRoot2(rootPath, targetPath) {
 async function findNearestGitRoot3(startPath) {
   let current = path29.resolve(startPath);
   try {
-    const stat = await fs24.stat(current);
+    const stat = await fs25.stat(current);
     if (!stat.isDirectory()) {
       current = path29.dirname(current);
     }
@@ -25772,7 +27329,7 @@ async function fetchHtml(url) {
 async function crawlDocsSource(url, maxPages, maxDepth) {
   const startUrl = new URL(normalizeUrlWithoutHash(url));
   const initial = await fetchHtml(startUrl.toString());
-  const sameDomainDocsLinks = uniqueStrings4(
+  const sameDomainDocsLinks = uniqueStrings5(
     initial.links.filter((candidate) => {
       const parsed = new URL(candidate);
       return isAllowedDocsCandidate(parsed, startUrl);
@@ -25837,7 +27394,7 @@ function matchesManagedSourceSpec(existing, input) {
 async function resolveManagedSourceInput(rootDir, input) {
   const absoluteInput = path29.resolve(rootDir, input);
   if (!(input.startsWith("http://") || input.startsWith("https://"))) {
-    const stat = await fs24.stat(absoluteInput).catch(() => null);
+    const stat = await fs25.stat(absoluteInput).catch(() => null);
     if (!stat) {
       throw new Error(`Source not found: ${input}`);
     }
@@ -25958,7 +27515,7 @@ async function runGitCommand(cwd, args) {
 async function syncGitHubRepoSource(rootDir, entry) {
   const workingDir = await managedSourceWorkingDir(rootDir, entry.id);
   const checkoutDir = path29.join(workingDir, "checkout");
-  await fs24.rm(checkoutDir, { recursive: true, force: true });
+  await fs25.rm(checkoutDir, { recursive: true, force: true });
   await ensureDir(workingDir);
   if (!entry.url) {
     throw new Error(`Managed source ${entry.id} is missing its repository URL.`);
@@ -25998,7 +27555,7 @@ async function syncCrawlSource(rootDir, entry, options) {
   }
   return {
     title: crawl.title,
-    sourceIds: uniqueStrings4(currentSourceIds).sort((left, right) => left.localeCompare(right)),
+    sourceIds: uniqueStrings5(currentSourceIds).sort((left, right) => left.localeCompare(right)),
     counts: {
       scannedCount: crawl.pages.length,
       importedCount,
@@ -26097,10 +27654,10 @@ function renderDeterministicSourceBrief(input) {
   const sourcePages = input.sourcePages.filter((page) => page.kind === "source").slice(0, 6);
   const conceptPages = input.sourcePages.filter((page) => page.kind === "concept").slice(0, 6);
   const entityPages = input.sourcePages.filter((page) => page.kind === "entity").slice(0, 6);
-  const questions = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 5);
+  const questions = uniqueStrings5(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 5);
   const summary = truncate(
     normalizeWhitespace(
-      uniqueStrings4(input.analyses.map((analysis) => analysis.summary).filter(Boolean)).join(" ") || `${input.source.title} has been compiled into a local source graph.`
+      uniqueStrings5(input.analyses.map((analysis) => analysis.summary).filter(Boolean)).join(" ") || `${input.source.title} has been compiled into a local source graph.`
     ),
     320
   );
@@ -26224,7 +27781,7 @@ async function writeSourceBriefForScope(rootDir, source) {
   const relatedPages = graph ? scopedSourcePages(graph, source.sourceIds) : [];
   const relatedPageIds = relatedPages.slice(0, 12).map((page) => page.id);
   const relatedNodeIds = graph ? scopedNodeIds(graph, source.sourceIds).slice(0, 20) : [];
-  const projectIds = uniqueStrings4(relatedPages.flatMap((page) => page.projectIds));
+  const projectIds = uniqueStrings5(relatedPages.flatMap((page) => page.projectIds));
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const output = buildOutputPage({
     title: `Source Brief: ${source.title}`,
@@ -26251,7 +27808,7 @@ async function writeSourceBriefForScope(rootDir, source) {
   });
   const absolutePath = path29.join(paths.wikiDir, output.page.path);
   await ensureDir(path29.dirname(absolutePath));
-  await fs24.writeFile(absolutePath, output.content, "utf8");
+  await fs25.writeFile(absolutePath, output.content, "utf8");
   return absolutePath;
 }
 async function writeSourceBrief(rootDir, source) {
@@ -26343,7 +27900,7 @@ function scopeOccurredAt(manifests) {
   return manifests.map((manifest) => manifest.details?.occurred_at).filter((value) => typeof value === "string" && value.trim().length > 0).sort((left, right) => right.localeCompare(left))[0];
 }
 function scopeParticipants(manifests) {
-  return uniqueStrings4(manifests.flatMap((manifest) => splitDelimitedDetail(manifest.details?.participants)));
+  return uniqueStrings5(manifests.flatMap((manifest) => splitDelimitedDetail(manifest.details?.participants)));
 }
 function scopeContainerTitle(manifests) {
   return manifests.find((manifest) => manifest.details?.container_title)?.details?.container_title ?? manifests[0]?.sourceGroupTitle;
@@ -26363,9 +27920,9 @@ function classifyGuidedEvidenceState(scope, targetPage, contradictions) {
 function renderDeterministicSourceReview(input) {
   const canonicalPages = input.sourcePages.filter((page) => page.kind === "source" || page.kind === "concept" || page.kind === "entity").slice(0, 10);
   const modulePages = input.sourcePages.filter((page) => page.kind === "module").slice(0, 8);
-  const questions = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 8);
-  const concepts = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.concepts.map((concept) => concept.name))).slice(0, 8);
-  const entities = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.entities.map((entity) => entity.name))).slice(0, 8);
+  const questions = uniqueStrings5(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 8);
+  const concepts = uniqueStrings5(input.analyses.flatMap((analysis) => analysis.concepts.map((concept) => concept.name))).slice(0, 8);
+  const entities = uniqueStrings5(input.analyses.flatMap((analysis) => analysis.entities.map((entity) => entity.name))).slice(0, 8);
   const contradictions = input.report?.contradictions.filter(
     (contradiction) => input.scope.sourceIds.includes(contradiction.sourceIdA) || input.scope.sourceIds.includes(contradiction.sourceIdB)
   ) ?? [];
@@ -26471,7 +28028,7 @@ async function buildSourceReviewStagedPage(rootDir, scope) {
   const relatedPages = graph ? scopedSourcePages(graph, scope.sourceIds) : [];
   const relatedPageIds = relatedPages.slice(0, 16).map((page) => page.id);
   const relatedNodeIds = graph ? scopedNodeIds(graph, scope.sourceIds).slice(0, 24) : [];
-  const projectIds = uniqueStrings4(relatedPages.flatMap((page) => page.projectIds));
+  const projectIds = uniqueStrings5(relatedPages.flatMap((page) => page.projectIds));
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const output = buildOutputPage({
     title: `Source Review: ${scope.title}`,
@@ -26561,7 +28118,7 @@ function insightTitleForTarget(page, scope) {
   return `${scope.title} Notes`;
 }
 function insightTagsForTarget(page) {
-  return uniqueStrings4(["insight", "guided-session", `guided/${page?.kind ?? "topic"}`]);
+  return uniqueStrings5(["insight", "guided-session", `guided/${page?.kind ?? "topic"}`]);
 }
 function guidedUpdateMarker(scopeId) {
   return {
@@ -26590,14 +28147,14 @@ ${block}
 function renderDeterministicSourceGuide(input) {
   const { canonicalPages, newPages, reinforcingPages } = classifySourceGuidePageBuckets(input.sourcePages, input.scope.sourceIds);
   const modulePages = input.sourcePages.filter((page) => page.kind === "module").slice(0, 6);
-  const takeaways = uniqueStrings4(
+  const takeaways = uniqueStrings5(
     input.analyses.flatMap((analysis) => [
       analysis.summary,
       ...analysis.concepts.map((concept) => concept.description),
       ...analysis.entities.map((entity) => entity.description)
     ]).filter(Boolean).map((value) => normalizeWhitespace(value))
   ).slice(0, 7).map((value) => truncate(value, 180));
-  const questions = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 6);
+  const questions = uniqueStrings5(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 6);
   const contradictions = input.report?.contradictions.filter(
     (contradiction) => input.scope.sourceIds.includes(contradiction.sourceIdA) || input.scope.sourceIds.includes(contradiction.sourceIdB)
   ) ?? [];
@@ -26719,7 +28276,7 @@ async function buildSourceGuideStagedPage(rootDir, scope) {
   const selectedTargets = selectGuidedTargetPages(scope, relatedPages, defaultGuidedSessionQuestions());
   const relatedPageIds = relatedPages.slice(0, 18).map((page) => page.id);
   const relatedNodeIds = graph ? scopedNodeIds(graph, scope.sourceIds).slice(0, 28) : [];
-  const projectIds = uniqueStrings4(relatedPages.flatMap((page) => page.projectIds));
+  const projectIds = uniqueStrings5(relatedPages.flatMap((page) => page.projectIds));
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const output = buildOutputPage({
     title: `Source Guide: ${scope.title}`,
@@ -26821,7 +28378,7 @@ async function buildSourceSessionSavedPage(rootDir, scope, session) {
   const analyses = await loadSourceAnalyses(rootDir, scope.sourceIds);
   const report = await readGraphReport(rootDir);
   const contradictions = findContradictionsForScope(scope, report);
-  const relatedPageIds = uniqueStrings4([
+  const relatedPageIds = uniqueStrings5([
     ...sourcePages.slice(0, 18).map((page) => page.id),
     ...session.targetedPagePaths.map((relativePath) => {
       const page = graph?.pages.find((candidate) => candidate.path === relativePath);
@@ -26829,7 +28386,7 @@ async function buildSourceSessionSavedPage(rootDir, scope, session) {
     })
   ]);
   const relatedNodeIds = graph ? scopedNodeIds(graph, scope.sourceIds).slice(0, 28) : [];
-  const projectIds = uniqueStrings4(sourcePages.flatMap((page) => page.projectIds));
+  const projectIds = uniqueStrings5(sourcePages.flatMap((page) => page.projectIds));
   const evidenceState = contradictions.length > 0 ? "conflicting" : session.targetedPagePaths.some(
     (targetPath) => sourcePages.some((page) => page.path === targetPath && page.sourceIds.some((sourceId) => !scope.sourceIds.includes(sourceId)))
   ) ? "reinforcing" : session.targetedPagePaths.length ? "new" : "needs_judgment";
@@ -26864,7 +28421,7 @@ async function buildSourceSessionSavedPage(rootDir, scope, session) {
       if (followups) {
         return followups.split(/\n+/).map((line) => line.trim()).filter(Boolean).map((line) => `- ${line.replace(/^-+\s*/, "")}`);
       }
-      const analysisQuestions = uniqueStrings4(analyses.flatMap((analysis) => analysis.questions)).slice(0, 6);
+      const analysisQuestions = uniqueStrings5(analyses.flatMap((analysis) => analysis.questions)).slice(0, 6);
       return analysisQuestions.length ? analysisQuestions.map((question) => `- ${question}`) : ["- No follow-up questions recorded yet."];
     })(),
     "",
@@ -26918,7 +28475,7 @@ async function persistSourceSessionPage(rootDir, scope, session) {
   const output = await buildSourceSessionSavedPage(rootDir, scope, session);
   const absolutePath = path29.join(paths.wikiDir, output.page.path);
   await ensureDir(path29.dirname(absolutePath));
-  await fs24.writeFile(absolutePath, output.content, "utf8");
+  await fs25.writeFile(absolutePath, output.content, "utf8");
   return { pageId: output.page.id, sessionPath: absolutePath };
 }
 async function buildGuidedUpdatePages(rootDir, scope, session) {
@@ -26939,7 +28496,7 @@ async function buildGuidedUpdatePages(rootDir, scope, session) {
   const selectedTargets = selectGuidedTargetPages(scope, sourcePages, session.questions);
   const useCanonicalTargets = config.profile.guidedSessionMode === "canonical_review" && selectedTargets.length > 0;
   const targetPages = useCanonicalTargets ? selectedTargets : [selectedTargets[0] ?? null];
-  session.targetedPagePaths = uniqueStrings4(
+  session.targetedPagePaths = uniqueStrings5(
     useCanonicalTargets ? selectedTargets.map((page) => page.path) : selectedTargets.length ? selectedTargets.map((page) => page.path) : session.targetedPagePaths
   );
   return await Promise.all(
@@ -26947,7 +28504,7 @@ async function buildGuidedUpdatePages(rootDir, scope, session) {
       const evidenceState = classifyGuidedEvidenceState(scope, targetPage, contradictions);
       const relativePath = useCanonicalTargets && targetPage ? targetPage.path : targetPage ? insightRelativePathForTarget(targetPage, scope) : `insights/topics/${slugify(scope.title)}.md`;
       const absolutePath = path29.join(paths.wikiDir, relativePath);
-      const existingContent = await fileExists(absolutePath) ? await fs24.readFile(absolutePath, "utf8") : "";
+      const existingContent = await fileExists(absolutePath) ? await fs25.readFile(absolutePath, "utf8") : "";
       const parsed = existingContent ? matter13(existingContent) : { data: {}, content: "" };
       const existingData = parsed.data;
       const existingSourceIds = Array.isArray(existingData.source_ids) ? existingData.source_ids.filter((value) => typeof value === "string") : [];
@@ -27018,24 +28575,24 @@ async function buildGuidedUpdatePages(rootDir, scope, session) {
             page_id: typeof existingData.page_id === "string" && existingData.page_id.trim() || (useCanonicalTargets && targetPage ? targetPage.id : `insight:${slugify(relativePath.replace(/\.md$/, ""))}`),
             kind: useCanonicalTargets && targetPage ? targetPage.kind : "insight",
             title,
-            tags: uniqueStrings4([
+            tags: uniqueStrings5([
               ...Array.isArray(existingData.tags) ? existingData.tags.filter((value) => typeof value === "string") : [],
               ...useCanonicalTargets ? ["guided-session", `guided/${targetPage?.kind ?? "page"}`] : insightTagsForTarget(targetPage)
             ]),
-            source_ids: uniqueStrings4([...existingSourceIds, ...scope.sourceIds]),
-            project_ids: uniqueStrings4([...existingProjectIds, ...targetPage?.projectIds ?? []]),
-            node_ids: uniqueStrings4([...existingNodeIds, ...targetPage?.nodeIds ?? []]),
+            source_ids: uniqueStrings5([...existingSourceIds, ...scope.sourceIds]),
+            project_ids: uniqueStrings5([...existingProjectIds, ...targetPage?.projectIds ?? []]),
+            node_ids: uniqueStrings5([...existingNodeIds, ...targetPage?.nodeIds ?? []]),
             freshness: "fresh",
             status: existingData.status === "archived" ? "archived" : "active",
             confidence: 0.83,
             created_at: createdAt,
             updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-            compiled_from: uniqueStrings4([
+            compiled_from: uniqueStrings5([
               ...Array.isArray(existingData.compiled_from) ? existingData.compiled_from.filter((value) => typeof value === "string") : [],
               ...scope.sourceIds
             ]),
             managed_by: typeof existingData.managed_by === "string" && (existingData.managed_by === "human" || existingData.managed_by === "system") ? existingData.managed_by : useCanonicalTargets ? "system" : "human",
-            backlinks: uniqueStrings4([
+            backlinks: uniqueStrings5([
               ...existingBacklinks,
               ...targetPage ? [targetPage.id] : [],
               `output:source-sessions/${scope.id}`,
@@ -27062,7 +28619,7 @@ async function buildGuidedUpdatePages(rootDir, scope, session) {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
       if (!useCanonicalTargets && !selectedTargets.length) {
-        session.targetedPagePaths = uniqueStrings4([...session.targetedPagePaths, relativePath]);
+        session.targetedPagePaths = uniqueStrings5([...session.targetedPagePaths, relativePath]);
       }
       return { page, content, label: "guided-update" };
     })
@@ -27385,7 +28942,7 @@ async function deleteManagedSource(rootDir, id) {
     sources.filter((source) => source.id !== id)
   );
   const workingDir = await managedSourceWorkingDir(rootDir, id);
-  await fs24.rm(workingDir, { recursive: true, force: true });
+  await fs25.rm(workingDir, { recursive: true, force: true });
   return { removed: target };
 }
 
@@ -27393,7 +28950,7 @@ async function deleteManagedSource(rootDir, id) {
 import { execFile as execFile2 } from "child_process";
 import { randomUUID } from "crypto";
 import { EventEmitter } from "events";
-import fs25 from "fs/promises";
+import fs26 from "fs/promises";
 import http from "http";
 import path30 from "path";
 import { promisify as promisify2 } from "util";
@@ -27549,7 +29106,7 @@ function toViewerLintFindings(findings) {
 var execFileAsync2 = promisify2(execFile2);
 async function isReadableFile(absolutePath) {
   try {
-    const stats = await fs25.stat(absolutePath);
+    const stats = await fs26.stat(absolutePath);
     return stats.isFile();
   } catch {
     return false;
@@ -27564,7 +29121,7 @@ async function readViewerPage(rootDir, relativePath) {
   if (!isPathWithin(paths.wikiDir, absolutePath) || !await isReadableFile(absolutePath)) {
     return null;
   }
-  const raw = await fs25.readFile(absolutePath, "utf8");
+  const raw = await fs26.readFile(absolutePath, "utf8");
   const parsed = matter14(raw);
   return {
     path: relativePath,
@@ -27584,7 +29141,7 @@ async function readViewerAsset(rootDir, relativePath) {
     return null;
   }
   return {
-    buffer: await fs25.readFile(absolutePath),
+    buffer: await fs26.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -27705,7 +29262,7 @@ async function startGraphServer(rootDir, port, options = {}) {
           response.end(JSON.stringify({ error: "Graph report artifact not found. Run `swarmvault compile` first." }));
           return;
         }
-        const body = await fs25.readFile(reportPath, "utf8");
+        const body = await fs26.readFile(reportPath, "utf8");
         response.writeHead(200, { "content-type": "application/json" });
         response.end(body);
         return;
@@ -27910,7 +29467,7 @@ async function startGraphServer(rootDir, port, options = {}) {
         response.end("Viewer build not found. Run `pnpm build` first.");
         return;
       }
-      const staticBody = await fs25.readFile(filePath);
+      const staticBody = await fs26.readFile(filePath);
       response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
       response.end(staticBody);
     } catch (error) {
@@ -27976,7 +29533,7 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
       } : null;
     })
   );
-  const rawHtml = await fs25.readFile(indexPath, "utf8");
+  const rawHtml = await fs26.readFile(indexPath, "utf8");
   const scriptMatch = rawHtml.match(/<script type="module" crossorigin src="([^"]+)"><\/script>/);
   const styleMatch = rawHtml.match(/<link rel="stylesheet" crossorigin href="([^"]+)">/);
   const scriptPath = scriptMatch?.[1] ? path30.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
@@ -27984,8 +29541,8 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
   if (!scriptPath || !await fileExists(scriptPath)) {
     throw new Error("Viewer script bundle not found. Run `pnpm build` first.");
   }
-  const script = await fs25.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs25.readFile(stylePath, "utf8") : "";
+  const script = await fs26.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs26.readFile(stylePath, "utf8") : "";
   const report = await readJsonFile(path30.join(paths.wikiDir, "graph", "report.json"));
   const embeddedData = JSON.stringify(
     { graph: buildViewerGraphArtifact(graph, { report, full: options.full ?? false }), pages: pages.filter(Boolean), report },
@@ -28009,8 +29566,8 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs25.mkdir(path30.dirname(outputPath), { recursive: true });
-  await fs25.writeFile(outputPath, html, "utf8");
+  await fs26.mkdir(path30.dirname(outputPath), { recursive: true });
+  await fs26.writeFile(outputPath, html, "utf8");
   return path30.resolve(outputPath);
 }
 export {
@@ -28020,9 +29577,11 @@ export {
   DEFAULT_PROMOTION_CONFIG,
   DEFAULT_REDACTION_PATTERNS,
   DEFAULT_STALE_THRESHOLD,
+  LARGE_REPO_NODE_THRESHOLD,
   acceptApproval,
   addInput,
   addManagedSource,
+  addWatchedRoot,
   applyDecayToPages,
   archiveCandidate,
   assertProviderCapability,
@@ -28080,6 +29639,7 @@ export {
   listPages,
   listSchedules,
   listTrackedRepoRoots,
+  listWatchedRoots,
   loadVaultConfig,
   loadVaultSchema,
   loadVaultSchemas,
@@ -28097,11 +29657,14 @@ export {
   readPage,
   rejectApproval,
   reloadManagedSources,
+  removeWatchedRoot,
   resetDecay,
   resolveConsolidationConfig,
   resolveDecayConfig,
+  resolveLargeRepoDefaults,
   resolvePaths,
   resolveRedactionPatterns,
+  resolveWatchedRepoRoots,
   resumeSourceSession,
   reviewManagedSource,
   reviewSourceScope,
@@ -28117,6 +29680,7 @@ export {
   startMcpServer,
   syncTrackedRepos,
   syncTrackedReposForWatch,
+  synthesizeHyperedgeHubs,
   trimToTokenBudget,
   uninstallGitHooks,
   watchVault