@swarmvaultai/engine 0.1.25 → 0.1.27

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-6UPHDGEB.js";
+} from "./chunk-LEUV6TWJ.js";
 
 // src/agents.ts
 import fs from "fs/promises";
@@ -662,7 +662,8 @@ async function uninstallGitHooks(rootDir) {
 
 // src/ingest.ts
 import fs9 from "fs/promises";
-import path9 from "path";
+import path10 from "path";
+import { pathToFileURL } from "url";
 import { Readability } from "@mozilla/readability";
 import matter3 from "gray-matter";
 import ignore from "ignore";
@@ -3143,9 +3144,68 @@ async function appendWatchRun(rootDir, run) {
   await appendJsonLine(paths.jobsLogPath, run);
 }
 
+// src/source-classification.ts
+import path8 from "path";
+var ALL_SOURCE_CLASSES = ["first_party", "third_party", "resource", "generated"];
+var THIRD_PARTY_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "vendor", "Pods"]);
+var GENERATED_SEGMENTS = /* @__PURE__ */ new Set(["dist", "build", ".next", "coverage", "DerivedData", "target"]);
+function matchesAnyGlob(relativePath, patterns) {
+  return patterns.some(
+    (pattern) => path8.matchesGlob(relativePath, pattern) || path8.matchesGlob(path8.posix.basename(relativePath), pattern)
+  );
+}
+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/watch-state.ts
 import fs8 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 import matter2 from "gray-matter";
 function pendingEntryKey(entry) {
   return entry.path;
@@ -3159,7 +3219,7 @@ function normalizeRelativePath(rootDir, filePath) {
   if (!filePath) {
     return void 0;
   }
-  return toPosix(path8.relative(rootDir, path8.resolve(filePath)));
+  return toPosix(path9.relative(rootDir, path9.resolve(filePath)));
 }
 async function readPendingSemanticRefresh(rootDir) {
   const { paths } = await initWorkspace(rootDir);
@@ -3253,7 +3313,7 @@ async function markPagesStaleForSources(rootDir, sourceIds) {
     if (page.freshness !== "stale" || !page.sourceIds.some((sourceId) => affectedSourceIds.has(sourceId))) {
       continue;
     }
-    const absolutePath = path8.join(paths.wikiDir, page.path);
+    const absolutePath = path9.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
@@ -3272,7 +3332,7 @@ async function markPagesStaleForSources(rootDir, sourceIds) {
 // src/ingest.ts
 var DEFAULT_MAX_ASSET_SIZE = 10 * 1024 * 1024;
 var DEFAULT_MAX_DIRECTORY_FILES = 5e3;
-var BUILT_IN_REPO_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
+var HARD_REPO_IGNORES = /* @__PURE__ */ new Set([".git", ".venv"]);
 function uniqueStrings(values) {
   return [...new Set(values.filter(Boolean))];
 }
@@ -3283,6 +3343,9 @@ function inferKind(mimeType, filePath) {
   if (mimeType.includes("markdown")) {
     return "markdown";
   }
+  if (mimeType.includes("html")) {
+    return "html";
+  }
   if (mimeType.startsWith("text/")) {
     return "text";
   }
@@ -3292,9 +3355,6 @@ function inferKind(mimeType, filePath) {
   if (mimeType.startsWith("image/")) {
     return "image";
   }
-  if (mimeType.includes("html")) {
-    return "html";
-  }
   return "binary";
 }
 function titleFromText(fallback, content) {
@@ -3308,36 +3368,47 @@ function normalizeIngestOptions(options) {
   return {
     includeAssets: options?.includeAssets ?? true,
     maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE)),
-    repoRoot: options?.repoRoot ? path9.resolve(options.repoRoot) : void 0,
+    repoRoot: options?.repoRoot ? path10.resolve(options.repoRoot) : void 0,
     include: (options?.include ?? []).map((pattern) => pattern.trim()).filter(Boolean),
     exclude: (options?.exclude ?? []).map((pattern) => pattern.trim()).filter(Boolean),
     maxFiles: Math.max(1, Math.floor(options?.maxFiles ?? DEFAULT_MAX_DIRECTORY_FILES)),
-    gitignore: options?.gitignore ?? true
+    gitignore: options?.gitignore ?? true,
+    extractClasses: options?.extractClasses ?? ["first_party"]
   };
 }
-function matchesAnyGlob(relativePath, patterns) {
+async function resolveRepoIngestOptions(rootDir, options) {
+  const normalized = normalizeIngestOptions(options);
+  const { config } = await loadVaultConfig(rootDir);
+  const repoAnalysis = config.repoAnalysis;
+  return {
+    ...normalized,
+    extractClasses: normalizeExtractClasses(repoAnalysis, normalized.extractClasses),
+    repoAnalysis
+  };
+}
+function matchesAnyGlob2(relativePath, patterns) {
   return patterns.some(
-    (pattern) => path9.matchesGlob(relativePath, pattern) || path9.matchesGlob(path9.posix.basename(relativePath), pattern)
+    (pattern) => path10.matchesGlob(relativePath, pattern) || path10.matchesGlob(path10.posix.basename(relativePath), pattern)
   );
 }
 function supportedDirectoryKind(sourceKind) {
   return sourceKind !== "binary";
 }
 async function findNearestGitRoot2(startPath) {
-  let current = path9.resolve(startPath);
+  let current = path10.resolve(startPath);
   try {
     const stat = await fs9.stat(current);
     if (!stat.isDirectory()) {
-      current = path9.dirname(current);
+      current = path10.dirname(current);
     }
   } catch {
-    current = path9.dirname(current);
+    current = path10.dirname(current);
   }
   while (true) {
-    if (await fileExists(path9.join(current, ".git"))) {
+    if (await fileExists(path10.join(current, ".git"))) {
       return current;
     }
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -3345,26 +3416,26 @@ async function findNearestGitRoot2(startPath) {
   }
 }
 function withinRoot(rootPath, targetPath) {
-  const relative = path9.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path9.isAbsolute(relative);
+  const relative = path10.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path10.isAbsolute(relative);
 }
 function repoRootFromManifest(manifest) {
   if (manifest.originType !== "file" || !manifest.originalPath || !manifest.repoRelativePath) {
     return null;
   }
-  const repoDir = path9.posix.dirname(manifest.repoRelativePath);
-  const fileDir = path9.dirname(path9.resolve(manifest.originalPath));
+  const repoDir = path10.posix.dirname(manifest.repoRelativePath);
+  const fileDir = path10.dirname(path10.resolve(manifest.originalPath));
   if (repoDir === "." || !repoDir) {
     return fileDir;
   }
   const segments = repoDir.split("/").filter(Boolean);
-  return path9.resolve(fileDir, ...segments.map(() => ".."));
+  return path10.resolve(fileDir, ...segments.map(() => ".."));
 }
 function repoRelativePathFor(absolutePath, repoRoot) {
   if (!repoRoot || !withinRoot(repoRoot, absolutePath)) {
     return void 0;
   }
-  const relative = toPosix(path9.relative(repoRoot, absolutePath));
+  const relative = toPosix(path10.relative(repoRoot, absolutePath));
   return relative && !relative.startsWith("..") ? relative : void 0;
 }
 function normalizeOriginUrl(input) {
@@ -3661,7 +3732,7 @@ function buildCompositeHash(payloadBytes, attachments = []) {
   return sha256(`${sha256(payloadBytes)}|${attachmentSignature}`);
 }
 function sanitizeAssetRelativePath(value) {
-  const normalized = path9.posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = path10.posix.normalize(value.replace(/\\/g, "/"));
   const segments = normalized.split("/").filter(Boolean).map((segment) => {
     if (segment === ".") {
       return "";
@@ -3681,7 +3752,7 @@ function normalizeLocalReference(value) {
     return null;
   }
   const lowered = candidate.toLowerCase();
-  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path9.isAbsolute(candidate)) {
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path10.isAbsolute(candidate)) {
     return null;
   }
   return candidate.replace(/\\/g, "/");
@@ -3748,7 +3819,7 @@ async function readManifestByHash(manifestsDir, contentHash) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path9.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path10.join(manifestsDir, entry.name));
     if (manifest?.contentHash === contentHash) {
       return manifest;
     }
@@ -3761,7 +3832,7 @@ async function readManifestByOrigin(manifestsDir, prepared) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path9.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path10.join(manifestsDir, entry.name));
     if (manifest && manifestMatchesOrigin(manifest, prepared)) {
       return manifest;
     }
@@ -3772,7 +3843,7 @@ async function loadGitignoreMatcher(repoRoot, enabled) {
   if (!enabled) {
     return null;
   }
-  const gitignorePath = path9.join(repoRoot, ".gitignore");
+  const gitignorePath = path10.join(repoRoot, ".gitignore");
   if (!await fileExists(gitignorePath)) {
     return null;
   }
@@ -3782,12 +3853,15 @@ async function loadGitignoreMatcher(repoRoot, enabled) {
 }
 function builtInIgnoreReason(relativePath) {
   for (const segment of relativePath.split("/")) {
-    if (BUILT_IN_REPO_IGNORES.has(segment)) {
+    if (HARD_REPO_IGNORES.has(segment)) {
       return `built_in_ignore:${segment}`;
     }
   }
   return null;
 }
+function sourceClassForRelativePath(relativePath, options) {
+  return classifyRepoPath(relativePath, options.repoAnalysis);
+}
 async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
   const matcher = await loadGitignoreMatcher(repoRoot, options.gitignore);
   const skipped = [];
@@ -3801,20 +3875,20 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
     const entries = await fs9.readdir(currentDir, { withFileTypes: true });
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const absolutePath = path9.join(currentDir, entry.name);
-      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path9.relative(inputDir, absolutePath));
+      const absolutePath = path10.join(currentDir, entry.name);
+      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(inputDir, absolutePath));
       const relativePath = relativeToRepo || entry.name;
       const builtInReason = builtInIgnoreReason(relativePath);
       if (builtInReason) {
-        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: builtInReason });
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: builtInReason });
         continue;
       }
       if (matcher?.ignores(relativePath)) {
-        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "gitignore" });
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "gitignore" });
         continue;
       }
-      if (matchesAnyGlob(relativePath, options.exclude)) {
-        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "exclude_glob" });
+      if (matchesAnyGlob2(relativePath, options.exclude)) {
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "exclude_glob" });
         continue;
       }
       if (entry.isDirectory()) {
@@ -3822,21 +3896,26 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
         continue;
       }
       if (!entry.isFile()) {
-        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
         continue;
       }
-      if (options.include.length > 0 && !matchesAnyGlob(relativePath, options.include)) {
-        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "include_glob" });
+      if (options.include.length > 0 && !matchesAnyGlob2(relativePath, options.include)) {
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "include_glob" });
         continue;
       }
       const mimeType = guessMimeType(absolutePath);
       const sourceKind = inferKind(mimeType, absolutePath);
+      const sourceClass = sourceClassForRelativePath(relativePath, options);
       if (!supportedDirectoryKind(sourceKind)) {
-        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+        continue;
+      }
+      if (!options.extractClasses.includes(sourceClass)) {
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: `source_class:${sourceClass}` });
         continue;
       }
       if (files.length >= options.maxFiles) {
-        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "max_files" });
+        skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "max_files" });
         continue;
       }
       files.push(absolutePath);
