@swarmvaultai/engine 0.1.33 → 0.2.0

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-IAEYFTUS.js";
+} from "./chunk-CWLDFLH2.js";
 
 // src/agents.ts
 import crypto from "crypto";
@@ -1721,8 +1721,8 @@ async function uninstallGitHooks(rootDir) {
 }
 
 // src/ingest.ts
-import fs10 from "fs/promises";
-import path11 from "path";
+import fs11 from "fs/promises";
+import path12 from "path";
 import { pathToFileURL } from "url";
 import { Readability } from "@mozilla/readability";
 import matter3 from "gray-matter";
@@ -4724,9 +4724,123 @@ function aggregateManifestSourceClass(manifests, sourceIds) {
   return aggregateSourceClass(sourceIds.map((sourceId) => byId.get(sourceId)));
 }
 
-// src/watch-state.ts
+// src/source-registry.ts
 import fs9 from "fs/promises";
 import path10 from "path";
+var MANAGED_SOURCES_VERSION = 1;
+function repoRootFromManifest(manifest) {
+  if (manifest.originType !== "file" || !manifest.originalPath || !manifest.repoRelativePath) {
+    return null;
+  }
+  const repoDir = path10.posix.dirname(manifest.repoRelativePath);
+  const fileDir = path10.dirname(path10.resolve(manifest.originalPath));
+  if (repoDir === "." || !repoDir) {
+    return fileDir;
+  }
+  const segments = repoDir.split("/").filter(Boolean);
+  return path10.resolve(fileDir, ...segments.map(() => ".."));
+}
+async function loadManifestArtifacts(paths) {
+  const entries = await fs9.readdir(paths.manifestsDir, { withFileTypes: true }).catch(() => []);
+  const manifests = await Promise.all(
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => await readJsonFile(path10.join(paths.manifestsDir, entry.name)))
+  );
+  return manifests.filter((manifest) => Boolean(manifest?.sourceId));
+}
+function buildLegacyDirectoryEntry(repoRoot, manifests) {
+  const repoTitle = path10.basename(repoRoot) || repoRoot;
+  const sourceIds = manifests.map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+  const createdAt = manifests.map((manifest) => manifest.createdAt).sort((left, right) => left.localeCompare(right))[0] ?? (/* @__PURE__ */ new Date()).toISOString();
+  const updatedAt = manifests.map((manifest) => manifest.updatedAt).sort((left, right) => right.localeCompare(left))[0] ?? createdAt;
+  return {
+    id: `directory-${slugify(repoTitle)}-${sha256(repoRoot).slice(0, 8)}`,
+    kind: "directory",
+    title: repoTitle,
+    path: repoRoot,
+    repoRoot,
+    createdAt,
+    updatedAt,
+    status: "ready",
+    sourceIds,
+    lastSyncAt: updatedAt,
+    lastSyncStatus: "success",
+    lastSyncCounts: {
+      scannedCount: manifests.length,
+      importedCount: manifests.length,
+      updatedCount: 0,
+      removedCount: 0,
+      skippedCount: 0
+    }
+  };
+}
+async function buildLegacyArtifact(paths) {
+  const manifests = await loadManifestArtifacts(paths);
+  const manifestsByRepoRoot = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    const repoRoot = repoRootFromManifest(manifest);
+    if (!repoRoot) {
+      continue;
+    }
+    const key = path10.resolve(repoRoot);
+    const bucket = manifestsByRepoRoot.get(key) ?? [];
+    bucket.push(manifest);
+    manifestsByRepoRoot.set(key, bucket);
+  }
+  const repoRoots = [...manifestsByRepoRoot.entries()].filter(([, repoManifests]) => {
+    return repoManifests.length > 1 || repoManifests.some((manifest) => manifest.sourceKind === "code");
+  });
+  return {
+    version: MANAGED_SOURCES_VERSION,
+    sources: repoRoots.sort((left, right) => left[0].localeCompare(right[0])).map(([repoRoot, repoManifests]) => buildLegacyDirectoryEntry(repoRoot, repoManifests))
+  };
+}
+async function ensureManagedSourcesArtifact(rootDir) {
+  const { paths } = await initWorkspace(rootDir);
+  if (await fileExists(paths.managedSourcesPath)) {
+    const existing = await readJsonFile(paths.managedSourcesPath);
+    if (existing?.version === MANAGED_SOURCES_VERSION && Array.isArray(existing.sources)) {
+      return {
+        version: MANAGED_SOURCES_VERSION,
+        sources: [...existing.sources].sort(
+          (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+        )
+      };
+    }
+  }
+  const artifact = await buildLegacyArtifact(paths);
+  await writeJsonFile(paths.managedSourcesPath, artifact);
+  return artifact;
+}
+async function loadManagedSources(rootDir) {
+  const artifact = await ensureManagedSourcesArtifact(rootDir);
+  return artifact.sources;
+}
+async function readManagedSourcesIfPresent(rootDir) {
+  const { paths } = await initWorkspace(rootDir);
+  if (!await fileExists(paths.managedSourcesPath)) {
+    return null;
+  }
+  const existing = await readJsonFile(paths.managedSourcesPath);
+  if (!existing?.version || !Array.isArray(existing.sources)) {
+    return null;
+  }
+  return existing.sources;
+}
+async function saveManagedSources(rootDir, sources) {
+  const { paths } = await initWorkspace(rootDir);
+  await writeJsonFile(paths.managedSourcesPath, {
+    version: MANAGED_SOURCES_VERSION,
+    sources: [...sources].sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
+  });
+}
+async function managedSourceWorkingDir(rootDir, sourceId) {
+  const { paths } = await initWorkspace(rootDir);
+  return path10.join(paths.managedSourcesDir, sourceId);
+}
+
+// src/watch-state.ts
+import fs10 from "fs/promises";
+import path11 from "path";
 import matter2 from "gray-matter";
 function pendingEntryKey(entry) {
   return entry.path;
@@ -4740,7 +4854,7 @@ function normalizeRelativePath(rootDir, filePath) {
   if (!filePath) {
     return void 0;
   }
-  return toPosix(path10.relative(rootDir, path10.resolve(filePath)));
+  return toPosix(path11.relative(rootDir, path11.resolve(filePath)));
 }
 async function readPendingSemanticRefresh(rootDir) {
   const { paths } = await initWorkspace(rootDir);
@@ -4834,11 +4948,11 @@ async function markPagesStaleForSources(rootDir, sourceIds) {
     if (page.freshness !== "stale" || !page.sourceIds.some((sourceId) => affectedSourceIds.has(sourceId))) {
       continue;
     }
-    const absolutePath = path10.join(paths.wikiDir, page.path);
+    const absolutePath = path11.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const raw = await fs9.readFile(absolutePath, "utf8");
+    const raw = await fs10.readFile(absolutePath, "utf8");
     const parsed = matter2(raw);
     if (parsed.data.freshness === "stale") {
       continue;
@@ -4888,7 +5002,7 @@ function inferKind(mimeType, filePath) {
   return "binary";
 }
 function isRstFilePath(filePath) {
-  const extension = path11.extname(filePath).toLowerCase();
+  const extension = path12.extname(filePath).toLowerCase();
   return extension === ".rst" || extension === ".rest";
 }
 function titleFromText(fallback, content, filePath) {
@@ -5031,7 +5145,7 @@ function normalizeIngestOptions(options) {
   return {
     includeAssets: options?.includeAssets ?? true,
     maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE)),
-    repoRoot: options?.repoRoot ? path11.resolve(options.repoRoot) : void 0,
+    repoRoot: options?.repoRoot ? path12.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)),
@@ -5051,27 +5165,27 @@ async function resolveRepoIngestOptions(rootDir, options) {
 }
 function matchesAnyGlob2(relativePath, patterns) {
   return patterns.some(
-    (pattern) => path11.matchesGlob(relativePath, pattern) || path11.matchesGlob(path11.posix.basename(relativePath), pattern)
+    (pattern) => path12.matchesGlob(relativePath, pattern) || path12.matchesGlob(path12.posix.basename(relativePath), pattern)
   );
 }
 function supportedDirectoryKind(sourceKind) {
   return sourceKind !== "binary";
 }
 async function findNearestGitRoot2(startPath) {
-  let current = path11.resolve(startPath);
+  let current = path12.resolve(startPath);
   try {
-    const stat = await fs10.stat(current);
+    const stat = await fs11.stat(current);
     if (!stat.isDirectory()) {
-      current = path11.dirname(current);
+      current = path12.dirname(current);
     }
   } catch {
-    current = path11.dirname(current);
+    current = path12.dirname(current);
   }
   while (true) {
-    if (await fileExists(path11.join(current, ".git"))) {
+    if (await fileExists(path12.join(current, ".git"))) {
       return current;
     }
-    const parent = path11.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -5079,26 +5193,26 @@ async function findNearestGitRoot2(startPath) {
   }
 }
 function withinRoot(rootPath, targetPath) {
-  const relative = path11.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path11.isAbsolute(relative);
+  const relative = path12.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path12.isAbsolute(relative);
 }
-function repoRootFromManifest(manifest) {
+function repoRootFromManifest2(manifest) {
   if (manifest.originType !== "file" || !manifest.originalPath || !manifest.repoRelativePath) {
     return null;
   }
-  const repoDir = path11.posix.dirname(manifest.repoRelativePath);
-  const fileDir = path11.dirname(path11.resolve(manifest.originalPath));
+  const repoDir = path12.posix.dirname(manifest.repoRelativePath);
+  const fileDir = path12.dirname(path12.resolve(manifest.originalPath));
   if (repoDir === "." || !repoDir) {
     return fileDir;
   }
   const segments = repoDir.split("/").filter(Boolean);
-  return path11.resolve(fileDir, ...segments.map(() => ".."));
+  return path12.resolve(fileDir, ...segments.map(() => ".."));
 }
 function repoRelativePathFor(absolutePath, repoRoot) {
   if (!repoRoot || !withinRoot(repoRoot, absolutePath)) {
     return void 0;
   }
-  const relative = toPosix(path11.relative(repoRoot, absolutePath));
+  const relative = toPosix(path12.relative(repoRoot, absolutePath));
   return relative && !relative.startsWith("..") ? relative : void 0;
 }
 function normalizeOriginUrl(input) {
@@ -5430,7 +5544,7 @@ function buildCompositeHash(payloadBytes, attachments = []) {
   return sha256(`${sha256(payloadBytes)}|${attachmentSignature}`);
 }
 function sanitizeAssetRelativePath(value) {
-  const normalized = path11.posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = path12.posix.normalize(value.replace(/\\/g, "/"));
   const segments = normalized.split("/").filter(Boolean).map((segment) => {
     if (segment === ".") {
       return "";
@@ -5450,7 +5564,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("#") || path11.isAbsolute(candidate)) {
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path12.isAbsolute(candidate)) {
     return null;
   }
   return candidate.replace(/\\/g, "/");
@@ -5528,12 +5642,12 @@ async function convertHtmlToMarkdown(html, url) {
   };
 }
 async function readManifestByHash(manifestsDir, contentHash) {
-  const entries = await fs10.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs11.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path11.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path12.join(manifestsDir, entry.name));
     if (manifest?.contentHash === contentHash) {
       return manifest;
     }
@@ -5541,12 +5655,12 @@ async function readManifestByHash(manifestsDir, contentHash) {
   return null;
 }
 async function readManifestByOrigin(manifestsDir, prepared) {
-  const entries = await fs10.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs11.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path11.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path12.join(manifestsDir, entry.name));
     if (manifest && manifestMatchesOrigin(manifest, prepared)) {
       return manifest;
     }
@@ -5557,12 +5671,12 @@ async function loadGitignoreMatcher(repoRoot, enabled) {
   if (!enabled) {
     return null;
   }
-  const gitignorePath = path11.join(repoRoot, ".gitignore");
+  const gitignorePath = path12.join(repoRoot, ".gitignore");
   if (!await fileExists(gitignorePath)) {
     return null;
   }
   const matcher = ignore();
-  matcher.add(await fs10.readFile(gitignorePath, "utf8"));
+  matcher.add(await fs11.readFile(gitignorePath, "utf8"));
   return matcher;
 }
 function builtInIgnoreReason(relativePath) {
@@ -5586,23 +5700,23 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
     if (!currentDir) {
       continue;
     }
-    const entries = await fs10.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs11.readdir(currentDir, { withFileTypes: true });
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const absolutePath = path11.join(currentDir, entry.name);
-      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(inputDir, absolutePath));
+      const absolutePath = path12.join(currentDir, entry.name);
+      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path12.relative(inputDir, absolutePath));
       const relativePath = relativeToRepo || entry.name;
       const builtInReason = builtInIgnoreReason(relativePath);
       if (builtInReason) {
-        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: builtInReason });
+        skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: builtInReason });
         continue;
       }
       if (matcher?.ignores(relativePath)) {
-        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "gitignore" });
+        skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "gitignore" });
         continue;
       }
       if (matchesAnyGlob2(relativePath, options.exclude)) {
-        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "exclude_glob" });
+        skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "exclude_glob" });
         continue;
       }
       if (entry.isDirectory()) {
@@ -5610,26 +5724,26 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
         continue;
       }
       if (!entry.isFile()) {
-        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
+        skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
         continue;
       }
       if (options.include.length > 0 && !matchesAnyGlob2(relativePath, options.include)) {
-        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "include_glob" });
+        skipped.push({ path: toPosix(path12.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(path11.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+        skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
         continue;
       }
       if (!options.extractClasses.includes(sourceClass)) {
-        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: `source_class:${sourceClass}` });
+        skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: `source_class:${sourceClass}` });
         continue;
       }
       if (files.length >= options.maxFiles) {
-        skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "max_files" });
+        skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "max_files" });
         continue;
       }
       files.push(absolutePath);