@@ -3858,12 +3937,12 @@ function resolveUrlMimeType(input, response) {
 function buildRemoteAssetRelativePath(assetUrl, mimeType) {
   const url = new URL(assetUrl);
   const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
-  const extension = path9.posix.extname(normalized);
-  const directory = path9.posix.dirname(normalized);
-  const basename = extension ? path9.posix.basename(normalized, extension) : path9.posix.basename(normalized);
+  const extension = path10.posix.extname(normalized);
+  const directory = path10.posix.dirname(normalized);
+  const basename = extension ? path10.posix.basename(normalized, extension) : path10.posix.basename(normalized);
   const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
   const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
-  return directory === "." ? hashedName : path9.posix.join(directory, hashedName);
+  return directory === "." ? hashedName : path10.posix.join(directory, hashedName);
 }
 async function readResponseBytesWithinLimit(response, maxBytes) {
   const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
@@ -3990,7 +4069,7 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   const extractionHash = prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact);
   const existingByOrigin = await readManifestByOrigin(paths.manifestsDir, prepared);
   const existingByHash = existingByOrigin ? null : await readManifestByHash(paths.manifestsDir, contentHash);
-  if (existingByOrigin && existingByOrigin.contentHash === contentHash && existingByOrigin.extractionHash === extractionHash && existingByOrigin.title === prepared.title && existingByOrigin.sourceKind === prepared.sourceKind && existingByOrigin.sourceType === prepared.sourceType && existingByOrigin.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath) {
+  if (existingByOrigin && existingByOrigin.contentHash === contentHash && existingByOrigin.extractionHash === extractionHash && existingByOrigin.title === prepared.title && existingByOrigin.sourceKind === prepared.sourceKind && existingByOrigin.sourceType === prepared.sourceType && existingByOrigin.sourceClass === prepared.sourceClass && existingByOrigin.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath) {
     return { manifest: existingByOrigin, isNew: false, wasUpdated: false };
   }
   if (existingByHash) {
@@ -3999,18 +4078,18 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   const previous = existingByOrigin ?? void 0;
   const sourceId = previous?.sourceId ?? `${slugify(prepared.title)}-${contentHash.slice(0, 8)}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const storedPath = path9.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
-  const extractedTextPath = prepared.extractedText ? path9.join(paths.extractsDir, `${sourceId}.md`) : void 0;
-  const extractedMetadataPath = prepared.extractionArtifact ? path9.join(paths.extractsDir, `${sourceId}.json`) : void 0;
-  const attachmentsDir = path9.join(paths.rawAssetsDir, sourceId);
+  const storedPath = path10.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
+  const extractedTextPath = prepared.extractedText ? path10.join(paths.extractsDir, `${sourceId}.md`) : void 0;
+  const extractedMetadataPath = prepared.extractionArtifact ? path10.join(paths.extractsDir, `${sourceId}.json`) : void 0;
+  const attachmentsDir = path10.join(paths.rawAssetsDir, sourceId);
   if (previous?.storedPath) {
-    await fs9.rm(path9.resolve(rootDir, previous.storedPath), { force: true });
+    await fs9.rm(path10.resolve(rootDir, previous.storedPath), { force: true });
   }
   if (previous?.extractedTextPath) {
-    await fs9.rm(path9.resolve(rootDir, previous.extractedTextPath), { force: true });
+    await fs9.rm(path10.resolve(rootDir, previous.extractedTextPath), { force: true });
   }
   if (previous?.extractedMetadataPath) {
-    await fs9.rm(path9.resolve(rootDir, previous.extractedMetadataPath), { force: true });
+    await fs9.rm(path10.resolve(rootDir, previous.extractedMetadataPath), { force: true });
   }
   await fs9.rm(attachmentsDir, { recursive: true, force: true });
   await fs9.writeFile(storedPath, prepared.payloadBytes);
@@ -4022,11 +4101,11 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   }
   const manifestAttachments = [];
   for (const attachment of attachments) {
-    const absoluteAttachmentPath = path9.join(attachmentsDir, attachment.relativePath);
-    await ensureDir(path9.dirname(absoluteAttachmentPath));
+    const absoluteAttachmentPath = path10.join(attachmentsDir, attachment.relativePath);
+    await ensureDir(path10.dirname(absoluteAttachmentPath));
     await fs9.writeFile(absoluteAttachmentPath, attachment.bytes);
     manifestAttachments.push({
-      path: toPosix(path9.relative(rootDir, absoluteAttachmentPath)),
+      path: toPosix(path10.relative(rootDir, absoluteAttachmentPath)),
       mimeType: attachment.mimeType,
       originalPath: attachment.originalPath
     });
@@ -4037,13 +4116,14 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     originType: prepared.originType,
     sourceKind: prepared.sourceKind,
     sourceType: prepared.sourceType,
+    sourceClass: prepared.sourceClass,
     language: prepared.language,
     originalPath: prepared.originalPath,
     repoRelativePath: prepared.repoRelativePath,
     url: prepared.url,
-    storedPath: toPosix(path9.relative(rootDir, storedPath)),
-    extractedTextPath: extractedTextPath ? toPosix(path9.relative(rootDir, extractedTextPath)) : void 0,
-    extractedMetadataPath: extractedMetadataPath ? toPosix(path9.relative(rootDir, extractedMetadataPath)) : void 0,
+    storedPath: toPosix(path10.relative(rootDir, storedPath)),
+    extractedTextPath: extractedTextPath ? toPosix(path10.relative(rootDir, extractedTextPath)) : void 0,
+    extractedMetadataPath: extractedMetadataPath ? toPosix(path10.relative(rootDir, extractedMetadataPath)) : void 0,
     extractionHash,
     mimeType: prepared.mimeType,
     contentHash,
@@ -4051,7 +4131,7 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
   };
-  await writeJsonFile(path9.join(paths.manifestsDir, `${sourceId}.json`), manifest);
+  await writeJsonFile(path10.join(paths.manifestsDir, `${sourceId}.json`), manifest);
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
@@ -4069,16 +4149,16 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   return { manifest, isNew: !previous, wasUpdated: Boolean(previous) };
 }
 async function removeManifestArtifacts(rootDir, manifest, paths) {
-  await fs9.rm(path9.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
-  await fs9.rm(path9.resolve(rootDir, manifest.storedPath), { force: true });
+  await fs9.rm(path10.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
+  await fs9.rm(path10.resolve(rootDir, manifest.storedPath), { force: true });
   if (manifest.extractedTextPath) {
-    await fs9.rm(path9.resolve(rootDir, manifest.extractedTextPath), { force: true });
+    await fs9.rm(path10.resolve(rootDir, manifest.extractedTextPath), { force: true });
   }
   if (manifest.extractedMetadataPath) {
-    await fs9.rm(path9.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
+    await fs9.rm(path10.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
   }
-  await fs9.rm(path9.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
-  await fs9.rm(path9.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
+  await fs9.rm(path10.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
+  await fs9.rm(path10.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
 }
 function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
   const candidates = [
@@ -4087,14 +4167,14 @@ function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path9.join(rootDir, ".claude"),
-    path9.join(rootDir, ".cursor"),
-    path9.join(rootDir, ".obsidian")
+    path10.join(rootDir, ".claude"),
+    path10.join(rootDir, ".cursor"),
+    path10.join(rootDir, ".obsidian")
   ];
-  return candidates.map((candidate) => path9.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
+  return candidates.map((candidate) => path10.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
 }
 function preparedMatchesManifest(manifest, prepared, contentHash) {
-  return manifest.contentHash === contentHash && manifest.extractionHash === (prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact)) && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.sourceType === prepared.sourceType && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
+  return manifest.contentHash === contentHash && manifest.extractionHash === (prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact)) && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.sourceType === prepared.sourceType && manifest.sourceClass === prepared.sourceClass && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
 }
 function shouldDeferWatchSemanticRefresh(sourceKind) {
   return sourceKind === "markdown" || sourceKind === "text" || sourceKind === "html" || sourceKind === "pdf" || sourceKind === "image";
@@ -4110,19 +4190,19 @@ async function listTrackedRepoRoots(rootDir) {
 }
 async function syncTrackedRepos(rootDir, options, repoRoots) {
   const { paths } = await initWorkspace(rootDir);
-  const normalizedOptions = normalizeIngestOptions(options);
+  const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path9.resolve(item)
+    (item) => path10.resolve(item)
   );
   const uniqueRoots = [...new Set(trackedRoots)].sort((left, right) => left.localeCompare(right));
   const manifestsByRepoRoot = /* @__PURE__ */ new Map();
   for (const manifest of manifests) {
     const repoRoot = repoRootFromManifest(manifest);
-    if (!repoRoot || !uniqueRoots.includes(path9.resolve(repoRoot))) {
+    if (!repoRoot || !uniqueRoots.includes(path10.resolve(repoRoot))) {
       continue;
     }
-    const key = path9.resolve(repoRoot);
+    const key = path10.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -4147,14 +4227,15 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     skipped.push(
       ...collected.skipped,
       ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
-        path: toPosix(path9.relative(rootDir, absolutePath)),
+        path: toPosix(path10.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
-    const currentPaths = new Set(files.map((absolutePath) => path9.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path10.resolve(absolutePath)));
     for (const absolutePath of files) {
-      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
+      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(repoRoot, absolutePath));
+      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
       const result = await persistPreparedInput(rootDir, prepared, paths);
       if (result.isNew) {
         imported.push(result.manifest);
@@ -4163,7 +4244,7 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
       }
     }
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path9.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path10.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         await removeManifestArtifacts(rootDir, manifest, paths);
         removed.push(manifest);
@@ -4171,7 +4252,7 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     }
   }
   if (uniqueRoots.length > 0) {
-    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path9.relative(rootDir, repoRoot)) || ".").join(","), [
+    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path10.relative(rootDir, repoRoot)) || ".").join(","), [
       `repo_roots=${uniqueRoots.length}`,
       `scanned=${scannedCount}`,
       `imported=${imported.length}`,
@@ -4191,19 +4272,19 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
 }
 async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   const { paths } = await initWorkspace(rootDir);
-  const normalizedOptions = normalizeIngestOptions(options);
+  const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path9.resolve(item)
+    (item) => path10.resolve(item)
   );
   const uniqueRoots = [...new Set(trackedRoots)].sort((left, right) => left.localeCompare(right));
   const manifestsByRepoRoot = /* @__PURE__ */ new Map();
   for (const manifest of manifests) {
     const repoRoot = repoRootFromManifest(manifest);
-    if (!repoRoot || !uniqueRoots.includes(path9.resolve(repoRoot))) {
+    if (!repoRoot || !uniqueRoots.includes(path10.resolve(repoRoot))) {
       continue;
     }
-    const key = path9.resolve(repoRoot);
+    const key = path10.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -4218,7 +4299,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   for (const repoRoot of uniqueRoots) {
     const repoManifests = manifestsByRepoRoot.get(repoRoot) ?? [];
     const manifestsByOriginalPath = new Map(
-      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path9.resolve(manifest.originalPath), manifest])
+      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path10.resolve(manifest.originalPath), manifest])
     );
     if (!await fileExists(repoRoot)) {
       for (const manifest of repoManifests) {
@@ -4226,7 +4307,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
           pendingSemanticRefresh.push({
             id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? manifest.storedPath),
             repoRoot,
-            path: toPosix(path9.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
+            path: toPosix(path10.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -4246,16 +4327,17 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     skipped.push(
       ...collected.skipped,
       ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
-        path: toPosix(path9.relative(rootDir, absolutePath)),
+        path: toPosix(path10.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
-    const currentPaths = new Set(files.map((absolutePath) => path9.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path10.resolve(absolutePath)));
     for (const absolutePath of files) {
-      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
+      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(repoRoot, absolutePath));
+      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
       if (shouldDeferWatchSemanticRefresh(prepared.sourceKind)) {
-        const existing = manifestsByOriginalPath.get(path9.resolve(absolutePath));
+        const existing = manifestsByOriginalPath.get(path10.resolve(absolutePath));
         const contentHash = buildCompositeHash(prepared.payloadBytes, prepared.attachments);
         const changed = !existing || !preparedMatchesManifest(existing, prepared, contentHash);
         if (changed) {
@@ -4263,10 +4345,10 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
             id: pendingSemanticRefreshId(
               existing ? "modified" : "added",
               repoRoot,
-              prepared.repoRelativePath ?? toPosix(path9.relative(repoRoot, absolutePath))
+              prepared.repoRelativePath ?? toPosix(path10.relative(repoRoot, absolutePath))
             ),
             repoRoot,
-            path: toPosix(path9.relative(rootDir, absolutePath)),
+            path: toPosix(path10.relative(rootDir, absolutePath)),
             changeType: existing ? "modified" : "added",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: existing?.sourceId,
@@ -4286,13 +4368,13 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
       }
     }
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path9.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path10.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         if (shouldDeferWatchSemanticRefresh(manifest.sourceKind)) {
           pendingSemanticRefresh.push({
-            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path9.relative(repoRoot, originalPath))),
+            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path10.relative(repoRoot, originalPath))),
             repoRoot,
-            path: toPosix(path9.relative(rootDir, originalPath)),
+            path: toPosix(path10.relative(rootDir, originalPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -4310,7 +4392,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     await appendLogEntry(
       rootDir,
       "sync_repo_watch",
-      uniqueRoots.map((repoRoot) => toPosix(path9.relative(rootDir, repoRoot)) || ".").join(","),
+      uniqueRoots.map((repoRoot) => toPosix(path10.relative(rootDir, repoRoot)) || ".").join(","),
       [
         `repo_roots=${uniqueRoots.length}`,
         `scanned=${scannedCount}`,
@@ -4335,26 +4417,32 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     staleSourceIds: [...staleSourceIds]
   };
 }
-async function prepareFileInput(rootDir, absoluteInput, repoRoot) {
+async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
   const payloadBytes = await fs9.readFile(absoluteInput);
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
   const language = inferCodeLanguage(absoluteInput, mimeType);
-  const storedExtension = path9.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
+  const storedExtension = path10.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
   let title;
   let extractedText;
   let extractionArtifact;
   if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
     extractedText = payloadBytes.toString("utf8");
-    title = titleFromText(path9.basename(absoluteInput, path9.extname(absoluteInput)), extractedText);
+    title = titleFromText(path10.basename(absoluteInput, path10.extname(absoluteInput)), extractedText);
     extractionArtifact = createPlainTextExtractionArtifact(sourceKind, mimeType);
+  } else if (sourceKind === "html") {
+    const html = payloadBytes.toString("utf8");
+    const converted = await convertHtmlToMarkdown(html, pathToFileURL(absoluteInput).toString());
+    title = converted.title;
+    extractedText = converted.markdown;
+    extractionArtifact = createHtmlReadabilityExtractionArtifact(sourceKind, mimeType);
   } else if (sourceKind === "pdf") {
-    title = path9.basename(absoluteInput, path9.extname(absoluteInput));
+    title = path10.basename(absoluteInput, path10.extname(absoluteInput));
     const extracted = await extractPdfText({ mimeType, bytes: payloadBytes });
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
   } else if (sourceKind === "image") {
-    title = path9.basename(absoluteInput, path9.extname(absoluteInput));
+    title = path10.basename(absoluteInput, path10.extname(absoluteInput));
     const extracted = await extractImageWithVision(rootDir, {
       title,
       mimeType,
@@ -4364,12 +4452,13 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot) {
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
   } else {
-    title = path9.basename(absoluteInput, path9.extname(absoluteInput));
+    title = path10.basename(absoluteInput, path10.extname(absoluteInput));
   }
   return {
     title,
     originType: "file",
     sourceKind,
+    sourceClass,
     language,
     originalPath: toPosix(absoluteInput),
     repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
@@ -4439,7 +4528,7 @@ async function prepareUrlInput(rootDir, input, options) {
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path9.extname(inputUrl.pathname);
+    const extension = path10.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = payloadBytes.toString("utf8");
@@ -4512,7 +4601,7 @@ async function collectInboxAttachmentRefs(inputDir, files) {
     }
     const sourceRefs = [];
     for (const ref of refs) {
-      const resolved = path9.resolve(path9.dirname(absolutePath), ref);
+      const resolved = path10.resolve(path10.dirname(absolutePath), ref);
       if (!resolved.startsWith(inputDir) || !await fileExists(resolved)) {
         continue;
       }
@@ -4548,7 +4637,7 @@ function rewriteMarkdownReferences(content, replacements) {
 async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
   const originalBytes = await fs9.readFile(absolutePath);
   const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path9.basename(absolutePath, path9.extname(absolutePath)), originalText);
+  const title = titleFromText(path10.basename(absolutePath, path10.extname(absolutePath)), originalText);
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
     const bytes = await fs9.readFile(attachmentRef.absolutePath);
@@ -4575,7 +4664,7 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     sourceKind: "markdown",
     originalPath: toPosix(absolutePath),
     mimeType: "text/markdown",
-    storedExtension: path9.extname(absolutePath) || ".md",
+    storedExtension: path10.extname(absolutePath) || ".md",
     payloadBytes: Buffer.from(rewrittenText, "utf8"),
     extractedText: rewrittenText,
     extractionArtifact,
@@ -4590,8 +4679,8 @@ function isSupportedInboxKind(sourceKind) {
 async function ingestInput(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInput = path9.resolve(rootDir, input);
-  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path9.dirname(absoluteInput));
+  const absoluteInput = path10.resolve(rootDir, input);
+  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path10.dirname(absoluteInput));
   const prepared = isHttpUrl(input) ? await prepareUrlInput(rootDir, input, normalizedOptions) : await prepareFileInput(rootDir, absoluteInput, repoRoot);
   const result = await persistPreparedInput(rootDir, prepared, paths);
   return result.manifest;
@@ -4680,8 +4769,8 @@ async function addInput(rootDir, input, options = {}) {
 }
 async function ingestDirectory(rootDir, inputDir, options) {
   const { paths } = await initWorkspace(rootDir);
-  const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInputDir = path9.resolve(rootDir, inputDir);
+  const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
+  const absoluteInputDir = path10.resolve(rootDir, inputDir);
   const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot2(absoluteInputDir) ?? absoluteInputDir;
   if (!await fileExists(absoluteInputDir)) {
     throw new Error(`Directory not found: ${absoluteInputDir}`);
@@ -4690,18 +4779,19 @@ async function ingestDirectory(rootDir, inputDir, options) {
   const imported = [];
   const updated = [];
   for (const absolutePath of files) {
-    const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
+    const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path10.relative(repoRoot, absolutePath));
+    const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (result.isNew) {
       imported.push(result.manifest);
     } else if (result.wasUpdated) {
       updated.push(result.manifest);
     } else {
-      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "duplicate_content" });
     }
   }
-  await appendLogEntry(rootDir, "ingest_directory", toPosix(path9.relative(rootDir, absoluteInputDir)) || ".", [
-    `repo_root=${toPosix(path9.relative(rootDir, repoRoot)) || "."}`,
+  await appendLogEntry(rootDir, "ingest_directory", toPosix(path10.relative(rootDir, absoluteInputDir)) || ".", [
+    `repo_root=${toPosix(path10.relative(rootDir, repoRoot)) || "."}`,
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `updated=${updated.length}`,
@@ -4718,7 +4808,7 @@ async function ingestDirectory(rootDir, inputDir, options) {
 }
 async function importInbox(rootDir, inputDir) {
   const { paths } = await initWorkspace(rootDir);
-  const effectiveInputDir = path9.resolve(rootDir, inputDir ?? paths.inboxDir);
+  const effectiveInputDir = path10.resolve(rootDir, inputDir ?? paths.inboxDir);
   if (!await fileExists(effectiveInputDir)) {
     throw new Error(`Inbox directory not found: ${effectiveInputDir}`);
   }
@@ -4729,31 +4819,31 @@ async function importInbox(rootDir, inputDir) {
   const skipped = [];
   let attachmentCount = 0;
   for (const absolutePath of files) {
-    const basename = path9.basename(absolutePath);
+    const basename = path10.basename(absolutePath);
     if (basename.startsWith(".")) {
-      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "hidden_file" });
+      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "hidden_file" });
       continue;
     }
     if (claimedAttachments.has(absolutePath)) {
-      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
+      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
     if (!isSupportedInboxKind(sourceKind)) {
-      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
       continue;
     }
     const prepared = sourceKind === "markdown" && refsBySource.has(absolutePath) ? await prepareInboxMarkdownInput(absolutePath, refsBySource.get(absolutePath) ?? []) : await prepareFileInput(rootDir, absolutePath);
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (!result.isNew) {
-      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path10.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
     attachmentCount += result.manifest.attachments?.length ?? 0;
     imported.push(result.manifest);
   }
-  await appendLogEntry(rootDir, "inbox_import", toPosix(path9.relative(rootDir, effectiveInputDir)) || ".", [
+  await appendLogEntry(rootDir, "inbox_import", toPosix(path10.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `attachments=${attachmentCount}`,
@@ -4774,7 +4864,7 @@ async function listManifests(rootDir) {
   }
   const entries = await fs9.readdir(paths.manifestsDir);
   const manifests = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path9.join(paths.manifestsDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path10.join(paths.manifestsDir, entry)))
   );
   return manifests.filter((manifest) => Boolean(manifest));
 }
@@ -4782,7 +4872,7 @@ async function readExtractedText(rootDir, manifest) {
   if (!manifest.extractedTextPath) {
     return void 0;
   }
-  const absolutePath = path9.resolve(rootDir, manifest.extractedTextPath);
+  const absolutePath = path10.resolve(rootDir, manifest.extractedTextPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
@@ -4792,7 +4882,7 @@ async function readExtractionArtifact(rootDir, manifest) {
   if (!manifest.extractedMetadataPath) {
     return void 0;
   }
-  const absolutePath = path9.resolve(rootDir, manifest.extractedMetadataPath);
+  const absolutePath = path10.resolve(rootDir, manifest.extractedMetadataPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
@@ -4800,15 +4890,15 @@ async function readExtractionArtifact(rootDir, manifest) {
 }
 
 // src/mcp.ts
-import fs16 from "fs/promises";
-import path19 from "path";
+import fs17 from "fs/promises";
+import path21 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z8 } from "zod";
 
 // src/schema.ts
 import fs10 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 function normalizeSchemaContent(content) {
   return content.trim() ? content.trim() : defaultVaultSchema().trim();
 }
@@ -4822,7 +4912,7 @@ async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
   };
 }
 function resolveProjectSchemaPath(rootDir, schemaPath) {
-  return path10.resolve(rootDir, schemaPath);
+  return path11.resolve(rootDir, schemaPath);
 }
 function composeVaultSchema(root, projectSchemas = []) {
   if (!projectSchemas.length) {
@@ -4838,7 +4928,7 @@ function composeVaultSchema(root, projectSchemas = []) {
       (schema) => [
         `## Project Schema`,
         "",
-        `Path: ${toPosix(path10.relative(path10.dirname(root.path), schema.path) || schema.path)}`,
+        `Path: ${toPosix(path11.relative(path11.dirname(root.path), schema.path) || schema.path)}`,
         "",
         schema.content
       ].join("\n")
@@ -4914,13 +5004,13 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs15 from "fs/promises";
-import path18 from "path";
+import fs16 from "fs/promises";
+import path20 from "path";
 import matter9 from "gray-matter";
 import { z as z7 } from "zod";
 
 // src/analysis.ts
-import path11 from "path";
+import path12 from "path";
 import { z as z2 } from "zod";
 var ANALYSIS_FORMAT_VERSION = 5;
 var sourceAnalysisSchema = z2.object({
@@ -5143,7 +5233,7 @@ function extractionWarningSummary(manifest, extraction) {
   return `Imported ${manifest.sourceKind} source. Text extraction is not yet available for this source.`;
 }
 async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path11.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cachePath = path12.join(paths.analysesDir, `${manifest.sourceId}.json`);
   const cached = await readJsonFile(cachePath);
   if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && cached.sourceHash === manifest.contentHash && cached.extractionHash === manifest.extractionHash && cached.schemaHash === schema.hash) {
     return cached;
@@ -5286,6 +5376,7 @@ function graphHash(graph) {
         type: node.type,
         label: node.label,
         pageId: node.pageId ?? null,
+        sourceClass: node.sourceClass ?? null,
         communityId: node.communityId ?? null,
         degree: node.degree ?? null,
         bridgeScore: node.bridgeScore ?? null,
@@ -5300,6 +5391,7 @@ function graphHash(graph) {
         relation: edge.relation,
         status: edge.status,
         evidenceClass: edge.evidenceClass,
+        similarityBasis: edge.similarityBasis ?? null,
         confidence: edge.confidence,
         provenance: [...edge.provenance].sort()
       })).sort((left, right) => left.id.localeCompare(right.id)),
@@ -5309,6 +5401,7 @@ function graphHash(graph) {
         kind: page.kind,
         status: page.status,
         sourceType: page.sourceType ?? null,
+        sourceClass: page.sourceClass ?? null,
         sourceIds: [...page.sourceIds].sort(),
         projectIds: [...page.projectIds].sort(),
         nodeIds: [...page.nodeIds].sort()
@@ -5386,7 +5479,7 @@ function conflictConfidence(claimA, claimB) {
 
 // src/deep-lint.ts
 import fs11 from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 import matter4 from "gray-matter";
 import { z as z5 } from "zod";
 
@@ -5407,7 +5500,7 @@ function normalizeFindingSeverity(value) {
 
 // src/orchestration.ts
 import { spawn } from "child_process";
-import path12 from "path";
+import path13 from "path";
 import { z as z3 } from "zod";
 var orchestrationRoleResultSchema = z3.object({
   summary: z3.string().optional(),
@@ -5500,7 +5593,7 @@ async function runProviderRole(rootDir, role, roleConfig, input) {
 }
 async function runCommandRole(rootDir, role, executor, input) {
   const [command, ...args] = executor.command;
-  const cwd = executor.cwd ? path12.resolve(rootDir, executor.cwd) : rootDir;
+  const cwd = executor.cwd ? path13.resolve(rootDir, executor.cwd) : rootDir;
   const child = spawn(command, args, {
     cwd,
     env: {
@@ -5594,8 +5687,8 @@ function summarizeRoleQuestions(results) {
 }
 
 // src/web-search/registry.ts
-import path13 from "path";
-import { pathToFileURL } from "url";
+import path14 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
 import { z as z4 } from "zod";
 
 // src/web-search/http-json.ts
@@ -5692,8 +5785,8 @@ async function createWebSearchAdapter(id, config, rootDir) {
       if (!config.module) {
         throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
       }
-      const resolvedModule = path13.isAbsolute(config.module) ? config.module : path13.resolve(rootDir, config.module);
-      const loaded = await import(pathToFileURL(resolvedModule).href);
+      const resolvedModule = path14.isAbsolute(config.module) ? config.module : path14.resolve(rootDir, config.module);
+      const loaded = await import(pathToFileURL2(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
     }
@@ -5752,7 +5845,7 @@ async function loadContextPages(rootDir, graph) {
   );
   return Promise.all(
     contextPages.slice(0, 18).map(async (page) => {
-      const absolutePath = path14.join(paths.wikiDir, page.path);
+      const absolutePath = path15.join(paths.wikiDir, page.path);
       const raw = await fs11.readFile(absolutePath, "utf8").catch(() => "");
       const parsed = matter4(raw);
       return {
@@ -5801,7 +5894,7 @@ function heuristicDeepFindings(contextPages, structuralFindings, graph) {
       code: "missing_citation",
       message: finding.message,
       pagePath: finding.pagePath,
-      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path14.basename(finding.pagePath, ".md")}?` : void 0
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path15.basename(finding.pagePath, ".md")}?` : void 0
     });
   }
   for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
@@ -5978,6 +6071,353 @@ async function runDeepLint(rootDir, structuralFindings, options = {}) {
   );
 }
 
+// src/embeddings.ts
+import fs12 from "fs/promises";
+import path16 from "path";
+var MAX_EMBEDDING_BATCH = 32;
+var MAX_SIMILARITY_NODES = 240;
+function cosineSimilarity(left, right) {
+  if (!left.length || left.length !== right.length) {
+    return 0;
+  }
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    dot += left[index] * right[index];
+    leftNorm += left[index] * left[index];
+    rightNorm += right[index] * right[index];
+  }
+  if (leftNorm <= 0 || rightNorm <= 0) {
+    return 0;
+  }
+  return dot / Math.sqrt(leftNorm * rightNorm);
+}
+function appendIfMissing(parts, value) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return;
+  }
+  if (!parts.includes(normalized)) {
+    parts.push(normalized);
+  }
+}
+async function loadPageContents(rootDir, graph) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const contents = /* @__PURE__ */ new Map();
+  await Promise.all(
+    graph.pages.map(async (page) => {
+      const absolutePath = path16.join(paths.wikiDir, page.path);
+      const content = await fs12.readFile(absolutePath, "utf8").catch(() => "");
+      contents.set(page.id, content);
+    })
+  );
+  return contents;
+}
+function itemTextForNode(node, graph, pageContents) {
+  const page = graph.pages.find((candidate) => candidate.id === node.pageId);
+  const parts = [`node ${node.type}`, node.label];
+  appendIfMissing(parts, node.sourceClass);
+  appendIfMissing(parts, node.language);
+  appendIfMissing(parts, page?.title);
+  appendIfMissing(parts, page?.sourceType);
+  appendIfMissing(parts, page?.sourceClass);
+  if (page) {
+    appendIfMissing(parts, pageContents.get(page.id)?.slice(0, 800));
+  }
+  return parts.join("\n");
+}
+function itemTextForPage(page, pageContents) {
+  const parts = [`page ${page.kind}`, page.title, page.path];
+  appendIfMissing(parts, page.sourceType);
+  appendIfMissing(parts, page.sourceClass);
+  appendIfMissing(parts, pageContents.get(page.id)?.slice(0, 1200));
+  return parts.join("\n");
+}
+function itemTextForHyperedge(graph, hyperedgeId) {
+  const hyperedge = graph.hyperedges.find((candidate) => candidate.id === hyperedgeId);
+  if (!hyperedge) {
+    return "";
+  }
+  const nodeLabels = hyperedge.nodeIds.map((nodeId) => graph.nodes.find((node) => node.id === nodeId)?.label).filter((value) => Boolean(value));
+  return [hyperedge.label, hyperedge.relation, hyperedge.why, ...nodeLabels].join("\n");
+}
+async function buildEmbeddableItems(rootDir, graph) {
+  const pageContents = await loadPageContents(rootDir, graph);
+  return uniqueBy(
+    [
+      ...graph.nodes.map(
+        (node) => ({
+          id: node.id,
+          kind: "node",
+          label: node.label,
+          text: itemTextForNode(node, graph, pageContents),
+          match: {
+            type: "node",
+            id: node.id,
+            label: node.label,
+            score: 0
+          }
+        })
+      ),
+      ...graph.pages.map(
+        (page) => ({
+          id: page.id,
+          kind: "page",
+          label: page.title,
+          text: itemTextForPage(page, pageContents),
+          match: {
+            type: "page",
+            id: page.id,
+            label: page.title,
+            score: 0
+          }
+        })
+      ),
+      ...(graph.hyperedges ?? []).map(
+        (hyperedge) => ({
+          id: hyperedge.id,
+          kind: "hyperedge",
+          label: hyperedge.label,
+          text: itemTextForHyperedge(graph, hyperedge.id),
+          match: {
+            type: "hyperedge",
+            id: hyperedge.id,
+            label: hyperedge.label,
+            score: 0
+          }
+        })
+      )
+    ],
+    (item) => `${item.kind}:${item.id}`
+  ).filter((item) => item.text.trim().length > 0);
+}
+async function resolveEmbeddingProvider(rootDir) {
+  const { config } = await loadVaultConfig(rootDir);
+  const explicitProviderId = config.tasks.embeddingProvider;
+  if (explicitProviderId) {
+    const providerConfig = config.providers[explicitProviderId];
+    if (!providerConfig) {
+      throw new Error(`No provider configured with id "${explicitProviderId}" for task "embeddingProvider".`);
+    }
+    const provider2 = await createProvider(explicitProviderId, providerConfig, rootDir);
+    if (!provider2.capabilities.has("embeddings") || typeof provider2.embedTexts !== "function") {
+      throw new Error(`Provider ${provider2.id} does not support required capability "embeddings".`);
+    }
+    return provider2;
+  }
+  const queryProviderId = config.tasks.queryProvider;
+  const queryProviderConfig = config.providers[queryProviderId];
+  if (!queryProviderConfig) {
+    return null;
+  }
+  const provider = await createProvider(queryProviderId, queryProviderConfig, rootDir);
+  return provider.capabilities.has("embeddings") && typeof provider.embedTexts === "function" ? provider : null;
+}
+async function readEmbeddingCache(rootDir) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const provider = await resolveEmbeddingProvider(rootDir);
+  if (!provider) {
+    return { artifact: null, provider: null };
+  }
+  const cache = await readJsonFile(paths.embeddingsPath);
+  if (!cache || cache.providerId !== provider.id || cache.providerModel !== provider.model) {
+    return { artifact: null, provider };
+  }
+  return { artifact: cache, provider };
+}
+async function writeEmbeddingCache(rootDir, provider, graphHash2, entries) {
+  const { paths } = await loadVaultConfig(rootDir);
+  await writeJsonFile(paths.embeddingsPath, {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    providerId: provider.id,
+    providerModel: provider.model,
+    graphHash: graphHash2,
+    entries: entries.sort((left, right) => `${left.kind}:${left.itemId}`.localeCompare(`${right.kind}:${right.itemId}`))
+  });
+}
+async function embedTexts(provider, texts) {
+  const vectors = [];
+  for (let index = 0; index < texts.length; index += MAX_EMBEDDING_BATCH) {
+    const batch = texts.slice(index, index + MAX_EMBEDDING_BATCH);
+    const nextVectors = await provider.embedTexts(batch);
+    vectors.push(...nextVectors);
+  }
+  return vectors;
+}
+async function resolveVectorsForItems(rootDir, graphHash2, items) {
+  const { artifact, provider } = await readEmbeddingCache(rootDir);
+  if (!provider) {
+    return { provider: null, vectors: /* @__PURE__ */ new Map() };
+  }
+  const cachedByKey = new Map(
+    (artifact?.entries ?? []).map((entry) => [`${entry.kind}:${entry.itemId}:${entry.contentHash}`, entry.values])
+  );
+  const vectors = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const item of items) {
+    const contentHash = sha256(item.text);
+    const cached = cachedByKey.get(`${item.kind}:${item.id}:${contentHash}`);
+    if (cached?.length) {
+      vectors.set(`${item.kind}:${item.id}`, cached);
+    } else {
+      missing.push(item);
+    }
+  }
+  if (missing.length) {
+    const nextVectors = await embedTexts(
+      provider,
+      missing.map((item) => item.text)
+    );
+    for (let index = 0; index < missing.length; index += 1) {
+      vectors.set(`${missing[index].kind}:${missing[index].id}`, nextVectors[index] ?? []);
+    }
+  }
+  await writeEmbeddingCache(
+    rootDir,
+    provider,
+    graphHash2,
+    items.map((item) => ({
+      itemId: item.id,
+      kind: item.kind,
+      label: item.label,
+      contentHash: sha256(item.text),
+      values: vectors.get(`${item.kind}:${item.id}`) ?? []
+    }))
+  );
+  return { provider, vectors };
+}
+async function semanticGraphMatches(rootDir, graph, question, limit = 12) {
+  const items = await buildEmbeddableItems(rootDir, graph);
+  const { provider, vectors } = await resolveVectorsForItems(rootDir, graph.generatedAt, items);
+  if (!provider) {
+    return [];
+  }
+  const [queryVector] = await provider.embedTexts([question]);
+  if (!Array.isArray(queryVector) || queryVector.length === 0) {
+    return [];
+  }
+  return items.map((item) => ({
+    ...item.match,
+    score: Math.max(0, Number((cosineSimilarity(queryVector, vectors.get(`${item.kind}:${item.id}`) ?? []) * 100).toFixed(2)))
+  })).filter((match) => match.score >= 18).sort((left, right) => right.score - left.score || left.label.localeCompare(right.label)).slice(0, limit);
+}
+function distinctScope(left, right) {
+  const leftSources = new Set(left.sourceIds);
+  const rightSources = new Set(right.sourceIds);
+  return [...leftSources].some((sourceId) => !rightSources.has(sourceId)) || [...rightSources].some((sourceId) => !leftSources.has(sourceId));
+}
+function nodePairKey(left, right) {
+  return [left, right].sort((a, b) => a.localeCompare(b)).join("|");
+}
+function similarityReasonsForNodes(left, right) {
+  const reasons = /* @__PURE__ */ new Set();
+  if (left.sourceClass && right.sourceClass && left.sourceClass === right.sourceClass) {
+    reasons.add("shared_tag");
+  }
+  if (left.language && right.language && left.language === right.language) {
+    reasons.add("shared_symbol");
+  }
+  return [...reasons].sort((a, b) => a.localeCompare(b));
+}
+async function embeddingSimilarityEdges(rootDir, graph) {
+  const candidateNodes = graph.nodes.filter(
+    (node) => (node.type === "source" || node.type === "module" || node.type === "rationale") && node.sourceClass !== "generated"
+  );
+  if (candidateNodes.length < 2 || candidateNodes.length > MAX_SIMILARITY_NODES) {
+    return [];
+  }
+  const items = candidateNodes.map(
+    (node) => ({
+      id: node.id,
+      kind: "node",
+      label: node.label,
+      text: [
+        node.label,
+        node.type,
+        node.sourceClass ?? "",
+        node.language ?? "",
+        graph.pages.find((page) => page.id === node.pageId)?.title ?? ""
+      ].filter(Boolean).join("\n"),
+      match: { type: "node", id: node.id, label: node.label, score: 0 }
+    })
+  );
+  const { provider, vectors } = await resolveVectorsForItems(rootDir, graph.generatedAt, items);
+  if (!provider) {
+    return [];
+  }
+  const directPairs = new Set(graph.edges.map((edge) => nodePairKey(edge.source, edge.target)));
+  const edges = [];
+  for (let leftIndex = 0; leftIndex < candidateNodes.length; leftIndex += 1) {
+    const left = candidateNodes[leftIndex];
+    const leftVector = vectors.get(`node:${left.id}`) ?? [];
+    const candidates = candidateNodes.slice(leftIndex + 1).filter((right) => distinctScope(left, right) && !directPairs.has(nodePairKey(left.id, right.id))).map((right) => ({
+      right,
+      score: cosineSimilarity(leftVector, vectors.get(`node:${right.id}`) ?? [])
+    })).filter((candidate) => candidate.score >= 0.82).sort((a, b) => b.score - a.score).slice(0, 3);
+    for (const candidate of candidates) {
+      const right = candidate.right;
+      const reasons = similarityReasonsForNodes(left, right) ?? [];
+      edges.push({
+        id: `similar-embed:${sha256(`${left.id}|${right.id}|${provider.id}`).slice(0, 16)}`,
+        source: left.id,
+        target: right.id,
+        relation: "semantically_similar_to",
+        status: "inferred",
+        evidenceClass: "inferred",
+        confidence: Number(candidate.score.toFixed(3)),
+        provenance: uniqueBy(
+          [...left.sourceIds, ...right.sourceIds].sort((a, b) => a.localeCompare(b)),
+          (value) => value
+        ),
+        similarityReasons: reasons.length ? reasons : ["shared_tag"],
+        similarityBasis: "embeddings"
+      });
+    }
+  }
+  return uniqueBy(edges, (edge) => edge.id).sort((left, right) => right.confidence - left.confidence || left.id.localeCompare(right.id));
+}
+function sourceClassBreakdown(graph) {
+  return {
+    first_party: {
+      sources: graph.sources.filter((source) => source.sourceClass === "first_party").length,
+      pages: graph.pages.filter((page) => page.sourceClass === "first_party").length,
+      nodes: graph.nodes.filter((node) => node.sourceClass === "first_party").length
+    },
+    third_party: {
+      sources: graph.sources.filter((source) => source.sourceClass === "third_party").length,
+      pages: graph.pages.filter((page) => page.sourceClass === "third_party").length,
+      nodes: graph.nodes.filter((node) => node.sourceClass === "third_party").length
+    },
+    resource: {
+      sources: graph.sources.filter((source) => source.sourceClass === "resource").length,
+      pages: graph.pages.filter((page) => page.sourceClass === "resource").length,
+      nodes: graph.nodes.filter((node) => node.sourceClass === "resource").length
+    },
+    generated: {
+      sources: graph.sources.filter((source) => source.sourceClass === "generated").length,
+      pages: graph.pages.filter((page) => page.sourceClass === "generated").length,
+      nodes: graph.nodes.filter((node) => node.sourceClass === "generated").length
+    }
+  };
+}
+function filterGraphBySourceClass(graph, sourceClass) {
+  const nodeIds = new Set(graph.nodes.filter((node) => node.sourceClass === sourceClass).map((node) => node.id));
+  const pageIds = new Set(graph.pages.filter((page) => page.sourceClass === sourceClass).map((page) => page.id));
+  return {
+    ...graph,
+    nodes: graph.nodes.filter((node) => nodeIds.has(node.id)),
+    edges: graph.edges.filter((edge) => nodeIds.has(edge.source) && nodeIds.has(edge.target)),
+    hyperedges: graph.hyperedges.filter((hyperedge) => hyperedge.nodeIds.every((nodeId) => nodeIds.has(nodeId))),
+    communities: (graph.communities ?? []).map((community) => ({
+      ...community,
+      nodeIds: community.nodeIds.filter((nodeId) => nodeIds.has(nodeId))
+    })).filter((community) => community.nodeIds.length > 0),
+    sources: graph.sources.filter((source) => source.sourceClass === sourceClass),
+    pages: graph.pages.filter((page) => pageIds.has(page.id))
+  };
+}
+
 // src/graph-enrichment.ts
 var STOPWORDS2 = /* @__PURE__ */ new Set([
   "about",
@@ -6204,7 +6644,8 @@ 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: [...reasons.keys()].sort((a, b) => a.localeCompare(b)),
+        similarityBasis: "feature_overlap"
       }
     ];
   }).sort((left, right) => right.confidence - left.confidence || left.id.localeCompare(right.id));
@@ -6287,9 +6728,11 @@ function buildModuleFormHyperedges(graph) {
     ];
   });
 }
-function enrichGraph(graph, manifests, analyses) {
+function enrichGraph(graph, manifests, analyses, extraSimilarityEdges = []) {
   const similarityEdges = buildSemanticSimilarityEdges(graph.nodes, graph.edges, manifests, analyses);
-  const enrichedEdges = [...graph.edges, ...similarityEdges].sort((left, right) => left.id.localeCompare(right.id));
+  const enrichedEdges = uniqueBy([...graph.edges, ...similarityEdges, ...extraSimilarityEdges], (edge) => edge.id).sort(
+    (left, right) => left.id.localeCompare(right.id)
+  );
   const hyperedges = uniqueBy(
     [
       ...buildTopicHyperedges({ ...graph, edges: enrichedEdges, hyperedges: [] }),
@@ -6420,13 +6863,19 @@ function queryGraph(graph, question, searchResults, options) {
   const traversal = options?.traversal ?? "bfs";
   const budget = Math.max(3, Math.min(options?.budget ?? 12, 50));
   const matches = uniqueBy(
-    [...pageSearchMatches(graph, question, searchResults), ...nodeMatches(graph, question), ...hyperedgeMatches(graph, question)],
+    [
+      ...options?.semanticMatches ?? [],
+      ...pageSearchMatches(graph, question, searchResults),
+      ...nodeMatches(graph, question),
+      ...hyperedgeMatches(graph, question)
+    ],
     (match) => `${match.type}:${match.id}`
   ).sort((left, right) => right.score - left.score || left.label.localeCompare(right.label)).slice(0, 12);
   const pages = pageById(graph);
   const seeds = uniqueBy(
     [
       ...searchResults.flatMap((result) => pages.get(result.pageId)?.nodeIds ?? []),
+      ...matches.filter((match) => match.type === "page").flatMap((match) => pages.get(match.id)?.nodeIds ?? []),
       ...matches.filter((match) => match.type === "node").map((match) => match.id),
       ...matches.filter((match) => match.type === "hyperedge").flatMap((match) => graph.hyperedges.find((hyperedge) => hyperedge.id === match.id)?.nodeIds ?? [])
     ],
@@ -6458,6 +6907,7 @@ function queryGraph(graph, question, searchResults, options) {
   const pageIds = uniqueBy(
     [
       ...searchResults.map((result) => result.pageId),
+      ...matches.filter((match) => match.type === "page").map((match) => match.id),
       ...visitedNodeIds.flatMap((nodeId) => {
         const node = nodes.get(nodeId);
         return node?.pageId ? [node.pageId] : [];
@@ -6478,7 +6928,7 @@ function queryGraph(graph, question, searchResults, options) {
     traversal,
     seedNodeIds: seeds,
     seedPageIds: uniqueBy(
-      searchResults.map((result) => result.pageId),
+      [...searchResults.map((result) => result.pageId), ...matches.filter((match) => match.type === "page").map((match) => match.id)],
       (item) => item
     ),
     visitedNodeIds,
@@ -6729,6 +7179,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
     kind: "source",
     title: analysis.title,
     ...manifest.sourceType ? { source_type: manifest.sourceType } : {},
+    ...manifest.sourceClass ? { source_class: manifest.sourceClass } : {},
     tags: decoratedTags(analysis.code ? ["source", "code"] : ["source"], decorations),
     source_ids: [manifest.sourceId],
     project_ids: decorations?.projectIds ?? [],
@@ -6752,6 +7203,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
     `Source ID: \`${manifest.sourceId}\``,
     manifest.url ? `Source URL: ${manifest.url}` : `Source Path: \`${manifest.originalPath ?? manifest.storedPath}\``,
     ...manifest.sourceType ? [`Source Type: \`${manifest.sourceType}\``, ""] : [""],
+    ...manifest.sourceClass ? [`Source Class: \`${manifest.sourceClass}\``, ""] : [],
     "",
     "## Summary",
     "",
@@ -6797,6 +7249,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
       title: analysis.title,
       kind: "source",
       sourceType: manifest.sourceType,
+      sourceClass: manifest.sourceClass,
       sourceIds: [manifest.sourceId],
       projectIds: decorations?.projectIds ?? [],
       nodeIds,
@@ -6859,6 +7312,7 @@ function buildModulePage(input) {
     page_id: pageId,
     kind: "module",
     title,
+    ...manifest.sourceClass ? { source_class: manifest.sourceClass } : {},
     tags: decoratedTags(["module", "code", code.language], { projectIds: input.projectIds, extraTags: input.extraTags }),
     source_ids: [manifest.sourceId],
     project_ids: input.projectIds ?? [],
@@ -6890,6 +7344,7 @@ function buildModulePage(input) {
     `Source ID: \`${manifest.sourceId}\``,
     `Source Path: \`${manifest.originalPath ?? manifest.storedPath}\``,
     ...manifest.repoRelativePath ? [`Repo Path: \`${manifest.repoRelativePath}\``] : [],
+    ...manifest.sourceClass ? [`Source Class: \`${manifest.sourceClass}\``] : [],
     `Language: \`${code.language}\``,
     ...code.moduleName ? [`Module Name: \`${code.moduleName}\``] : [],
     ...code.namespace ? [`Namespace/Package: \`${code.namespace}\``] : [],
@@ -6940,6 +7395,7 @@ function buildModulePage(input) {
       path: relativePath,
       title,
       kind: "module",
+      sourceClass: manifest.sourceClass,
       sourceIds: [manifest.sourceId],
       projectIds: input.projectIds ?? [],
       nodeIds,
@@ -6974,6 +7430,7 @@ function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHash
     page_id: pageId,
     kind,
     title: name,
+    ...decorations?.sourceClass ? { source_class: decorations.sourceClass } : {},
     tags: decoratedTags(metadata.status === "candidate" ? [kind, "candidate"] : [kind], decorations),
     source_ids: sourceIds,
     project_ids: decorations?.projectIds ?? [],
@@ -7015,6 +7472,7 @@ function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHash
       path: relativePath,
       title: name,
       kind,
+      sourceClass: decorations?.sourceClass,
       sourceIds,
       projectIds: decorations?.projectIds ?? [],
       nodeIds: [pageId],
@@ -7146,15 +7604,15 @@ function sourceTypeForNode(node, pagesById) {
   return pagesById.get(node.pageId)?.sourceType;
 }
 function supportingPathDetails(graph, edge) {
-  const path23 = shortestGraphPath(graph, edge.source, edge.target);
+  const path25 = shortestGraphPath(graph, edge.source, edge.target);
   const edgesById = new Map(graph.edges.map((item) => [item.id, item]));
-  const pathEdges = path23.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
+  const pathEdges = path25.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
   return {
-    pathNodeIds: path23.nodeIds,
-    pathEdgeIds: path23.edgeIds,
+    pathNodeIds: path25.nodeIds,
+    pathEdgeIds: path25.edgeIds,
     pathRelations: pathEdges.map((item) => item.relation),
     pathEvidenceClasses: pathEdges.map((item) => item.evidenceClass),
-    pathSummary: path23.summary
+    pathSummary: path25.summary
   };
 }
 function surpriseScore(edge, graph, pagesById, hyperedgesByNodeId) {
@@ -7223,7 +7681,7 @@ function topSurprisingConnections(graph, pagesById) {
     }).map((edge) => {
       const source = nodesById.get(edge.source);
       const target = nodesById.get(edge.target);
-      const path23 = supportingPathDetails(graph, edge);
+      const path25 = supportingPathDetails(graph, edge);
       const scored = surpriseScore(edge, graph, pagesById, hyperedgesByNodeId);
       return {
         id: edge.id,
@@ -7234,11 +7692,11 @@ function topSurprisingConnections(graph, pagesById) {
         relation: edge.relation,
         evidenceClass: edge.evidenceClass,
         confidence: edge.confidence,
-        pathNodeIds: path23.pathNodeIds,
-        pathEdgeIds: path23.pathEdgeIds,
-        pathRelations: path23.pathRelations,
-        pathEvidenceClasses: path23.pathEvidenceClasses,
-        pathSummary: path23.pathSummary,
+        pathNodeIds: path25.pathNodeIds,
+        pathEdgeIds: path25.pathEdgeIds,
+        pathRelations: path25.pathRelations,
+        pathEvidenceClasses: path25.pathEvidenceClasses,
+        pathSummary: path25.pathSummary,
         why: scored.why,
         explanation: scored.explanation,
         surpriseScore: scored.score
@@ -7263,10 +7721,12 @@ function suggestedGraphQuestions(graph) {
   ]).slice(0, 6);
 }
 function buildGraphReportArtifact(input) {
-  const pagesById = new Map(input.graph.pages.map((page) => [page.id, page]));
-  const godNodes = input.graph.nodes.filter((node) => node.isGodNode).sort((left, right) => (right.degree ?? 0) - (left.degree ?? 0)).slice(0, 8);
-  const bridgeNodes = input.graph.nodes.filter((node) => (node.bridgeScore ?? 0) > 0).sort((left, right) => (right.bridgeScore ?? 0) - (left.bridgeScore ?? 0)).slice(0, 8);
-  const thinCommunities = (input.graph.communities ?? []).filter((community) => community.nodeIds.length <= 2).map((community) => {
+  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 bridgeNodes = reportGraph.nodes.filter((node) => (node.bridgeScore ?? 0) > 0).sort((left, right) => (right.bridgeScore ?? 0) - (left.bridgeScore ?? 0)).slice(0, 8);
+  const thinCommunities = (reportGraph.communities ?? []).filter((community) => community.nodeIds.length <= 2).map((community) => {
     const page = input.communityPages.find((candidate) => candidate.id === `graph:${community.id}`);
     return {
       id: community.id,
@@ -7277,8 +7737,19 @@ function buildGraphReportArtifact(input) {
       title: page?.title
     };
   });
-  const surprisingConnections = topSurprisingConnections(input.graph, pagesById);
-  const groupPatterns = topGroupPatterns(input.graph);
+  const surprisingConnections = topSurprisingConnections(reportGraph, pagesById);
+  const groupPatterns = topGroupPatterns(reportGraph);
+  const breakdown = sourceClassBreakdown(input.graph);
+  const warnings = [];
+  const nonFirstPartyNodes = input.graph.nodes.length - breakdown.first_party.nodes;
+  if (input.graph.nodes.length >= 1200) {
+    warnings.push(`Large graph detected (${input.graph.nodes.length} nodes). First-party defaults are applied to report highlights.`);
+  }
+  if (nonFirstPartyNodes > 0 && nonFirstPartyNodes / Math.max(1, input.graph.nodes.length) >= 0.25) {
+    warnings.push(
+      `Non-first-party material accounts for ${(nonFirstPartyNodes / Math.max(1, input.graph.nodes.length) * 100).toFixed(1)}% of graph nodes.`
+    );
+  }
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     graphHash: input.graphHash,
@@ -7288,6 +7759,14 @@ function buildGraphReportArtifact(input) {
       pages: input.graph.pages.length,
       communities: input.graph.communities?.length ?? 0
     },
+    firstPartyOverview: {
+      nodes: reportGraph.nodes.length,
+      edges: reportGraph.edges.length,
+      pages: reportGraph.pages.length,
+      communities: reportGraph.communities?.length ?? 0
+    },
+    sourceClassBreakdown: breakdown,
+    warnings,
     benchmark: input.benchmark ? {
       generatedAt: input.benchmark.generatedAt,
       stale: input.benchmarkStale ?? false,
@@ -7383,6 +7862,18 @@ function buildGraphReportPage(input) {
     `- Edges: ${input.report.overview.edges}`,
     `- Pages: ${input.report.overview.pages}`,
     `- Communities: ${input.report.overview.communities}`,
+    `- Default Focus: First-party nodes/pages (${input.report.firstPartyOverview.nodes} nodes, ${input.report.firstPartyOverview.edges} edges, ${input.report.firstPartyOverview.pages} pages).`,
+    "",
+    "## Repo Quality Warnings",
+    "",
+    ...input.report.warnings.length ? input.report.warnings.map((warning) => `- ${warning}`) : ["- No large-repo warnings."],
+    "",
+    "## Source Class Breakdown",
+    "",
+    `- First-party: ${input.report.sourceClassBreakdown.first_party.sources} sources, ${input.report.sourceClassBreakdown.first_party.pages} pages, ${input.report.sourceClassBreakdown.first_party.nodes} nodes`,
+    `- Third-party: ${input.report.sourceClassBreakdown.third_party.sources} sources, ${input.report.sourceClassBreakdown.third_party.pages} pages, ${input.report.sourceClassBreakdown.third_party.nodes} nodes`,
+    `- Resources: ${input.report.sourceClassBreakdown.resource.sources} sources, ${input.report.sourceClassBreakdown.resource.pages} pages, ${input.report.sourceClassBreakdown.resource.nodes} nodes`,
+    `- Generated: ${input.report.sourceClassBreakdown.generated.sources} sources, ${input.report.sourceClassBreakdown.generated.pages} pages, ${input.report.sourceClassBreakdown.generated.nodes} nodes`,
     "",
     "## Benchmark Summary",
     "",
@@ -8090,13 +8581,13 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
-import fs13 from "fs/promises";
-import path16 from "path";
+import fs14 from "fs/promises";
+import path18 from "path";
 import matter7 from "gray-matter";
 
 // src/pages.ts
-import fs12 from "fs/promises";
-import path15 from "path";
+import fs13 from "fs/promises";
+import path17 from "path";
 import matter6 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -8121,6 +8612,9 @@ function normalizePageManager(value, fallback = "system") {
 function normalizeSourceType(value) {
   return value === "arxiv" || value === "doi" || value === "tweet" || value === "article" || value === "url" ? value : void 0;
 }
+function normalizeSourceClass(value) {
+  return value === "first_party" || value === "third_party" || value === "resource" || value === "generated" ? value : void 0;
+}
 function normalizeOutputFormat(value, fallback = "markdown") {
   return value === "report" || value === "slides" || value === "chart" || value === "image" ? value : fallback;
 }
@@ -8171,7 +8665,7 @@ async function loadExistingManagedPageState(absolutePath, defaults = {}) {
       updatedAt: updatedFallback
     };
   }
-  const content = await fs12.readFile(absolutePath, "utf8");
+  const content = await fs13.readFile(absolutePath, "utf8");
   const parsed = matter6(content);
   return {
     status: normalizePageStatus(parsed.data.status, defaults.status ?? "active"),
@@ -8210,7 +8704,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 : path15.basename(relativePath, ".md");
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(relativePath, ".md");
   const kind = inferPageKind(relativePath, parsed.data.kind);
   const sourceIds = normalizeStringArray(parsed.data.source_ids);
   const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -8227,6 +8721,7 @@ function parseStoredPage(relativePath, content, defaults = {}) {
     title,
     kind,
     sourceType: normalizeSourceType(parsed.data.source_type),
+    sourceClass: normalizeSourceClass(parsed.data.source_class),
     sourceIds,
     projectIds,
     nodeIds,
@@ -8250,18 +8745,18 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   };
 }
 async function loadInsightPages(wikiDir) {
-  const insightsDir = path15.join(wikiDir, "insights");
+  const insightsDir = path17.join(wikiDir, "insights");
   if (!await fileExists(insightsDir)) {
     return [];
   }
-  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path15.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
+  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path17.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
   const insights = [];
   for (const absolutePath of files) {
-    const relativePath = toPosix(path15.relative(wikiDir, absolutePath));
-    const content = await fs12.readFile(absolutePath, "utf8");
+    const relativePath = toPosix(path17.relative(wikiDir, absolutePath));
+    const content = await fs13.readFile(absolutePath, "utf8");
     const parsed = matter6(content);
-    const stats = await fs12.stat(absolutePath);
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : path15.basename(absolutePath, ".md");
+    const stats = await fs13.stat(absolutePath);
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(absolutePath, ".md");
     const sourceIds = normalizeStringArray(parsed.data.source_ids);
     const projectIds = normalizeProjectIds(parsed.data.project_ids);
     const nodeIds = normalizeStringArray(parsed.data.node_ids);
@@ -8279,6 +8774,7 @@ async function loadInsightPages(wikiDir) {
         path: relativePath,
         title,
         kind: "insight",
+        sourceClass: normalizeSourceClass(parsed.data.source_class),
         sourceIds,
         projectIds,
         nodeIds,
@@ -8323,27 +8819,27 @@ function relatedOutputsForPage(targetPage, outputPages) {
   return outputPages.map((page) => ({ page, rank: relationRank(page, targetPage) })).filter((item) => item.rank > 0).sort((left, right) => right.rank - left.rank || left.page.title.localeCompare(right.page.title)).map((item) => item.page);
 }
 async function resolveUniqueOutputSlug(wikiDir, baseSlug) {
-  const outputsDir = path16.join(wikiDir, "outputs");
+  const outputsDir = path18.join(wikiDir, "outputs");
   const root = baseSlug || "output";
   let candidate = root;
   let counter = 2;
-  while (await fileExists(path16.join(outputsDir, `${candidate}.md`))) {
+  while (await fileExists(path18.join(outputsDir, `${candidate}.md`))) {
     candidate = `${root}-${counter}`;
     counter++;
   }
   return candidate;
 }
 async function loadSavedOutputPages(wikiDir) {
-  const outputsDir = path16.join(wikiDir, "outputs");
-  const entries = await fs13.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
+  const outputsDir = path18.join(wikiDir, "outputs");
+  const entries = await fs14.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
   const outputs = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") {
       continue;
     }
-    const relativePath = path16.posix.join("outputs", entry.name);
-    const absolutePath = path16.join(outputsDir, entry.name);
-    const content = await fs13.readFile(absolutePath, "utf8");
+    const relativePath = path18.posix.join("outputs", entry.name);
+    const absolutePath = path18.join(outputsDir, entry.name);
+    const content = await fs14.readFile(absolutePath, "utf8");
     const parsed = matter7(content);
     const slug = entry.name.replace(/\.md$/, "");
     const title = typeof parsed.data.title === "string" ? parsed.data.title : slug;
@@ -8356,7 +8852,7 @@ async function loadSavedOutputPages(wikiDir) {
     const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
     const backlinks = normalizeStringArray(parsed.data.backlinks);
     const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
-    const stats = await fs13.stat(absolutePath);
+    const stats = await fs14.stat(absolutePath);
     const createdAt = typeof parsed.data.created_at === "string" ? parsed.data.created_at : stats.birthtimeMs > 0 ? stats.birthtime.toISOString() : stats.mtime.toISOString();
     const updatedAt = typeof parsed.data.updated_at === "string" ? parsed.data.updated_at : stats.mtime.toISOString();
     outputs.push({
@@ -8394,8 +8890,8 @@ async function loadSavedOutputPages(wikiDir) {
 }
 
 // src/search.ts
-import fs14 from "fs/promises";
-import path17 from "path";
+import fs15 from "fs/promises";
+import path19 from "path";
 import matter8 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
@@ -8417,8 +8913,11 @@ function normalizeStatus(value) {
 function normalizeSourceType2(value) {
   return value === "arxiv" || value === "doi" || value === "tweet" || value === "article" || value === "url" ? value : void 0;
 }
+function normalizeSourceClass2(value) {
+  return value === "first_party" || value === "third_party" || value === "resource" || value === "generated" ? value : void 0;
+}
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path17.dirname(dbPath));
+  await ensureDir(path19.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -8433,6 +8932,7 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
       kind TEXT NOT NULL,
       status TEXT NOT NULL,
       source_type TEXT NOT NULL,
+      source_class TEXT NOT NULL,
       project_ids TEXT NOT NULL,
       project_key TEXT NOT NULL
     );
@@ -8446,11 +8946,11 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
     DELETE FROM pages;
   `);
   const insertPage = db.prepare(
-    "INSERT INTO pages (id, path, title, body, kind, status, source_type, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    "INSERT INTO pages (id, path, title, body, kind, status, source_type, source_class, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
   );
   for (const page of pages) {
-    const absolutePath = path17.join(wikiDir, page.path);
-    const content = await fs14.readFile(absolutePath, "utf8");
+    const absolutePath = path19.join(wikiDir, page.path);
+    const content = await fs15.readFile(absolutePath, "utf8");
     const parsed = matter8(content);
     insertPage.run(
       page.id,
@@ -8460,6 +8960,7 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
       page.kind,
       page.status,
       typeof parsed.data.source_type === "string" ? parsed.data.source_type : "",
+      typeof parsed.data.source_class === "string" ? parsed.data.source_class : "",
       JSON.stringify(page.projectIds),
       page.projectIds.map((projectId) => `|${projectId}|`).join("")
     );
@@ -8497,6 +8998,10 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
     clauses.push("pages.source_type = ?");
     params.push(options.sourceType);
   }
+  if (options.sourceClass && options.sourceClass !== "all") {
+    clauses.push("pages.source_class = ?");
+    params.push(options.sourceClass);
+  }
   const statement = db.prepare(`
     SELECT
       pages.id AS pageId,
@@ -8505,6 +9010,7 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
       pages.kind AS kind,
       pages.status AS status,
       pages.source_type AS sourceType,
+      pages.source_class AS sourceClass,
       pages.project_ids AS projectIds,
       snippet(page_search, 1, '[', ']', '...', 16) AS snippet,
       bm25(page_search) AS rank
@@ -8533,6 +9039,7 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
     kind: normalizeKind(row.kind),
     status: normalizeStatus(row.status),
     sourceType: normalizeSourceType2(row.sourceType),
+    sourceClass: normalizeSourceClass2(row.sourceClass),
     snippet: String(row.snippet ?? ""),
     rank: Number(row.rank ?? 0)
   }));
@@ -8560,7 +9067,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path18.join("outputs", "assets", slug, fileName));
+  return toPosix(path20.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -8700,7 +9207,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-6KZMA3XM.js");
+  const { createProvider: createProvider2 } = await import("./registry-YGVTLIZH.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -8898,7 +9405,7 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path18.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path20.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
@@ -8924,10 +9431,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path18.isAbsolute(rawPath)) {
+  if (!path20.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path18.relative(rootDir, rawPath));
+  const relative = toPosix(path20.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -9101,7 +9608,7 @@ function pageHashes(pages) {
   return Object.fromEntries(pages.map((page) => [page.page.id, page.contentHash]));
 }
 async function buildManagedGraphPage(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs15.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs16.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -9139,7 +9646,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs15.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs16.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -9258,7 +9765,11 @@ function deriveGraphMetrics(nodes, edges) {
     communities
   };
 }
+function resetGraphNodeMetrics(nodes) {
+  return nodes.map(({ communityId: _communityId, degree: _degree, bridgeScore: _bridgeScore, isGodNode: _isGodNode, ...node }) => node);
+}
 function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
+  const manifestsById = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
   const sourceNodes = manifests.map((manifest) => ({
     id: `source:${manifest.sourceId}`,
     type: "source",
@@ -9268,6 +9779,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
     confidence: 1,
     sourceIds: [manifest.sourceId],
     projectIds: scopedProjectIdsFromSources([manifest.sourceId], sourceProjects),
+    sourceClass: manifest.sourceClass,
     language: manifest.language
   }));
   const conceptMap = /* @__PURE__ */ new Map();
@@ -9284,7 +9796,6 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
     edgesById.add(edge.id);
     edges.push(edge);
   };
-  const manifestsById = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
   const analysesBySourceId = new Map(analyses.map((analysis) => [analysis.sourceId, analysis]));
   for (const analysis of analyses) {
     for (const concept of analysis.concepts) {
@@ -9298,7 +9809,8 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
         freshness: "fresh",
         confidence: nodeConfidence(sourceIds.length),
         sourceIds,
-        projectIds: scopedProjectIdsFromSources(sourceIds, sourceProjects)
+        projectIds: scopedProjectIdsFromSources(sourceIds, sourceProjects),
+        sourceClass: aggregateManifestSourceClass(manifests, sourceIds)
       });
       pushEdge({
         id: `${analysis.sourceId}->${concept.id}`,
@@ -9322,7 +9834,8 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
         freshness: "fresh",
         confidence: nodeConfidence(sourceIds.length),
         sourceIds,
-        projectIds: scopedProjectIdsFromSources(sourceIds, sourceProjects)
+        projectIds: scopedProjectIdsFromSources(sourceIds, sourceProjects),
+        sourceClass: aggregateManifestSourceClass(manifests, sourceIds)
       });
       pushEdge({
         id: `${analysis.sourceId}->${entity.id}`,
@@ -9350,6 +9863,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
         confidence: 1,
         sourceIds: [analysis.sourceId],
         projectIds: scopedProjectIdsFromSources([analysis.sourceId], sourceProjects),
+        sourceClass: manifest.sourceClass,
         language: analysis.code.language,
         moduleId
       });
@@ -9373,6 +9887,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
           confidence: symbol.exported ? 0.88 : 0.74,
           sourceIds: [analysis.sourceId],
           projectIds: scopedProjectIdsFromSources([analysis.sourceId], sourceProjects),
+          sourceClass: manifest.sourceClass,
           language: analysis.code.language,
           moduleId,
           symbolKind: symbol.kind
@@ -9413,6 +9928,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
           confidence: 1,
           sourceIds: [analysis.sourceId],
           projectIds: scopedProjectIdsFromSources([analysis.sourceId], sourceProjects),
+          sourceClass: manifest.sourceClass,
           language: analysis.code.language,
           moduleId
         });
@@ -9608,7 +10124,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
-    const absolutePath = path18.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
+    const absolutePath = path20.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
     communityRecords.push(
       await buildManagedGraphPage(
         absolutePath,
@@ -9636,7 +10152,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     recentResearchSources: recentResearchSourcePages(graph, previousCompiledAt),
     graphHash: graphHash(graph)
   });
-  const reportAbsolutePath = path18.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path20.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -9657,7 +10173,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path18.resolve(wikiDir, relativePath);
+  const absolutePath = path20.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -9688,6 +10204,7 @@ function emptyGraphPage(input) {
     path: input.path,
     title: input.title,
     kind: input.kind,
+    sourceClass: input.sourceClass,
     sourceIds: input.sourceIds,
     projectIds: input.projectIds ?? [],
     nodeIds: input.nodeIds,
@@ -9719,29 +10236,29 @@ async function requiredCompileArtifactsExist(paths) {
     paths.graphPath,
     paths.codeIndexPath,
     paths.searchDbPath,
-    path18.join(paths.wikiDir, "index.md"),
-    path18.join(paths.wikiDir, "sources", "index.md"),
-    path18.join(paths.wikiDir, "code", "index.md"),
-    path18.join(paths.wikiDir, "concepts", "index.md"),
-    path18.join(paths.wikiDir, "entities", "index.md"),
-    path18.join(paths.wikiDir, "outputs", "index.md"),
-    path18.join(paths.wikiDir, "projects", "index.md"),
-    path18.join(paths.wikiDir, "candidates", "index.md")
+    path20.join(paths.wikiDir, "index.md"),
+    path20.join(paths.wikiDir, "sources", "index.md"),
+    path20.join(paths.wikiDir, "code", "index.md"),
+    path20.join(paths.wikiDir, "concepts", "index.md"),
+    path20.join(paths.wikiDir, "entities", "index.md"),
+    path20.join(paths.wikiDir, "outputs", "index.md"),
+    path20.join(paths.wikiDir, "projects", "index.md"),
+    path20.join(paths.wikiDir, "candidates", "index.md")
   ];
   const checks = await Promise.all(requiredPaths.map((filePath) => fileExists(filePath)));
   return checks.every(Boolean);
 }
 async function loadAvailableCachedAnalyses(paths, manifests) {
   const analyses = await Promise.all(
-    manifests.map(async (manifest) => readJsonFile(path18.join(paths.analysesDir, `${manifest.sourceId}.json`)))
+    manifests.map(async (manifest) => readJsonFile(path20.join(paths.analysesDir, `${manifest.sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis));
 }
 function approvalManifestPath(paths, approvalId) {
-  return path18.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path20.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path18.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path20.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
@@ -9751,7 +10268,7 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs15.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs16.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph) {
@@ -9766,7 +10283,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path18.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path20.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -9799,7 +10316,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path18.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path20.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
@@ -9811,16 +10328,16 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
 }
 async function stageApprovalBundle(paths, changedFiles, deletedPaths, previousGraph, graph) {
   const approvalId = `compile-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path18.join(paths.approvalsDir, approvalId);
+  const approvalDir = path20.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path18.join(approvalDir, "wiki"));
-  await ensureDir(path18.join(approvalDir, "state"));
+  await ensureDir(path20.join(approvalDir, "wiki"));
+  await ensureDir(path20.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path18.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path18.dirname(targetPath));
-    await fs15.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path20.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path20.dirname(targetPath));
+    await fs16.writeFile(targetPath, file.content, "utf8");
   }
-  await fs15.writeFile(path18.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs16.writeFile(path20.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9856,6 +10373,7 @@ async function syncVaultArtifacts(rootDir, input) {
       title: modulePageTitle(manifest),
       kind: "module",
       sourceIds: [manifest.sourceId],
+      sourceClass: manifest.sourceClass,
       projectIds: sourceProjectIds,
       nodeIds: [analysis.code.moduleId, ...analysis.code.symbols.map((symbol) => symbol.id)],
       schemaHash: sourceSchemaHash,
@@ -9868,6 +10386,7 @@ async function syncVaultArtifacts(rootDir, input) {
       title: analysis.title,
       kind: "source",
       sourceIds: [manifest.sourceId],
+      sourceClass: manifest.sourceClass,
       projectIds: sourceProjectIds,
       nodeIds: [
         `source:${manifest.sourceId}`,
@@ -9880,7 +10399,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path18.join(paths.wikiDir, preview.path),
+      path20.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -9895,7 +10414,8 @@ async function syncVaultArtifacts(rootDir, input) {
         modulePreview ?? void 0,
         {
           projectIds: sourceProjectIds,
-          extraTags: sourceCategoryTags
+          extraTags: sourceCategoryTags,
+          sourceClass: manifest.sourceClass
         }
       )
     );
@@ -9925,7 +10445,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path18.join(paths.wikiDir, modulePreview.path),
+          path20.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -9957,9 +10477,10 @@ async function syncVaultArtifacts(rootDir, input) {
       const previousEntry = input.previousState?.candidateHistory?.[pageId];
       const promoted = previousEntry?.status === "active" || promoteCandidates && shouldPromoteCandidate(previousEntry, sourceIds);
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
+      const aggregateSourceClass2 = aggregateManifestSourceClass(input.manifests, sourceIds);
       const fallbackPaths = [
-        path18.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path18.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path20.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path20.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -9968,6 +10489,7 @@ async function syncVaultArtifacts(rootDir, input) {
         title: aggregate.name,
         kind: itemKind,
         sourceIds,
+        sourceClass: aggregateSourceClass2,
         projectIds,
         nodeIds: [pageId],
         schemaHash,
@@ -9976,7 +10498,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path18.join(paths.wikiDir, relativePath),
+        path20.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -10000,7 +10522,8 @@ async function syncVaultArtifacts(rootDir, input) {
               aggregate.name,
               ...aggregate.descriptions,
               ...aggregate.sourceAnalyses.map((item) => item.summary)
-            ])
+            ]),
+            sourceClass: aggregateSourceClass2
           }
         )
       );
@@ -10016,7 +10539,20 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const compiledPages = records.map((record) => record.page);
   const basePages = [...compiledPages, ...input.outputPages, ...input.insightPages];
-  const baseGraph = buildGraph(input.manifests, input.analyses, basePages, input.sourceProjects, input.codeIndex);
+  const structuralGraph = buildGraph(input.manifests, input.analyses, basePages, input.sourceProjects, input.codeIndex);
+  const embeddingEdges = await embeddingSimilarityEdges(rootDir, structuralGraph).catch(() => []);
+  const baseGraph = embeddingEdges.length > 0 ? (() => {
+    const edges = uniqueBy([...structuralGraph.edges, ...embeddingEdges], (edge) => edge.id).sort(
+      (left, right) => left.id.localeCompare(right.id)
+    );
+    const metrics = deriveGraphMetrics(resetGraphNodeMetrics(structuralGraph.nodes), edges);
+    return {
+      ...structuralGraph,
+      nodes: metrics.nodes,
+      edges,
+      communities: metrics.communities
+    };
+  })() : structuralGraph;
   const graphOrientation = await buildGraphOrientationPages(baseGraph, paths, globalSchemaHash, input.previousState?.generatedAt);
   records.push(...graphOrientation.records);
   const allPages = [...basePages, ...graphOrientation.records.map((record) => record.page)];
@@ -10057,7 +10593,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path18.join(paths.wikiDir, "projects", "index.md"),
+      path20.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -10081,7 +10617,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path18.join(paths.wikiDir, projectIndexRef.path),
+        path20.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -10109,7 +10645,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path18.join(paths.wikiDir, "index.md"),
+      path20.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -10140,7 +10676,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path18.join(paths.wikiDir, relativePath),
+        path20.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -10151,12 +10687,12 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const nextPagePaths = new Set(records.map((record) => record.page.path));
   const obsoleteGraphPaths = (previousGraph?.pages ?? []).filter((page) => page.kind !== "output" && page.kind !== "insight").map((page) => page.path).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path18.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path20.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
   const obsoletePaths = uniqueStrings3([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path18.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs15.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path20.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs16.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -10181,10 +10717,10 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs15.rm(path18.join(paths.wikiDir, relativePath), { force: true });
+    await fs16.rm(path20.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
-  await writeJsonFile(path18.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+  await writeJsonFile(path20.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   await writeJsonFile(paths.codeIndexPath, input.codeIndex);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
@@ -10255,17 +10791,17 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path18.join(paths.wikiDir, "sources")),
-    ensureDir(path18.join(paths.wikiDir, "code")),
-    ensureDir(path18.join(paths.wikiDir, "concepts")),
-    ensureDir(path18.join(paths.wikiDir, "entities")),
-    ensureDir(path18.join(paths.wikiDir, "outputs")),
-    ensureDir(path18.join(paths.wikiDir, "graph")),
-    ensureDir(path18.join(paths.wikiDir, "graph", "communities")),
-    ensureDir(path18.join(paths.wikiDir, "projects")),
-    ensureDir(path18.join(paths.wikiDir, "candidates"))
+    ensureDir(path20.join(paths.wikiDir, "sources")),
+    ensureDir(path20.join(paths.wikiDir, "code")),
+    ensureDir(path20.join(paths.wikiDir, "concepts")),
+    ensureDir(path20.join(paths.wikiDir, "entities")),
+    ensureDir(path20.join(paths.wikiDir, "outputs")),
+    ensureDir(path20.join(paths.wikiDir, "graph")),
+    ensureDir(path20.join(paths.wikiDir, "graph", "communities")),
+    ensureDir(path20.join(paths.wikiDir, "projects")),
+    ensureDir(path20.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path18.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path20.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -10286,7 +10822,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       outputs: pages.filter((page) => page.kind === "output" && page.projectIds.includes(project.id)),
       candidates: pages.filter((page) => page.status === "candidate" && page.projectIds.includes(project.id))
     };
-    const absolutePath = path18.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path20.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -10304,7 +10840,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path18.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path20.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -10325,7 +10861,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ["candidates/index.md", "candidates", pagesWithGraph.filter((page) => page.status === "candidate")],
     ["graph/index.md", "graph", pagesWithGraph.filter((page) => page.kind === "graph_report" || page.kind === "community_summary")]
   ]) {
-    const absolutePath = path18.join(paths.wikiDir, relativePath);
+    const absolutePath = path20.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -10339,23 +10875,23 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     );
   }
   for (const record of graphOrientation.records) {
-    await writeFileIfChanged(path18.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path20.join(paths.wikiDir, record.page.path), record.content);
   }
   if (graphOrientation.report) {
-    await writeJsonFile(path18.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+    await writeJsonFile(path20.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path18.relative(paths.wikiDir, absolutePath)));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path20.relative(paths.wikiDir, absolutePath)));
   const allowedProjectIndexPaths = /* @__PURE__ */ new Set([
     "projects/index.md",
     ...configuredProjects.map((project) => `projects/${project.id}/index.md`)
   ]);
   await Promise.all(
-    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs15.rm(path18.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs16.rm(path20.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingGraphPages = (await listFilesRecursive(path18.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path18.relative(paths.wikiDir, absolutePath)));
+  const existingGraphPages = (await listFilesRecursive(path20.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path20.relative(paths.wikiDir, absolutePath)));
   const allowedGraphPages = /* @__PURE__ */ new Set(["graph/index.md", ...graphOrientation.records.map((record) => record.page.path)]);
   await Promise.all(
-    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs15.rm(path18.join(paths.wikiDir, relativePath), { force: true }))
+    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs16.rm(path20.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
@@ -10375,7 +10911,7 @@ async function prepareOutputPageSave(rootDir, input) {
       confidence: 0.74
     }
   });
-  const absolutePath = path18.join(paths.wikiDir, output.page.path);
+  const absolutePath = path20.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -10387,15 +10923,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path18.dirname(prepared.savedPath));
-  await fs15.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path20.dirname(prepared.savedPath));
+  await fs16.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path18.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path18.dirname(assetPath));
+    const assetPath = path20.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path20.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs15.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs16.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs15.writeFile(assetPath, assetFile.content);
+      await fs16.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -10416,7 +10952,7 @@ async function prepareExploreHubSave(rootDir, input) {
       confidence: 0.76
     }
   });
-  const absolutePath = path18.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path20.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -10428,15 +10964,15 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path18.dirname(prepared.savedPath));
-  await fs15.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path20.dirname(prepared.savedPath));
+  await fs16.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path18.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path18.dirname(assetPath));
+    const assetPath = path20.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path20.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs15.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs16.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs15.writeFile(assetPath, assetFile.content);
+      await fs16.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -10453,17 +10989,17 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     }))
   ]);
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path18.join(paths.approvalsDir, approvalId);
+  const approvalDir = path20.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path18.join(approvalDir, "wiki"));
-  await ensureDir(path18.join(approvalDir, "state"));
+  await ensureDir(path20.join(approvalDir, "wiki"));
+  await ensureDir(path20.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path18.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path18.dirname(targetPath));
+    const targetPath = path20.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path20.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs15.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs16.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs15.writeFile(targetPath, file.content, "utf8");
+      await fs16.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -10478,7 +11014,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs15.writeFile(path18.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs16.writeFile(path20.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10507,9 +11043,9 @@ async function executeQuery(rootDir, question, format) {
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path18.join(paths.wikiDir, result.path);
+      const absolutePath = path20.join(paths.wikiDir, result.path);
       try {
-        const content = await fs15.readFile(absolutePath, "utf8");
+        const content = await fs16.readFile(absolutePath, "utf8");
         const parsed = matter9(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
@@ -10691,7 +11227,7 @@ function sortGraphPages(pages) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs15.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs16.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -10707,8 +11243,8 @@ async function readApproval(rootDir, approvalId) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs15.readFile(path18.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs15.readFile(path18.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs16.readFile(path20.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs16.readFile(path20.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       return {
         ...entry,
         currentContent,
@@ -10736,26 +11272,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path18.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs15.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path18.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path18.dirname(targetAbsolutePath));
-      await fs15.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path20.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs16.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path20.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path20.dirname(targetAbsolutePath));
+      await fs16.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs15.rm(path18.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs16.rm(path20.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       const nextPage = bundleGraph?.pages.find((page) => page.id === entry.pageId && page.path === entry.nextPath) ?? parseStoredPage(entry.nextPath, stagedContent);
       if (nextPage.kind === "output" && nextPage.outputAssets?.length) {
-        const outputAssetDir = path18.join(paths.wikiDir, "outputs", "assets", path18.basename(nextPage.path, ".md"));
-        await fs15.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path20.join(paths.wikiDir, "outputs", "assets", path20.basename(nextPage.path, ".md"));
+        await fs16.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path18.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path20.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path18.join(paths.wikiDir, asset.path);
-          await ensureDir(path18.dirname(targetAssetPath));
-          await fs15.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path20.join(paths.wikiDir, asset.path);
+          await ensureDir(path20.dirname(targetAssetPath));
+          await fs16.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -10766,10 +11302,10 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
     } else {
       const deletedPage = nextPages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? bundleGraph?.pages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? null;
       if (entry.previousPath) {
-        await fs15.rm(path18.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs16.rm(path20.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs15.rm(path18.join(paths.wikiDir, "outputs", "assets", path18.basename(deletedPage.path, ".md")), {
+        await fs16.rm(path20.join(paths.wikiDir, "outputs", "assets", path20.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -10860,7 +11396,7 @@ async function promoteCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  const raw = await fs15.readFile(path18.join(paths.wikiDir, candidate.path), "utf8");
+  const raw = await fs16.readFile(path20.join(paths.wikiDir, candidate.path), "utf8");
   const parsed = matter9(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const nextContent = matter9.stringify(parsed.content, {
@@ -10872,10 +11408,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path18.join(paths.wikiDir, nextPath);
-  await ensureDir(path18.dirname(nextAbsolutePath));
-  await fs15.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs15.rm(path18.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path20.join(paths.wikiDir, nextPath);
+  await ensureDir(path20.dirname(nextAbsolutePath));
+  await fs16.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs16.rm(path20.join(paths.wikiDir, candidate.path), { force: true });
   const nextPage = parseStoredPage(nextPath, nextContent, { createdAt: candidate.createdAt, updatedAt: nextUpdatedAt });
   const nextPages = sortGraphPages(
     (graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path).concat(nextPage)
@@ -10920,7 +11456,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs15.rm(path18.join(paths.wikiDir, candidate.path), { force: true });
+  await fs16.rm(path20.join(paths.wikiDir, candidate.path), { force: true });
   const nextPages = sortGraphPages((graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path));
   const nextGraph = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10959,18 +11495,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path18.join(rootDir, ".obsidian");
+  const obsidianDir = path20.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path18.join(obsidianDir, "app.json"), {
+    writeJsonFile(path20.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path18.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path20.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -10980,7 +11516,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path18.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path20.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -10992,7 +11528,7 @@ async function ensureObsidianWorkspace(rootDir) {
       })),
       localJumps: false
     }),
-    writeJsonFile(path18.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path20.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -11007,7 +11543,7 @@ async function ensureObsidianWorkspace(rootDir) {
 async function initVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path18.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path20.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
@@ -11043,7 +11579,7 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path18.join(paths.wikiDir, "projects", "index.md"),
+    path20.join(paths.wikiDir, "projects", "index.md"),
     matter9.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
@@ -11065,7 +11601,7 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path18.join(paths.wikiDir, "candidates", "index.md"),
+    path20.join(paths.wikiDir, "candidates", "index.md"),
     matter9.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
@@ -11201,7 +11737,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path18.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path20.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           return cached;
         }
@@ -11225,22 +11761,22 @@ async function compileVault(rootDir, options = {}) {
       }
       const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
       if (analysisSignature(enriched) !== analysisSignature(analysis)) {
-        await writeJsonFile(path18.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+        await writeJsonFile(path20.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
       }
       return enriched;
     })
   );
   await Promise.all([
-    ensureDir(path18.join(paths.wikiDir, "sources")),
-    ensureDir(path18.join(paths.wikiDir, "code")),
-    ensureDir(path18.join(paths.wikiDir, "concepts")),
-    ensureDir(path18.join(paths.wikiDir, "entities")),
-    ensureDir(path18.join(paths.wikiDir, "outputs")),
-    ensureDir(path18.join(paths.wikiDir, "projects")),
-    ensureDir(path18.join(paths.wikiDir, "insights")),
-    ensureDir(path18.join(paths.wikiDir, "candidates")),
-    ensureDir(path18.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path18.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path20.join(paths.wikiDir, "sources")),
+    ensureDir(path20.join(paths.wikiDir, "code")),
+    ensureDir(path20.join(paths.wikiDir, "concepts")),
+    ensureDir(path20.join(paths.wikiDir, "entities")),
+    ensureDir(path20.join(paths.wikiDir, "outputs")),
+    ensureDir(path20.join(paths.wikiDir, "projects")),
+    ensureDir(path20.join(paths.wikiDir, "insights")),
+    ensureDir(path20.join(paths.wikiDir, "candidates")),
+    ensureDir(path20.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path20.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
@@ -11387,7 +11923,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path18.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path20.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -11643,9 +12179,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path18.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path20.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path18.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path20.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -11706,11 +12242,18 @@ async function ensureCompiledGraph(rootDir) {
   }
   return graph;
 }
-async function queryGraphVault(rootDir, question, options = {}) {
+async function runResolvedGraphQuery(rootDir, graph, question, options = {}) {
   const { paths } = await loadVaultConfig(rootDir);
-  const graph = await ensureCompiledGraph(rootDir);
   const searchResults = searchPages(paths.searchDbPath, question, { limit: Math.max(5, options.budget ?? 10) });
-  return queryGraph(graph, question, searchResults, options);
+  const semanticMatches = await semanticGraphMatches(rootDir, graph, question, Math.max(8, options.budget ?? 12)).catch(() => []);
+  return queryGraph(graph, question, searchResults, {
+    ...options,
+    semanticMatches
+  });
+}
+async function queryGraphVault(rootDir, question, options = {}) {
+  const graph = await ensureCompiledGraph(rootDir);
+  return runResolvedGraphQuery(rootDir, graph, question, options);
 }
 async function benchmarkVault(rootDir, options = {}) {
   const { config, paths } = await loadVaultConfig(rootDir);
@@ -11725,30 +12268,31 @@ async function benchmarkVault(rootDir, options = {}) {
     }
   }
   for (const page of graph.pages) {
-    const absolutePath = path18.join(paths.wikiDir, page.path);
+    const absolutePath = path20.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const parsed = matter9(await fs15.readFile(absolutePath, "utf8"));
+    const parsed = matter9(await fs16.readFile(absolutePath, "utf8"));
     pageContentsById.set(page.id, parsed.content);
   }
   const configuredQuestions = (config.benchmark?.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
   const maxQuestions = Math.max(1, options.maxQuestions ?? config.benchmark?.maxQuestions ?? 3);
   const questions = (options.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
   const sampleQuestions = (questions.length ? questions : configuredQuestions.length ? configuredQuestions : defaultBenchmarkQuestionsForGraph(graph, maxQuestions)).slice(0, maxQuestions);
-  const perQuestion = sampleQuestions.map((question) => {
-    const searchResults = searchPages(paths.searchDbPath, question, { limit: 12 });
-    const result = queryGraph(graph, question, searchResults, { budget: 12 });
-    const metrics = benchmarkQueryTokens(graph, result, pageContentsById);
-    return {
-      question,
-      queryTokens: metrics.queryTokens,
-      reduction: metrics.reduction,
-      visitedNodeIds: result.visitedNodeIds,
-      visitedEdgeIds: result.visitedEdgeIds,
-      pageIds: result.pageIds
-    };
-  });
+  const perQuestion = await Promise.all(
+    sampleQuestions.map(async (question) => {
+      const result = await runResolvedGraphQuery(rootDir, graph, question, { budget: 12 });
+      const metrics = benchmarkQueryTokens(graph, result, pageContentsById);
+      return {
+        question,
+        queryTokens: metrics.queryTokens,
+        reduction: metrics.reduction,
+        visitedNodeIds: result.visitedNodeIds,
+        visitedEdgeIds: result.visitedEdgeIds,
+        pageIds: result.pageIds
+      };
+    })
+  );
   const artifact = buildBenchmarkArtifact({
     graph,
     corpusWords,
@@ -11773,7 +12317,7 @@ async function listGraphHyperedges(rootDir, target, limit = 25) {
 }
 async function readGraphReport(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
-  return readJsonFile(path18.join(paths.wikiDir, "graph", "report.json"));
+  return readJsonFile(path20.join(paths.wikiDir, "graph", "report.json"));
 }
 async function listGodNodes(rootDir, limit = 10) {
   const graph = await ensureCompiledGraph(rootDir);
@@ -11786,15 +12330,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path18.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path20.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs15.readFile(absolutePath, "utf8");
+  const raw = await fs16.readFile(absolutePath, "utf8");
   const parsed = matter9(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path18.basename(relativePath, path18.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path20.basename(relativePath, path20.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -11830,7 +12374,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "warning",
           code: "stale_page",
           message: `Page ${page.title} is stale because the vault schema changed.`,
-          pagePath: path18.join(paths.wikiDir, page.path),
+          pagePath: path20.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -11841,7 +12385,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
             severity: "warning",
             code: "stale_page",
             message: `Page ${page.title} is stale because source ${sourceId} changed.`,
-            pagePath: path18.join(paths.wikiDir, page.path),
+            pagePath: path20.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -11852,13 +12396,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path18.join(paths.wikiDir, page.path),
+          pagePath: path20.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path18.join(paths.wikiDir, page.path);
+      const absolutePath = path20.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs15.readFile(absolutePath, "utf8");
+        const content = await fs16.readFile(absolutePath, "utf8");
         if (content.includes("## Claims")) {
           const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
           if (uncited.length) {
@@ -11938,7 +12482,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.25";
+var SERVER_VERSION = "0.1.27";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -12209,7 +12753,7 @@ async function createMcpServer(rootDir) {
     },
     async () => {
       const { paths } = await loadVaultConfig(rootDir);
-      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path19.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path21.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -12242,8 +12786,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path19.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs16.readFile(absolutePath, "utf8"));
+      const absolutePath = path21.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs17.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -12251,11 +12795,11 @@ async function createMcpServer(rootDir) {
     new ResourceTemplate("swarmvault://sessions/{path}", {
       list: async () => {
         const { paths } = await loadVaultConfig(rootDir);
-        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path19.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path21.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path19.basename(relativePath, ".md"),
+            name: path21.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -12272,11 +12816,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path19.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path21.resolve(paths.sessionsDir, relativePath);
       if (!absolutePath.startsWith(paths.sessionsDir) || !await fileExists(absolutePath)) {
         return asTextResource(`swarmvault://sessions/${encodedPath}`, `Session not found: ${relativePath}`);
       }
-      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs16.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs17.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -12324,13 +12868,13 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs17 from "fs/promises";
-import path20 from "path";
+import fs18 from "fs/promises";
+import path22 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path20.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path22.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path20.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path22.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -12433,13 +12977,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs17.open(leasePath, "wx");
+  const handle = await fs18.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs17.rm(leasePath, { force: true });
+    await fs18.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -12587,31 +13131,31 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/viewer.ts
 import { execFile } from "child_process";
-import fs18 from "fs/promises";
+import fs19 from "fs/promises";
 import http from "http";
-import path22 from "path";
+import path24 from "path";
 import { promisify } from "util";
 import matter10 from "gray-matter";
 import mime2 from "mime-types";
 
 // src/watch.ts
-import path21 from "path";
+import path23 from "path";
 import process2 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
 var BACKOFF_THRESHOLD = 3;
 var CRITICAL_THRESHOLD = 10;
-var REPO_WATCH_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
+var REPO_WATCH_IGNORES = /* @__PURE__ */ new Set([".git", ".venv"]);
 function withinRoot2(rootPath, targetPath) {
-  const relative = path21.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative);
+  const relative = path23.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path23.isAbsolute(relative);
 }
 function hasIgnoredRepoSegment(baseDir, targetPath) {
-  const relativePath = path21.relative(baseDir, targetPath);
+  const relativePath = path23.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath.split(path21.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+  return relativePath.split(path23.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
 }
 function workspaceIgnoreRoots(rootDir, paths) {
   return [
@@ -12620,16 +13164,16 @@ function workspaceIgnoreRoots(rootDir, paths) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path21.join(rootDir, ".claude"),
-    path21.join(rootDir, ".cursor"),
-    path21.join(rootDir, ".obsidian")
-  ].map((candidate) => path21.resolve(candidate));
+    path23.join(rootDir, ".claude"),
+    path23.join(rootDir, ".cursor"),
+    path23.join(rootDir, ".obsidian")
+  ].map((candidate) => path23.resolve(candidate));
 }
 async function resolveWatchTargets(rootDir, paths, options) {
-  const targets = /* @__PURE__ */ new Set([path21.resolve(paths.inboxDir)]);
+  const targets = /* @__PURE__ */ new Set([path23.resolve(paths.inboxDir)]);
   if (options.repo) {
     for (const repoRoot of await listTrackedRepoRoots(rootDir)) {
-      targets.add(path21.resolve(repoRoot));
+      targets.add(path23.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
@@ -12759,7 +13303,7 @@ async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   const baseDebounceMs = options.debounceMs ?? 900;
   const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
-  const inboxWatchRoot = path21.resolve(paths.inboxDir);
+  const inboxWatchRoot = path23.resolve(paths.inboxDir);
   let watchTargets = await resolveWatchTargets(rootDir, paths, options);
   let timer;
   let running = false;
@@ -12773,7 +13317,7 @@ async function watchVault(rootDir, options = {}) {
     usePolling: true,
     interval: 100,
     ignored: (targetPath) => {
-      const absolutePath = path21.resolve(targetPath);
+      const absolutePath = path23.resolve(targetPath);
       const primaryTarget = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
@@ -12945,8 +13489,8 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path21.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
-    return path21.relative(baseDir, targetPath) || ".";
+    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path23.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path23.relative(baseDir, targetPath) || ".";
   };
   watcher.on("add", (filePath) => schedule(`add:${reasonForPath(filePath)}`)).on("change", (filePath) => schedule(`change:${reasonForPath(filePath)}`)).on("unlink", (filePath) => schedule(`unlink:${reasonForPath(filePath)}`)).on("addDir", (dirPath) => schedule(`addDir:${reasonForPath(dirPath)}`)).on("unlinkDir", (dirPath) => schedule(`unlinkDir:${reasonForPath(dirPath)}`)).on("error", (caught) => schedule(`error:${caught instanceof Error ? caught.message : String(caught)}`));
   await new Promise((resolve, reject) => {
@@ -12987,15 +13531,15 @@ async function getWatchStatus(rootDir) {
 var execFileAsync = promisify(execFile);
 async function readViewerPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path22.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path24.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs18.readFile(absolutePath, "utf8");
+  const raw = await fs19.readFile(absolutePath, "utf8");
   const parsed = matter10(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path22.basename(relativePath, path22.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path24.basename(relativePath, path24.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -13003,12 +13547,12 @@ async function readViewerPage(rootDir, relativePath) {
 }
 async function readViewerAsset(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path22.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path24.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs18.readFile(absolutePath),
+    buffer: await fs19.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -13031,12 +13575,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path22.join(viewerDistDir, "index.html");
+  const indexPath = path24.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path22.dirname(viewerDistDir);
-  if (await fileExists(path22.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path24.dirname(viewerDistDir);
+  if (await fileExists(path24.join(viewerProjectDir, "package.json"))) {
     await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -13053,7 +13597,7 @@ async function startGraphServer(rootDir, port) {
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs18.readFile(paths.graphPath, "utf8"));
+      response.end(await fs19.readFile(paths.graphPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/graph/query") {
@@ -13096,26 +13640,28 @@ async function startGraphServer(rootDir, port) {
       const status = url.searchParams.get("status") ?? "all";
       const project = url.searchParams.get("project") ?? "all";
       const sourceType = url.searchParams.get("sourceType") ?? "all";
+      const sourceClass = url.searchParams.get("sourceClass") ?? "all";
       const results = searchPages(paths.searchDbPath, query, {
         limit: Number.isFinite(limit) ? limit : 10,
         kind,
         status,
         project,
-        sourceType
+        sourceType,
+        sourceClass
       });
       response.writeHead(200, { "content-type": "application/json" });
       response.end(JSON.stringify(results));
       return;
     }
     if (url.pathname === "/api/graph-report") {
-      const reportPath = path22.join(paths.wikiDir, "graph", "report.json");
+      const reportPath = path24.join(paths.wikiDir, "graph", "report.json");
       if (!await fileExists(reportPath)) {
         response.writeHead(404, { "content-type": "application/json" });
         response.end(JSON.stringify({ error: "Graph report artifact not found. Run `swarmvault compile` first." }));
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs18.readFile(reportPath, "utf8"));
+      response.end(await fs19.readFile(reportPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/watch-status") {
@@ -13198,8 +13744,8 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path22.join(paths.viewerDistDir, relativePath);
-    const fallback = path22.join(paths.viewerDistDir, "index.html");
+    const target = path24.join(paths.viewerDistDir, relativePath);
+    const fallback = path24.join(paths.viewerDistDir, "index.html");
     const filePath = await fileExists(target) ? target : fallback;
     if (!await fileExists(filePath)) {
       response.writeHead(503, { "content-type": "text/plain" });
@@ -13207,7 +13753,7 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs18.readFile(filePath));
+    response.end(await fs19.readFile(filePath));
   });
   await new Promise((resolve) => {
     server.listen(effectivePort, resolve);
@@ -13234,7 +13780,7 @@ async function exportGraphHtml(rootDir, outputPath) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path22.join(paths.viewerDistDir, "index.html");
+  const indexPath = path24.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -13248,6 +13794,7 @@ async function exportGraphHtml(rootDir, outputPath) {
         kind: page.kind,
         status: page.status,
         sourceType: page.sourceType,
+        sourceClass: page.sourceClass,
         projectIds: page.projectIds,
         content: loaded.content,
         assets: await Promise.all(
@@ -13259,17 +13806,17 @@ async function exportGraphHtml(rootDir, outputPath) {
       } : null;
     })
   );
-  const rawHtml = await fs18.readFile(indexPath, "utf8");
+  const rawHtml = await fs19.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] ? path22.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path22.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path24.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path24.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
   if (!scriptPath || !await fileExists(scriptPath)) {
     throw new Error("Viewer script bundle not found. Run `pnpm build` first.");
   }
-  const script = await fs18.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs18.readFile(stylePath, "utf8") : "";
-  const report = await readJsonFile(path22.join(paths.wikiDir, "graph", "report.json"));
+  const script = await fs19.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs19.readFile(stylePath, "utf8") : "";
+  const report = await readJsonFile(path24.join(paths.wikiDir, "graph", "report.json"));
   const embeddedData = JSON.stringify({ graph, pages: pages.filter(Boolean), report }, null, 2).replace(/</g, "\\u003c");
   const html = [
     "<!doctype html>",
@@ -13288,9 +13835,9 @@ async function exportGraphHtml(rootDir, outputPath) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs18.mkdir(path22.dirname(outputPath), { recursive: true });
-  await fs18.writeFile(outputPath, html, "utf8");
-  return path22.resolve(outputPath);
+  await fs19.mkdir(path24.dirname(outputPath), { recursive: true });
+  await fs19.writeFile(outputPath, html, "utf8");
+  return path24.resolve(outputPath);
 }
 export {
   acceptApproval,