@@ -5651,12 +5765,12 @@ function resolveUrlMimeType(input, response) {
 function buildRemoteAssetRelativePath(assetUrl, mimeType) {
   const url = new URL(assetUrl);
   const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
-  const extension = path11.posix.extname(normalized);
-  const directory = path11.posix.dirname(normalized);
-  const basename = extension ? path11.posix.basename(normalized, extension) : path11.posix.basename(normalized);
+  const extension = path12.posix.extname(normalized);
+  const directory = path12.posix.dirname(normalized);
+  const basename = extension ? path12.posix.basename(normalized, extension) : path12.posix.basename(normalized);
   const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
   const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
-  return directory === "." ? hashedName : path11.posix.join(directory, hashedName);
+  return directory === "." ? hashedName : path12.posix.join(directory, hashedName);
 }
 async function readResponseBytesWithinLimit(response, maxBytes) {
   const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
@@ -5809,34 +5923,34 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   const previous = existingByOrigin ?? void 0;
   const sourceId = previous?.sourceId ?? `${slugify(prepared.title)}-${contentHash.slice(0, 8)}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const storedPath = path11.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
-  const extractedTextPath = prepared.extractedText ? path11.join(paths.extractsDir, `${sourceId}.md`) : void 0;
-  const extractedMetadataPath = prepared.extractionArtifact ? path11.join(paths.extractsDir, `${sourceId}.json`) : void 0;
-  const attachmentsDir = path11.join(paths.rawAssetsDir, sourceId);
+  const storedPath = path12.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
+  const extractedTextPath = prepared.extractedText ? path12.join(paths.extractsDir, `${sourceId}.md`) : void 0;
+  const extractedMetadataPath = prepared.extractionArtifact ? path12.join(paths.extractsDir, `${sourceId}.json`) : void 0;
+  const attachmentsDir = path12.join(paths.rawAssetsDir, sourceId);
   if (previous?.storedPath) {
-    await fs10.rm(path11.resolve(rootDir, previous.storedPath), { force: true });
+    await fs11.rm(path12.resolve(rootDir, previous.storedPath), { force: true });
   }
   if (previous?.extractedTextPath) {
-    await fs10.rm(path11.resolve(rootDir, previous.extractedTextPath), { force: true });
+    await fs11.rm(path12.resolve(rootDir, previous.extractedTextPath), { force: true });
   }
   if (previous?.extractedMetadataPath) {
-    await fs10.rm(path11.resolve(rootDir, previous.extractedMetadataPath), { force: true });
+    await fs11.rm(path12.resolve(rootDir, previous.extractedMetadataPath), { force: true });
   }
-  await fs10.rm(attachmentsDir, { recursive: true, force: true });
-  await fs10.writeFile(storedPath, prepared.payloadBytes);
+  await fs11.rm(attachmentsDir, { recursive: true, force: true });
+  await fs11.writeFile(storedPath, prepared.payloadBytes);
   if (prepared.extractedText && extractedTextPath) {
-    await fs10.writeFile(extractedTextPath, prepared.extractedText, "utf8");
+    await fs11.writeFile(extractedTextPath, prepared.extractedText, "utf8");
   }
   if (prepared.extractionArtifact && extractedMetadataPath) {
     await writeJsonFile(extractedMetadataPath, prepared.extractionArtifact);
   }
   const manifestAttachments = [];
   for (const attachment of attachments) {
-    const absoluteAttachmentPath = path11.join(attachmentsDir, attachment.relativePath);
-    await ensureDir(path11.dirname(absoluteAttachmentPath));
-    await fs10.writeFile(absoluteAttachmentPath, attachment.bytes);
+    const absoluteAttachmentPath = path12.join(attachmentsDir, attachment.relativePath);
+    await ensureDir(path12.dirname(absoluteAttachmentPath));
+    await fs11.writeFile(absoluteAttachmentPath, attachment.bytes);
     manifestAttachments.push({
-      path: toPosix(path11.relative(rootDir, absoluteAttachmentPath)),
+      path: toPosix(path12.relative(rootDir, absoluteAttachmentPath)),
       mimeType: attachment.mimeType,
       originalPath: attachment.originalPath
     });
@@ -5852,9 +5966,9 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     originalPath: prepared.originalPath,
     repoRelativePath: prepared.repoRelativePath,
     url: prepared.url,
-    storedPath: toPosix(path11.relative(rootDir, storedPath)),
-    extractedTextPath: extractedTextPath ? toPosix(path11.relative(rootDir, extractedTextPath)) : void 0,
-    extractedMetadataPath: extractedMetadataPath ? toPosix(path11.relative(rootDir, extractedMetadataPath)) : void 0,
+    storedPath: toPosix(path12.relative(rootDir, storedPath)),
+    extractedTextPath: extractedTextPath ? toPosix(path12.relative(rootDir, extractedTextPath)) : void 0,
+    extractedMetadataPath: extractedMetadataPath ? toPosix(path12.relative(rootDir, extractedMetadataPath)) : void 0,
     extractionHash,
     mimeType: prepared.mimeType,
     contentHash,
@@ -5862,7 +5976,7 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
   };
-  await writeJsonFile(path11.join(paths.manifestsDir, `${sourceId}.json`), manifest);
+  await writeJsonFile(path12.join(paths.manifestsDir, `${sourceId}.json`), manifest);
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
@@ -5880,16 +5994,16 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   return { manifest, isNew: !previous, wasUpdated: Boolean(previous) };
 }
 async function removeManifestArtifacts(rootDir, manifest, paths) {
-  await fs10.rm(path11.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
-  await fs10.rm(path11.resolve(rootDir, manifest.storedPath), { force: true });
+  await fs11.rm(path12.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
+  await fs11.rm(path12.resolve(rootDir, manifest.storedPath), { force: true });
   if (manifest.extractedTextPath) {
-    await fs10.rm(path11.resolve(rootDir, manifest.extractedTextPath), { force: true });
+    await fs11.rm(path12.resolve(rootDir, manifest.extractedTextPath), { force: true });
   }
   if (manifest.extractedMetadataPath) {
-    await fs10.rm(path11.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
+    await fs11.rm(path12.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
   }
-  await fs10.rm(path11.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
-  await fs10.rm(path11.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
+  await fs11.rm(path12.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
+  await fs11.rm(path12.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
 }
 function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
   const candidates = [
@@ -5898,11 +6012,11 @@ function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path11.join(rootDir, ".claude"),
-    path11.join(rootDir, ".cursor"),
-    path11.join(rootDir, ".obsidian")
+    path12.join(rootDir, ".claude"),
+    path12.join(rootDir, ".cursor"),
+    path12.join(rootDir, ".obsidian")
   ];
-  return candidates.map((candidate) => path11.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
+  return candidates.map((candidate) => path12.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
 }
 function preparedMatchesManifest(manifest, prepared, contentHash) {
   return manifest.contentHash === contentHash && manifest.extractionHash === (prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact)) && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.sourceType === prepared.sourceType && manifest.sourceClass === prepared.sourceClass && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
@@ -5914,8 +6028,15 @@ function pendingSemanticRefreshId(changeType, repoRoot, relativePath) {
   return `pending:${changeType}:${sha256(`${toPosix(repoRoot)}:${relativePath}`).slice(0, 12)}`;
 }
 async function listTrackedRepoRoots(rootDir) {
+  const managedSources = await readManagedSourcesIfPresent(rootDir).catch(() => null);
+  if (managedSources && managedSources.length > 0) {
+    const directoryRoots = managedSources.filter((source) => source.kind === "directory" && source.path).map((source) => path12.resolve(source.path));
+    if (directoryRoots.length > 0) {
+      return [...new Set(directoryRoots)].sort((left, right) => left.localeCompare(right));
+    }
+  }
   const manifests = await listManifests(rootDir);
-  return [...new Set(manifests.map((manifest) => repoRootFromManifest(manifest)).filter((item) => Boolean(item)))].sort(
+  return [...new Set(manifests.map((manifest) => repoRootFromManifest2(manifest)).filter((item) => Boolean(item)))].sort(
     (left, right) => left.localeCompare(right)
   );
 }
@@ -5924,16 +6045,16 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
   const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path11.resolve(item)
+    (item) => path12.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(path11.resolve(repoRoot))) {
+    const repoRoot = repoRootFromManifest2(manifest);
+    if (!repoRoot || !uniqueRoots.includes(path12.resolve(repoRoot))) {
       continue;
     }
-    const key = path11.resolve(repoRoot);
+    const key = path12.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -5958,15 +6079,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(path11.relative(rootDir, absolutePath)),
+        path: toPosix(path12.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
     const progress = createProgressReporter("sync", files.length);
-    const currentPaths = new Set(files.map((absolutePath) => path11.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path12.resolve(absolutePath)));
     for (const absolutePath of files) {
-      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(repoRoot, absolutePath));
+      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path12.relative(repoRoot, absolutePath));
       const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
       const result = await persistPreparedInput(rootDir, prepared, paths);
       if (result.isNew) {
@@ -5976,9 +6097,9 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
       }
       progress.tick();
     }
-    progress.finish(`repo=${toPosix(path11.relative(rootDir, repoRoot)) || "."}`);
+    progress.finish(`repo=${toPosix(path12.relative(rootDir, repoRoot)) || "."}`);
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path11.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path12.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         await removeManifestArtifacts(rootDir, manifest, paths);
         removed.push(manifest);
@@ -5986,7 +6107,7 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     }
   }
   if (uniqueRoots.length > 0) {
-    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path11.relative(rootDir, repoRoot)) || ".").join(","), [
+    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path12.relative(rootDir, repoRoot)) || ".").join(","), [
       `repo_roots=${uniqueRoots.length}`,
       `scanned=${scannedCount}`,
       `imported=${imported.length}`,
@@ -6009,16 +6130,16 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path11.resolve(item)
+    (item) => path12.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(path11.resolve(repoRoot))) {
+    const repoRoot = repoRootFromManifest2(manifest);
+    if (!repoRoot || !uniqueRoots.includes(path12.resolve(repoRoot))) {
       continue;
     }
-    const key = path11.resolve(repoRoot);
+    const key = path12.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -6033,7 +6154,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) => [path11.resolve(manifest.originalPath), manifest])
+      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path12.resolve(manifest.originalPath), manifest])
     );
     if (!await fileExists(repoRoot)) {
       for (const manifest of repoManifests) {
@@ -6041,7 +6162,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
           pendingSemanticRefresh.push({
             id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? manifest.storedPath),
             repoRoot,
-            path: toPosix(path11.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
+            path: toPosix(path12.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -6061,18 +6182,18 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     skipped.push(
       ...collected.skipped,
       ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
-        path: toPosix(path11.relative(rootDir, absolutePath)),
+        path: toPosix(path12.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
     const progress = createProgressReporter("sync-watch", files.length);
-    const currentPaths = new Set(files.map((absolutePath) => path11.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path12.resolve(absolutePath)));
     for (const absolutePath of files) {
-      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(repoRoot, absolutePath));
+      const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path12.relative(repoRoot, absolutePath));
       const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
       if (shouldDeferWatchSemanticRefresh(prepared.sourceKind)) {
-        const existing = manifestsByOriginalPath.get(path11.resolve(absolutePath));
+        const existing = manifestsByOriginalPath.get(path12.resolve(absolutePath));
         const contentHash = buildCompositeHash(prepared.payloadBytes, prepared.attachments);
         const changed = !existing || !preparedMatchesManifest(existing, prepared, contentHash);
         if (changed) {
@@ -6080,10 +6201,10 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
             id: pendingSemanticRefreshId(
               existing ? "modified" : "added",
               repoRoot,
-              prepared.repoRelativePath ?? toPosix(path11.relative(repoRoot, absolutePath))
+              prepared.repoRelativePath ?? toPosix(path12.relative(repoRoot, absolutePath))
             ),
             repoRoot,
-            path: toPosix(path11.relative(rootDir, absolutePath)),
+            path: toPosix(path12.relative(rootDir, absolutePath)),
             changeType: existing ? "modified" : "added",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: existing?.sourceId,
@@ -6104,15 +6225,15 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
       }
       progress.tick();
     }
-    progress.finish(`repo=${toPosix(path11.relative(rootDir, repoRoot)) || "."}`);
+    progress.finish(`repo=${toPosix(path12.relative(rootDir, repoRoot)) || "."}`);
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path11.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path12.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         if (shouldDeferWatchSemanticRefresh(manifest.sourceKind)) {
           pendingSemanticRefresh.push({
-            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path11.relative(repoRoot, originalPath))),
+            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path12.relative(repoRoot, originalPath))),
             repoRoot,
-            path: toPosix(path11.relative(rootDir, originalPath)),
+            path: toPosix(path12.relative(rootDir, originalPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -6130,7 +6251,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     await appendLogEntry(
       rootDir,
       "sync_repo_watch",
-      uniqueRoots.map((repoRoot) => toPosix(path11.relative(rootDir, repoRoot)) || ".").join(","),
+      uniqueRoots.map((repoRoot) => toPosix(path12.relative(rootDir, repoRoot)) || ".").join(","),
       [
         `repo_roots=${uniqueRoots.length}`,
         `scanned=${scannedCount}`,
@@ -6156,17 +6277,17 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   };
 }
 async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
-  const payloadBytes = await fs10.readFile(absoluteInput);
+  const payloadBytes = await fs11.readFile(absoluteInput);
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
   const language = inferCodeLanguage(absoluteInput, mimeType);
-  const storedExtension = path11.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
+  const storedExtension = path12.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
   let title;
   let extractedText;
   let extractionArtifact;
   if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
     extractedText = extractedTextForPlainSource(absoluteInput, sourceKind, payloadBytes.toString("utf8"));
-    title = titleFromText(path11.basename(absoluteInput, path11.extname(absoluteInput)), extractedText, absoluteInput);
+    title = titleFromText(path12.basename(absoluteInput, path12.extname(absoluteInput)), extractedText, absoluteInput);
     extractionArtifact = createPlainTextExtractionArtifact(sourceKind, mimeType);
   } else if (sourceKind === "html") {
     const html = payloadBytes.toString("utf8");
@@ -6175,18 +6296,18 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
     extractedText = converted.markdown;
     extractionArtifact = createHtmlReadabilityExtractionArtifact(sourceKind, mimeType);
   } else if (sourceKind === "pdf") {
-    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
     const extracted = await extractPdfText({ mimeType, bytes: payloadBytes });
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
   } else if (sourceKind === "docx") {
-    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
     const extracted = await extractDocxText({ mimeType, bytes: payloadBytes });
     title = extracted.artifact.metadata?.title?.trim() || title;
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
   } else if (sourceKind === "image") {
-    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
     const extracted = await extractImageWithVision(rootDir, {
       title,
       mimeType,
@@ -6196,7 +6317,7 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
   } else {
-    title = path11.basename(absoluteInput, path11.extname(absoluteInput));
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
   }
   return {
     title,
@@ -6273,7 +6394,7 @@ async function prepareUrlInput(rootDir, input, options) {
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path11.extname(inputUrl.pathname);
+    const extension = path12.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = extractedTextForPlainSource(inputUrl.pathname, sourceKind, payloadBytes.toString("utf8"));
@@ -6344,14 +6465,14 @@ async function collectInboxAttachmentRefs(inputDir, files) {
     if (sourceKind !== "markdown" && sourceKind !== "html") {
       continue;
     }
-    const content = await fs10.readFile(absolutePath, "utf8");
+    const content = await fs11.readFile(absolutePath, "utf8");
     const refs = sourceKind === "html" ? extractHtmlLocalReferences(content, pathToFileURL(absolutePath).toString()) : extractMarkdownReferences(content);
     if (!refs.length) {
       continue;
     }
     const sourceRefs = [];
     for (const ref of refs) {
-      const resolved = path11.resolve(path11.dirname(absolutePath), ref);
+      const resolved = path12.resolve(path12.dirname(absolutePath), ref);
       if (!resolved.startsWith(inputDir) || !await fileExists(resolved)) {
         continue;
       }
@@ -6385,12 +6506,12 @@ function rewriteMarkdownReferences(content, replacements) {
   });
 }
 async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs10.readFile(absolutePath);
+  const originalBytes = await fs11.readFile(absolutePath);
   const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path11.basename(absolutePath, path11.extname(absolutePath)), originalText);
+  const title = titleFromText(path12.basename(absolutePath, path12.extname(absolutePath)), originalText);
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
-    const bytes = await fs10.readFile(attachmentRef.absolutePath);
+    const bytes = await fs11.readFile(attachmentRef.absolutePath);
     attachments.push({
       relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
       mimeType: guessMimeType(attachmentRef.absolutePath),
@@ -6414,7 +6535,7 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     sourceKind: "markdown",
     originalPath: toPosix(absolutePath),
     mimeType: "text/markdown",
-    storedExtension: path11.extname(absolutePath) || ".md",
+    storedExtension: path12.extname(absolutePath) || ".md",
     payloadBytes: Buffer.from(rewrittenText, "utf8"),
     extractedText: rewrittenText,
     extractionArtifact,
@@ -6424,12 +6545,12 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
   };
 }
 async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs10.readFile(absolutePath);
+  const originalBytes = await fs11.readFile(absolutePath);
   const originalHtml = originalBytes.toString("utf8");
   const initialConversion = await convertHtmlToMarkdown(originalHtml, pathToFileURL(absolutePath).toString());
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
-    const bytes = await fs10.readFile(attachmentRef.absolutePath);
+    const bytes = await fs11.readFile(attachmentRef.absolutePath);
     attachments.push({
       relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
       mimeType: guessMimeType(attachmentRef.absolutePath),
@@ -6438,7 +6559,7 @@ async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
     });
   }
   const contentHash = buildCompositeHash(originalBytes, attachments);
-  const fallbackTitle = path11.basename(absolutePath, path11.extname(absolutePath));
+  const fallbackTitle = path12.basename(absolutePath, path12.extname(absolutePath));
   const title = initialConversion.title || fallbackTitle;
   const sourceId = `${slugify(title)}-${contentHash.slice(0, 8)}`;
   const replacements = new Map(
@@ -6456,7 +6577,7 @@ async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
     sourceKind: "html",
     originalPath: toPosix(absolutePath),
     mimeType: "text/html",
-    storedExtension: path11.extname(absolutePath) || ".html",
+    storedExtension: path12.extname(absolutePath) || ".html",
     payloadBytes: Buffer.from(rewrittenHtml, "utf8"),
     extractedText: converted.markdown,
     extractionArtifact,
@@ -6468,14 +6589,16 @@ async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
 function isSupportedInboxKind(sourceKind) {
   return ["markdown", "text", "html", "pdf", "docx", "image"].includes(sourceKind);
 }
-async function ingestInput(rootDir, input, options) {
+async function ingestInputDetailed(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInput = path11.resolve(rootDir, input);
-  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path11.dirname(absoluteInput));
+  const absoluteInput = path12.resolve(rootDir, input);
+  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path12.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;
+  return await persistPreparedInput(rootDir, prepared, paths);
+}
+async function ingestInput(rootDir, input, options) {
+  return (await ingestInputDetailed(rootDir, input, options)).manifest;
 }
 async function addInput(rootDir, input, options = {}) {
   const { paths } = await initWorkspace(rootDir);
@@ -6562,7 +6685,7 @@ async function addInput(rootDir, input, options = {}) {
 async function ingestDirectory(rootDir, inputDir, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
-  const absoluteInputDir = path11.resolve(rootDir, inputDir);
+  const absoluteInputDir = path12.resolve(rootDir, inputDir);
   const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot2(absoluteInputDir) ?? absoluteInputDir;
   if (!await fileExists(absoluteInputDir)) {
     throw new Error(`Directory not found: ${absoluteInputDir}`);
@@ -6572,7 +6695,7 @@ async function ingestDirectory(rootDir, inputDir, options) {
   const updated = [];
   const progress = createProgressReporter("ingest", files.length);
   for (const absolutePath of files) {
-    const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path11.relative(repoRoot, absolutePath));
+    const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path12.relative(repoRoot, absolutePath));
     const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (result.isNew) {
@@ -6580,13 +6703,13 @@ async function ingestDirectory(rootDir, inputDir, options) {
     } else if (result.wasUpdated) {
       updated.push(result.manifest);
     } else {
-      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "duplicate_content" });
     }
     progress.tick();
   }
   progress.finish(`imported=${imported.length}, updated=${updated.length}, skipped=${skipped.length}`);
-  await appendLogEntry(rootDir, "ingest_directory", toPosix(path11.relative(rootDir, absoluteInputDir)) || ".", [
-    `repo_root=${toPosix(path11.relative(rootDir, repoRoot)) || "."}`,
+  await appendLogEntry(rootDir, "ingest_directory", toPosix(path12.relative(rootDir, absoluteInputDir)) || ".", [
+    `repo_root=${toPosix(path12.relative(rootDir, repoRoot)) || "."}`,
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `updated=${updated.length}`,
@@ -6603,7 +6726,7 @@ async function ingestDirectory(rootDir, inputDir, options) {
 }
 async function importInbox(rootDir, inputDir) {
   const { paths } = await initWorkspace(rootDir);
-  const effectiveInputDir = path11.resolve(rootDir, inputDir ?? paths.inboxDir);
+  const effectiveInputDir = path12.resolve(rootDir, inputDir ?? paths.inboxDir);
   if (!await fileExists(effectiveInputDir)) {
     throw new Error(`Inbox directory not found: ${effectiveInputDir}`);
   }
@@ -6614,31 +6737,31 @@ async function importInbox(rootDir, inputDir) {
   const skipped = [];
   let attachmentCount = 0;
   for (const absolutePath of files) {
-    const basename = path11.basename(absolutePath);
+    const basename = path12.basename(absolutePath);
     if (basename.startsWith(".")) {
-      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "hidden_file" });
+      skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "hidden_file" });
       continue;
     }
     if (claimedAttachments.has(absolutePath)) {
-      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
+      skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
     if (!isSupportedInboxKind(sourceKind)) {
-      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+      skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
       continue;
     }
     const prepared = sourceKind === "markdown" && refsBySource.has(absolutePath) ? await prepareInboxMarkdownInput(absolutePath, refsBySource.get(absolutePath) ?? []) : sourceKind === "html" && refsBySource.has(absolutePath) ? await prepareInboxHtmlInput(absolutePath, refsBySource.get(absolutePath) ?? []) : await prepareFileInput(rootDir, absolutePath);
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (!result.isNew) {
-      skipped.push({ path: toPosix(path11.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
     attachmentCount += result.manifest.attachments?.length ?? 0;
     imported.push(result.manifest);
   }
-  await appendLogEntry(rootDir, "inbox_import", toPosix(path11.relative(rootDir, effectiveInputDir)) || ".", [
+  await appendLogEntry(rootDir, "inbox_import", toPosix(path12.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `attachments=${attachmentCount}`,
@@ -6657,27 +6780,36 @@ async function listManifests(rootDir) {
   if (!await fileExists(paths.manifestsDir)) {
     return [];
   }
-  const entries = await fs10.readdir(paths.manifestsDir);
+  const entries = await fs11.readdir(paths.manifestsDir);
   const manifests = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path11.join(paths.manifestsDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path12.join(paths.manifestsDir, entry)))
   );
   return manifests.filter((manifest) => Boolean(manifest));
 }
+async function removeManifestBySourceId(rootDir, sourceId) {
+  const { paths } = await initWorkspace(rootDir);
+  const manifest = await readJsonFile(path12.join(paths.manifestsDir, `${sourceId}.json`));
+  if (!manifest) {
+    return null;
+  }
+  await removeManifestArtifacts(rootDir, manifest, paths);
+  return manifest;
+}
 async function readExtractedText(rootDir, manifest) {
   if (!manifest.extractedTextPath) {
     return void 0;
   }
-  const absolutePath = path11.resolve(rootDir, manifest.extractedTextPath);
+  const absolutePath = path12.resolve(rootDir, manifest.extractedTextPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
-  return fs10.readFile(absolutePath, "utf8");
+  return fs11.readFile(absolutePath, "utf8");
 }
 async function readExtractionArtifact(rootDir, manifest) {
   if (!manifest.extractedMetadataPath) {
     return void 0;
   }
-  const absolutePath = path11.resolve(rootDir, manifest.extractedMetadataPath);
+  const absolutePath = path12.resolve(rootDir, manifest.extractedMetadataPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
@@ -6685,20 +6817,20 @@ async function readExtractionArtifact(rootDir, manifest) {
 }
 
 // src/mcp.ts
-import fs18 from "fs/promises";
-import path22 from "path";
+import fs19 from "fs/promises";
+import path23 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 fs11 from "fs/promises";
-import path12 from "path";
+import fs12 from "fs/promises";
+import path13 from "path";
 function normalizeSchemaContent(content) {
   return content.trim() ? content.trim() : defaultVaultSchema().trim();
 }
 async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
-  const content = await fileExists(schemaPath) ? await fs11.readFile(schemaPath, "utf8") : fallback;
+  const content = await fileExists(schemaPath) ? await fs12.readFile(schemaPath, "utf8") : fallback;
   const normalized = normalizeSchemaContent(content);
   return {
     path: schemaPath,
@@ -6707,7 +6839,7 @@ async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
   };
 }
 function resolveProjectSchemaPath(rootDir, schemaPath) {
-  return path12.resolve(rootDir, schemaPath);
+  return path13.resolve(rootDir, schemaPath);
 }
 function composeVaultSchema(root, projectSchemas = []) {
   if (!projectSchemas.length) {
@@ -6723,7 +6855,7 @@ function composeVaultSchema(root, projectSchemas = []) {
       (schema) => [
         `## Project Schema`,
         "",
-        `Path: ${toPosix(path12.relative(path12.dirname(root.path), schema.path) || schema.path)}`,
+        `Path: ${toPosix(path13.relative(path13.dirname(root.path), schema.path) || schema.path)}`,
         "",
         schema.content
       ].join("\n")
@@ -6799,13 +6931,13 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs17 from "fs/promises";
-import path21 from "path";
+import fs18 from "fs/promises";
+import path22 from "path";
 import matter9 from "gray-matter";
 import { z as z7 } from "zod";
 
 // src/analysis.ts
-import path13 from "path";
+import path14 from "path";
 import { z as z2 } from "zod";
 var ANALYSIS_FORMAT_VERSION = 6;
 var sourceAnalysisSchema = z2.object({
@@ -7034,7 +7166,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 = path13.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cachePath = path14.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;
@@ -7124,8 +7256,8 @@ function conflictConfidence(claimA, claimB) {
 }
 
 // src/deep-lint.ts
-import fs12 from "fs/promises";
-import path16 from "path";
+import fs13 from "fs/promises";
+import path17 from "path";
 import matter4 from "gray-matter";
 import { z as z5 } from "zod";
 
@@ -7146,7 +7278,7 @@ function normalizeFindingSeverity(value) {
 
 // src/orchestration.ts
 import { spawn } from "child_process";
-import path14 from "path";
+import path15 from "path";
 import { z as z3 } from "zod";
 var orchestrationRoleResultSchema = z3.object({
   summary: z3.string().optional(),
@@ -7239,7 +7371,7 @@ async function runProviderRole(rootDir, role, roleConfig, input) {
 }
 async function runCommandRole(rootDir, role, executor, input) {
   const [command, ...args] = executor.command;
-  const cwd = executor.cwd ? path14.resolve(rootDir, executor.cwd) : rootDir;
+  const cwd = executor.cwd ? path15.resolve(rootDir, executor.cwd) : rootDir;
   const child = spawn(command, args, {
     cwd,
     env: {
@@ -7333,7 +7465,7 @@ function summarizeRoleQuestions(results) {
 }
 
 // src/web-search/registry.ts
-import path15 from "path";
+import path16 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { z as z4 } from "zod";
 
@@ -7431,7 +7563,7 @@ async function createWebSearchAdapter(id, config, rootDir) {
       if (!config.module) {
         throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
       }
-      const resolvedModule = path15.isAbsolute(config.module) ? config.module : path15.resolve(rootDir, config.module);
+      const resolvedModule = path16.isAbsolute(config.module) ? config.module : path16.resolve(rootDir, config.module);
       const loaded = await import(pathToFileURL2(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
@@ -7498,8 +7630,8 @@ async function loadContextPages(rootDir, graph) {
   );
   return Promise.all(
     contextPages.slice(0, 18).map(async (page) => {
-      const absolutePath = path16.join(paths.wikiDir, page.path);
-      const raw = await fs12.readFile(absolutePath, "utf8").catch(() => "");
+      const absolutePath = path17.join(paths.wikiDir, page.path);
+      const raw = await fs13.readFile(absolutePath, "utf8").catch(() => "");
       const parsed = matter4(raw);
       return {
         id: page.id,
@@ -7547,7 +7679,7 @@ function heuristicDeepFindings(contextPages, structuralFindings, graph) {
       code: "missing_citation",
       message: finding.message,
       pagePath: finding.pagePath,
-      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path16.basename(finding.pagePath, ".md")}?` : void 0
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path17.basename(finding.pagePath, ".md")}?` : void 0
     });
   }
   for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
@@ -7726,8 +7858,8 @@ async function runDeepLint(rootDir, structuralFindings, options = {}) {
 }
 
 // src/embeddings.ts
-import fs13 from "fs/promises";
-import path17 from "path";
+import fs14 from "fs/promises";
+import path18 from "path";
 var MAX_EMBEDDING_BATCH = 32;
 var MAX_SIMILARITY_NODES = 240;
 function cosineSimilarity(left, right) {
@@ -7761,8 +7893,8 @@ async function loadPageContents(rootDir, graph) {
   const contents = /* @__PURE__ */ new Map();
   await Promise.all(
     graph.pages.map(async (page) => {
-      const absolutePath = path17.join(paths.wikiDir, page.path);
-      const content = await fs13.readFile(absolutePath, "utf8").catch(() => {
+      const absolutePath = path18.join(paths.wikiDir, page.path);
+      const content = await fs14.readFile(absolutePath, "utf8").catch(() => {
         process.stderr.write(`[swarmvault] Warning: could not read page ${page.path} for embedding
 `);
         return "";
@@ -9264,15 +9396,15 @@ function sourceTypeForNode(node, pagesById) {
   return pagesById.get(node.pageId)?.sourceType;
 }
 function supportingPathDetails(graph, edge) {
-  const path26 = shortestGraphPath(graph, edge.source, edge.target);
+  const path28 = shortestGraphPath(graph, edge.source, edge.target);
   const edgesById = new Map(graph.edges.map((item) => [item.id, item]));
-  const pathEdges = path26.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
+  const pathEdges = path28.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
   return {
-    pathNodeIds: path26.nodeIds,
-    pathEdgeIds: path26.edgeIds,
+    pathNodeIds: path28.nodeIds,
+    pathEdgeIds: path28.edgeIds,
     pathRelations: pathEdges.map((item) => item.relation),
     pathEvidenceClasses: pathEdges.map((item) => item.evidenceClass),
-    pathSummary: path26.summary
+    pathSummary: path28.summary
   };
 }
 function surpriseScore(edge, graph, pagesById, hyperedgesByNodeId) {
@@ -9341,7 +9473,7 @@ function topSurprisingConnections(graph, pagesById) {
     }).map((edge) => {
       const source = nodesById.get(edge.source);
       const target = nodesById.get(edge.target);
-      const path26 = supportingPathDetails(graph, edge);
+      const path28 = supportingPathDetails(graph, edge);
       const scored = surpriseScore(edge, graph, pagesById, hyperedgesByNodeId);
       return {
         id: edge.id,
@@ -9352,11 +9484,11 @@ function topSurprisingConnections(graph, pagesById) {
         relation: edge.relation,
         evidenceClass: edge.evidenceClass,
         confidence: edge.confidence,
-        pathNodeIds: path26.pathNodeIds,
-        pathEdgeIds: path26.pathEdgeIds,
-        pathRelations: path26.pathRelations,
-        pathEvidenceClasses: path26.pathEvidenceClasses,
-        pathSummary: path26.pathSummary,
+        pathNodeIds: path28.pathNodeIds,
+        pathEdgeIds: path28.pathEdgeIds,
+        pathRelations: path28.pathRelations,
+        pathEvidenceClasses: path28.pathEvidenceClasses,
+        pathSummary: path28.pathSummary,
         why: scored.why,
         explanation: scored.explanation,
         surpriseScore: scored.score
@@ -10283,13 +10415,13 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
-import fs15 from "fs/promises";
-import path19 from "path";
+import fs16 from "fs/promises";
+import path20 from "path";
 import matter7 from "gray-matter";
 
 // src/pages.ts
-import fs14 from "fs/promises";
-import path18 from "path";
+import fs15 from "fs/promises";
+import path19 from "path";
 import matter6 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -10367,7 +10499,7 @@ async function loadExistingManagedPageState(absolutePath, defaults = {}) {
       updatedAt: updatedFallback
     };
   }
-  const content = await fs14.readFile(absolutePath, "utf8");
+  const content = await fs15.readFile(absolutePath, "utf8");
   const parsed = matter6(content);
   return {
     status: normalizePageStatus(parsed.data.status, defaults.status ?? "active"),
@@ -10406,7 +10538,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 : path18.basename(relativePath, ".md");
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path19.basename(relativePath, ".md");
   const kind = inferPageKind(relativePath, parsed.data.kind);
   const sourceIds = normalizeStringArray(parsed.data.source_ids);
   const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -10447,18 +10579,18 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   };
 }
 async function loadInsightPages(wikiDir) {
-  const insightsDir = path18.join(wikiDir, "insights");
+  const insightsDir = path19.join(wikiDir, "insights");
   if (!await fileExists(insightsDir)) {
     return [];
   }
-  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path18.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
+  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path19.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
   const insights = [];
   for (const absolutePath of files) {
-    const relativePath = toPosix(path18.relative(wikiDir, absolutePath));
-    const content = await fs14.readFile(absolutePath, "utf8");
+    const relativePath = toPosix(path19.relative(wikiDir, absolutePath));
+    const content = await fs15.readFile(absolutePath, "utf8");
     const parsed = matter6(content);
-    const stats = await fs14.stat(absolutePath);
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : path18.basename(absolutePath, ".md");
+    const stats = await fs15.stat(absolutePath);
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path19.basename(absolutePath, ".md");
     const sourceIds = normalizeStringArray(parsed.data.source_ids);
     const projectIds = normalizeProjectIds(parsed.data.project_ids);
     const nodeIds = normalizeStringArray(parsed.data.node_ids);
@@ -10521,79 +10653,94 @@ 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 = path19.join(wikiDir, "outputs");
+  const outputsDir = path20.join(wikiDir, "outputs");
   const root = baseSlug || "output";
   let candidate = root;
   let counter = 2;
-  while (await fileExists(path19.join(outputsDir, `${candidate}.md`))) {
+  while (await fileExists(path20.join(outputsDir, `${candidate}.md`))) {
     candidate = `${root}-${counter}`;
     counter++;
   }
   return candidate;
 }
 async function loadSavedOutputPages(wikiDir) {
-  const outputsDir = path19.join(wikiDir, "outputs");
-  const entries = await fs15.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
+  const outputsDir = path20.join(wikiDir, "outputs");
+  const entries = await fs16.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
   const outputs = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") {
+  const queue = [{ absoluteDir: outputsDir, relativeDir: "outputs" }];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
       continue;
     }
-    const relativePath = path19.posix.join("outputs", entry.name);
-    const absolutePath = path19.join(outputsDir, entry.name);
-    const content = await fs15.readFile(absolutePath, "utf8");
-    const parsed = matter7(content);
-    const slug = entry.name.replace(/\.md$/, "");
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : slug;
-    const pageId = typeof parsed.data.page_id === "string" ? parsed.data.page_id : `output:${slug}`;
-    const sourceIds = normalizeStringArray(parsed.data.source_ids);
-    const projectIds = normalizeProjectIds(parsed.data.project_ids);
-    const nodeIds = normalizeStringArray(parsed.data.node_ids);
-    const relatedPageIds = normalizeStringArray(parsed.data.related_page_ids);
-    const relatedNodeIds = normalizeStringArray(parsed.data.related_node_ids);
-    const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
-    const backlinks = normalizeStringArray(parsed.data.backlinks);
-    const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
-    const stats = await fs15.stat(absolutePath);
-    const createdAt = typeof parsed.data.created_at === "string" ? parsed.data.created_at : stats.birthtimeMs > 0 ? stats.birthtime.toISOString() : stats.mtime.toISOString();
-    const updatedAt = typeof parsed.data.updated_at === "string" ? parsed.data.updated_at : stats.mtime.toISOString();
-    outputs.push({
-      page: {
-        id: pageId,
-        path: relativePath,
-        title,
-        kind: "output",
-        sourceIds,
-        projectIds,
-        nodeIds,
-        freshness: parsed.data.freshness === "stale" ? "stale" : "fresh",
-        status: normalizePageStatus(parsed.data.status, "active"),
-        confidence: typeof parsed.data.confidence === "number" ? parsed.data.confidence : 0.74,
-        backlinks,
-        schemaHash: typeof parsed.data.schema_hash === "string" ? parsed.data.schema_hash : "",
-        sourceHashes: normalizeSourceHashes(parsed.data.source_hashes),
-        relatedPageIds,
-        relatedNodeIds,
-        relatedSourceIds,
-        createdAt,
-        updatedAt,
-        compiledFrom: compiledFrom.length ? compiledFrom : relatedSourceIds,
-        managedBy: normalizePageManager(parsed.data.managed_by, "system"),
-        origin: typeof parsed.data.origin === "string" ? parsed.data.origin : void 0,
-        question: typeof parsed.data.question === "string" ? parsed.data.question : void 0,
-        outputFormat: parsed.data.output_format === "report" || parsed.data.output_format === "slides" || parsed.data.output_format === "chart" || parsed.data.output_format === "image" ? parsed.data.output_format : "markdown",
-        outputAssets: normalizeOutputAssets(parsed.data.output_assets)
-      },
-      content,
-      contentHash: sha256(content)
-    });
+    const currentEntries = current.absoluteDir === outputsDir ? entries : await fs16.readdir(current.absoluteDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of currentEntries) {
+      if (entry.isDirectory()) {
+        queue.push({
+          absoluteDir: path20.join(current.absoluteDir, entry.name),
+          relativeDir: path20.posix.join(current.relativeDir, entry.name)
+        });
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") {
+        continue;
+      }
+      const relativePath = path20.posix.join(current.relativeDir, entry.name);
+      const absolutePath = path20.join(current.absoluteDir, entry.name);
+      const content = await fs16.readFile(absolutePath, "utf8");
+      const parsed = matter7(content);
+      const slug = relativePath.replace(/^outputs\//, "").replace(/\.md$/, "");
+      const title = typeof parsed.data.title === "string" ? parsed.data.title : path20.basename(slug);
+      const pageId = typeof parsed.data.page_id === "string" ? parsed.data.page_id : `output:${slug}`;
+      const sourceIds = normalizeStringArray(parsed.data.source_ids);
+      const projectIds = normalizeProjectIds(parsed.data.project_ids);
+      const nodeIds = normalizeStringArray(parsed.data.node_ids);
+      const relatedPageIds = normalizeStringArray(parsed.data.related_page_ids);
+      const relatedNodeIds = normalizeStringArray(parsed.data.related_node_ids);
+      const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
+      const backlinks = normalizeStringArray(parsed.data.backlinks);
+      const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
+      const stats = await fs16.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({
+        page: {
+          id: pageId,
+          path: relativePath,
+          title,
+          kind: "output",
+          sourceIds,
+          projectIds,
+          nodeIds,
+          freshness: parsed.data.freshness === "stale" ? "stale" : "fresh",
+          status: normalizePageStatus(parsed.data.status, "active"),
+          confidence: typeof parsed.data.confidence === "number" ? parsed.data.confidence : 0.74,
+          backlinks,
+          schemaHash: typeof parsed.data.schema_hash === "string" ? parsed.data.schema_hash : "",
+          sourceHashes: normalizeSourceHashes(parsed.data.source_hashes),
+          relatedPageIds,
+          relatedNodeIds,
+          relatedSourceIds,
+          createdAt,
+          updatedAt,
+          compiledFrom: compiledFrom.length ? compiledFrom : relatedSourceIds,
+          managedBy: normalizePageManager(parsed.data.managed_by, "system"),
+          origin: typeof parsed.data.origin === "string" ? parsed.data.origin : void 0,
+          question: typeof parsed.data.question === "string" ? parsed.data.question : void 0,
+          outputFormat: parsed.data.output_format === "report" || parsed.data.output_format === "slides" || parsed.data.output_format === "chart" || parsed.data.output_format === "image" ? parsed.data.output_format : "markdown",
+          outputAssets: normalizeOutputAssets(parsed.data.output_assets)
+        },
+        content,
+        contentHash: sha256(content)
+      });
+    }
   }
   return outputs.sort((left, right) => left.page.title.localeCompare(right.page.title));
 }
 
 // src/search.ts
-import fs16 from "fs/promises";
-import path20 from "path";
+import fs17 from "fs/promises";
+import path21 from "path";
 import matter8 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
@@ -10619,7 +10766,7 @@ function normalizeSourceClass2(value) {
   return value === "first_party" || value === "third_party" || value === "resource" || value === "generated" ? value : void 0;
 }
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path20.dirname(dbPath));
+  await ensureDir(path21.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -10651,8 +10798,8 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
     "INSERT INTO pages (id, path, title, body, kind, status, source_type, source_class, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
   );
   for (const page of pages) {
-    const absolutePath = path20.join(wikiDir, page.path);
-    const content = await fs16.readFile(absolutePath, "utf8");
+    const absolutePath = path21.join(wikiDir, page.path);
+    const content = await fs17.readFile(absolutePath, "utf8");
     const parsed = matter8(content);
     insertPage.run(
       page.id,
@@ -10801,7 +10948,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path21.join("outputs", "assets", slug, fileName));
+  return toPosix(path22.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -10941,7 +11088,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-G7NSRYCO.js");
+  const { createProvider: createProvider2 } = await import("./registry-2REAPKPO.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -11139,7 +11286,7 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path21.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path22.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
@@ -11165,10 +11312,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path21.isAbsolute(rawPath)) {
+  if (!path22.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path21.relative(rootDir, rawPath));
+  const relative = toPosix(path22.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -11342,7 +11489,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 fs17.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs18.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -11380,7 +11527,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs17.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs18.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -11503,7 +11650,7 @@ function resetGraphNodeMetrics(nodes) {
   return nodes.map(({ communityId: _communityId, degree: _degree, bridgeScore: _bridgeScore, isGodNode: _isGodNode, ...node }) => node);
 }
 function manifestRepoPath(manifest) {
-  return toPosix(manifest.repoRelativePath ?? path21.basename(manifest.originalPath ?? manifest.storedPath));
+  return toPosix(manifest.repoRelativePath ?? path22.basename(manifest.originalPath ?? manifest.storedPath));
 }
 function goPackageScopeKey(manifest, analysis) {
   if (analysis.code?.language !== "go") {
@@ -11513,7 +11660,7 @@ function goPackageScopeKey(manifest, analysis) {
   if (!packageName) {
     return null;
   }
-  return `${packageName}:${path21.posix.dirname(manifestRepoPath(manifest))}`;
+  return `${packageName}:${path22.posix.dirname(manifestRepoPath(manifest))}`;
 }
 function buildGoPackageSymbolLookups(analyses, manifestsById) {
   const lookups = /* @__PURE__ */ new Map();
@@ -11982,7 +12129,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
-    const absolutePath = path21.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
+    const absolutePath = path22.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
     communityRecords.push(
       await buildManagedGraphPage(
         absolutePath,
@@ -12011,7 +12158,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     graphHash: graphHash(graph),
     contradictions
   });
-  const reportAbsolutePath = path21.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path22.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -12032,7 +12179,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path21.resolve(wikiDir, relativePath);
+  const absolutePath = path22.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -12095,29 +12242,29 @@ async function requiredCompileArtifactsExist(paths) {
     paths.graphPath,
     paths.codeIndexPath,
     paths.searchDbPath,
-    path21.join(paths.wikiDir, "index.md"),
-    path21.join(paths.wikiDir, "sources", "index.md"),
-    path21.join(paths.wikiDir, "code", "index.md"),
-    path21.join(paths.wikiDir, "concepts", "index.md"),
-    path21.join(paths.wikiDir, "entities", "index.md"),
-    path21.join(paths.wikiDir, "outputs", "index.md"),
-    path21.join(paths.wikiDir, "projects", "index.md"),
-    path21.join(paths.wikiDir, "candidates", "index.md")
+    path22.join(paths.wikiDir, "index.md"),
+    path22.join(paths.wikiDir, "sources", "index.md"),
+    path22.join(paths.wikiDir, "code", "index.md"),
+    path22.join(paths.wikiDir, "concepts", "index.md"),
+    path22.join(paths.wikiDir, "entities", "index.md"),
+    path22.join(paths.wikiDir, "outputs", "index.md"),
+    path22.join(paths.wikiDir, "projects", "index.md"),
+    path22.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(path21.join(paths.analysesDir, `${manifest.sourceId}.json`)))
+    manifests.map(async (manifest) => readJsonFile(path22.join(paths.analysesDir, `${manifest.sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis));
 }
 function approvalManifestPath(paths, approvalId) {
-  return path21.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path22.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path21.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path22.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
@@ -12127,7 +12274,7 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs17.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs18.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph) {
@@ -12142,7 +12289,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path21.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path22.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -12175,7 +12322,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path21.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path22.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
@@ -12187,16 +12334,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 = path21.join(paths.approvalsDir, approvalId);
+  const approvalDir = path22.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path21.join(approvalDir, "wiki"));
-  await ensureDir(path21.join(approvalDir, "state"));
+  await ensureDir(path22.join(approvalDir, "wiki"));
+  await ensureDir(path22.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path21.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path21.dirname(targetPath));
-    await fs17.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path22.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path22.dirname(targetPath));
+    await fs18.writeFile(targetPath, file.content, "utf8");
   }
-  await fs17.writeFile(path21.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs18.writeFile(path22.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12258,7 +12405,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path21.join(paths.wikiDir, preview.path),
+      path22.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -12304,7 +12451,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path21.join(paths.wikiDir, modulePreview.path),
+          path22.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -12338,8 +12485,8 @@ async function syncVaultArtifacts(rootDir, input) {
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const aggregateSourceClass2 = aggregateManifestSourceClass(input.manifests, sourceIds);
       const fallbackPaths = [
-        path21.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path21.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path22.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path22.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -12357,7 +12504,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path21.join(paths.wikiDir, relativePath),
+        path22.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -12474,7 +12621,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path21.join(paths.wikiDir, "projects", "index.md"),
+      path22.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -12498,7 +12645,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path21.join(paths.wikiDir, projectIndexRef.path),
+        path22.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -12526,7 +12673,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path21.join(paths.wikiDir, "index.md"),
+      path22.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -12557,7 +12704,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path21.join(paths.wikiDir, relativePath),
+        path22.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -12568,12 +12715,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(path21.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
   const obsoletePaths = uniqueStrings3([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path21.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs17.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path22.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs18.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -12598,10 +12745,10 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs17.rm(path21.join(paths.wikiDir, relativePath), { force: true });
+    await fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
-  await writeJsonFile(path21.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+  await writeJsonFile(path22.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   await writeJsonFile(paths.codeIndexPath, input.codeIndex);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
@@ -12672,17 +12819,17 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path21.join(paths.wikiDir, "sources")),
-    ensureDir(path21.join(paths.wikiDir, "code")),
-    ensureDir(path21.join(paths.wikiDir, "concepts")),
-    ensureDir(path21.join(paths.wikiDir, "entities")),
-    ensureDir(path21.join(paths.wikiDir, "outputs")),
-    ensureDir(path21.join(paths.wikiDir, "graph")),
-    ensureDir(path21.join(paths.wikiDir, "graph", "communities")),
-    ensureDir(path21.join(paths.wikiDir, "projects")),
-    ensureDir(path21.join(paths.wikiDir, "candidates"))
+    ensureDir(path22.join(paths.wikiDir, "sources")),
+    ensureDir(path22.join(paths.wikiDir, "code")),
+    ensureDir(path22.join(paths.wikiDir, "concepts")),
+    ensureDir(path22.join(paths.wikiDir, "entities")),
+    ensureDir(path22.join(paths.wikiDir, "outputs")),
+    ensureDir(path22.join(paths.wikiDir, "graph")),
+    ensureDir(path22.join(paths.wikiDir, "graph", "communities")),
+    ensureDir(path22.join(paths.wikiDir, "projects")),
+    ensureDir(path22.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path21.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path22.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -12703,7 +12850,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 = path21.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path22.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -12721,7 +12868,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path21.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path22.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -12742,7 +12889,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 = path21.join(paths.wikiDir, relativePath);
+    const absolutePath = path22.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -12756,23 +12903,23 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     );
   }
   for (const record of graphOrientation.records) {
-    await writeFileIfChanged(path21.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path22.join(paths.wikiDir, record.page.path), record.content);
   }
   if (graphOrientation.report) {
-    await writeJsonFile(path21.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+    await writeJsonFile(path22.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path21.relative(paths.wikiDir, absolutePath)));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.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) => fs17.rm(path21.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingGraphPages = (await listFilesRecursive(path21.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path21.relative(paths.wikiDir, absolutePath)));
+  const existingGraphPages = (await listFilesRecursive(path22.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.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) => fs17.rm(path21.join(paths.wikiDir, relativePath), { force: true }))
+    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
@@ -12792,7 +12939,7 @@ async function prepareOutputPageSave(rootDir, input) {
       confidence: 0.74
     }
   });
-  const absolutePath = path21.join(paths.wikiDir, output.page.path);
+  const absolutePath = path22.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -12804,15 +12951,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path21.dirname(prepared.savedPath));
-  await fs17.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path22.dirname(prepared.savedPath));
+  await fs18.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path21.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path21.dirname(assetPath));
+    const assetPath = path22.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path22.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs17.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs18.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs17.writeFile(assetPath, assetFile.content);
+      await fs18.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -12833,7 +12980,7 @@ async function prepareExploreHubSave(rootDir, input) {
       confidence: 0.76
     }
   });
-  const absolutePath = path21.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path22.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -12845,15 +12992,15 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path21.dirname(prepared.savedPath));
-  await fs17.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path22.dirname(prepared.savedPath));
+  await fs18.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path21.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path21.dirname(assetPath));
+    const assetPath = path22.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path22.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs17.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs18.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs17.writeFile(assetPath, assetFile.content);
+      await fs18.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -12870,17 +13017,17 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     }))
   ]);
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path21.join(paths.approvalsDir, approvalId);
+  const approvalDir = path22.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path21.join(approvalDir, "wiki"));
-  await ensureDir(path21.join(approvalDir, "state"));
+  await ensureDir(path22.join(approvalDir, "wiki"));
+  await ensureDir(path22.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path21.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path21.dirname(targetPath));
+    const targetPath = path22.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path22.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs17.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs18.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs17.writeFile(targetPath, file.content, "utf8");
+      await fs18.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -12895,7 +13042,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs17.writeFile(path21.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs18.writeFile(path22.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12924,9 +13071,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 = path21.join(paths.wikiDir, result.path);
+      const absolutePath = path22.join(paths.wikiDir, result.path);
       try {
-        const content = await fs17.readFile(absolutePath, "utf8");
+        const content = await fs18.readFile(absolutePath, "utf8");
         const parsed = matter9(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
@@ -13160,7 +13307,7 @@ function computeChangeSummary(current, staged, changeType) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs17.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs18.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -13176,8 +13323,8 @@ async function readApproval(rootDir, approvalId, options) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs17.readFile(path21.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs17.readFile(path21.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs18.readFile(path22.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs18.readFile(path22.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       const detail = {
         ...entry,
         currentContent,
@@ -13210,26 +13357,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path21.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs17.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path21.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path21.dirname(targetAbsolutePath));
-      await fs17.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path22.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs18.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path22.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path22.dirname(targetAbsolutePath));
+      await fs18.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs17.rm(path21.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs18.rm(path22.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 = path21.join(paths.wikiDir, "outputs", "assets", path21.basename(nextPage.path, ".md"));
-        await fs17.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path22.join(paths.wikiDir, "outputs", "assets", path22.basename(nextPage.path, ".md"));
+        await fs18.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path21.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path22.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path21.join(paths.wikiDir, asset.path);
-          await ensureDir(path21.dirname(targetAssetPath));
-          await fs17.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path22.join(paths.wikiDir, asset.path);
+          await ensureDir(path22.dirname(targetAssetPath));
+          await fs18.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -13240,10 +13387,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 fs17.rm(path21.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs18.rm(path22.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs17.rm(path21.join(paths.wikiDir, "outputs", "assets", path21.basename(deletedPage.path, ".md")), {
+        await fs18.rm(path22.join(paths.wikiDir, "outputs", "assets", path22.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -13334,7 +13481,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 fs17.readFile(path21.join(paths.wikiDir, candidate.path), "utf8");
+  const raw = await fs18.readFile(path22.join(paths.wikiDir, candidate.path), "utf8");
   const parsed = matter9(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const nextContent = matter9.stringify(parsed.content, {
@@ -13346,10 +13493,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path21.join(paths.wikiDir, nextPath);
-  await ensureDir(path21.dirname(nextAbsolutePath));
-  await fs17.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs17.rm(path21.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path22.join(paths.wikiDir, nextPath);
+  await ensureDir(path22.dirname(nextAbsolutePath));
+  await fs18.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs18.rm(path22.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)
@@ -13394,7 +13541,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs17.rm(path21.join(paths.wikiDir, candidate.path), { force: true });
+  await fs18.rm(path22.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(),
@@ -13433,18 +13580,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path21.join(rootDir, ".obsidian");
+  const obsidianDir = path22.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path21.join(obsidianDir, "app.json"), {
+    writeJsonFile(path22.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path21.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path22.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -13454,7 +13601,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path21.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path22.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -13466,7 +13613,7 @@ async function ensureObsidianWorkspace(rootDir) {
       })),
       localJumps: false
     }),
-    writeJsonFile(path21.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path22.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -13481,7 +13628,7 @@ async function ensureObsidianWorkspace(rootDir) {
 async function initVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path21.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path22.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
@@ -13517,7 +13664,7 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path21.join(paths.wikiDir, "projects", "index.md"),
+    path22.join(paths.wikiDir, "projects", "index.md"),
     matter9.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
@@ -13539,7 +13686,7 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path21.join(paths.wikiDir, "candidates", "index.md"),
+    path22.join(paths.wikiDir, "candidates", "index.md"),
     matter9.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
@@ -13678,7 +13825,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path21.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path22.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           analysisProgress.tick(manifest.title);
           return cached;
@@ -13706,22 +13853,22 @@ async function compileVault(rootDir, options = {}) {
       }
       const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
       if (analysisSignature(enriched) !== analysisSignature(analysis)) {
-        await writeJsonFile(path21.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+        await writeJsonFile(path22.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
       }
       return enriched;
     })
   );
   await Promise.all([
-    ensureDir(path21.join(paths.wikiDir, "sources")),
-    ensureDir(path21.join(paths.wikiDir, "code")),
-    ensureDir(path21.join(paths.wikiDir, "concepts")),
-    ensureDir(path21.join(paths.wikiDir, "entities")),
-    ensureDir(path21.join(paths.wikiDir, "outputs")),
-    ensureDir(path21.join(paths.wikiDir, "projects")),
-    ensureDir(path21.join(paths.wikiDir, "insights")),
-    ensureDir(path21.join(paths.wikiDir, "candidates")),
-    ensureDir(path21.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path21.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path22.join(paths.wikiDir, "sources")),
+    ensureDir(path22.join(paths.wikiDir, "code")),
+    ensureDir(path22.join(paths.wikiDir, "concepts")),
+    ensureDir(path22.join(paths.wikiDir, "entities")),
+    ensureDir(path22.join(paths.wikiDir, "outputs")),
+    ensureDir(path22.join(paths.wikiDir, "projects")),
+    ensureDir(path22.join(paths.wikiDir, "insights")),
+    ensureDir(path22.join(paths.wikiDir, "candidates")),
+    ensureDir(path22.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path22.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
@@ -13868,7 +14015,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path21.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path22.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -14124,9 +14271,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path21.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path22.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path21.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path22.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -14213,11 +14360,11 @@ async function benchmarkVault(rootDir, options = {}) {
     }
   }
   for (const page of graph.pages) {
-    const absolutePath = path21.join(paths.wikiDir, page.path);
+    const absolutePath = path22.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const parsed = matter9(await fs17.readFile(absolutePath, "utf8"));
+    const parsed = matter9(await fs18.readFile(absolutePath, "utf8"));
     pageContentsById.set(page.id, parsed.content);
   }
   const configuredQuestions = (config.benchmark?.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
@@ -14262,7 +14409,7 @@ async function listGraphHyperedges(rootDir, target, limit = 25) {
 }
 async function readGraphReport(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
-  return readJsonFile(path21.join(paths.wikiDir, "graph", "report.json"));
+  return readJsonFile(path22.join(paths.wikiDir, "graph", "report.json"));
 }
 async function listGodNodes(rootDir, limit = 10) {
   const graph = await ensureCompiledGraph(rootDir);
@@ -14275,15 +14422,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path21.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path22.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs17.readFile(absolutePath, "utf8");
+  const raw = await fs18.readFile(absolutePath, "utf8");
   const parsed = matter9(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path21.basename(relativePath, path21.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path22.basename(relativePath, path22.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -14319,7 +14466,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: path21.join(paths.wikiDir, page.path),
+          pagePath: path22.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -14330,7 +14477,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: path21.join(paths.wikiDir, page.path),
+            pagePath: path22.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -14341,13 +14488,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path21.join(paths.wikiDir, page.path),
+          pagePath: path22.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path21.join(paths.wikiDir, page.path);
+      const absolutePath = path22.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs17.readFile(absolutePath, "utf8");
+        const content = await fs18.readFile(absolutePath, "utf8");
         if (content.includes("## Claims")) {
           const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
           if (uncited.length) {
@@ -14464,7 +14611,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.33";
+var SERVER_VERSION = "0.2.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -14735,7 +14882,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(path22.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path23.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -14768,8 +14915,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path22.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs18.readFile(absolutePath, "utf8"));
+      const absolutePath = path23.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs19.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -14777,11 +14924,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(path22.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path23.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path22.basename(relativePath, ".md"),
+            name: path23.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -14798,11 +14945,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path22.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path23.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 fs18.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs19.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -14850,13 +14997,13 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs19 from "fs/promises";
-import path23 from "path";
+import fs20 from "fs/promises";
+import path24 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path23.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path24.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path23.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path24.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -14959,13 +15106,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs19.open(leasePath, "wx");
+  const handle = await fs20.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs19.rm(leasePath, { force: true });
+    await fs20.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -15111,33 +15258,750 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
   };
 }
 
+// src/sources.ts
+import { spawn as spawn2 } from "child_process";
+import fs21 from "fs/promises";
+import path25 from "path";
+import { JSDOM as JSDOM3 } from "jsdom";
+var DEFAULT_CRAWL_MAX_PAGES = 12;
+var DEFAULT_CRAWL_MAX_DEPTH = 2;
+var DOCS_HINT_SEGMENTS = /* @__PURE__ */ new Set([
+  "docs",
+  "documentation",
+  "wiki",
+  "help",
+  "reference",
+  "references",
+  "guide",
+  "guides",
+  "tutorial",
+  "tutorials",
+  "manual",
+  "api",
+  "apis",
+  "getting-started"
+]);
+function uniqueStrings4(values) {
+  return uniqueBy(values.filter(Boolean), (value) => value);
+}
+function normalizeManagedStatus(value) {
+  return value === "missing" || value === "error" ? value : "ready";
+}
+function withinRoot2(rootPath, targetPath) {
+  const relative = path25.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path25.isAbsolute(relative);
+}
+async function findNearestGitRoot3(startPath) {
+  let current = path25.resolve(startPath);
+  try {
+    const stat = await fs21.stat(current);
+    if (!stat.isDirectory()) {
+      current = path25.dirname(current);
+    }
+  } catch {
+    current = path25.dirname(current);
+  }
+  while (true) {
+    if (await fileExists(path25.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path25.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function normalizeUrlWithoutHash(input) {
+  const url = new URL(input);
+  url.hash = "";
+  if (url.protocol === "http:" && url.port === "80" || url.protocol === "https:" && url.port === "443") {
+    url.port = "";
+  }
+  return url.toString();
+}
+function normalizeGitHubRepoRootUrl(input) {
+  let parsed;
+  try {
+    parsed = new URL(input);
+  } catch {
+    return null;
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host !== "github.com" && host !== "www.github.com") {
+    return null;
+  }
+  const segments = parsed.pathname.split("/").map((segment) => segment.trim()).filter(Boolean);
+  if (segments.length !== 2) {
+    return null;
+  }
+  const [owner, repoSegment] = segments;
+  const repo = repoSegment.replace(/\.git$/i, "");
+  if (!owner || !repo) {
+    return null;
+  }
+  const url = `https://github.com/${owner}/${repo}`;
+  return {
+    url,
+    cloneUrl: `${url}.git`,
+    title: `${owner}/${repo}`
+  };
+}
+function looksLikeDocsPathname(pathname) {
+  const segments = pathname.split("/").map((segment) => segment.trim().toLowerCase()).filter(Boolean);
+  return segments.some((segment) => DOCS_HINT_SEGMENTS.has(segment));
+}
+function isLikelyDocsStartUrl(url) {
+  return looksLikeDocsPathname(url.pathname) || url.hostname.toLowerCase().startsWith("docs.");
+}
+function normalizeCrawlCandidate(href, baseUrl) {
+  try {
+    const url = new URL(href, baseUrl);
+    if (!["http:", "https:"].includes(url.protocol)) {
+      return null;
+    }
+    if (url.hash) {
+      url.hash = "";
+    }
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function pathPrefix(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "/";
+  }
+  return `/${segments[0]}`;
+}
+function isAllowedDocsCandidate(candidate, startUrl) {
+  if (candidate.origin !== startUrl.origin) {
+    return false;
+  }
+  const extension = path25.extname(candidate.pathname).toLowerCase();
+  if (extension && extension !== ".html" && extension !== ".htm" && extension !== ".md") {
+    return false;
+  }
+  if (looksLikeDocsPathname(candidate.pathname)) {
+    return true;
+  }
+  const startPrefix = pathPrefix(startUrl.pathname);
+  const candidatePrefix = pathPrefix(candidate.pathname);
+  return startPrefix !== "/" && candidatePrefix === startPrefix;
+}
+async function fetchHtml(url) {
+  await validateUrlSafety(url);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() ?? "text/html";
+  if (!contentType.includes("html")) {
+    throw new Error(`Unsupported docs crawl content type at ${url}: ${contentType}`);
+  }
+  const html = await response.text();
+  const dom = new JSDOM3(html, { url });
+  const document = dom.window.document;
+  const title = document.title.trim() || url;
+  const links = [...document.querySelectorAll("a[href]")].map((anchor) => normalizeCrawlCandidate(anchor.getAttribute("href") ?? "", url)).filter((value) => Boolean(value));
+  return { title, links };
+}
+async function crawlDocsSource(url, maxPages, maxDepth) {
+  const startUrl = new URL(normalizeUrlWithoutHash(url));
+  const initial = await fetchHtml(startUrl.toString());
+  const sameDomainDocsLinks = uniqueStrings4(
+    initial.links.filter((candidate) => {
+      const parsed = new URL(candidate);
+      return isAllowedDocsCandidate(parsed, startUrl);
+    })
+  );
+  if (!isLikelyDocsStartUrl(startUrl) && sameDomainDocsLinks.length < 3) {
+    throw new Error(
+      "This URL does not look like a docs hub. Use `swarmvault add` for single articles or `swarmvault ingest` for direct files."
+    );
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queued = /* @__PURE__ */ new Set();
+  const pages = [];
+  const queue = [{ url: startUrl.toString(), depth: 0 }];
+  queued.add(startUrl.toString());
+  while (queue.length > 0 && pages.length < maxPages) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    if (visited.has(current.url)) {
+      continue;
+    }
+    visited.add(current.url);
+    pages.push(current.url);
+    if (current.depth >= maxDepth) {
+      continue;
+    }
+    const { links } = await fetchHtml(current.url);
+    for (const candidate of links) {
+      if (pages.length + queue.length >= maxPages) {
+        break;
+      }
+      if (queued.has(candidate) || visited.has(candidate)) {
+        continue;
+      }
+      const parsed = new URL(candidate);
+      if (!isAllowedDocsCandidate(parsed, startUrl)) {
+        continue;
+      }
+      queued.add(candidate);
+      queue.push({ url: candidate, depth: current.depth + 1 });
+    }
+  }
+  return {
+    title: initial.title,
+    pages
+  };
+}
+function stableManagedSourceId(kind, raw, fallbackTitle) {
+  return `${kind}-${slugify(fallbackTitle)}-${sha256(raw).slice(0, 8)}`;
+}
+function matchesManagedSourceSpec(existing, input) {
+  if (existing.kind !== input.kind) {
+    return false;
+  }
+  if (input.kind === "directory") {
+    return path25.resolve(existing.path ?? "") === path25.resolve(input.path);
+  }
+  return (existing.url ?? "") === input.url;
+}
+async function resolveManagedSourceInput(rootDir, input) {
+  const absoluteInput = path25.resolve(rootDir, input);
+  if (!(input.startsWith("http://") || input.startsWith("https://"))) {
+    const stat = await fs21.stat(absoluteInput).catch(() => null);
+    if (!stat) {
+      throw new Error(`Source not found: ${input}`);
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(
+        "`swarmvault source add` supports directories, public GitHub repo root URLs, and docs hubs. Use `swarmvault ingest` for single files."
+      );
+    }
+    const detectedRepoRoot = await findNearestGitRoot3(absoluteInput);
+    const repoRoot = detectedRepoRoot && !(withinRoot2(rootDir, absoluteInput) && !withinRoot2(rootDir, detectedRepoRoot)) ? detectedRepoRoot : absoluteInput;
+    return {
+      kind: "directory",
+      path: absoluteInput,
+      repoRoot,
+      title: path25.basename(absoluteInput) || absoluteInput
+    };
+  }
+  const github = normalizeGitHubRepoRootUrl(input);
+  if (github) {
+    return {
+      kind: "github_repo",
+      ...github
+    };
+  }
+  const parsed = new URL(input);
+  if (parsed.hostname.toLowerCase().includes("github.com")) {
+    throw new Error(
+      "`swarmvault source add` only supports public GitHub repo root URLs. Use a repo root like https://github.com/owner/repo."
+    );
+  }
+  return {
+    kind: "crawl_url",
+    url: normalizeUrlWithoutHash(input),
+    title: parsed.hostname
+  };
+}
+function directorySourceIdsFor(manifests, inputPath) {
+  return manifests.filter((manifest) => manifest.originalPath && withinRoot2(path25.resolve(inputPath), path25.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+}
+async function syncDirectorySource(rootDir, inputPath, repoRoot) {
+  const manifestsBefore = await listManifests(rootDir);
+  const previousInScope = manifestsBefore.filter(
+    (manifest) => manifest.originalPath && withinRoot2(path25.resolve(inputPath), path25.resolve(manifest.originalPath))
+  );
+  const result = await ingestDirectory(rootDir, inputPath, { repoRoot });
+  const removed = [];
+  for (const manifest of previousInScope) {
+    if (!manifest.originalPath) {
+      continue;
+    }
+    if (await fileExists(path25.resolve(manifest.originalPath))) {
+      continue;
+    }
+    const removedManifest = await removeManifestBySourceId(rootDir, manifest.sourceId);
+    if (removedManifest) {
+      removed.push(removedManifest.sourceId);
+    }
+  }
+  const manifestsAfter = await listManifests(rootDir);
+  return {
+    title: path25.basename(inputPath) || inputPath,
+    sourceIds: directorySourceIdsFor(manifestsAfter, inputPath),
+    counts: {
+      scannedCount: result.scannedCount,
+      importedCount: result.imported.length,
+      updatedCount: result.updated.length,
+      removedCount: removed.length,
+      skippedCount: result.skipped.length
+    },
+    changed: result.imported.length + result.updated.length + removed.length > 0
+  };
+}
+async function runGitCommand(cwd, args) {
+  await new Promise((resolve, reject) => {
+    const child = spawn2("git", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(stderr.trim() || `git ${args.join(" ")} failed with exit code ${code ?? 1}`));
+    });
+  });
+}
+async function syncGitHubRepoSource(rootDir, entry) {
+  const workingDir = await managedSourceWorkingDir(rootDir, entry.id);
+  const checkoutDir = path25.join(workingDir, "checkout");
+  await fs21.rm(checkoutDir, { recursive: true, force: true });
+  await ensureDir(workingDir);
+  if (!entry.url) {
+    throw new Error(`Managed source ${entry.id} is missing its repository URL.`);
+  }
+  const github = normalizeGitHubRepoRootUrl(entry.url);
+  if (!github) {
+    throw new Error(`Managed source ${entry.id} has an invalid GitHub repo URL.`);
+  }
+  await runGitCommand(workingDir, ["clone", "--depth", "1", github.cloneUrl, "checkout"]);
+  return await syncDirectorySource(rootDir, checkoutDir, checkoutDir);
+}
+async function syncCrawlSource(rootDir, entry, options) {
+  if (!entry.url) {
+    throw new Error(`Managed source ${entry.id} is missing its URL.`);
+  }
+  const crawl = await crawlDocsSource(entry.url, options.maxPages ?? DEFAULT_CRAWL_MAX_PAGES, options.maxDepth ?? DEFAULT_CRAWL_MAX_DEPTH);
+  const previousSourceIds = [...entry.sourceIds];
+  const currentSourceIds = [];
+  let importedCount = 0;
+  let updatedCount = 0;
+  for (const pageUrl of crawl.pages) {
+    const persisted = await ingestInputDetailed(rootDir, pageUrl);
+    currentSourceIds.push(persisted.manifest.sourceId);
+    if (persisted.isNew) {
+      importedCount += 1;
+    } else if (persisted.wasUpdated) {
+      updatedCount += 1;
+    }
+  }
+  let removedCount = 0;
+  for (const sourceId of previousSourceIds) {
+    if (currentSourceIds.includes(sourceId)) {
+      continue;
+    }
+    if (await removeManifestBySourceId(rootDir, sourceId)) {
+      removedCount += 1;
+    }
+  }
+  return {
+    title: crawl.title,
+    sourceIds: uniqueStrings4(currentSourceIds).sort((left, right) => left.localeCompare(right)),
+    counts: {
+      scannedCount: crawl.pages.length,
+      importedCount,
+      updatedCount,
+      removedCount,
+      skippedCount: 0
+    },
+    changed: importedCount + updatedCount + removedCount > 0
+  };
+}
+async function syncManagedSource(rootDir, entry, options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    let sync;
+    if (entry.kind === "directory") {
+      if (!entry.path || !entry.repoRoot) {
+        throw new Error(`Managed source ${entry.id} is missing its directory path.`);
+      }
+      if (!await fileExists(entry.path)) {
+        return {
+          ...entry,
+          status: "missing",
+          updatedAt: now,
+          lastSyncAt: now,
+          lastSyncStatus: "error",
+          lastError: `Directory not found: ${entry.path}`,
+          changed: false
+        };
+      }
+      sync = await syncDirectorySource(rootDir, entry.path, entry.repoRoot);
+    } else if (entry.kind === "github_repo") {
+      sync = await syncGitHubRepoSource(rootDir, entry);
+    } else {
+      sync = await syncCrawlSource(rootDir, entry, options);
+    }
+    return {
+      ...entry,
+      title: sync.title || entry.title,
+      sourceIds: sync.sourceIds,
+      status: "ready",
+      updatedAt: now,
+      lastSyncAt: now,
+      lastSyncStatus: "success",
+      lastSyncCounts: sync.counts,
+      lastError: void 0,
+      changed: sync.changed
+    };
+  } catch (error) {
+    return {
+      ...entry,
+      status: normalizeManagedStatus(entry.status),
+      updatedAt: now,
+      lastSyncAt: now,
+      lastSyncStatus: "error",
+      lastError: error instanceof Error ? error.message : String(error),
+      changed: false
+    };
+  }
+}
+function scopedSourcePages(graph, sourceIds) {
+  const scopedSet = new Set(sourceIds);
+  return graph.pages.filter((page) => page.sourceIds.some((sourceId) => scopedSet.has(sourceId)));
+}
+function scopedNodeIds(graph, sourceIds) {
+  const scopedSet = new Set(sourceIds);
+  return graph.nodes.filter((node) => node.sourceIds.some((sourceId) => scopedSet.has(sourceId))).map((node) => node.id);
+}
+async function loadSourceAnalyses(rootDir, sourceIds) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const analyses = await Promise.all(
+    sourceIds.map(async (sourceId) => await readJsonFile(path25.join(paths.analysesDir, `${sourceId}.json`)))
+  );
+  return analyses.filter((analysis) => Boolean(analysis?.sourceId));
+}
+function renderDeterministicSourceBrief(input) {
+  const modulePages = input.sourcePages.filter((page) => page.kind === "module").slice(0, 6);
+  const sourcePages = input.sourcePages.filter((page) => page.kind === "source").slice(0, 6);
+  const conceptPages = input.sourcePages.filter((page) => page.kind === "concept").slice(0, 6);
+  const entityPages = input.sourcePages.filter((page) => page.kind === "entity").slice(0, 6);
+  const questions = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 5);
+  const summary = truncate(
+    normalizeWhitespace(
+      uniqueStrings4(input.analyses.map((analysis) => analysis.summary).filter(Boolean)).join(" ") || `${input.source.title} has been compiled into a local source graph.`
+    ),
+    320
+  );
+  const scopedNodeIdSet = new Set(scopedNodeIds(input.graph, input.source.sourceIds));
+  const surprises = input.report?.surprisingConnections.filter((connection) => scopedNodeIdSet.has(connection.sourceNodeId) || scopedNodeIdSet.has(connection.targetNodeId)).slice(0, 4) ?? [];
+  const contradictions = input.report?.contradictions.filter(
+    (contradiction) => input.source.sourceIds.includes(contradiction.sourceIdA) || input.source.sourceIds.includes(contradiction.sourceIdB)
+  ) ?? [];
+  return [
+    `# Source Brief: ${input.source.title}`,
+    "",
+    "## What This Source Is",
+    "",
+    summary,
+    "",
+    "## Read First",
+    "",
+    ...sourcePages.length ? sourcePages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No source page links are available yet."],
+    "",
+    "## Core Pages",
+    "",
+    ...modulePages.length ? modulePages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No module pages are available yet."],
+    ...conceptPages.length ? ["", "Concept pages:", ...conceptPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`)] : [],
+    ...entityPages.length ? ["", "Entity pages:", ...entityPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`)] : [],
+    "",
+    "## How The Important Parts Fit Together",
+    "",
+    `- Compiled source pages: ${sourcePages.length}`,
+    `- Module pages: ${modulePages.length}`,
+    `- Graph nodes touching this source: ${scopedNodeIdSet.size}`,
+    `- Current tracked source ids: ${input.source.sourceIds.length}`,
+    "",
+    "## Surprises",
+    "",
+    ...surprises.length ? surprises.map((surprise) => `- ${surprise.explanation}`) : ["- No surprising cross-source connections were highlighted for this source yet."],
+    "",
+    "## Contradictions",
+    "",
+    ...contradictions.length ? contradictions.map(
+      (contradiction) => `- ${contradiction.claimA} / ${contradiction.claimB} (sources: ${contradiction.sourceIdA}, ${contradiction.sourceIdB})`
+    ) : ["- No contradictions were detected for this source."],
+    "",
+    "## Open Questions",
+    "",
+    ...questions.length ? questions.map((question) => `- ${question}`) : ["- No extracted open questions yet."],
+    "",
+    "## Suggested Next Questions",
+    "",
+    ...(input.report?.suggestedQuestions ?? []).slice(0, 5).map((question) => `- ${question}`) || [
+      "- Ask `swarmvault query` about the main modules or sections in this source."
+    ],
+    ""
+  ].join("\n");
+}
+async function generateSourceBriefMarkdown(rootDir, source) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    return null;
+  }
+  const sourcePages = scopedSourcePages(graph, source.sourceIds);
+  const analyses = await loadSourceAnalyses(rootDir, source.sourceIds);
+  const report = await readGraphReport(rootDir);
+  const fallback = renderDeterministicSourceBrief({
+    source,
+    sourcePages,
+    graph,
+    analyses,
+    report
+  });
+  const provider = await getProviderForTask(rootDir, "queryProvider");
+  if (provider.type === "heuristic") {
+    return fallback;
+  }
+  try {
+    const schemas = await loadVaultSchemas(rootDir);
+    const pageContext = sourcePages.slice(0, 10).map((page) => `- ${page.title} (${page.kind}) -> ${page.path}`).join("\n");
+    const analysisContext = analyses.slice(0, 6).map(
+      (analysis) => `# ${analysis.title}
+Summary: ${analysis.summary}
+Questions: ${analysis.questions.join(" | ") || "none"}
+Concepts: ${analysis.concepts.map((concept) => concept.name).join(", ") || "none"}
+Entities: ${analysis.entities.map((entity) => entity.name).join(", ") || "none"}`
+    ).join("\n\n---\n\n");
+    const response = await provider.generateText({
+      system: buildSchemaPrompt(
+        schemas.effective.global,
+        "Write a concise markdown source brief with sections: What This Source Is, Read First, Core Pages, How The Important Parts Fit Together, Surprises, Contradictions, Open Questions, Suggested Next Questions. Ground every claim in the provided context."
+      ),
+      prompt: [
+        `Source title: ${source.title}`,
+        `Source kind: ${source.kind}`,
+        `Tracked source ids: ${source.sourceIds.join(", ") || "none"}`,
+        "",
+        "Pages:",
+        pageContext || "- none",
+        "",
+        "Analyses:",
+        analysisContext || "No analysis context available.",
+        "",
+        "Deterministic fallback draft:",
+        fallback
+      ].join("\n")
+    });
+    return response.text?.trim() ? response.text.trim() : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function writeSourceBrief(rootDir, source) {
+  if (!source.sourceIds.length) {
+    return null;
+  }
+  const { paths } = await loadVaultConfig(rootDir);
+  const markdown = await generateSourceBriefMarkdown(rootDir, source);
+  if (!markdown) {
+    return null;
+  }
+  const graph = await readJsonFile(paths.graphPath);
+  const relatedPages = graph ? scopedSourcePages(graph, source.sourceIds) : [];
+  const relatedPageIds = relatedPages.slice(0, 12).map((page) => page.id);
+  const relatedNodeIds = graph ? scopedNodeIds(graph, source.sourceIds).slice(0, 20) : [];
+  const projectIds = uniqueStrings4(relatedPages.flatMap((page) => page.projectIds));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const output = buildOutputPage({
+    title: `Source Brief: ${source.title}`,
+    question: `Brief ${source.title}`,
+    answer: markdown,
+    citations: source.sourceIds,
+    schemaHash: graph?.generatedAt ?? "",
+    outputFormat: "report",
+    relatedPageIds,
+    relatedNodeIds,
+    relatedSourceIds: source.sourceIds,
+    projectIds,
+    extraTags: ["source-brief"],
+    origin: "query",
+    slug: `source-briefs/${source.id}`,
+    metadata: {
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+      compiledFrom: source.sourceIds,
+      managedBy: "system",
+      confidence: 0.82
+    }
+  });
+  const absolutePath = path25.join(paths.wikiDir, output.page.path);
+  await ensureDir(path25.dirname(absolutePath));
+  await fs21.writeFile(absolutePath, output.content, "utf8");
+  return absolutePath;
+}
+async function generateBriefsForSources(rootDir, sources) {
+  const briefPaths = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const briefPath = await writeSourceBrief(rootDir, source);
+    if (briefPath) {
+      briefPaths.set(source.id, briefPath);
+    }
+  }
+  if (briefPaths.size > 0) {
+    await refreshVaultAfterOutputSave(rootDir);
+  }
+  return briefPaths;
+}
+function shouldCompile(changedSources, graphExists, compileRequested) {
+  return compileRequested && (!graphExists || changedSources.length > 0);
+}
+async function listManagedSourceRecords(rootDir) {
+  await ensureManagedSourcesArtifact(rootDir);
+  return await loadManagedSources(rootDir);
+}
+async function addManagedSource(rootDir, input, options = {}) {
+  const compileRequested = options.compile ?? true;
+  const briefRequested = options.brief ?? true;
+  const sources = await loadManagedSources(rootDir);
+  const resolved = await resolveManagedSourceInput(rootDir, input);
+  const existing = sources.find((candidate) => matchesManagedSourceSpec(candidate, resolved));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const source = existing ?? {
+    id: resolved.kind === "directory" ? stableManagedSourceId("directory", path25.resolve(resolved.path), resolved.title) : stableManagedSourceId(resolved.kind, resolved.url, resolved.title),
+    kind: resolved.kind,
+    title: resolved.title,
+    path: resolved.kind === "directory" ? resolved.path : void 0,
+    repoRoot: resolved.kind === "directory" ? resolved.repoRoot : void 0,
+    url: resolved.kind === "directory" ? void 0 : resolved.url,
+    createdAt: now,
+    updatedAt: now,
+    status: "ready",
+    sourceIds: []
+  };
+  const synced = await syncManagedSource(rootDir, source, options);
+  if (synced.lastSyncStatus === "error") {
+    throw new Error(synced.lastError ?? `Failed to add managed source ${synced.id}.`);
+  }
+  const graphExists = await loadVaultConfig(rootDir).then(({ paths }) => fileExists(paths.graphPath));
+  let compile;
+  if (shouldCompile([synced], graphExists, compileRequested)) {
+    compile = await compileVault(rootDir, {});
+  }
+  let briefGenerated = false;
+  let briefPath;
+  if (compileRequested && briefRequested && synced.status === "ready") {
+    const briefs = await generateBriefsForSources(rootDir, [synced]);
+    briefPath = briefs.get(synced.id);
+    briefGenerated = Boolean(briefPath);
+  }
+  const nextSource = {
+    ...synced,
+    briefPath: briefPath ?? synced.briefPath,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const nextSources = existing ? sources.map((candidate) => candidate.id === nextSource.id ? nextSource : candidate) : [...sources, nextSource];
+  await saveManagedSources(rootDir, nextSources);
+  return {
+    source: nextSource,
+    compile,
+    briefGenerated
+  };
+}
+async function reloadManagedSources(rootDir, options = {}) {
+  const compileRequested = options.compile ?? true;
+  const briefRequested = options.brief ?? true;
+  const sources = await loadManagedSources(rootDir);
+  const selected = options.all || !options.id ? sources : sources.filter((source) => source.id === options.id);
+  if (!selected.length) {
+    throw new Error(options.id ? `Managed source not found: ${options.id}` : "No managed sources registered.");
+  }
+  const syncedSources = [];
+  const changedSources = [];
+  for (const source of selected) {
+    const synced = await syncManagedSource(rootDir, source, options);
+    syncedSources.push(synced);
+    if (synced.changed) {
+      changedSources.push(synced);
+    }
+  }
+  const graphExists = await loadVaultConfig(rootDir).then(({ paths }) => fileExists(paths.graphPath));
+  let compile;
+  if (shouldCompile(changedSources, graphExists, compileRequested)) {
+    compile = await compileVault(rootDir, {});
+  }
+  const briefPaths = compileRequested && briefRequested ? await generateBriefsForSources(
+    rootDir,
+    syncedSources.filter((source) => source.status === "ready")
+  ) : /* @__PURE__ */ new Map();
+  const nextSources = sources.map((source) => {
+    const synced = syncedSources.find((candidate) => candidate.id === source.id);
+    if (!synced) {
+      return source;
+    }
+    return {
+      ...synced,
+      briefPath: briefPaths.get(synced.id) ?? synced.briefPath,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  });
+  await saveManagedSources(rootDir, nextSources);
+  return {
+    sources: nextSources.filter((source) => selected.some((candidate) => candidate.id === source.id)),
+    compile,
+    briefPaths: [...briefPaths.values()]
+  };
+}
+async function deleteManagedSource(rootDir, id) {
+  const sources = await loadManagedSources(rootDir);
+  const target = sources.find((source) => source.id === id);
+  if (!target) {
+    throw new Error(`Managed source not found: ${id}`);
+  }
+  await saveManagedSources(
+    rootDir,
+    sources.filter((source) => source.id !== id)
+  );
+  const workingDir = await managedSourceWorkingDir(rootDir, id);
+  await fs21.rm(workingDir, { recursive: true, force: true });
+  return { removed: target };
+}
+
 // src/viewer.ts
 import { execFile } from "child_process";
-import fs20 from "fs/promises";
+import fs22 from "fs/promises";
 import http from "http";
-import path25 from "path";
+import path27 from "path";
 import { promisify } from "util";
 import matter10 from "gray-matter";
 import mime2 from "mime-types";
 
 // src/watch.ts
-import path24 from "path";
+import path26 from "path";
 import process3 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", ".venv"]);
-function withinRoot2(rootPath, targetPath) {
-  const relative = path24.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative);
+function withinRoot3(rootPath, targetPath) {
+  const relative = path26.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path26.isAbsolute(relative);
 }
 function hasIgnoredRepoSegment(baseDir, targetPath) {
-  const relativePath = path24.relative(baseDir, targetPath);
+  const relativePath = path26.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath.split(path24.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+  return relativePath.split(path26.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
 }
 function workspaceIgnoreRoots(rootDir, paths) {
   return [
@@ -15146,16 +16010,16 @@ function workspaceIgnoreRoots(rootDir, paths) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path24.join(rootDir, ".claude"),
-    path24.join(rootDir, ".cursor"),
-    path24.join(rootDir, ".obsidian")
-  ].map((candidate) => path24.resolve(candidate));
+    path26.join(rootDir, ".claude"),
+    path26.join(rootDir, ".cursor"),
+    path26.join(rootDir, ".obsidian")
+  ].map((candidate) => path26.resolve(candidate));
 }
 async function resolveWatchTargets(rootDir, paths, options) {
-  const targets = /* @__PURE__ */ new Set([path24.resolve(paths.inboxDir)]);
+  const targets = /* @__PURE__ */ new Set([path26.resolve(paths.inboxDir)]);
   if (options.repo) {
     for (const repoRoot of await listTrackedRepoRoots(rootDir)) {
-      targets.add(path24.resolve(repoRoot));
+      targets.add(path26.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
@@ -15285,7 +16149,7 @@ async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   const baseDebounceMs = options.debounceMs ?? 900;
   const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
-  const inboxWatchRoot = path24.resolve(paths.inboxDir);
+  const inboxWatchRoot = path26.resolve(paths.inboxDir);
   let watchTargets = await resolveWatchTargets(rootDir, paths, options);
   let timer;
   let running = false;
@@ -15300,12 +16164,12 @@ async function watchVault(rootDir, options = {}) {
     usePolling: true,
     interval: 100,
     ignored: (targetPath) => {
-      const absolutePath = path24.resolve(targetPath);
-      const primaryTarget = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
+      const absolutePath = path26.resolve(targetPath);
+      const primaryTarget = watchTargets.filter((watchTarget) => withinRoot3(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
       }
-      if (primaryTarget !== inboxWatchRoot && ignoredRoots.some((ignoreRoot) => withinRoot2(ignoreRoot, absolutePath))) {
+      if (primaryTarget !== inboxWatchRoot && ignoredRoots.some((ignoreRoot) => withinRoot3(ignoreRoot, absolutePath))) {
         return true;
       }
       return hasIgnoredRepoSegment(primaryTarget, absolutePath);
@@ -15489,8 +16353,8 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path24.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
-    return path24.relative(baseDir, targetPath) || ".";
+    const baseDir = watchTargets.filter((watchTarget) => withinRoot3(watchTarget, path26.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path26.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) => {
@@ -15532,15 +16396,15 @@ async function getWatchStatus(rootDir) {
 var execFileAsync = promisify(execFile);
 async function readViewerPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path25.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path27.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs20.readFile(absolutePath, "utf8");
+  const raw = await fs22.readFile(absolutePath, "utf8");
   const parsed = matter10(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path25.basename(relativePath, path25.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path27.basename(relativePath, path27.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -15548,12 +16412,12 @@ async function readViewerPage(rootDir, relativePath) {
 }
 async function readViewerAsset(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path25.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path27.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs20.readFile(absolutePath),
+    buffer: await fs22.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -15576,12 +16440,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path25.join(viewerDistDir, "index.html");
+  const indexPath = path27.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path25.dirname(viewerDistDir);
-  if (await fileExists(path25.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path27.dirname(viewerDistDir);
+  if (await fileExists(path27.join(viewerProjectDir, "package.json"))) {
     await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -15598,7 +16462,7 @@ async function startGraphServer(rootDir, port) {
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs20.readFile(paths.graphPath, "utf8"));
+      response.end(await fs22.readFile(paths.graphPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/graph/query") {
@@ -15655,14 +16519,14 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     if (url.pathname === "/api/graph-report") {
-      const reportPath = path25.join(paths.wikiDir, "graph", "report.json");
+      const reportPath = path27.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 fs20.readFile(reportPath, "utf8"));
+      response.end(await fs22.readFile(reportPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/watch-status") {
@@ -15745,8 +16609,8 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path25.join(paths.viewerDistDir, relativePath);
-    const fallback = path25.join(paths.viewerDistDir, "index.html");
+    const target = path27.join(paths.viewerDistDir, relativePath);
+    const fallback = path27.join(paths.viewerDistDir, "index.html");
     const filePath = await fileExists(target) ? target : fallback;
     if (!await fileExists(filePath)) {
       response.writeHead(503, { "content-type": "text/plain" });
@@ -15754,7 +16618,7 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs20.readFile(filePath));
+    response.end(await fs22.readFile(filePath));
   });
   await new Promise((resolve) => {
     server.listen(effectivePort, resolve);
@@ -15781,7 +16645,7 @@ async function exportGraphHtml(rootDir, outputPath) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path25.join(paths.viewerDistDir, "index.html");
+  const indexPath = path27.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -15807,17 +16671,17 @@ async function exportGraphHtml(rootDir, outputPath) {
       } : null;
     })
   );
-  const rawHtml = await fs20.readFile(indexPath, "utf8");
+  const rawHtml = await fs22.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] ? path25.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path25.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path27.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path27.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 fs20.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs20.readFile(stylePath, "utf8") : "";
-  const report = await readJsonFile(path25.join(paths.wikiDir, "graph", "report.json"));
+  const script = await fs22.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs22.readFile(stylePath, "utf8") : "";
+  const report = await readJsonFile(path27.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>",
@@ -15836,13 +16700,14 @@ async function exportGraphHtml(rootDir, outputPath) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs20.mkdir(path25.dirname(outputPath), { recursive: true });
-  await fs20.writeFile(outputPath, html, "utf8");
-  return path25.resolve(outputPath);
+  await fs22.mkdir(path27.dirname(outputPath), { recursive: true });
+  await fs22.writeFile(outputPath, html, "utf8");
+  return path27.resolve(outputPath);
 }
 export {
   acceptApproval,
   addInput,
+  addManagedSource,
   archiveCandidate,
   assertProviderCapability,
   benchmarkVault,
@@ -15853,6 +16718,7 @@ export {
   createWebSearchAdapter,
   defaultVaultConfig,
   defaultVaultSchema,
+  deleteManagedSource,
   explainGraphVault,
   exploreVault,
   exportGraphFormat,
@@ -15875,6 +16741,7 @@ export {
   listCandidates,
   listGodNodes,
   listGraphHyperedges,
+  listManagedSourceRecords,
   listManifests,
   listPages,
   listSchedules,
@@ -15892,6 +16759,7 @@ export {
   readGraphReport,
   readPage,
   rejectApproval,
+  reloadManagedSources,
   resolvePaths,
   runSchedule,
   runWatchCycle,