@swarmvaultai/engine 0.1.21 → 0.1.23

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-QMW7OISM.js";
+} from "./chunk-6UPHDGEB.js";
 
 // src/agents.ts
 import fs from "fs/promises";
@@ -593,9 +593,10 @@ async function uninstallGitHooks(rootDir) {
 }
 
 // src/ingest.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 import { Readability } from "@mozilla/readability";
+import matter3 from "gray-matter";
 import ignore from "ignore";
 import { JSDOM } from "jsdom";
 import mime from "mime-types";
@@ -2728,9 +2729,10 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType) ?? "typescript";
   const { code, rationales } = language === "javascript" || language === "jsx" || language === "typescript" || language === "tsx" ? analyzeTypeScriptLikeCode(manifest, extractedText) : await analyzeTreeSitterCode(manifest, extractedText, language);
   return {
-    analysisVersion: 4,
+    analysisVersion: 5,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
+    extractionHash: manifest.extractionHash,
     schemaHash,
     title: manifest.title,
     summary: summarizeModule(manifest, code),
@@ -2744,19 +2746,247 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
   };
 }
 
-// src/logs.ts
+// src/extraction.ts
 import fs6 from "fs/promises";
+import os from "os";
 import path6 from "path";
+import { z } from "zod";
+var imageVisionExtractionSchema = z.object({
+  title: z.string().min(1).nullable().optional(),
+  summary: z.string().min(1),
+  text: z.string().default(""),
+  concepts: z.array(
+    z.object({
+      name: z.string().min(1),
+      description: z.string().default("")
+    })
+  ).max(12).default([]),
+  entities: z.array(
+    z.object({
+      name: z.string().min(1),
+      description: z.string().default("")
+    })
+  ).max(12).default([]),
+  claims: z.array(
+    z.object({
+      text: z.string().min(1),
+      confidence: z.number().min(0).max(1).default(0.65),
+      polarity: z.enum(["positive", "negative", "neutral"]).default("neutral")
+    })
+  ).max(8).default([]),
+  questions: z.array(z.string().min(1)).max(6).default([])
+});
+function extractionMetadata(sourceKind, mimeType, extractor) {
+  return {
+    extractor,
+    sourceKind,
+    mimeType,
+    producedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildExtractionHash(extractedText, artifact) {
+  if (!extractedText && !artifact) {
+    return void 0;
+  }
+  const normalizedArtifact = artifact ? {
+    ...artifact,
+    producedAt: void 0
+  } : null;
+  return sha256(
+    JSON.stringify({
+      extractedText: extractedText ?? null,
+      artifact: normalizedArtifact
+    })
+  );
+}
+function createPlainTextExtractionArtifact(sourceKind, mimeType) {
+  return extractionMetadata(sourceKind, mimeType, "plain_text");
+}
+function createHtmlReadabilityExtractionArtifact(sourceKind, mimeType) {
+  return extractionMetadata(sourceKind, mimeType, "html_readability");
+}
+function normalizeVisionMarkdown(payload) {
+  const sections = [];
+  if (payload.summary.trim()) {
+    sections.push(payload.summary.trim());
+  }
+  if (payload.text.trim()) {
+    sections.push(payload.text.trim());
+  }
+  if (payload.claims.length) {
+    sections.push(payload.claims.map((claim) => `- ${claim.text}`).join("\n"));
+  }
+  return sections.join("\n\n").trim();
+}
+async function materializeAttachmentPath(input) {
+  if (input.filePath) {
+    return {
+      filePath: input.filePath,
+      cleanup: async () => {
+      }
+    };
+  }
+  if (!input.bytes) {
+    throw new Error("Image extraction requires a file path or bytes.");
+  }
+  const tempDir = await fs6.mkdtemp(path6.join(os.tmpdir(), "swarmvault-image-extract-"));
+  const extension = input.mimeType.split("/")[1]?.split("+")[0] ?? "bin";
+  const tempPath = path6.join(tempDir, `source.${extension}`);
+  await fs6.writeFile(tempPath, input.bytes);
+  return {
+    filePath: tempPath,
+    cleanup: async () => {
+      await fs6.rm(tempDir, { recursive: true, force: true });
+    }
+  };
+}
+async function extractImageWithVision(rootDir, input) {
+  let provider;
+  try {
+    provider = await getProviderForTask(rootDir, "visionProvider");
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("image", input.mimeType, "image_vision"),
+        warnings: [`Vision extraction unavailable: ${error instanceof Error ? error.message : "provider not configured"}`]
+      }
+    };
+  }
+  if (provider.type === "heuristic" || !provider.capabilities.has("vision") || !provider.capabilities.has("structured")) {
+    return {
+      artifact: {
+        ...extractionMetadata("image", input.mimeType, "image_vision"),
+        warnings: [`Vision extraction unavailable for provider ${provider.id}. Configure a structured multimodal provider.`]
+      }
+    };
+  }
+  const attachment = await materializeAttachmentPath(input);
+  try {
+    const parsed = await provider.generateStructured(
+      {
+        system: [
+          "You extract grounded notes from a single image for a local-first knowledge vault.",
+          "Only describe content that is actually visible.",
+          "If the image contains text, transcribe it accurately.",
+          "If the image is a diagram or screenshot, summarize the key visible relationships and labels without speculation."
+        ].join("\n"),
+        prompt: [
+          `Source title: ${input.title}`,
+          "Return structured extraction for this image.",
+          "Include a concise summary, OCR-style text, grounded concepts/entities, visible claims, and follow-up questions."
+        ].join("\n"),
+        attachments: [{ mimeType: input.mimeType, filePath: attachment.filePath }]
+      },
+      imageVisionExtractionSchema
+    );
+    const artifact = {
+      ...extractionMetadata("image", input.mimeType, "image_vision"),
+      providerId: provider.id,
+      providerModel: provider.model,
+      vision: {
+        title: parsed.title ?? void 0,
+        summary: parsed.summary,
+        text: parsed.text,
+        concepts: parsed.concepts,
+        entities: parsed.entities,
+        claims: parsed.claims,
+        questions: parsed.questions
+      }
+    };
+    return {
+      title: parsed.title ?? void 0,
+      extractedText: normalizeVisionMarkdown(parsed),
+      artifact
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("image", input.mimeType, "image_vision"),
+        providerId: provider.id,
+        providerModel: provider.model,
+        warnings: [`Vision extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  } finally {
+    await attachment.cleanup();
+  }
+}
+function normalizePdfMetadata(raw) {
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const metadata = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") {
+      const cleaned = normalizeWhitespace(value);
+      if (cleaned) {
+        metadata[key] = cleaned;
+      }
+    }
+  }
+  return Object.keys(metadata).length ? metadata : void 0;
+}
+async function extractPdfText(input) {
+  try {
+    const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+    const task = pdfjs.getDocument({
+      data: new Uint8Array(input.bytes),
+      useWorkerFetch: false,
+      isEvalSupported: false,
+      disableFontFace: true,
+      verbosity: 0
+    });
+    const document = await task.promise;
+    const pageTexts = [];
+    for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {
+      const page = await document.getPage(pageNumber);
+      const textContent = await page.getTextContent();
+      const pageText = normalizeWhitespace(
+        textContent.items.map((item) => typeof item === "object" && item && "str" in item && typeof item.str === "string" ? item.str : "").join(" ")
+      );
+      if (pageText) {
+        pageTexts.push(pageText);
+      }
+      page.cleanup();
+    }
+    const metadataResult = await document.getMetadata().catch(() => null);
+    await task.destroy();
+    const extractedText = pageTexts.join("\n\n").trim();
+    const artifact = {
+      ...extractionMetadata("pdf", input.mimeType, "pdf_text"),
+      pageCount: document.numPages,
+      metadata: normalizePdfMetadata(metadataResult?.info)
+    };
+    if (!extractedText) {
+      artifact.warnings = ["PDF text extraction completed but produced no extractable text."];
+    }
+    return {
+      extractedText: extractedText || void 0,
+      artifact
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("pdf", input.mimeType, "pdf_text"),
+        warnings: [`PDF text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+
+// src/logs.ts
+import fs7 from "fs/promises";
+import path7 from "path";
 import matter from "gray-matter";
 async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.sessionsDir);
   const timestamp = startedAt.replace(/[:.]/g, "-");
   const baseName = `${timestamp}-${operation}-${slugify(title)}`;
-  let candidate = path6.join(paths.sessionsDir, `${baseName}.md`);
+  let candidate = path7.join(paths.sessionsDir, `${baseName}.md`);
   let counter = 2;
   while (await fileExists(candidate)) {
-    candidate = path6.join(paths.sessionsDir, `${baseName}-${counter}.md`);
+    candidate = path7.join(paths.sessionsDir, `${baseName}-${counter}.md`);
     counter++;
   }
   return candidate;
@@ -2764,11 +2994,11 @@ async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
 async function appendLogEntry(rootDir, action, title, lines = []) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.wikiDir);
-  const logPath = path6.join(paths.wikiDir, "log.md");
+  const logPath = path7.join(paths.wikiDir, "log.md");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
   const entry = [`## [${timestamp}] ${action} | ${title}`, ...lines.map((line) => `- ${line}`), ""].join("\n");
-  const existing = await fileExists(logPath) ? await fs6.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs6.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs7.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs7.writeFile(logPath, `${existing}${entry}
 `, "utf8");
 }
 async function recordSession(rootDir, input) {
@@ -2778,8 +3008,8 @@ async function recordSession(rootDir, input) {
   const finishedAtIso = new Date(input.finishedAt ?? input.startedAt).toISOString();
   const durationMs = Math.max(0, new Date(finishedAtIso).getTime() - new Date(startedAtIso).getTime());
   const sessionPath = await resolveUniqueSessionPath(rootDir, input.operation, input.title, startedAtIso);
-  const sessionId = path6.basename(sessionPath, ".md");
-  const relativeSessionPath = path6.relative(rootDir, sessionPath).split(path6.sep).join(path6.posix.sep);
+  const sessionId = path7.basename(sessionPath, ".md");
+  const relativeSessionPath = path7.relative(rootDir, sessionPath).split(path7.sep).join(path7.posix.sep);
   const frontmatter = Object.fromEntries(
     Object.entries({
       session_id: sessionId,
@@ -2827,7 +3057,7 @@ async function recordSession(rootDir, input) {
     frontmatter
   );
   await writeFileIfChanged(sessionPath, content);
-  const logPath = path6.join(paths.wikiDir, "log.md");
+  const logPath = path7.join(paths.wikiDir, "log.md");
   const timestamp = startedAtIso.slice(0, 19).replace("T", " ");
   const entry = [
     `## [${timestamp}] ${input.operation} | ${input.title}`,
@@ -2835,8 +3065,8 @@ async function recordSession(rootDir, input) {
     ...(input.lines ?? []).map((line) => `- ${line}`),
     ""
   ].join("\n");
-  const existing = await fileExists(logPath) ? await fs6.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs6.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs7.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs7.writeFile(logPath, `${existing}${entry}
 `, "utf8");
   return { sessionPath, sessionId };
 }
@@ -2846,8 +3076,8 @@ async function appendWatchRun(rootDir, run) {
 }
 
 // src/watch-state.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import matter2 from "gray-matter";
 function pendingEntryKey(entry) {
   return entry.path;
@@ -2861,7 +3091,7 @@ function normalizeRelativePath(rootDir, filePath) {
   if (!filePath) {
     return void 0;
   }
-  return toPosix(path7.relative(rootDir, path7.resolve(filePath)));
+  return toPosix(path8.relative(rootDir, path8.resolve(filePath)));
 }
 async function readPendingSemanticRefresh(rootDir) {
   const { paths } = await initWorkspace(rootDir);
@@ -2955,11 +3185,11 @@ async function markPagesStaleForSources(rootDir, sourceIds) {
     if (page.freshness !== "stale" || !page.sourceIds.some((sourceId) => affectedSourceIds.has(sourceId))) {
       continue;
     }
-    const absolutePath = path7.join(paths.wikiDir, page.path);
+    const absolutePath = path8.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const raw = await fs7.readFile(absolutePath, "utf8");
+    const raw = await fs8.readFile(absolutePath, "utf8");
     const parsed = matter2(raw);
     if (parsed.data.freshness === "stale") {
       continue;
@@ -2975,6 +3205,9 @@ async function markPagesStaleForSources(rootDir, sourceIds) {
 var DEFAULT_MAX_ASSET_SIZE = 10 * 1024 * 1024;
 var DEFAULT_MAX_DIRECTORY_FILES = 5e3;
 var BUILT_IN_REPO_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
+function uniqueStrings(values) {
+  return [...new Set(values.filter(Boolean))];
+}
 function inferKind(mimeType, filePath) {
   if (inferCodeLanguage(filePath, mimeType)) {
     return "code";
@@ -3007,7 +3240,7 @@ function normalizeIngestOptions(options) {
   return {
     includeAssets: options?.includeAssets ?? true,
     maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE)),
-    repoRoot: options?.repoRoot ? path8.resolve(options.repoRoot) : void 0,
+    repoRoot: options?.repoRoot ? path9.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)),
@@ -3016,27 +3249,27 @@ function normalizeIngestOptions(options) {
 }
 function matchesAnyGlob(relativePath, patterns) {
   return patterns.some(
-    (pattern) => path8.matchesGlob(relativePath, pattern) || path8.matchesGlob(path8.posix.basename(relativePath), pattern)
+    (pattern) => path9.matchesGlob(relativePath, pattern) || path9.matchesGlob(path9.posix.basename(relativePath), pattern)
   );
 }
 function supportedDirectoryKind(sourceKind) {
   return sourceKind !== "binary";
 }
 async function findNearestGitRoot2(startPath) {
-  let current = path8.resolve(startPath);
+  let current = path9.resolve(startPath);
   try {
-    const stat = await fs8.stat(current);
+    const stat = await fs9.stat(current);
     if (!stat.isDirectory()) {
-      current = path8.dirname(current);
+      current = path9.dirname(current);
     }
   } catch {
-    current = path8.dirname(current);
+    current = path9.dirname(current);
   }
   while (true) {
-    if (await fileExists(path8.join(current, ".git"))) {
+    if (await fileExists(path9.join(current, ".git"))) {
       return current;
     }
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -3044,26 +3277,26 @@ async function findNearestGitRoot2(startPath) {
   }
 }
 function withinRoot(rootPath, targetPath) {
-  const relative = path8.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
+  const relative = path9.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path9.isAbsolute(relative);
 }
 function repoRootFromManifest(manifest) {
   if (manifest.originType !== "file" || !manifest.originalPath || !manifest.repoRelativePath) {
     return null;
   }
-  const repoDir = path8.posix.dirname(manifest.repoRelativePath);
-  const fileDir = path8.dirname(path8.resolve(manifest.originalPath));
+  const repoDir = path9.posix.dirname(manifest.repoRelativePath);
+  const fileDir = path9.dirname(path9.resolve(manifest.originalPath));
   if (repoDir === "." || !repoDir) {
     return fileDir;
   }
   const segments = repoDir.split("/").filter(Boolean);
-  return path8.resolve(fileDir, ...segments.map(() => ".."));
+  return path9.resolve(fileDir, ...segments.map(() => ".."));
 }
 function repoRelativePathFor(absolutePath, repoRoot) {
   if (!repoRoot || !withinRoot(repoRoot, absolutePath)) {
     return void 0;
   }
-  const relative = toPosix(path8.relative(repoRoot, absolutePath));
+  const relative = toPosix(path9.relative(repoRoot, absolutePath));
   return relative && !relative.startsWith("..") ? relative : void 0;
 }
 function normalizeOriginUrl(input) {
@@ -3092,6 +3325,22 @@ function arxivIdFromInput(input) {
     return null;
   }
 }
+function doiFromInput(input) {
+  const trimmed = input.trim();
+  if (/^10\.\S+\/\S+$/i.test(trimmed)) {
+    return trimmed.replace(/\s+/g, "");
+  }
+  try {
+    const url = new URL(trimmed);
+    if (url.hostname === "doi.org" || url.hostname === "dx.doi.org") {
+      const doi = decodeURIComponent(url.pathname.replace(/^\/+/, ""));
+      return /^10\.\S+\/\S+$/i.test(doi) ? doi : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
 function isTweetUrl(input) {
   try {
     const url = new URL(input);
@@ -3101,26 +3350,25 @@ function isTweetUrl(input) {
   }
 }
 function markdownFrontmatter(value) {
-  const lines = ["---"];
-  for (const [key, rawValue] of Object.entries(value)) {
-    if (!rawValue) {
-      continue;
-    }
-    lines.push(`${key}: "${rawValue.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`);
-  }
-  lines.push("---", "");
-  return lines;
+  const normalized = Object.fromEntries(
+    Object.entries(value).filter(
+      ([, rawValue]) => Array.isArray(rawValue) ? rawValue.length > 0 : Boolean(typeof rawValue === "string" ? rawValue.trim() : rawValue)
+    )
+  );
+  return matter3.stringify("", normalized).trimEnd().split("\n").concat([""]);
 }
 function prepareCapturedMarkdownInput(input) {
   return {
     title: input.title,
     originType: "url",
     sourceKind: "markdown",
+    sourceType: input.sourceType,
     url: normalizeOriginUrl(input.url),
     mimeType: "text/markdown",
     storedExtension: ".md",
     payloadBytes: Buffer.from(input.markdown, "utf8"),
     extractedText: input.markdown,
+    attachments: input.attachments,
     logDetails: input.logDetails
   };
 }
@@ -3131,6 +3379,17 @@ async function fetchText(url) {
   }
   return response.text();
 }
+async function fetchResolvedText(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  return {
+    text: await response.text(),
+    finalUrl: normalizeOriginUrl(response.url || url),
+    contentType: response.headers.get("content-type")?.split(";")[0]?.trim() || "text/html"
+  };
+}
 function domTextFromHtml(html, baseUrl) {
   const dom = new JSDOM(`<body>${html}</body>`, { url: baseUrl });
   return normalizeWhitespace(dom.window.document.body.textContent ?? "");
@@ -3150,11 +3409,16 @@ async function captureArxivMarkdown(input, options) {
   const authors = [...document.querySelectorAll('meta[name="citation_author"]')].map((node) => node.getAttribute("content")?.trim()).filter((value) => Boolean(value));
   const authorsText = authors.join(", ") || stripLeadingLabel(document.querySelector(".authors")?.textContent?.trim() ?? "", "Authors:");
   const abstract = stripLeadingLabel(document.querySelector("blockquote.abstract")?.textContent?.trim() ?? "", "Abstract:");
+  const categories = [...document.querySelectorAll(".subheader .primary-subject, .metatable .tablecell.subjects")].flatMap((node) => (node.textContent ?? "").split(/;/g)).map((value) => value.trim()).filter(Boolean);
   const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
   const markdown = [
     ...markdownFrontmatter({
-      capture_type: "arxiv",
+      source_type: "arxiv",
       source_url: normalizedUrl,
+      canonical_url: normalizedUrl,
+      title,
+      authors,
+      tags: uniqueStrings(categories),
       arxiv_id: arxivId,
       author: options.author,
       contributor: options.contributor,
@@ -3194,8 +3458,11 @@ async function captureTweetMarkdown(input, options) {
   const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
   const markdown = [
     ...markdownFrontmatter({
-      capture_type: "tweet",
+      source_type: "tweet",
       source_url: normalizedUrl,
+      canonical_url: canonicalUrl,
+      title,
+      authors: postAuthor ? [postAuthor] : void 0,
       author: options.author,
       contributor: options.contributor,
       captured_at: capturedAt
@@ -3217,6 +3484,101 @@ async function captureTweetMarkdown(input, options) {
   ].join("\n");
   return { title, normalizedUrl, markdown };
 }
+function firstMetaContent(document, selectors) {
+  for (const selector of selectors) {
+    const value = document.querySelector(selector)?.getAttribute("content")?.trim();
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function metaContents(document, selectors) {
+  return uniqueStrings(
+    selectors.flatMap(
+      (selector) => [...document.querySelectorAll(selector)].map((node) => node.getAttribute("content")?.trim() ?? "").filter(Boolean)
+    )
+  );
+}
+function splitKeywords(value) {
+  return uniqueStrings(
+    (value ?? "").split(/[;,]/g).map((item) => item.trim()).filter(Boolean)
+  );
+}
+async function captureArticleMarkdown(rootDir, input, options, extra = { sourceType: "article" }) {
+  const resolved = await fetchResolvedText(input);
+  if (!resolved.contentType.includes("html")) {
+    throw new Error(`Unsupported article content type: ${resolved.contentType}`);
+  }
+  const dom = new JSDOM(resolved.text, { url: resolved.finalUrl });
+  const document = dom.window.document;
+  const canonicalHref = document.querySelector('link[rel="canonical"]')?.getAttribute("href")?.trim();
+  const canonicalUrl = canonicalHref ? normalizeOriginUrl(new URL(canonicalHref, resolved.finalUrl).toString()) : resolved.finalUrl;
+  const title = firstMetaContent(document, ['meta[name="citation_title"]', 'meta[property="og:title"]', 'meta[name="twitter:title"]']) ?? (document.title.trim() || canonicalUrl);
+  const authors = uniqueStrings([
+    ...metaContents(document, ['meta[name="citation_author"]']),
+    ...metaContents(document, ['meta[name="author"]', 'meta[property="article:author"]'])
+  ]);
+  const publishedAt = firstMetaContent(document, [
+    'meta[name="citation_publication_date"]',
+    'meta[name="citation_online_date"]',
+    'meta[property="article:published_time"]',
+    'meta[name="pubdate"]'
+  ]);
+  const updatedAt = firstMetaContent(document, ['meta[property="article:modified_time"]', 'meta[name="lastmod"]']);
+  const tags = uniqueStrings([
+    ...metaContents(document, ['meta[property="article:tag"]']),
+    ...splitKeywords(firstMetaContent(document, ['meta[name="keywords"]']))
+  ]);
+  const inferredDoi = extra.doi ?? firstMetaContent(document, ['meta[name="citation_doi"]', 'meta[name="dc.identifier"]'])?.replace(/^doi:\s*/i, "") ?? void 0;
+  const normalizedOptions = normalizeIngestOptions(options);
+  const prepared = await prepareUrlInput(rootDir, canonicalUrl, normalizedOptions);
+  if (prepared.sourceKind !== "markdown" && prepared.sourceKind !== "text") {
+    throw new Error(`Unsupported prepared article kind: ${prepared.sourceKind}`);
+  }
+  const body = prepared.extractedText ?? prepared.payloadBytes.toString("utf8");
+  const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const markdown = [
+    ...markdownFrontmatter({
+      source_type: extra.sourceType,
+      source_url: extra.sourceUrl ?? input,
+      canonical_url: canonicalUrl,
+      title,
+      authors,
+      published_at: publishedAt,
+      updated_at: updatedAt,
+      doi: inferredDoi,
+      tags,
+      author: options.author,
+      contributor: options.contributor,
+      captured_at: capturedAt
+    }),
+    body.trim(),
+    "",
+    "## Source",
+    "",
+    `- URL: ${canonicalUrl}`,
+    ...extra.sourceType === "doi" && inferredDoi ? [`- DOI: ${inferredDoi}`] : [],
+    ""
+  ].join("\n");
+  return {
+    title,
+    normalizedUrl: canonicalUrl,
+    markdown,
+    attachments: prepared.attachments
+  };
+}
+async function captureDoiMarkdown(rootDir, input, options) {
+  const doi = doiFromInput(input);
+  if (!doi) {
+    throw new Error(`Could not determine a DOI from ${input}`);
+  }
+  return captureArticleMarkdown(rootDir, `https://doi.org/${encodeURIComponent(doi)}`, options, {
+    sourceType: "doi",
+    sourceUrl: input,
+    doi
+  });
+}
 function manifestMatchesOrigin(manifest, prepared) {
   if (prepared.originType === "url") {
     return Boolean(prepared.url && manifest.url && normalizeOriginUrl(manifest.url) === normalizeOriginUrl(prepared.url));
@@ -3231,7 +3593,7 @@ function buildCompositeHash(payloadBytes, attachments = []) {
   return sha256(`${sha256(payloadBytes)}|${attachmentSignature}`);
 }
 function sanitizeAssetRelativePath(value) {
-  const normalized = path8.posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = path9.posix.normalize(value.replace(/\\/g, "/"));
   const segments = normalized.split("/").filter(Boolean).map((segment) => {
     if (segment === ".") {
       return "";
@@ -3251,7 +3613,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("#") || path8.isAbsolute(candidate)) {
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path9.isAbsolute(candidate)) {
     return null;
   }
   return candidate.replace(/\\/g, "/");
@@ -3313,12 +3675,12 @@ async function convertHtmlToMarkdown(html, url) {
   };
 }
 async function readManifestByHash(manifestsDir, contentHash) {
-  const entries = await fs8.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs9.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path8.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path9.join(manifestsDir, entry.name));
     if (manifest?.contentHash === contentHash) {
       return manifest;
     }
@@ -3326,12 +3688,12 @@ async function readManifestByHash(manifestsDir, contentHash) {
   return null;
 }
 async function readManifestByOrigin(manifestsDir, prepared) {
-  const entries = await fs8.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs9.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path8.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path9.join(manifestsDir, entry.name));
     if (manifest && manifestMatchesOrigin(manifest, prepared)) {
       return manifest;
     }
@@ -3342,12 +3704,12 @@ async function loadGitignoreMatcher(repoRoot, enabled) {
   if (!enabled) {
     return null;
   }
-  const gitignorePath = path8.join(repoRoot, ".gitignore");
+  const gitignorePath = path9.join(repoRoot, ".gitignore");
   if (!await fileExists(gitignorePath)) {
     return null;
   }
   const matcher = ignore();
-  matcher.add(await fs8.readFile(gitignorePath, "utf8"));
+  matcher.add(await fs9.readFile(gitignorePath, "utf8"));
   return matcher;
 }
 function builtInIgnoreReason(relativePath) {
@@ -3368,23 +3730,23 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
     if (!currentDir) {
       continue;
     }
-    const entries = await fs8.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs9.readdir(currentDir, { withFileTypes: true });
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const absolutePath = path8.join(currentDir, entry.name);
-      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path8.relative(inputDir, absolutePath));
+      const absolutePath = path9.join(currentDir, entry.name);
+      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path9.relative(inputDir, absolutePath));
       const relativePath = relativeToRepo || entry.name;
       const builtInReason = builtInIgnoreReason(relativePath);
       if (builtInReason) {
-        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: builtInReason });
+        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: builtInReason });
         continue;
       }
       if (matcher?.ignores(relativePath)) {
-        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "gitignore" });
+        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "gitignore" });
         continue;
       }
       if (matchesAnyGlob(relativePath, options.exclude)) {
-        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "exclude_glob" });
+        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "exclude_glob" });
         continue;
       }
       if (entry.isDirectory()) {
@@ -3392,21 +3754,21 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
         continue;
       }
       if (!entry.isFile()) {
-        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
+        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
         continue;
       }
       if (options.include.length > 0 && !matchesAnyGlob(relativePath, options.include)) {
-        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "include_glob" });
+        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "include_glob" });
         continue;
       }
       const mimeType = guessMimeType(absolutePath);
       const sourceKind = inferKind(mimeType, absolutePath);
       if (!supportedDirectoryKind(sourceKind)) {
-        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
         continue;
       }
       if (files.length >= options.maxFiles) {
-        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "max_files" });
+        skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "max_files" });
         continue;
       }
       files.push(absolutePath);
@@ -3428,12 +3790,12 @@ function resolveUrlMimeType(input, response) {
 function buildRemoteAssetRelativePath(assetUrl, mimeType) {
   const url = new URL(assetUrl);
   const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
-  const extension = path8.posix.extname(normalized);
-  const directory = path8.posix.dirname(normalized);
-  const basename = extension ? path8.posix.basename(normalized, extension) : path8.posix.basename(normalized);
+  const extension = path9.posix.extname(normalized);
+  const directory = path9.posix.dirname(normalized);
+  const basename = extension ? path9.posix.basename(normalized, extension) : path9.posix.basename(normalized);
   const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
   const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
-  return directory === "." ? hashedName : path8.posix.join(directory, hashedName);
+  return directory === "." ? hashedName : path9.posix.join(directory, hashedName);
 }
 async function readResponseBytesWithinLimit(response, maxBytes) {
   const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
@@ -3557,9 +3919,10 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   await ensureDir(paths.extractsDir);
   const attachments = prepared.attachments ?? [];
   const contentHash = prepared.contentHash ?? buildCompositeHash(prepared.payloadBytes, attachments);
+  const extractionHash = prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact);
   const existingByOrigin = await readManifestByOrigin(paths.manifestsDir, prepared);
   const existingByHash = existingByOrigin ? null : await readManifestByHash(paths.manifestsDir, contentHash);
-  if (existingByOrigin && existingByOrigin.contentHash === contentHash && existingByOrigin.title === prepared.title && existingByOrigin.sourceKind === prepared.sourceKind && existingByOrigin.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath) {
+  if (existingByOrigin && existingByOrigin.contentHash === contentHash && existingByOrigin.extractionHash === extractionHash && existingByOrigin.title === prepared.title && existingByOrigin.sourceKind === prepared.sourceKind && existingByOrigin.sourceType === prepared.sourceType && existingByOrigin.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath) {
     return { manifest: existingByOrigin, isNew: false, wasUpdated: false };
   }
   if (existingByHash) {
@@ -3568,27 +3931,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 = path8.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
-  const extractedTextPath = prepared.extractedText ? path8.join(paths.extractsDir, `${sourceId}.md`) : void 0;
-  const attachmentsDir = path8.join(paths.rawAssetsDir, sourceId);
+  const storedPath = path9.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
+  const extractedTextPath = prepared.extractedText ? path9.join(paths.extractsDir, `${sourceId}.md`) : void 0;
+  const extractedMetadataPath = prepared.extractionArtifact ? path9.join(paths.extractsDir, `${sourceId}.json`) : void 0;
+  const attachmentsDir = path9.join(paths.rawAssetsDir, sourceId);
   if (previous?.storedPath) {
-    await fs8.rm(path8.resolve(rootDir, previous.storedPath), { force: true });
+    await fs9.rm(path9.resolve(rootDir, previous.storedPath), { force: true });
   }
   if (previous?.extractedTextPath) {
-    await fs8.rm(path8.resolve(rootDir, previous.extractedTextPath), { force: true });
+    await fs9.rm(path9.resolve(rootDir, previous.extractedTextPath), { force: true });
+  }
+  if (previous?.extractedMetadataPath) {
+    await fs9.rm(path9.resolve(rootDir, previous.extractedMetadataPath), { force: true });
   }
-  await fs8.rm(attachmentsDir, { recursive: true, force: true });
-  await fs8.writeFile(storedPath, prepared.payloadBytes);
+  await fs9.rm(attachmentsDir, { recursive: true, force: true });
+  await fs9.writeFile(storedPath, prepared.payloadBytes);
   if (prepared.extractedText && extractedTextPath) {
-    await fs8.writeFile(extractedTextPath, prepared.extractedText, "utf8");
+    await fs9.writeFile(extractedTextPath, prepared.extractedText, "utf8");
+  }
+  if (prepared.extractionArtifact && extractedMetadataPath) {
+    await writeJsonFile(extractedMetadataPath, prepared.extractionArtifact);
   }
   const manifestAttachments = [];
   for (const attachment of attachments) {
-    const absoluteAttachmentPath = path8.join(attachmentsDir, attachment.relativePath);
-    await ensureDir(path8.dirname(absoluteAttachmentPath));
-    await fs8.writeFile(absoluteAttachmentPath, attachment.bytes);
+    const absoluteAttachmentPath = path9.join(attachmentsDir, attachment.relativePath);
+    await ensureDir(path9.dirname(absoluteAttachmentPath));
+    await fs9.writeFile(absoluteAttachmentPath, attachment.bytes);
     manifestAttachments.push({
-      path: toPosix(path8.relative(rootDir, absoluteAttachmentPath)),
+      path: toPosix(path9.relative(rootDir, absoluteAttachmentPath)),
       mimeType: attachment.mimeType,
       originalPath: attachment.originalPath
     });
@@ -3598,19 +3968,22 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     title: prepared.title,
     originType: prepared.originType,
     sourceKind: prepared.sourceKind,
+    sourceType: prepared.sourceType,
     language: prepared.language,
     originalPath: prepared.originalPath,
     repoRelativePath: prepared.repoRelativePath,
     url: prepared.url,
-    storedPath: toPosix(path8.relative(rootDir, storedPath)),
-    extractedTextPath: extractedTextPath ? toPosix(path8.relative(rootDir, extractedTextPath)) : void 0,
+    storedPath: toPosix(path9.relative(rootDir, storedPath)),
+    extractedTextPath: extractedTextPath ? toPosix(path9.relative(rootDir, extractedTextPath)) : void 0,
+    extractedMetadataPath: extractedMetadataPath ? toPosix(path9.relative(rootDir, extractedMetadataPath)) : void 0,
+    extractionHash,
     mimeType: prepared.mimeType,
     contentHash,
     createdAt: previous?.createdAt ?? now,
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
   };
-  await writeJsonFile(path8.join(paths.manifestsDir, `${sourceId}.json`), manifest);
+  await writeJsonFile(path9.join(paths.manifestsDir, `${sourceId}.json`), manifest);
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
@@ -3628,13 +4001,16 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   return { manifest, isNew: !previous, wasUpdated: Boolean(previous) };
 }
 async function removeManifestArtifacts(rootDir, manifest, paths) {
-  await fs8.rm(path8.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
-  await fs8.rm(path8.resolve(rootDir, manifest.storedPath), { force: true });
+  await fs9.rm(path9.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
+  await fs9.rm(path9.resolve(rootDir, manifest.storedPath), { force: true });
   if (manifest.extractedTextPath) {
-    await fs8.rm(path8.resolve(rootDir, manifest.extractedTextPath), { force: true });
+    await fs9.rm(path9.resolve(rootDir, manifest.extractedTextPath), { force: true });
+  }
+  if (manifest.extractedMetadataPath) {
+    await fs9.rm(path9.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
   }
-  await fs8.rm(path8.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
-  await fs8.rm(path8.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
+  await fs9.rm(path9.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
+  await fs9.rm(path9.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
 }
 function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
   const candidates = [
@@ -3643,14 +4019,14 @@ function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path8.join(rootDir, ".claude"),
-    path8.join(rootDir, ".cursor"),
-    path8.join(rootDir, ".obsidian")
+    path9.join(rootDir, ".claude"),
+    path9.join(rootDir, ".cursor"),
+    path9.join(rootDir, ".obsidian")
   ];
-  return candidates.map((candidate) => path8.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
+  return candidates.map((candidate) => path9.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.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
+  return manifest.contentHash === contentHash && manifest.extractionHash === (prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact)) && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.sourceType === prepared.sourceType && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
 }
 function shouldDeferWatchSemanticRefresh(sourceKind) {
   return sourceKind === "markdown" || sourceKind === "text" || sourceKind === "html" || sourceKind === "pdf" || sourceKind === "image";
@@ -3669,16 +4045,16 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
   const normalizedOptions = normalizeIngestOptions(options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path8.resolve(item)
+    (item) => path9.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(path8.resolve(repoRoot))) {
+    if (!repoRoot || !uniqueRoots.includes(path9.resolve(repoRoot))) {
       continue;
     }
-    const key = path8.resolve(repoRoot);
+    const key = path9.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -3703,12 +4079,12 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     skipped.push(
       ...collected.skipped,
       ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
-        path: toPosix(path8.relative(rootDir, absolutePath)),
+        path: toPosix(path9.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
-    const currentPaths = new Set(files.map((absolutePath) => path8.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path9.resolve(absolutePath)));
     for (const absolutePath of files) {
       const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
       const result = await persistPreparedInput(rootDir, prepared, paths);
@@ -3719,7 +4095,7 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
       }
     }
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path8.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path9.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         await removeManifestArtifacts(rootDir, manifest, paths);
         removed.push(manifest);
@@ -3727,7 +4103,7 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     }
   }
   if (uniqueRoots.length > 0) {
-    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path8.relative(rootDir, repoRoot)) || ".").join(","), [
+    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path9.relative(rootDir, repoRoot)) || ".").join(","), [
       `repo_roots=${uniqueRoots.length}`,
       `scanned=${scannedCount}`,
       `imported=${imported.length}`,
@@ -3750,16 +4126,16 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   const normalizedOptions = normalizeIngestOptions(options);
   const manifests = await listManifests(rootDir);
   const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
-    (item) => path8.resolve(item)
+    (item) => path9.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(path8.resolve(repoRoot))) {
+    if (!repoRoot || !uniqueRoots.includes(path9.resolve(repoRoot))) {
       continue;
     }
-    const key = path8.resolve(repoRoot);
+    const key = path9.resolve(repoRoot);
     const bucket = manifestsByRepoRoot.get(key) ?? [];
     bucket.push(manifest);
     manifestsByRepoRoot.set(key, bucket);
@@ -3774,7 +4150,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) => [path8.resolve(manifest.originalPath), manifest])
+      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path9.resolve(manifest.originalPath), manifest])
     );
     if (!await fileExists(repoRoot)) {
       for (const manifest of repoManifests) {
@@ -3782,7 +4158,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
           pendingSemanticRefresh.push({
             id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? manifest.storedPath),
             repoRoot,
-            path: toPosix(path8.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
+            path: toPosix(path9.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -3802,16 +4178,16 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     skipped.push(
       ...collected.skipped,
       ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
-        path: toPosix(path8.relative(rootDir, absolutePath)),
+        path: toPosix(path9.relative(rootDir, absolutePath)),
         reason: "workspace_generated"
       }))
     );
     scannedCount += files.length;
-    const currentPaths = new Set(files.map((absolutePath) => path8.resolve(absolutePath)));
+    const currentPaths = new Set(files.map((absolutePath) => path9.resolve(absolutePath)));
     for (const absolutePath of files) {
       const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
       if (shouldDeferWatchSemanticRefresh(prepared.sourceKind)) {
-        const existing = manifestsByOriginalPath.get(path8.resolve(absolutePath));
+        const existing = manifestsByOriginalPath.get(path9.resolve(absolutePath));
         const contentHash = buildCompositeHash(prepared.payloadBytes, prepared.attachments);
         const changed = !existing || !preparedMatchesManifest(existing, prepared, contentHash);
         if (changed) {
@@ -3819,10 +4195,10 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
             id: pendingSemanticRefreshId(
               existing ? "modified" : "added",
               repoRoot,
-              prepared.repoRelativePath ?? toPosix(path8.relative(repoRoot, absolutePath))
+              prepared.repoRelativePath ?? toPosix(path9.relative(repoRoot, absolutePath))
             ),
             repoRoot,
-            path: toPosix(path8.relative(rootDir, absolutePath)),
+            path: toPosix(path9.relative(rootDir, absolutePath)),
             changeType: existing ? "modified" : "added",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: existing?.sourceId,
@@ -3842,13 +4218,13 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
       }
     }
     for (const manifest of repoManifests) {
-      const originalPath = manifest.originalPath ? path8.resolve(manifest.originalPath) : null;
+      const originalPath = manifest.originalPath ? path9.resolve(manifest.originalPath) : null;
       if (originalPath && !currentPaths.has(originalPath)) {
         if (shouldDeferWatchSemanticRefresh(manifest.sourceKind)) {
           pendingSemanticRefresh.push({
-            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path8.relative(repoRoot, originalPath))),
+            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path9.relative(repoRoot, originalPath))),
             repoRoot,
-            path: toPosix(path8.relative(rootDir, originalPath)),
+            path: toPosix(path9.relative(rootDir, originalPath)),
             changeType: "removed",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceId: manifest.sourceId,
@@ -3866,7 +4242,7 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     await appendLogEntry(
       rootDir,
       "sync_repo_watch",
-      uniqueRoots.map((repoRoot) => toPosix(path8.relative(rootDir, repoRoot)) || ".").join(","),
+      uniqueRoots.map((repoRoot) => toPosix(path9.relative(rootDir, repoRoot)) || ".").join(","),
       [
         `repo_roots=${uniqueRoots.length}`,
         `scanned=${scannedCount}`,
@@ -3891,19 +4267,36 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     staleSourceIds: [...staleSourceIds]
   };
 }
-async function prepareFileInput(_rootDir, absoluteInput, repoRoot) {
-  const payloadBytes = await fs8.readFile(absoluteInput);
+async function prepareFileInput(rootDir, absoluteInput, repoRoot) {
+  const payloadBytes = await fs9.readFile(absoluteInput);
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
   const language = inferCodeLanguage(absoluteInput, mimeType);
-  const storedExtension = path8.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
+  const storedExtension = path9.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
   let title;
   let extractedText;
+  let extractionArtifact;
   if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
     extractedText = payloadBytes.toString("utf8");
-    title = titleFromText(path8.basename(absoluteInput, path8.extname(absoluteInput)), extractedText);
+    title = titleFromText(path9.basename(absoluteInput, path9.extname(absoluteInput)), extractedText);
+    extractionArtifact = createPlainTextExtractionArtifact(sourceKind, mimeType);
+  } else if (sourceKind === "pdf") {
+    title = path9.basename(absoluteInput, path9.extname(absoluteInput));
+    const extracted = await extractPdfText({ mimeType, bytes: payloadBytes });
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "image") {
+    title = path9.basename(absoluteInput, path9.extname(absoluteInput));
+    const extracted = await extractImageWithVision(rootDir, {
+      title,
+      mimeType,
+      filePath: absoluteInput
+    });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
   } else {
-    title = path8.basename(absoluteInput, path8.extname(absoluteInput));
+    title = path9.basename(absoluteInput, path9.extname(absoluteInput));
   }
   return {
     title,
@@ -3915,15 +4308,18 @@ async function prepareFileInput(_rootDir, absoluteInput, repoRoot) {
     mimeType,
     storedExtension,
     payloadBytes,
-    extractedText
+    extractedText,
+    extractionArtifact,
+    extractionHash: buildExtractionHash(extractedText, extractionArtifact)
   };
 }
-async function prepareUrlInput(input, options) {
+async function prepareUrlInput(rootDir, input, options) {
   const response = await fetch(input);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${input}: ${response.status} ${response.statusText}`);
   }
-  const inputUrl = new URL(input);
+  const finalUrl = normalizeOriginUrl(response.url || input);
+  const inputUrl = new URL(finalUrl);
   const originalPayloadBytes = Buffer.from(await response.arrayBuffer());
   let payloadBytes = originalPayloadBytes;
   let mimeType = resolveUrlMimeType(input, response);
@@ -3932,18 +4328,19 @@ async function prepareUrlInput(input, options) {
   let storedExtension = ".bin";
   let title = inputUrl.hostname + inputUrl.pathname;
   let extractedText;
+  let extractionArtifact;
   let attachments;
   let contentHash;
   const logDetails = [];
   if (sourceKind === "html" || mimeType.startsWith("text/html")) {
     const html = originalPayloadBytes.toString("utf8");
-    const initialConversion = await convertHtmlToMarkdown(html, input);
+    const initialConversion = await convertHtmlToMarkdown(html, finalUrl);
     title = initialConversion.title;
     let localizedHtml = html;
     let localAssetReplacements;
     if (options.includeAssets) {
       const { attachments: remoteAttachments, skippedCount } = await collectRemoteImageAttachments(
-        extractHtmlImageReferences(html, input),
+        extractHtmlImageReferences(html, finalUrl),
         options
       );
       if (remoteAttachments.length) {
@@ -3953,18 +4350,19 @@ async function prepareUrlInput(input, options) {
         localAssetReplacements = new Map(
           remoteAttachments.map((attachment) => [attachment.originalPath ?? "", `../assets/${sourceId}/${attachment.relativePath}`])
         );
-        localizedHtml = rewriteHtmlImageReferences(html, input, localAssetReplacements);
+        localizedHtml = rewriteHtmlImageReferences(html, finalUrl, localAssetReplacements);
         logDetails.push(`remote_assets=${remoteAttachments.length}`);
       }
       if (skippedCount) {
         logDetails.push(`remote_asset_skips=${skippedCount}`);
       }
     }
-    const converted = localizedHtml === html && !attachments?.length ? initialConversion : await convertHtmlToMarkdown(localizedHtml, input);
+    const converted = localizedHtml === html && !attachments?.length ? initialConversion : await convertHtmlToMarkdown(localizedHtml, finalUrl);
     extractedText = converted.markdown;
+    extractionArtifact = createHtmlReadabilityExtractionArtifact("markdown", "text/markdown");
     if (localAssetReplacements?.size) {
       const absoluteLocalAssetReplacements = new Map(
-        [...localAssetReplacements.values()].map((replacement) => [new URL(replacement, input).toString(), replacement])
+        [...localAssetReplacements.values()].map((replacement) => [new URL(replacement, finalUrl).toString(), replacement])
       );
       extractedText = rewriteMarkdownImageTargets(extractedText, absoluteLocalAssetReplacements);
     }
@@ -3973,14 +4371,15 @@ async function prepareUrlInput(input, options) {
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path8.extname(inputUrl.pathname);
+    const extension = path9.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = payloadBytes.toString("utf8");
       title = titleFromText(title || inputUrl.hostname, extractedText);
+      extractionArtifact = createPlainTextExtractionArtifact(sourceKind, mimeType);
       if (sourceKind === "markdown" && options.includeAssets) {
         const { attachments: remoteAttachments, skippedCount } = await collectRemoteImageAttachments(
-          extractMarkdownImageReferences(extractedText, input),
+          extractMarkdownImageReferences(extractedText, finalUrl),
           options
         );
         if (remoteAttachments.length) {
@@ -3990,7 +4389,7 @@ async function prepareUrlInput(input, options) {
           const replacements = new Map(
             remoteAttachments.map((attachment) => [attachment.originalPath ?? "", `../assets/${sourceId}/${attachment.relativePath}`])
           );
-          extractedText = rewriteMarkdownImageReferences(extractedText, input, replacements);
+          extractedText = rewriteMarkdownImageReferences(extractedText, finalUrl, replacements);
           payloadBytes = Buffer.from(extractedText, "utf8");
           logDetails.push(`remote_assets=${remoteAttachments.length}`);
         }
@@ -3998,6 +4397,19 @@ async function prepareUrlInput(input, options) {
           logDetails.push(`remote_asset_skips=${skippedCount}`);
         }
       }
+    } else if (sourceKind === "pdf") {
+      const extracted = await extractPdfText({ mimeType, bytes: payloadBytes });
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "image") {
+      const extracted = await extractImageWithVision(rootDir, {
+        title,
+        mimeType,
+        bytes: payloadBytes
+      });
+      title = extracted.title?.trim() || title;
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
     }
   }
   return {
@@ -4005,11 +4417,13 @@ async function prepareUrlInput(input, options) {
     originType: "url",
     sourceKind,
     language,
-    url: input,
+    url: finalUrl,
     mimeType,
     storedExtension,
     payloadBytes,
     extractedText,
+    extractionArtifact,
+    extractionHash: buildExtractionHash(extractedText, extractionArtifact),
     attachments,
     contentHash,
     logDetails
@@ -4023,14 +4437,14 @@ async function collectInboxAttachmentRefs(inputDir, files) {
     if (sourceKind !== "markdown") {
       continue;
     }
-    const content = await fs8.readFile(absolutePath, "utf8");
+    const content = await fs9.readFile(absolutePath, "utf8");
     const refs = extractMarkdownReferences(content);
     if (!refs.length) {
       continue;
     }
     const sourceRefs = [];
     for (const ref of refs) {
-      const resolved = path8.resolve(path8.dirname(absolutePath), ref);
+      const resolved = path9.resolve(path9.dirname(absolutePath), ref);
       if (!resolved.startsWith(inputDir) || !await fileExists(resolved)) {
         continue;
       }
@@ -4064,12 +4478,12 @@ function rewriteMarkdownReferences(content, replacements) {
   });
 }
 async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs8.readFile(absolutePath);
+  const originalBytes = await fs9.readFile(absolutePath);
   const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path8.basename(absolutePath, path8.extname(absolutePath)), originalText);
+  const title = titleFromText(path9.basename(absolutePath, path9.extname(absolutePath)), originalText);
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
-    const bytes = await fs8.readFile(attachmentRef.absolutePath);
+    const bytes = await fs9.readFile(attachmentRef.absolutePath);
     attachments.push({
       relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
       mimeType: guessMimeType(attachmentRef.absolutePath),
@@ -4086,15 +4500,18 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     ])
   );
   const rewrittenText = rewriteMarkdownReferences(originalText, replacements);
+  const extractionArtifact = createPlainTextExtractionArtifact("markdown", "text/markdown");
   return {
     title,
     originType: "file",
     sourceKind: "markdown",
     originalPath: toPosix(absolutePath),
     mimeType: "text/markdown",
-    storedExtension: path8.extname(absolutePath) || ".md",
+    storedExtension: path9.extname(absolutePath) || ".md",
     payloadBytes: Buffer.from(rewrittenText, "utf8"),
     extractedText: rewrittenText,
+    extractionArtifact,
+    extractionHash: buildExtractionHash(rewrittenText, extractionArtifact),
     attachments,
     contentHash
   };
@@ -4105,16 +4522,16 @@ function isSupportedInboxKind(sourceKind) {
 async function ingestInput(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInput = path8.resolve(rootDir, input);
-  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path8.dirname(absoluteInput));
-  const prepared = isHttpUrl(input) ? await prepareUrlInput(input, normalizedOptions) : await prepareFileInput(rootDir, absoluteInput, repoRoot);
+  const absoluteInput = path9.resolve(rootDir, input);
+  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path9.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;
 }
 async function addInput(rootDir, input, options = {}) {
   const { paths } = await initWorkspace(rootDir);
-  if (!isHttpUrl(input) && !arxivIdFromInput(input)) {
-    throw new Error("`swarmvault add` only supports URLs and bare arXiv ids in the current release.");
+  if (!isHttpUrl(input) && !arxivIdFromInput(input) && !doiFromInput(input)) {
+    throw new Error("`swarmvault add` only supports URLs, bare arXiv ids, and bare DOI strings in the current release.");
   }
   let prepared = null;
   let captureType = "url";
@@ -4127,26 +4544,55 @@ async function addInput(rootDir, input, options = {}) {
         title: captured.title,
         url: captured.normalizedUrl,
         markdown: captured.markdown,
+        sourceType: "arxiv",
         logDetails: ["capture_type=arxiv"]
       });
       captureType = "arxiv";
       normalizedUrl = captured.normalizedUrl;
+    } else if (doiFromInput(input)) {
+      const captured = await captureDoiMarkdown(rootDir, input, options);
+      prepared = prepareCapturedMarkdownInput({
+        title: captured.title,
+        url: captured.normalizedUrl,
+        markdown: captured.markdown,
+        sourceType: "doi",
+        attachments: captured.attachments,
+        logDetails: ["capture_type=doi"]
+      });
+      captureType = "doi";
+      normalizedUrl = captured.normalizedUrl;
     } else if (isTweetUrl(input)) {
       const captured = await captureTweetMarkdown(input, options);
       prepared = prepareCapturedMarkdownInput({
         title: captured.title,
         url: captured.normalizedUrl,
         markdown: captured.markdown,
+        sourceType: "tweet",
         logDetails: ["capture_type=tweet"]
       });
       captureType = "tweet";
       normalizedUrl = captured.normalizedUrl;
+    } else if (isHttpUrl(input)) {
+      const captured = await captureArticleMarkdown(rootDir, input, options, {
+        sourceType: "article",
+        sourceUrl: input
+      });
+      prepared = prepareCapturedMarkdownInput({
+        title: captured.title,
+        url: captured.normalizedUrl,
+        markdown: captured.markdown,
+        sourceType: "article",
+        attachments: captured.attachments,
+        logDetails: ["capture_type=article"]
+      });
+      captureType = "article";
+      normalizedUrl = captured.normalizedUrl;
     }
   } catch {
     fallback = true;
   }
   if (!prepared) {
-    normalizedUrl = arxivIdFromInput(input) ? `https://arxiv.org/abs/${arxivIdFromInput(input)}` : normalizeOriginUrl(input);
+    normalizedUrl = arxivIdFromInput(input) ? `https://arxiv.org/abs/${arxivIdFromInput(input)}` : doiFromInput(input) ? `https://doi.org/${encodeURIComponent(doiFromInput(input) ?? "")}` : normalizeOriginUrl(input);
     return {
       captureType: "url",
       manifest: await ingestInput(rootDir, normalizedUrl, options),
@@ -4167,7 +4613,7 @@ async function addInput(rootDir, input, options = {}) {
 async function ingestDirectory(rootDir, inputDir, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInputDir = path8.resolve(rootDir, inputDir);
+  const absoluteInputDir = path9.resolve(rootDir, inputDir);
   const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot2(absoluteInputDir) ?? absoluteInputDir;
   if (!await fileExists(absoluteInputDir)) {
     throw new Error(`Directory not found: ${absoluteInputDir}`);
@@ -4183,11 +4629,11 @@ async function ingestDirectory(rootDir, inputDir, options) {
     } else if (result.wasUpdated) {
       updated.push(result.manifest);
     } else {
-      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "duplicate_content" });
     }
   }
-  await appendLogEntry(rootDir, "ingest_directory", toPosix(path8.relative(rootDir, absoluteInputDir)) || ".", [
-    `repo_root=${toPosix(path8.relative(rootDir, repoRoot)) || "."}`,
+  await appendLogEntry(rootDir, "ingest_directory", toPosix(path9.relative(rootDir, absoluteInputDir)) || ".", [
+    `repo_root=${toPosix(path9.relative(rootDir, repoRoot)) || "."}`,
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `updated=${updated.length}`,
@@ -4204,7 +4650,7 @@ async function ingestDirectory(rootDir, inputDir, options) {
 }
 async function importInbox(rootDir, inputDir) {
   const { paths } = await initWorkspace(rootDir);
-  const effectiveInputDir = path8.resolve(rootDir, inputDir ?? paths.inboxDir);
+  const effectiveInputDir = path9.resolve(rootDir, inputDir ?? paths.inboxDir);
   if (!await fileExists(effectiveInputDir)) {
     throw new Error(`Inbox directory not found: ${effectiveInputDir}`);
   }
@@ -4215,31 +4661,31 @@ async function importInbox(rootDir, inputDir) {
   const skipped = [];
   let attachmentCount = 0;
   for (const absolutePath of files) {
-    const basename = path8.basename(absolutePath);
+    const basename = path9.basename(absolutePath);
     if (basename.startsWith(".")) {
-      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "hidden_file" });
+      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "hidden_file" });
       continue;
     }
     if (claimedAttachments.has(absolutePath)) {
-      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
+      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
     if (!isSupportedInboxKind(sourceKind)) {
-      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
       continue;
     }
     const prepared = sourceKind === "markdown" && refsBySource.has(absolutePath) ? await prepareInboxMarkdownInput(absolutePath, refsBySource.get(absolutePath) ?? []) : await prepareFileInput(rootDir, absolutePath);
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (!result.isNew) {
-      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path9.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
     attachmentCount += result.manifest.attachments?.length ?? 0;
     imported.push(result.manifest);
   }
-  await appendLogEntry(rootDir, "inbox_import", toPosix(path8.relative(rootDir, effectiveInputDir)) || ".", [
+  await appendLogEntry(rootDir, "inbox_import", toPosix(path9.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `attachments=${attachmentCount}`,
@@ -4258,9 +4704,9 @@ async function listManifests(rootDir) {
   if (!await fileExists(paths.manifestsDir)) {
     return [];
   }
-  const entries = await fs8.readdir(paths.manifestsDir);
+  const entries = await fs9.readdir(paths.manifestsDir);
   const manifests = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path8.join(paths.manifestsDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path9.join(paths.manifestsDir, entry)))
   );
   return manifests.filter((manifest) => Boolean(manifest));
 }
@@ -4268,28 +4714,38 @@ async function readExtractedText(rootDir, manifest) {
   if (!manifest.extractedTextPath) {
     return void 0;
   }
-  const absolutePath = path8.resolve(rootDir, manifest.extractedTextPath);
+  const absolutePath = path9.resolve(rootDir, manifest.extractedTextPath);
+  if (!await fileExists(absolutePath)) {
+    return void 0;
+  }
+  return fs9.readFile(absolutePath, "utf8");
+}
+async function readExtractionArtifact(rootDir, manifest) {
+  if (!manifest.extractedMetadataPath) {
+    return void 0;
+  }
+  const absolutePath = path9.resolve(rootDir, manifest.extractedMetadataPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
-  return fs8.readFile(absolutePath, "utf8");
+  return await readJsonFile(absolutePath) ?? void 0;
 }
 
 // src/mcp.ts
-import fs15 from "fs/promises";
-import path18 from "path";
+import fs16 from "fs/promises";
+import path19 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/schema.ts
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 function normalizeSchemaContent(content) {
   return content.trim() ? content.trim() : defaultVaultSchema().trim();
 }
 async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
-  const content = await fileExists(schemaPath) ? await fs9.readFile(schemaPath, "utf8") : fallback;
+  const content = await fileExists(schemaPath) ? await fs10.readFile(schemaPath, "utf8") : fallback;
   const normalized = normalizeSchemaContent(content);
   return {
     path: schemaPath,
@@ -4298,7 +4754,7 @@ async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
   };
 }
 function resolveProjectSchemaPath(rootDir, schemaPath) {
-  return path9.resolve(rootDir, schemaPath);
+  return path10.resolve(rootDir, schemaPath);
 }
 function composeVaultSchema(root, projectSchemas = []) {
   if (!projectSchemas.length) {
@@ -4314,7 +4770,7 @@ function composeVaultSchema(root, projectSchemas = []) {
       (schema) => [
         `## Project Schema`,
         "",
-        `Path: ${toPosix(path9.relative(path9.dirname(root.path), schema.path) || schema.path)}`,
+        `Path: ${toPosix(path10.relative(path10.dirname(root.path), schema.path) || schema.path)}`,
         "",
         schema.content
       ].join("\n")
@@ -4390,30 +4846,30 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs14 from "fs/promises";
-import path17 from "path";
-import matter8 from "gray-matter";
-import { z as z6 } from "zod";
+import fs15 from "fs/promises";
+import path18 from "path";
+import matter9 from "gray-matter";
+import { z as z7 } from "zod";
 
 // src/analysis.ts
-import path10 from "path";
-import { z } from "zod";
-var ANALYSIS_FORMAT_VERSION = 4;
-var sourceAnalysisSchema = z.object({
-  title: z.string().min(1),
-  summary: z.string().min(1),
-  concepts: z.array(z.object({ name: z.string().min(1), description: z.string().default("") })).max(12).default([]),
-  entities: z.array(z.object({ name: z.string().min(1), description: z.string().default("") })).max(12).default([]),
-  claims: z.array(
-    z.object({
-      text: z.string().min(1),
-      confidence: z.number().min(0).max(1).default(0.6),
-      status: z.enum(["extracted", "inferred", "conflicted", "stale"]).default("extracted"),
-      polarity: z.enum(["positive", "negative", "neutral"]).default("neutral"),
-      citation: z.string().min(1)
+import path11 from "path";
+import { z as z2 } from "zod";
+var ANALYSIS_FORMAT_VERSION = 5;
+var sourceAnalysisSchema = z2.object({
+  title: z2.string().min(1),
+  summary: z2.string().min(1),
+  concepts: z2.array(z2.object({ name: z2.string().min(1), description: z2.string().default("") })).max(12).default([]),
+  entities: z2.array(z2.object({ name: z2.string().min(1), description: z2.string().default("") })).max(12).default([]),
+  claims: z2.array(
+    z2.object({
+      text: z2.string().min(1),
+      confidence: z2.number().min(0).max(1).default(0.6),
+      status: z2.enum(["extracted", "inferred", "conflicted", "stale"]).default("extracted"),
+      polarity: z2.enum(["positive", "negative", "neutral"]).default("neutral"),
+      citation: z2.string().min(1)
     })
   ).max(8).default([]),
-  questions: z.array(z.string()).max(6).default([])
+  questions: z2.array(z2.string()).max(6).default([])
 });
 var STOPWORDS = /* @__PURE__ */ new Set([
   "about",
@@ -4502,6 +4958,7 @@ function heuristicAnalysis(manifest, text, schemaHash) {
     analysisVersion: ANALYSIS_FORMAT_VERSION,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
+    extractionHash: manifest.extractionHash,
     schemaHash,
     title: deriveTitle(manifest, text),
     summary: firstSentences(normalized, 3) || truncate(normalized, 280) || `Imported ${manifest.sourceKind} source.`,
@@ -4548,6 +5005,7 @@ ${truncate(text, 18e3)}`
     analysisVersion: ANALYSIS_FORMAT_VERSION,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
+    extractionHash: manifest.extractionHash,
     schemaHash: schema.hash,
     title: parsed.title,
     summary: parsed.summary,
@@ -4574,24 +5032,97 @@ ${truncate(text, 18e3)}`
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function analysisFromVisionExtraction(manifest, extraction, schemaHash) {
+  if (!extraction.vision) {
+    return null;
+  }
+  return {
+    analysisVersion: ANALYSIS_FORMAT_VERSION,
+    sourceId: manifest.sourceId,
+    sourceHash: manifest.contentHash,
+    extractionHash: manifest.extractionHash,
+    schemaHash,
+    title: extraction.vision.title?.trim() || manifest.title,
+    summary: extraction.vision.summary,
+    concepts: extraction.vision.concepts.map((term) => ({
+      id: `concept:${slugify(term.name)}`,
+      name: term.name,
+      description: term.description
+    })),
+    entities: extraction.vision.entities.map((term) => ({
+      id: `entity:${slugify(term.name)}`,
+      name: term.name,
+      description: term.description
+    })),
+    claims: extraction.vision.claims.map((claim, index) => ({
+      id: `claim:${manifest.sourceId}:${index + 1}`,
+      text: claim.text,
+      confidence: claim.confidence,
+      status: "extracted",
+      polarity: claim.polarity,
+      citation: manifest.sourceId
+    })),
+    questions: extraction.vision.questions,
+    rationales: [],
+    producedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function extractionWarningSummary(manifest, extraction) {
+  const warning = extraction?.warnings?.find(Boolean);
+  if (warning) {
+    return `Imported ${manifest.sourceKind} source. ${warning}`;
+  }
+  return `Imported ${manifest.sourceKind} source. Text extraction is not yet available for this source.`;
+}
 async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path10.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cachePath = path11.join(paths.analysesDir, `${manifest.sourceId}.json`);
   const cached = await readJsonFile(cachePath);
-  if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && cached.sourceHash === manifest.contentHash && cached.schemaHash === schema.hash) {
+  if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && cached.sourceHash === manifest.contentHash && cached.extractionHash === manifest.extractionHash && cached.schemaHash === schema.hash) {
     return cached;
   }
+  const extraction = await readExtractionArtifact(paths.rootDir, manifest);
   const content = normalizeWhitespace(extractedText ?? "");
   let analysis;
   if (manifest.sourceKind === "code" && content) {
     analysis = await analyzeCodeSource(manifest, extractedText ?? "", schema.hash);
+  } else if (manifest.sourceKind === "image") {
+    const visionAnalysis = extraction ? analysisFromVisionExtraction(manifest, extraction, schema.hash) : null;
+    if (visionAnalysis) {
+      analysis = visionAnalysis;
+    } else if (!content) {
+      analysis = {
+        analysisVersion: ANALYSIS_FORMAT_VERSION,
+        sourceId: manifest.sourceId,
+        sourceHash: manifest.contentHash,
+        extractionHash: manifest.extractionHash,
+        schemaHash: schema.hash,
+        title: manifest.title,
+        summary: extractionWarningSummary(manifest, extraction),
+        concepts: [],
+        entities: [],
+        claims: [],
+        questions: [],
+        rationales: [],
+        producedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } else if (provider.type === "heuristic") {
+      analysis = heuristicAnalysis(manifest, content, schema.hash);
+    } else {
+      try {
+        analysis = await providerAnalysis(manifest, content, provider, schema);
+      } catch {
+        analysis = heuristicAnalysis(manifest, content, schema.hash);
+      }
+    }
   } else if (!content) {
     analysis = {
       analysisVersion: ANALYSIS_FORMAT_VERSION,
       sourceId: manifest.sourceId,
       sourceHash: manifest.contentHash,
+      extractionHash: manifest.extractionHash,
       schemaHash: schema.hash,
       title: manifest.title,
-      summary: `Imported ${manifest.sourceKind} source. Text extraction is not yet available for this source.`,
+      summary: extractionWarningSummary(manifest, extraction),
       concepts: [],
       entities: [],
       claims: [],
@@ -4624,6 +5155,7 @@ var DEFAULT_BENCHMARK_QUESTIONS = [
   "Where are the biggest knowledge gaps?",
   "What evidence should I read first?"
 ];
+var RESEARCH_BENCHMARK_QUESTION = "Which research sources should I read first, and why?";
 function nodeMap(graph) {
   return new Map(graph.nodes.map((node) => [node.id, node]));
 }
@@ -4673,9 +5205,68 @@ function benchmarkQueryTokens(graph, queryResult, pageContentsById) {
     queryTokens,
     reduction: 0,
     visitedNodeIds: queryResult.visitedNodeIds,
+    visitedEdgeIds: queryResult.visitedEdgeIds,
     pageIds: queryResult.pageIds
   };
 }
+function graphHash(graph) {
+  const hashedPages = graph.pages.filter((page) => page.kind !== "graph_report" && page.kind !== "community_summary");
+  const normalized = JSON.stringify(
+    {
+      nodes: [...graph.nodes].map((node) => ({
+        id: node.id,
+        type: node.type,
+        label: node.label,
+        pageId: node.pageId ?? null,
+        communityId: node.communityId ?? null,
+        degree: node.degree ?? null,
+        bridgeScore: node.bridgeScore ?? null,
+        isGodNode: node.isGodNode ?? false,
+        sourceIds: [...node.sourceIds].sort(),
+        projectIds: [...node.projectIds].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id)),
+      edges: [...graph.edges].map((edge) => ({
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+        relation: edge.relation,
+        status: edge.status,
+        evidenceClass: edge.evidenceClass,
+        confidence: edge.confidence,
+        provenance: [...edge.provenance].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id)),
+      pages: [...hashedPages].map((page) => ({
+        id: page.id,
+        path: page.path,
+        kind: page.kind,
+        status: page.status,
+        sourceType: page.sourceType ?? null,
+        sourceIds: [...page.sourceIds].sort(),
+        projectIds: [...page.projectIds].sort(),
+        nodeIds: [...page.nodeIds].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id)),
+      communities: [...graph.communities ?? []].map((community) => ({
+        id: community.id,
+        label: community.label,
+        nodeIds: [...community.nodeIds].sort()
+      })).sort((left, right) => left.id.localeCompare(right.id))
+    },
+    null,
+    0
+  );
+  return sha256(normalized);
+}
+function hasResearchSources(pages) {
+  return pages.some((page) => page.kind === "source" && Boolean(page.sourceType) && page.sourceType !== "url");
+}
+function defaultBenchmarkQuestionsForGraph(graph, maxQuestions = 3) {
+  const normalizedLimit = Math.max(1, Math.min(maxQuestions, DEFAULT_BENCHMARK_QUESTIONS.length));
+  const questions = [...DEFAULT_BENCHMARK_QUESTIONS];
+  if (hasResearchSources(graph.pages)) {
+    questions.unshift(RESEARCH_BENCHMARK_QUESTION);
+  }
+  return uniqueBy(questions, (item) => item).slice(0, normalizedLimit);
+}
 function buildBenchmarkArtifact(input) {
   const corpusTokens = Math.max(1, Math.round(input.corpusWords * (100 / 75)));
   const perQuestion = input.perQuestion.filter((entry) => entry.queryTokens > 0).map((entry) => ({
@@ -4684,8 +5275,18 @@ function buildBenchmarkArtifact(input) {
   }));
   const avgQueryTokens = perQuestion.length ? Math.max(1, Math.round(perQuestion.reduce((total, entry) => total + entry.queryTokens, 0) / perQuestion.length)) : 0;
   const reductionRatio = avgQueryTokens ? Number(Math.max(0, 1 - avgQueryTokens / Math.max(1, corpusTokens)).toFixed(3)) : 0;
+  const uniqueVisitedNodes = new Set(perQuestion.flatMap((entry) => entry.visitedNodeIds)).size;
+  const summary = {
+    questionCount: input.questions.length,
+    uniqueVisitedNodes,
+    finalContextTokens: avgQueryTokens,
+    naiveCorpusTokens: corpusTokens,
+    avgReduction: reductionRatio,
+    reductionRatio
+  };
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    graphHash: graphHash(input.graph),
     corpusWords: input.corpusWords,
     corpusTokens,
     nodes: input.graph.nodes.length,
@@ -4693,7 +5294,9 @@ function buildBenchmarkArtifact(input) {
     avgQueryTokens,
     reductionRatio,
     sampleQuestions: input.questions,
-    perQuestion
+    perQuestion,
+    questionResults: perQuestion,
+    summary
   };
 }
 
@@ -4714,10 +5317,10 @@ function conflictConfidence(claimA, claimB) {
 }
 
 // src/deep-lint.ts
-import fs10 from "fs/promises";
-import path13 from "path";
-import matter3 from "gray-matter";
-import { z as z4 } from "zod";
+import fs11 from "fs/promises";
+import path14 from "path";
+import matter4 from "gray-matter";
+import { z as z5 } from "zod";
 
 // src/findings.ts
 function normalizeFindingSeverity(value) {
@@ -4736,25 +5339,25 @@ function normalizeFindingSeverity(value) {
 
 // src/orchestration.ts
 import { spawn } from "child_process";
-import path11 from "path";
-import { z as z2 } from "zod";
-var orchestrationRoleResultSchema = z2.object({
-  summary: z2.string().optional(),
-  findings: z2.array(
-    z2.object({
-      severity: z2.string().optional().default("info"),
-      message: z2.string().min(1),
-      relatedPageIds: z2.array(z2.string()).optional(),
-      relatedSourceIds: z2.array(z2.string()).optional(),
-      suggestedQuery: z2.string().optional()
+import path12 from "path";
+import { z as z3 } from "zod";
+var orchestrationRoleResultSchema = z3.object({
+  summary: z3.string().optional(),
+  findings: z3.array(
+    z3.object({
+      severity: z3.string().optional().default("info"),
+      message: z3.string().min(1),
+      relatedPageIds: z3.array(z3.string()).optional(),
+      relatedSourceIds: z3.array(z3.string()).optional(),
+      suggestedQuery: z3.string().optional()
     })
   ).default([]),
-  questions: z2.array(z2.string().min(1)).default([]),
-  proposals: z2.array(
-    z2.object({
-      path: z2.string().min(1),
-      content: z2.string().min(1),
-      reason: z2.string().min(1)
+  questions: z3.array(z3.string().min(1)).default([]),
+  proposals: z3.array(
+    z3.object({
+      path: z3.string().min(1),
+      content: z3.string().min(1),
+      reason: z3.string().min(1)
     })
   ).default([])
 });
@@ -4829,7 +5432,7 @@ async function runProviderRole(rootDir, role, roleConfig, input) {
 }
 async function runCommandRole(rootDir, role, executor, input) {
   const [command, ...args] = executor.command;
-  const cwd = executor.cwd ? path11.resolve(rootDir, executor.cwd) : rootDir;
+  const cwd = executor.cwd ? path12.resolve(rootDir, executor.cwd) : rootDir;
   const child = spawn(command, args, {
     cwd,
     env: {
@@ -4923,9 +5526,9 @@ function summarizeRoleQuestions(results) {
 }
 
 // src/web-search/registry.ts
-import path12 from "path";
+import path13 from "path";
 import { pathToFileURL } from "url";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/web-search/http-json.ts
 function deepGet(value, pathValue) {
@@ -5007,10 +5610,10 @@ var HttpJsonWebSearchAdapter = class {
 };
 
 // src/web-search/registry.ts
-var customWebSearchModuleSchema = z3.object({
-  createAdapter: z3.function({
-    input: [z3.string(), z3.custom(), z3.string()],
-    output: z3.promise(z3.custom())
+var customWebSearchModuleSchema = z4.object({
+  createAdapter: z4.function({
+    input: [z4.string(), z4.custom(), z4.string()],
+    output: z4.promise(z4.custom())
   })
 });
 async function createWebSearchAdapter(id, config, rootDir) {
@@ -5021,7 +5624,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 = path12.isAbsolute(config.module) ? config.module : path12.resolve(rootDir, config.module);
+      const resolvedModule = path13.isAbsolute(config.module) ? config.module : path13.resolve(rootDir, config.module);
       const loaded = await import(pathToFileURL(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
@@ -5045,15 +5648,15 @@ async function getWebSearchAdapterForTask(rootDir, task) {
 }
 
 // src/deep-lint.ts
-var deepLintResponseSchema = z4.object({
-  findings: z4.array(
-    z4.object({
-      severity: z4.string().optional().default("info"),
-      code: z4.enum(["coverage_gap", "contradiction_candidate", "missing_citation", "candidate_page", "follow_up_question"]),
-      message: z4.string().min(1),
-      relatedSourceIds: z4.array(z4.string()).default([]),
-      relatedPageIds: z4.array(z4.string()).default([]),
-      suggestedQuery: z4.string().optional()
+var deepLintResponseSchema = z5.object({
+  findings: z5.array(
+    z5.object({
+      severity: z5.string().optional().default("info"),
+      code: z5.enum(["coverage_gap", "contradiction_candidate", "missing_citation", "candidate_page", "follow_up_question"]),
+      message: z5.string().min(1),
+      relatedSourceIds: z5.array(z5.string()).default([]),
+      relatedPageIds: z5.array(z5.string()).default([]),
+      suggestedQuery: z5.string().optional()
     })
   ).max(20)
 });
@@ -5081,9 +5684,9 @@ async function loadContextPages(rootDir, graph) {
   );
   return Promise.all(
     contextPages.slice(0, 18).map(async (page) => {
-      const absolutePath = path13.join(paths.wikiDir, page.path);
-      const raw = await fs10.readFile(absolutePath, "utf8").catch(() => "");
-      const parsed = matter3(raw);
+      const absolutePath = path14.join(paths.wikiDir, page.path);
+      const raw = await fs11.readFile(absolutePath, "utf8").catch(() => "");
+      const parsed = matter4(raw);
       return {
         id: page.id,
         title: page.title,
@@ -5130,7 +5733,7 @@ function heuristicDeepFindings(contextPages, structuralFindings, graph) {
       code: "missing_citation",
       message: finding.message,
       pagePath: finding.pagePath,
-      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path13.basename(finding.pagePath, ".md")}?` : void 0
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path14.basename(finding.pagePath, ".md")}?` : void 0
     });
   }
   for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
@@ -5611,12 +6214,15 @@ function topGodNodes(graph, limit = 10) {
 }
 
 // src/markdown.ts
-import matter4 from "gray-matter";
-function uniqueStrings(values) {
+import matter5 from "gray-matter";
+function uniqueStrings2(values) {
   return uniqueBy(values.filter(Boolean), (value) => value);
 }
+function safeFrontmatter(value) {
+  return JSON.parse(JSON.stringify(value));
+}
 function decoratedTags(baseTags, decorations) {
-  return uniqueStrings([
+  return uniqueStrings2([
     ...baseTags,
     ...(decorations?.projectIds ?? []).map((projectId) => `project/${projectId}`),
     ...decorations?.extraTags ?? []
@@ -5695,6 +6301,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
     page_id: pageId,
     kind: "source",
     title: analysis.title,
+    ...manifest.sourceType ? { source_type: manifest.sourceType } : {},
     tags: decoratedTags(analysis.code ? ["source", "code"] : ["source"], decorations),
     source_ids: [manifest.sourceId],
     project_ids: decorations?.projectIds ?? [],
@@ -5717,6 +6324,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
     "",
     `Source ID: \`${manifest.sourceId}\``,
     manifest.url ? `Source URL: ${manifest.url}` : `Source Path: \`${manifest.originalPath ?? manifest.storedPath}\``,
+    ...manifest.sourceType ? [`Source Type: \`${manifest.sourceType}\``, ""] : [""],
     "",
     "## Summary",
     "",
@@ -5761,6 +6369,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
       path: relativePath,
       title: analysis.title,
       kind: "source",
+      sourceType: manifest.sourceType,
       sourceIds: [manifest.sourceId],
       projectIds: decorations?.projectIds ?? [],
       nodeIds,
@@ -5778,7 +6387,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
       compiledFrom: metadata.compiledFrom,
       managedBy: metadata.managedBy
     },
-    content: matter4.stringify(body, frontmatter)
+    content: matter5.stringify(body, safeFrontmatter(frontmatter))
   };
 }
 function buildModulePage(input) {
@@ -5793,7 +6402,7 @@ function buildModulePage(input) {
   const nodeIds = [code.moduleId, ...code.symbols.map((symbol) => symbol.id)];
   const localModuleBacklinks = input.localModules.map((moduleRef) => moduleRef.page.id);
   const relatedOutputs = input.relatedOutputs ?? [];
-  const backlinks = uniqueStrings([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]);
+  const backlinks = uniqueStrings2([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]);
   const importsSection = code.imports.length ? code.imports.map((item) => {
     const localModule = item.resolvedSourceId ? input.localModules.find((moduleRef) => moduleRef.sourceId === item.resolvedSourceId && moduleRef.reExport === item.reExport) : void 0;
     const importedBits = [
@@ -5839,9 +6448,9 @@ function buildModulePage(input) {
     source_hashes: {
       [manifest.sourceId]: manifest.contentHash
     },
-    related_page_ids: uniqueStrings([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
+    related_page_ids: uniqueStrings2([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
     related_node_ids: [],
-    related_source_ids: uniqueStrings([
+    related_source_ids: uniqueStrings2([
       manifest.sourceId,
       ...input.localModules.map((moduleRef) => moduleRef.sourceId),
       ...relatedOutputs.flatMap((page) => page.sourceIds)
@@ -5913,9 +6522,9 @@ function buildModulePage(input) {
       backlinks,
       schemaHash,
       sourceHashes: { [manifest.sourceId]: manifest.contentHash },
-      relatedPageIds: uniqueStrings([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
+      relatedPageIds: uniqueStrings2([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]),
       relatedNodeIds: [],
-      relatedSourceIds: uniqueStrings([
+      relatedSourceIds: uniqueStrings2([
         manifest.sourceId,
         ...input.localModules.map((moduleRef) => moduleRef.sourceId),
         ...relatedOutputs.flatMap((page) => page.sourceIds)
@@ -5925,7 +6534,7 @@ function buildModulePage(input) {
       compiledFrom: metadata.compiledFrom,
       managedBy: metadata.managedBy
     },
-    content: matter4.stringify(body, frontmatter)
+    content: matter5.stringify(body, frontmatter)
   };
 }
 function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHashes, schemaHash, metadata, relativePath, relatedOutputs = [], decorations) {
@@ -5996,7 +6605,7 @@ function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHash
       compiledFrom: metadata.compiledFrom,
       managedBy: metadata.managedBy
     },
-    content: matter4.stringify(body, frontmatter)
+    content: matter5.stringify(body, frontmatter)
   };
 }
 function buildIndexPage(pages, schemaHash, metadata, projectPages = []) {
@@ -6072,7 +6681,7 @@ function buildIndexPage(pages, schemaHash, metadata, projectPages = []) {
 }
 function buildSectionIndex(kind, pages, schemaHash, metadata, projectIds = []) {
   const title = kind.charAt(0).toUpperCase() + kind.slice(1);
-  return matter4.stringify(
+  return matter5.stringify(
     [`# ${title}`, "", ...pages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`), ""].join("\n"),
     {
       page_id: `${kind}:index`,
@@ -6114,27 +6723,118 @@ function crossCommunityEdges(graph) {
 function suggestedGraphQuestions(graph) {
   const thinCommunities = (graph.communities ?? []).filter((community) => community.nodeIds.length <= 2);
   const bridgeNodes = graph.nodes.filter((node) => (node.bridgeScore ?? 0) > 0).sort((left, right) => (right.bridgeScore ?? 0) - (left.bridgeScore ?? 0)).slice(0, 3);
-  return uniqueStrings([
+  return uniqueStrings2([
     ...thinCommunities.map((community) => `What sources would strengthen community ${community.label}?`),
     ...bridgeNodes.map((node) => `Why does ${node.label} connect multiple communities in the vault?`)
   ]).slice(0, 6);
 }
+function buildGraphReportArtifact(input) {
+  const nodesById = new Map(input.graph.nodes.map((node) => [node.id, node]));
+  const godNodes = input.graph.nodes.filter((node) => node.isGodNode).sort((left, right) => (right.degree ?? 0) - (left.degree ?? 0)).slice(0, 8);
+  const bridgeNodes = input.graph.nodes.filter((node) => (node.bridgeScore ?? 0) > 0).sort((left, right) => (right.bridgeScore ?? 0) - (left.bridgeScore ?? 0)).slice(0, 8);
+  const thinCommunities = (input.graph.communities ?? []).filter((community) => community.nodeIds.length <= 2).map((community) => {
+    const page = input.communityPages.find((candidate) => candidate.id === `graph:${community.id}`);
+    return {
+      id: community.id,
+      label: community.label,
+      nodeCount: community.nodeIds.length,
+      pageId: page?.id,
+      path: page?.path,
+      title: page?.title
+    };
+  });
+  const surprisingConnections = crossCommunityEdges(input.graph).slice(0, 8).map((edge) => {
+    const source = nodesById.get(edge.source);
+    const target = nodesById.get(edge.target);
+    const path23 = shortestGraphPath(input.graph, edge.source, edge.target);
+    const sourceCommunity = source?.communityId ? input.graph.communities?.find((community) => community.id === source.communityId) : void 0;
+    const targetCommunity = target?.communityId ? input.graph.communities?.find((community) => community.id === target.communityId) : void 0;
+    return {
+      id: edge.id,
+      sourceNodeId: edge.source,
+      sourceLabel: source?.label ?? edge.source,
+      targetNodeId: edge.target,
+      targetLabel: target?.label ?? edge.target,
+      relation: edge.relation,
+      evidenceClass: edge.evidenceClass,
+      confidence: edge.confidence,
+      pathNodeIds: path23.nodeIds,
+      pathEdgeIds: path23.edgeIds,
+      pathSummary: path23.summary,
+      explanation: normalizeWhitespace(
+        [
+          `${source?.label ?? edge.source} links ${sourceCommunity?.label ? `from ${sourceCommunity.label}` : ""}`.trim(),
+          `to ${target?.label ?? edge.target}${targetCommunity?.label ? ` in ${targetCommunity.label}` : ""}`.trim(),
+          `through ${edge.relation} with ${edge.evidenceClass} evidence at ${edge.confidence.toFixed(2)} confidence.`
+        ].join(" ")
+      )
+    };
+  });
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    graphHash: input.graphHash,
+    overview: {
+      nodes: input.graph.nodes.length,
+      edges: input.graph.edges.length,
+      pages: input.graph.pages.length,
+      communities: input.graph.communities?.length ?? 0
+    },
+    benchmark: input.benchmark ? {
+      generatedAt: input.benchmark.generatedAt,
+      stale: input.benchmarkStale ?? false,
+      summary: input.benchmark.summary,
+      questionCount: input.benchmark.sampleQuestions.length
+    } : void 0,
+    godNodes: godNodes.map((node) => ({
+      nodeId: node.id,
+      label: node.label,
+      pageId: node.pageId,
+      degree: node.degree,
+      bridgeScore: node.bridgeScore
+    })),
+    bridgeNodes: bridgeNodes.map((node) => ({
+      nodeId: node.id,
+      label: node.label,
+      pageId: node.pageId,
+      degree: node.degree,
+      bridgeScore: node.bridgeScore
+    })),
+    thinCommunities,
+    surprisingConnections,
+    suggestedQuestions: suggestedGraphQuestions(input.graph),
+    communityPages: input.communityPages.map((page) => ({
+      id: page.id,
+      path: page.path,
+      title: page.title
+    })),
+    recentResearchSources: (input.recentResearchSources ?? []).map((page) => ({
+      pageId: page.id,
+      path: page.path,
+      title: page.title,
+      sourceType: page.sourceType,
+      updatedAt: page.updatedAt
+    }))
+  };
+}
 function buildGraphReportPage(input) {
   const pageId = "graph:report";
   const pathValue = pagePathFor("graph_report", "report");
   const pagesById = new Map(input.graph.pages.map((page) => [page.id, page]));
   const nodesById = new Map(input.graph.nodes.map((node) => [node.id, node]));
-  const godNodes = input.graph.nodes.filter((node) => node.isGodNode).sort((left, right) => (right.degree ?? 0) - (left.degree ?? 0)).slice(0, 8);
-  const bridgeNodes = input.graph.nodes.filter((node) => (node.bridgeScore ?? 0) > 0).sort((left, right) => (right.bridgeScore ?? 0) - (left.bridgeScore ?? 0)).slice(0, 8);
-  const surprisingEdges = crossCommunityEdges(input.graph).slice(0, 8);
-  const thinCommunities = (input.graph.communities ?? []).filter((community) => community.nodeIds.length <= 2);
-  const relatedNodeIds = uniqueStrings([...godNodes, ...bridgeNodes].map((node) => node.id));
-  const relatedPageIds = uniqueStrings([
-    ...godNodes.map((node) => node.pageId ?? ""),
-    ...bridgeNodes.map((node) => node.pageId ?? ""),
-    ...input.communityPages.map((page) => page.id)
+  const relatedNodeIds = uniqueStrings2([
+    ...input.report.godNodes.map((node) => node.nodeId),
+    ...input.report.bridgeNodes.map((node) => node.nodeId)
+  ]);
+  const relatedPageIds = uniqueStrings2([
+    ...input.report.godNodes.map((node) => node.pageId ?? ""),
+    ...input.report.bridgeNodes.map((node) => node.pageId ?? ""),
+    ...input.report.communityPages.map((page) => page.id),
+    ...input.report.recentResearchSources.map((page) => page.pageId)
+  ]);
+  const relatedSourceIds = uniqueStrings2([
+    ...relatedNodeIds.flatMap((nodeId) => nodesById.get(nodeId)?.sourceIds ?? []),
+    ...input.report.recentResearchSources.flatMap((page) => pagesById.get(page.pageId)?.sourceIds ?? [])
   ]);
-  const relatedSourceIds = uniqueStrings(relatedNodeIds.flatMap((nodeId) => nodesById.get(nodeId)?.sourceIds ?? []));
   const frontmatter = {
     page_id: pageId,
     kind: "graph_report",
@@ -6162,47 +6862,66 @@ function buildGraphReportPage(input) {
     "",
     "## Overview",
     "",
-    `- Nodes: ${input.graph.nodes.length}`,
-    `- Edges: ${input.graph.edges.length}`,
-    `- Pages: ${input.graph.pages.length}`,
-    `- Communities: ${input.graph.communities?.length ?? 0}`,
+    `- Nodes: ${input.report.overview.nodes}`,
+    `- Edges: ${input.report.overview.edges}`,
+    `- Pages: ${input.report.overview.pages}`,
+    `- Communities: ${input.report.overview.communities}`,
     "",
-    ...input.benchmark ? [
-      "## Benchmark",
-      "",
-      `- Corpus Tokens: ${input.benchmark.corpusTokens}`,
-      `- Avg Query Tokens: ${input.benchmark.avgQueryTokens}`,
-      `- Reduction Ratio: ${(input.benchmark.reductionRatio * 100).toFixed(1)}%`,
-      `- Sample Questions: ${input.benchmark.sampleQuestions.length}`,
+    "## Benchmark Summary",
+    "",
+    ...input.report.benchmark ? [
+      `- Generated At: ${input.report.benchmark.generatedAt}`,
+      `- Status: ${input.report.benchmark.stale ? "Stale (graph changed since benchmark ran)" : "Fresh"}`,
+      `- Naive Corpus Tokens: ${input.report.benchmark.summary.naiveCorpusTokens}`,
+      `- Final Context Tokens: ${input.report.benchmark.summary.finalContextTokens}`,
+      `- Unique Nodes Considered: ${input.report.benchmark.summary.uniqueVisitedNodes}`,
+      `- Reduction Ratio: ${(input.report.benchmark.summary.reductionRatio * 100).toFixed(1)}%`,
+      `- Questions: ${input.report.benchmark.questionCount}`,
       ""
-    ] : [],
-    "## God Nodes",
+    ] : ["- No benchmark results yet.", ""],
+    "## Top God Nodes",
     "",
-    ...godNodes.length ? godNodes.map((node) => `- ${graphNodeLink(node, pagesById)} (${nodeSummary(node)})`) : ["- No high-connectivity nodes detected."],
+    ...input.report.godNodes.length ? input.report.godNodes.map((node) => {
+      const graphNode = nodesById.get(node.nodeId);
+      return graphNode ? `- ${graphNodeLink(graphNode, pagesById)} (${nodeSummary(graphNode)})` : `- \`${node.nodeId}\``;
+    }) : ["- No high-connectivity nodes detected."],
     "",
-    "## Bridge Nodes",
+    "## Top Bridge Nodes",
     "",
-    ...bridgeNodes.length ? bridgeNodes.map((node) => `- ${graphNodeLink(node, pagesById)} (${nodeSummary(node)})`) : ["- No cross-community bridge nodes detected."],
+    ...input.report.bridgeNodes.length ? input.report.bridgeNodes.map((node) => {
+      const graphNode = nodesById.get(node.nodeId);
+      return graphNode ? `- ${graphNodeLink(graphNode, pagesById)} (${nodeSummary(graphNode)})` : `- \`${node.nodeId}\``;
+    }) : ["- No cross-community bridge nodes detected."],
     "",
     "## Communities",
     "",
-    ...input.communityPages.length ? input.communityPages.map((page) => `- ${pageLink(page)}`) : ["- No community summaries generated yet."],
+    ...input.report.communityPages.length ? input.report.communityPages.map((page) => `- ${pageLink(page)}`) : ["- No community summaries generated yet."],
     "",
-    "## Thin Communities",
+    "## Thin Or Underlinked Areas",
     "",
-    ...thinCommunities.length ? thinCommunities.map((community) => `- ${community.label} (${community.nodeIds.length} node(s))`) : ["- No thin communities detected."],
+    ...input.report.thinCommunities.length ? input.report.thinCommunities.map(
+      (community) => community.path ? `- [[${community.path.replace(/\.md$/, "")}|${community.title ?? community.label}]] (${community.nodeCount} node(s))` : `- ${community.label} (${community.nodeCount} node(s))`
+    ) : ["- No thin communities detected."],
     "",
-    "## Cross-Community Surprises",
+    "## Surprising Connections",
     "",
-    ...surprisingEdges.length ? surprisingEdges.map((edge) => {
-      const source = nodesById.get(edge.source);
-      const target = nodesById.get(edge.target);
-      return `- ${source ? graphNodeLink(source, pagesById) : `\`${edge.source}\``} ${edge.relation} ${target ? graphNodeLink(target, pagesById) : `\`${edge.target}\``} (${edge.evidenceClass}, ${edge.confidence.toFixed(2)})`;
+    ...input.report.surprisingConnections.length ? input.report.surprisingConnections.map((connection) => {
+      const source = nodesById.get(connection.sourceNodeId);
+      const target = nodesById.get(connection.targetNodeId);
+      const sourceLabel = source ? graphNodeLink(source, pagesById) : `\`${connection.sourceNodeId}\``;
+      const targetLabel = target ? graphNodeLink(target, pagesById) : `\`${connection.targetNodeId}\``;
+      return `- ${sourceLabel} ${connection.relation} ${targetLabel} (${connection.evidenceClass}, ${connection.confidence.toFixed(2)}). ${connection.explanation} Path: ${connection.pathSummary}.`;
     }) : ["- No cross-community links detected."],
     "",
-    "## Suggested Follow-Up Questions",
+    "## New Research Sources",
+    "",
+    ...input.report.recentResearchSources.length ? input.report.recentResearchSources.map(
+      (page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]] (\`${page.sourceType}\`, updated ${page.updatedAt})`
+    ) : ["- No newly captured research sources since the previous compile."],
+    "",
+    "## Suggested Questions",
     "",
-    ...suggestedGraphQuestions(input.graph).map((question) => `- ${question}`),
+    ...input.report.suggestedQuestions.map((question) => `- ${question}`),
     ""
   ].join("\n");
   return {
@@ -6228,7 +6947,7 @@ function buildGraphReportPage(input) {
       compiledFrom: input.metadata.compiledFrom,
       managedBy: input.metadata.managedBy
     },
-    content: matter4.stringify(body, frontmatter)
+    content: matter5.stringify(body, frontmatter)
   };
 }
 function buildCommunitySummaryPage(input) {
@@ -6237,14 +6956,14 @@ function buildCommunitySummaryPage(input) {
   const nodesById = new Map(input.graph.nodes.map((node) => [node.id, node]));
   const pagesById = new Map(input.graph.pages.map((page) => [page.id, page]));
   const communityNodes = input.community.nodeIds.map((nodeId) => nodesById.get(nodeId)).filter((node) => Boolean(node));
-  const communityPageIds = uniqueStrings(communityNodes.map((node) => node.pageId ?? ""));
+  const communityPageIds = uniqueStrings2(communityNodes.map((node) => node.pageId ?? ""));
   const communityPages = communityPageIds.map((id) => pagesById.get(id)).filter((page) => Boolean(page));
   const externalEdges = input.graph.edges.filter((edge) => {
     const source = nodesById.get(edge.source);
     const target = nodesById.get(edge.target);
     return source?.communityId === input.community.id && target?.communityId && target.communityId !== input.community.id;
   }).slice(0, 8);
-  const relatedSourceIds = uniqueStrings(communityNodes.flatMap((node) => node.sourceIds));
+  const relatedSourceIds = uniqueStrings2(communityNodes.flatMap((node) => node.sourceIds));
   const frontmatter = {
     page_id: pageId,
     kind: "community_summary",
@@ -6263,7 +6982,7 @@ function buildCommunitySummaryPage(input) {
     backlinks: ["graph:report"],
     schema_hash: input.schemaHash,
     source_hashes: {},
-    related_page_ids: uniqueStrings(["graph:report", ...communityPageIds]),
+    related_page_ids: uniqueStrings2(["graph:report", ...communityPageIds]),
     related_node_ids: input.community.nodeIds,
     related_source_ids: relatedSourceIds
   };
@@ -6302,7 +7021,7 @@ function buildCommunitySummaryPage(input) {
       backlinks: ["graph:report"],
       schemaHash: input.schemaHash,
       sourceHashes: {},
-      relatedPageIds: uniqueStrings(["graph:report", ...communityPageIds]),
+      relatedPageIds: uniqueStrings2(["graph:report", ...communityPageIds]),
       relatedNodeIds: input.community.nodeIds,
       relatedSourceIds,
       createdAt: input.metadata.createdAt,
@@ -6310,11 +7029,11 @@ function buildCommunitySummaryPage(input) {
       compiledFrom: input.metadata.compiledFrom,
       managedBy: input.metadata.managedBy
     },
-    content: matter4.stringify(body, frontmatter)
+    content: matter5.stringify(body, frontmatter)
   };
 }
 function buildProjectsIndex(projectPages, schemaHash, metadata) {
-  return matter4.stringify(
+  return matter5.stringify(
     [
       "# Projects",
       "",
@@ -6344,7 +7063,7 @@ function buildProjectsIndex(projectPages, schemaHash, metadata) {
 }
 function buildProjectIndex(input) {
   const title = `Project: ${input.projectId}`;
-  return matter4.stringify(
+  return matter5.stringify(
     [
       `# ${title}`,
       "",
@@ -6457,7 +7176,7 @@ function buildOutputPage(input) {
       outputFormat: input.outputFormat,
       outputAssets
     },
-    content: matter4.stringify(
+    content: matter5.stringify(
       (input.outputFormat === "slides" ? [
         input.answer,
         "",
@@ -6583,7 +7302,7 @@ function buildExploreHubPage(input) {
       outputFormat: input.outputFormat,
       outputAssets
     },
-    content: matter4.stringify(
+    content: matter5.stringify(
       (input.outputFormat === "slides" ? [
         `# ${title}`,
         "",
@@ -6653,49 +7372,49 @@ function buildExploreHubPage(input) {
 }
 
 // src/output-artifacts.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function escapeXml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function clampNumber(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
-var chartSpecSchema = z5.object({
-  kind: z5.enum(["bar", "line"]).default("bar"),
-  title: z5.string().min(1),
-  subtitle: z5.string().optional(),
-  xLabel: z5.string().optional(),
-  yLabel: z5.string().optional(),
-  seriesLabel: z5.string().optional(),
-  data: z5.array(
-    z5.object({
-      label: z5.string().min(1),
-      value: z5.number().finite()
+var chartSpecSchema = z6.object({
+  kind: z6.enum(["bar", "line"]).default("bar"),
+  title: z6.string().min(1),
+  subtitle: z6.string().optional(),
+  xLabel: z6.string().optional(),
+  yLabel: z6.string().optional(),
+  seriesLabel: z6.string().optional(),
+  data: z6.array(
+    z6.object({
+      label: z6.string().min(1),
+      value: z6.number().finite()
     })
   ).min(2).max(12),
-  notes: z5.array(z5.string().min(1)).max(5).optional()
+  notes: z6.array(z6.string().min(1)).max(5).optional()
 });
-var sceneSpecSchema = z5.object({
-  title: z5.string().min(1),
-  alt: z5.string().min(1),
-  background: z5.string().optional(),
-  width: z5.number().int().positive().max(2400).optional(),
-  height: z5.number().int().positive().max(2400).optional(),
-  elements: z5.array(
-    z5.object({
-      kind: z5.enum(["shape", "label"]),
-      shape: z5.enum(["rect", "circle", "line"]).optional(),
-      x: z5.number().finite(),
-      y: z5.number().finite(),
-      width: z5.number().finite().optional(),
-      height: z5.number().finite().optional(),
-      radius: z5.number().finite().optional(),
-      text: z5.string().optional(),
-      fontSize: z5.number().finite().optional(),
-      fill: z5.string().optional(),
-      stroke: z5.string().optional(),
-      strokeWidth: z5.number().finite().optional(),
-      opacity: z5.number().finite().optional()
+var sceneSpecSchema = z6.object({
+  title: z6.string().min(1),
+  alt: z6.string().min(1),
+  background: z6.string().optional(),
+  width: z6.number().int().positive().max(2400).optional(),
+  height: z6.number().int().positive().max(2400).optional(),
+  elements: z6.array(
+    z6.object({
+      kind: z6.enum(["shape", "label"]),
+      shape: z6.enum(["rect", "circle", "line"]).optional(),
+      x: z6.number().finite(),
+      y: z6.number().finite(),
+      width: z6.number().finite().optional(),
+      height: z6.number().finite().optional(),
+      radius: z6.number().finite().optional(),
+      text: z6.string().optional(),
+      fontSize: z6.number().finite().optional(),
+      fill: z6.string().optional(),
+      stroke: z6.string().optional(),
+      strokeWidth: z6.number().finite().optional(),
+      opacity: z6.number().finite().optional()
     })
   ).min(1).max(32)
 });
@@ -6847,14 +7566,14 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
+import fs13 from "fs/promises";
+import path16 from "path";
+import matter7 from "gray-matter";
+
+// src/pages.ts
 import fs12 from "fs/promises";
 import path15 from "path";
 import matter6 from "gray-matter";
-
-// src/pages.ts
-import fs11 from "fs/promises";
-import path14 from "path";
-import matter5 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
@@ -6875,6 +7594,9 @@ function normalizePageStatus(value, fallback = "active") {
 function normalizePageManager(value, fallback = "system") {
   return value === "human" || value === "system" ? value : fallback;
 }
+function normalizeSourceType(value) {
+  return value === "arxiv" || value === "doi" || value === "tweet" || value === "article" || value === "url" ? value : void 0;
+}
 function normalizeOutputFormat(value, fallback = "markdown") {
   return value === "report" || value === "slides" || value === "chart" || value === "image" ? value : fallback;
 }
@@ -6925,8 +7647,8 @@ async function loadExistingManagedPageState(absolutePath, defaults = {}) {
       updatedAt: updatedFallback
     };
   }
-  const content = await fs11.readFile(absolutePath, "utf8");
-  const parsed = matter5(content);
+  const content = await fs12.readFile(absolutePath, "utf8");
+  const parsed = matter6(content);
   return {
     status: normalizePageStatus(parsed.data.status, defaults.status ?? "active"),
     managedBy: normalizePageManager(parsed.data.managed_by, defaults.managedBy ?? "system"),
@@ -6960,11 +7682,11 @@ function inferPageKind(relativePath, explicitKind = void 0) {
   return "index";
 }
 function parseStoredPage(relativePath, content, defaults = {}) {
-  const parsed = matter5(content);
+  const parsed = matter6(content);
   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 : path14.basename(relativePath, ".md");
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path15.basename(relativePath, ".md");
   const kind = inferPageKind(relativePath, parsed.data.kind);
   const sourceIds = normalizeStringArray(parsed.data.source_ids);
   const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -6980,6 +7702,7 @@ function parseStoredPage(relativePath, content, defaults = {}) {
     path: relativePath,
     title,
     kind,
+    sourceType: normalizeSourceType(parsed.data.source_type),
     sourceIds,
     projectIds,
     nodeIds,
@@ -7003,18 +7726,18 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   };
 }
 async function loadInsightPages(wikiDir) {
-  const insightsDir = path14.join(wikiDir, "insights");
+  const insightsDir = path15.join(wikiDir, "insights");
   if (!await fileExists(insightsDir)) {
     return [];
   }
-  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path14.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
+  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path15.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
   const insights = [];
   for (const absolutePath of files) {
-    const relativePath = toPosix(path14.relative(wikiDir, absolutePath));
-    const content = await fs11.readFile(absolutePath, "utf8");
-    const parsed = matter5(content);
-    const stats = await fs11.stat(absolutePath);
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : path14.basename(absolutePath, ".md");
+    const relativePath = toPosix(path15.relative(wikiDir, absolutePath));
+    const content = await fs12.readFile(absolutePath, "utf8");
+    const parsed = matter6(content);
+    const stats = await fs12.stat(absolutePath);
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path15.basename(absolutePath, ".md");
     const sourceIds = normalizeStringArray(parsed.data.source_ids);
     const projectIds = normalizeProjectIds(parsed.data.project_ids);
     const nodeIds = normalizeStringArray(parsed.data.node_ids);
@@ -7076,28 +7799,28 @@ 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 = path15.join(wikiDir, "outputs");
+  const outputsDir = path16.join(wikiDir, "outputs");
   const root = baseSlug || "output";
   let candidate = root;
   let counter = 2;
-  while (await fileExists(path15.join(outputsDir, `${candidate}.md`))) {
+  while (await fileExists(path16.join(outputsDir, `${candidate}.md`))) {
     candidate = `${root}-${counter}`;
     counter++;
   }
   return candidate;
 }
 async function loadSavedOutputPages(wikiDir) {
-  const outputsDir = path15.join(wikiDir, "outputs");
-  const entries = await fs12.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
+  const outputsDir = path16.join(wikiDir, "outputs");
+  const entries = await fs13.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
   const outputs = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") {
       continue;
     }
-    const relativePath = path15.posix.join("outputs", entry.name);
-    const absolutePath = path15.join(outputsDir, entry.name);
-    const content = await fs12.readFile(absolutePath, "utf8");
-    const parsed = matter6(content);
+    const relativePath = path16.posix.join("outputs", entry.name);
+    const absolutePath = path16.join(outputsDir, entry.name);
+    const content = await fs13.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}`;
@@ -7109,7 +7832,7 @@ async function loadSavedOutputPages(wikiDir) {
     const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
     const backlinks = normalizeStringArray(parsed.data.backlinks);
     const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
-    const stats = await fs12.stat(absolutePath);
+    const stats = await fs13.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({
@@ -7147,9 +7870,9 @@ async function loadSavedOutputPages(wikiDir) {
 }
 
 // src/search.ts
-import fs13 from "fs/promises";
-import path16 from "path";
-import matter7 from "gray-matter";
+import fs14 from "fs/promises";
+import path17 from "path";
+import matter8 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
   if (!builtin?.DatabaseSync) {
@@ -7167,8 +7890,11 @@ function normalizeKind(value) {
 function normalizeStatus(value) {
   return value === "draft" || value === "candidate" || value === "active" || value === "archived" ? value : void 0;
 }
+function normalizeSourceType2(value) {
+  return value === "arxiv" || value === "doi" || value === "tweet" || value === "article" || value === "url" ? value : void 0;
+}
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path16.dirname(dbPath));
+  await ensureDir(path17.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -7182,6 +7908,7 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
       body TEXT NOT NULL,
       kind TEXT NOT NULL,
       status TEXT NOT NULL,
+      source_type TEXT NOT NULL,
       project_ids TEXT NOT NULL,
       project_key TEXT NOT NULL
     );
@@ -7195,12 +7922,12 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
     DELETE FROM pages;
   `);
   const insertPage = db.prepare(
-    "INSERT INTO pages (id, path, title, body, kind, status, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    "INSERT INTO pages (id, path, title, body, kind, status, source_type, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
   );
   for (const page of pages) {
-    const absolutePath = path16.join(wikiDir, page.path);
-    const content = await fs13.readFile(absolutePath, "utf8");
-    const parsed = matter7(content);
+    const absolutePath = path17.join(wikiDir, page.path);
+    const content = await fs14.readFile(absolutePath, "utf8");
+    const parsed = matter8(content);
     insertPage.run(
       page.id,
       page.path,
@@ -7208,6 +7935,7 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
       parsed.content,
       page.kind,
       page.status,
+      typeof parsed.data.source_type === "string" ? parsed.data.source_type : "",
       JSON.stringify(page.projectIds),
       page.projectIds.map((projectId) => `|${projectId}|`).join("")
     );
@@ -7241,6 +7969,10 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
       params.push(`%|${options.project}|%`);
     }
   }
+  if (options.sourceType && options.sourceType !== "all") {
+    clauses.push("pages.source_type = ?");
+    params.push(options.sourceType);
+  }
   const statement = db.prepare(`
     SELECT
       pages.id AS pageId,
@@ -7248,6 +7980,7 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
       pages.title AS title,
       pages.kind AS kind,
       pages.status AS status,
+      pages.source_type AS sourceType,
       pages.project_ids AS projectIds,
       snippet(page_search, 1, '[', ']', '...', 16) AS snippet,
       bm25(page_search) AS rank
@@ -7275,13 +8008,14 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
     title: String(row.title ?? ""),
     kind: normalizeKind(row.kind),
     status: normalizeStatus(row.status),
+    sourceType: normalizeSourceType2(row.sourceType),
     snippet: String(row.snippet ?? ""),
     rank: Number(row.rank ?? 0)
   }));
 }
 
 // src/vault.ts
-function uniqueStrings2(values) {
+function uniqueStrings3(values) {
   return uniqueBy(values.filter(Boolean), (value) => value);
 }
 function normalizeOutputFormat2(format) {
@@ -7302,7 +8036,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path17.join("outputs", "assets", slug, fileName));
+  return toPosix(path18.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -7442,7 +8176,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-X5PMZTZY.js");
+  const { createProvider: createProvider2 } = await import("./registry-6KZMA3XM.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -7640,13 +8374,13 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path17.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path18.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
   return Object.entries(config.projects ?? {}).map(([id, project]) => ({
     id,
-    roots: uniqueStrings2(project.roots.map(normalizeProjectRoot)).filter(Boolean),
+    roots: uniqueStrings3(project.roots.map(normalizeProjectRoot)).filter(Boolean),
     schemaPath: project.schemaPath
   })).sort((left, right) => left.id.localeCompare(right.id));
 }
@@ -7666,10 +8400,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path17.isAbsolute(rawPath)) {
+  if (!path18.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path17.relative(rootDir, rawPath));
+  const relative = toPosix(path18.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -7694,11 +8428,11 @@ function resolveSourceProjects(rootDir, manifests, config) {
   return Object.fromEntries(manifests.map((manifest) => [manifest.sourceId, resolveSourceProjectId(rootDir, manifest, config)]));
 }
 function scopedProjectIdsFromSources(sourceIds, sourceProjects) {
-  const projectIds = uniqueStrings2(sourceIds.map((sourceId) => sourceProjects[sourceId] ?? "").filter(Boolean));
+  const projectIds = uniqueStrings3(sourceIds.map((sourceId) => sourceProjects[sourceId] ?? "").filter(Boolean));
   return projectIds.length === 1 ? projectIds : [];
 }
 function schemaProjectIdsFromPages(pageIds, pageMap2) {
-  return uniqueStrings2(
+  return uniqueStrings3(
     pageIds.flatMap((pageId) => pageMap2.get(pageId)?.projectIds ?? []).filter(Boolean).sort((left, right) => left.localeCompare(right))
   );
 }
@@ -7707,7 +8441,7 @@ function categoryTagsForSchema(schema, texts) {
   if (!haystack) {
     return [];
   }
-  return uniqueStrings2(
+  return uniqueStrings3(
     schemaCategoryLabels({ path: "", hash: "", content: schema.content }).filter((label) => haystack.includes(label.toLowerCase())).map((label) => `category/${slugify(label)}`)
   ).slice(0, 3);
 }
@@ -7843,7 +8577,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 fs14.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs15.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -7881,7 +8615,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs14.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs15.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -7918,7 +8652,7 @@ async function buildManagedContent(absolutePath, defaults, build) {
   return content;
 }
 function indexCompiledFrom(pages) {
-  return uniqueStrings2(pages.flatMap((page) => page.sourceIds));
+  return uniqueStrings3(pages.flatMap((page) => page.sourceIds));
 }
 function deriveGraphMetrics(nodes, edges) {
   const adjacency = /* @__PURE__ */ new Map();
@@ -8321,17 +9055,29 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
     pages
   };
 }
-async function buildGraphOrientationPages(graph, paths, schemaHash) {
+function recentResearchSourcePages(graph, previousCompiledAt) {
+  const previousTimestamp = previousCompiledAt ? Date.parse(previousCompiledAt) : Number.NaN;
+  return graph.pages.filter(
+    (page) => page.kind === "source" && Boolean(page.sourceType) && page.sourceType !== "url"
+  ).filter((page) => Number.isNaN(previousTimestamp) || Date.parse(page.updatedAt) > previousTimestamp).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) || left.title.localeCompare(right.title)).slice(0, 8).map((page) => ({
+    id: page.id,
+    path: page.path,
+    title: page.title,
+    updatedAt: page.updatedAt,
+    sourceType: page.sourceType
+  }));
+}
+async function buildGraphOrientationPages(graph, paths, schemaHash, previousCompiledAt) {
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
-    const absolutePath = path17.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
+    const absolutePath = path18.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
     communityRecords.push(
       await buildManagedGraphPage(
         absolutePath,
         {
           managedBy: "system",
-          compiledFrom: uniqueStrings2(
+          compiledFrom: uniqueStrings3(
             community.nodeIds.flatMap((nodeId) => graph.nodes.find((node) => node.id === nodeId)?.sourceIds ?? [])
           ),
           confidence: 1
@@ -8345,26 +9091,36 @@ async function buildGraphOrientationPages(graph, paths, schemaHash) {
       )
     );
   }
-  const reportAbsolutePath = path17.join(paths.wikiDir, "graph", "report.md");
+  const report = buildGraphReportArtifact({
+    graph,
+    communityPages: communityRecords.map((record) => record.page),
+    benchmark,
+    benchmarkStale: benchmark ? benchmark.graphHash !== graphHash(graph) : false,
+    recentResearchSources: recentResearchSourcePages(graph, previousCompiledAt),
+    graphHash: graphHash(graph)
+  });
+  const reportAbsolutePath = path18.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
       managedBy: "system",
-      compiledFrom: uniqueStrings2(graph.pages.flatMap((page) => page.sourceIds)),
+      compiledFrom: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
       confidence: 1
     },
     (metadata) => buildGraphReportPage({
       graph,
       schemaHash,
       metadata,
-      communityPages: communityRecords.map((record) => record.page),
-      benchmark
+      report
     })
   );
-  return [reportRecord, ...communityRecords];
+  return {
+    records: [reportRecord, ...communityRecords],
+    report
+  };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path17.resolve(wikiDir, relativePath);
+  const absolutePath = path18.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -8426,29 +9182,29 @@ async function requiredCompileArtifactsExist(paths) {
     paths.graphPath,
     paths.codeIndexPath,
     paths.searchDbPath,
-    path17.join(paths.wikiDir, "index.md"),
-    path17.join(paths.wikiDir, "sources", "index.md"),
-    path17.join(paths.wikiDir, "code", "index.md"),
-    path17.join(paths.wikiDir, "concepts", "index.md"),
-    path17.join(paths.wikiDir, "entities", "index.md"),
-    path17.join(paths.wikiDir, "outputs", "index.md"),
-    path17.join(paths.wikiDir, "projects", "index.md"),
-    path17.join(paths.wikiDir, "candidates", "index.md")
+    path18.join(paths.wikiDir, "index.md"),
+    path18.join(paths.wikiDir, "sources", "index.md"),
+    path18.join(paths.wikiDir, "code", "index.md"),
+    path18.join(paths.wikiDir, "concepts", "index.md"),
+    path18.join(paths.wikiDir, "entities", "index.md"),
+    path18.join(paths.wikiDir, "outputs", "index.md"),
+    path18.join(paths.wikiDir, "projects", "index.md"),
+    path18.join(paths.wikiDir, "candidates", "index.md")
   ];
   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(path17.join(paths.analysesDir, `${manifest.sourceId}.json`)))
+    manifests.map(async (manifest) => readJsonFile(path18.join(paths.analysesDir, `${manifest.sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis));
 }
 function approvalManifestPath(paths, approvalId) {
-  return path17.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path18.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path17.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path18.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
@@ -8458,7 +9214,7 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs14.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs15.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph) {
@@ -8473,7 +9229,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path17.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path18.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -8506,7 +9262,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path17.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path18.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
@@ -8518,16 +9274,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 = path17.join(paths.approvalsDir, approvalId);
+  const approvalDir = path18.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path17.join(approvalDir, "wiki"));
-  await ensureDir(path17.join(approvalDir, "state"));
+  await ensureDir(path18.join(approvalDir, "wiki"));
+  await ensureDir(path18.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path17.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path17.dirname(targetPath));
-    await fs14.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path18.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path18.dirname(targetPath));
+    await fs15.writeFile(targetPath, file.content, "utf8");
   }
-  await fs14.writeFile(path17.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs15.writeFile(path18.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8587,7 +9343,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path17.join(paths.wikiDir, preview.path),
+      path18.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -8632,7 +9388,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path17.join(paths.wikiDir, modulePreview.path),
+          path18.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -8658,15 +9414,15 @@ async function syncVaultArtifacts(rootDir, input) {
       const itemKind = kind === "concepts" ? "concept" : "entity";
       const slug = slugify(aggregate.name);
       const pageId = `${itemKind}:${slug}`;
-      const sourceIds = uniqueStrings2(aggregate.sourceAnalyses.map((item) => item.sourceId));
+      const sourceIds = uniqueStrings3(aggregate.sourceAnalyses.map((item) => item.sourceId));
       const projectIds = scopedProjectIdsFromSources(sourceIds, input.sourceProjects);
       const schemaHash = effectiveHashForProject(input.schemas, projectIds[0] ?? null);
       const previousEntry = input.previousState?.candidateHistory?.[pageId];
       const promoted = previousEntry?.status === "active" || promoteCandidates && shouldPromoteCandidate(previousEntry, sourceIds);
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const fallbackPaths = [
-        path17.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path17.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path18.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path18.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -8683,7 +9439,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path17.join(paths.wikiDir, relativePath),
+        path18.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -8724,9 +9480,9 @@ async function syncVaultArtifacts(rootDir, input) {
   const compiledPages = records.map((record) => record.page);
   const basePages = [...compiledPages, ...input.outputPages, ...input.insightPages];
   const baseGraph = buildGraph(input.manifests, input.analyses, basePages, input.sourceProjects, input.codeIndex);
-  const graphOrientationRecords = await buildGraphOrientationPages(baseGraph, paths, globalSchemaHash);
-  records.push(...graphOrientationRecords);
-  const allPages = [...basePages, ...graphOrientationRecords.map((record) => record.page)];
+  const graphOrientation = await buildGraphOrientationPages(baseGraph, paths, globalSchemaHash, input.previousState?.generatedAt);
+  records.push(...graphOrientation.records);
+  const allPages = [...basePages, ...graphOrientation.records.map((record) => record.page)];
   const graph = {
     ...baseGraph,
     pages: allPages
@@ -8764,7 +9520,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path17.join(paths.wikiDir, "projects", "index.md"),
+      path18.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -8788,7 +9544,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path17.join(paths.wikiDir, projectIndexRef.path),
+        path18.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -8816,7 +9572,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path17.join(paths.wikiDir, "index.md"),
+      path18.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -8847,7 +9603,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path17.join(paths.wikiDir, relativePath),
+        path18.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -8858,12 +9614,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(path17.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const obsoletePaths = uniqueStrings2([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path18.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const obsoletePaths = uniqueStrings3([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path17.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs14.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path18.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs15.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -8888,9 +9644,10 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs14.rm(path17.join(paths.wikiDir, relativePath), { force: true });
+    await fs15.rm(path18.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
+  await writeJsonFile(path18.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   await writeJsonFile(paths.codeIndexPath, input.codeIndex);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
@@ -8916,7 +9673,7 @@ async function syncVaultArtifacts(rootDir, input) {
   return {
     graph,
     allPages,
-    changedPages: uniqueStrings2([...changedPages, ...writeChanges]),
+    changedPages: uniqueStrings3([...changedPages, ...writeChanges]),
     promotedPageIds,
     candidatePageCount: candidatePages.length,
     staged: false
@@ -8925,18 +9682,20 @@ async function syncVaultArtifacts(rootDir, input) {
 async function refreshIndexesAndSearch(rootDir, pages) {
   const { config, paths } = await loadVaultConfig(rootDir);
   const schemas = await loadVaultSchemas(rootDir);
+  const compileState = await readJsonFile(paths.compileStatePath);
   const globalSchemaHash = schemas.effective.global.hash;
   const currentGraph = await readJsonFile(paths.graphPath);
   const basePages = pages.filter((page) => page.kind !== "graph_report" && page.kind !== "community_summary");
-  const graphOrientationRecords = currentGraph ? await buildGraphOrientationPages(
+  const graphOrientation = currentGraph ? await buildGraphOrientationPages(
     {
       ...currentGraph,
       pages: basePages
     },
     paths,
-    globalSchemaHash
-  ) : [];
-  const pagesWithGraph = sortGraphPages([...basePages, ...graphOrientationRecords.map((record) => record.page)]);
+    globalSchemaHash,
+    compileState?.generatedAt
+  ) : { records: [], report: null };
+  const pagesWithGraph = sortGraphPages([...basePages, ...graphOrientation.records.map((record) => record.page)]);
   if (currentGraph) {
     await writeJsonFile(paths.graphPath, {
       ...currentGraph,
@@ -8959,17 +9718,17 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path17.join(paths.wikiDir, "sources")),
-    ensureDir(path17.join(paths.wikiDir, "code")),
-    ensureDir(path17.join(paths.wikiDir, "concepts")),
-    ensureDir(path17.join(paths.wikiDir, "entities")),
-    ensureDir(path17.join(paths.wikiDir, "outputs")),
-    ensureDir(path17.join(paths.wikiDir, "graph")),
-    ensureDir(path17.join(paths.wikiDir, "graph", "communities")),
-    ensureDir(path17.join(paths.wikiDir, "projects")),
-    ensureDir(path17.join(paths.wikiDir, "candidates"))
+    ensureDir(path18.join(paths.wikiDir, "sources")),
+    ensureDir(path18.join(paths.wikiDir, "code")),
+    ensureDir(path18.join(paths.wikiDir, "concepts")),
+    ensureDir(path18.join(paths.wikiDir, "entities")),
+    ensureDir(path18.join(paths.wikiDir, "outputs")),
+    ensureDir(path18.join(paths.wikiDir, "graph")),
+    ensureDir(path18.join(paths.wikiDir, "graph", "communities")),
+    ensureDir(path18.join(paths.wikiDir, "projects")),
+    ensureDir(path18.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path17.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path18.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -8990,7 +9749,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 = path17.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path18.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -9008,7 +9767,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path17.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path18.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -9029,7 +9788,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 = path17.join(paths.wikiDir, relativePath);
+    const absolutePath = path18.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -9042,21 +9801,24 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  for (const record of graphOrientationRecords) {
-    await writeFileIfChanged(path17.join(paths.wikiDir, record.page.path), record.content);
+  for (const record of graphOrientation.records) {
+    await writeFileIfChanged(path18.join(paths.wikiDir, record.page.path), record.content);
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path17.relative(paths.wikiDir, absolutePath)));
+  if (graphOrientation.report) {
+    await writeJsonFile(path18.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+  }
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path18.relative(paths.wikiDir, absolutePath)));
   const 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) => fs14.rm(path17.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs15.rm(path18.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingGraphPages = (await listFilesRecursive(path17.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path17.relative(paths.wikiDir, absolutePath)));
-  const allowedGraphPages = /* @__PURE__ */ new Set(["graph/index.md", ...graphOrientationRecords.map((record) => record.page.path)]);
+  const existingGraphPages = (await listFilesRecursive(path18.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path18.relative(paths.wikiDir, absolutePath)));
+  const 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) => fs14.rm(path17.join(paths.wikiDir, relativePath), { force: true }))
+    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs15.rm(path18.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
@@ -9071,12 +9833,12 @@ async function prepareOutputPageSave(rootDir, input) {
       status: "active",
       createdAt: now,
       updatedAt: now,
-      compiledFrom: uniqueStrings2(input.relatedSourceIds ?? input.citations),
+      compiledFrom: uniqueStrings3(input.relatedSourceIds ?? input.citations),
       managedBy: "system",
       confidence: 0.74
     }
   });
-  const absolutePath = path17.join(paths.wikiDir, output.page.path);
+  const absolutePath = path18.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -9088,15 +9850,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path17.dirname(prepared.savedPath));
-  await fs14.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path18.dirname(prepared.savedPath));
+  await fs15.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path17.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path17.dirname(assetPath));
+    const assetPath = path18.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path18.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs14.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs15.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs14.writeFile(assetPath, assetFile.content);
+      await fs15.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -9112,12 +9874,12 @@ async function prepareExploreHubSave(rootDir, input) {
       status: "active",
       createdAt: now,
       updatedAt: now,
-      compiledFrom: uniqueStrings2(input.citations),
+      compiledFrom: uniqueStrings3(input.citations),
       managedBy: "system",
       confidence: 0.76
     }
   });
-  const absolutePath = path17.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path18.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -9129,15 +9891,15 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path17.dirname(prepared.savedPath));
-  await fs14.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path18.dirname(prepared.savedPath));
+  await fs15.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path17.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path17.dirname(assetPath));
+    const assetPath = path18.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path18.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs14.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs15.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs14.writeFile(assetPath, assetFile.content);
+      await fs15.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -9154,17 +9916,17 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     }))
   ]);
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path17.join(paths.approvalsDir, approvalId);
+  const approvalDir = path18.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path17.join(approvalDir, "wiki"));
-  await ensureDir(path17.join(approvalDir, "state"));
+  await ensureDir(path18.join(approvalDir, "wiki"));
+  await ensureDir(path18.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path17.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path17.dirname(targetPath));
+    const targetPath = path18.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path18.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs14.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs15.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs14.writeFile(targetPath, file.content, "utf8");
+      await fs15.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -9178,7 +9940,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs14.writeFile(path17.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs15.writeFile(path18.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9207,10 +9969,10 @@ async function executeQuery(rootDir, question, format) {
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path17.join(paths.wikiDir, result.path);
+      const absolutePath = path18.join(paths.wikiDir, result.path);
       try {
-        const content = await fs14.readFile(absolutePath, "utf8");
-        const parsed = matter8(content);
+        const content = await fs15.readFile(absolutePath, "utf8");
+        const parsed = matter9(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
       } catch {
@@ -9307,8 +10069,8 @@ async function generateFollowUpQuestions(rootDir, question, answer) {
 Current answer:
 ${answer}`
     },
-    z6.object({
-      questions: z6.array(z6.string().min(1)).max(5)
+    z7.object({
+      questions: z7.array(z7.string().min(1)).max(5)
     })
   );
   return uniqueBy(response.questions, (item) => item).filter((item) => item !== question);
@@ -9391,7 +10153,7 @@ function sortGraphPages(pages) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs14.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs15.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -9407,8 +10169,8 @@ async function readApproval(rootDir, approvalId) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs14.readFile(path17.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs14.readFile(path17.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs15.readFile(path18.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs15.readFile(path18.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       return {
         ...entry,
         currentContent,
@@ -9436,26 +10198,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path17.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs14.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path17.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path17.dirname(targetAbsolutePath));
-      await fs14.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path18.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs15.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path18.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path18.dirname(targetAbsolutePath));
+      await fs15.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs14.rm(path17.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs15.rm(path18.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 = path17.join(paths.wikiDir, "outputs", "assets", path17.basename(nextPage.path, ".md"));
-        await fs14.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path18.join(paths.wikiDir, "outputs", "assets", path18.basename(nextPage.path, ".md"));
+        await fs15.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path17.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path18.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path17.join(paths.wikiDir, asset.path);
-          await ensureDir(path17.dirname(targetAssetPath));
-          await fs14.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path18.join(paths.wikiDir, asset.path);
+          await ensureDir(path18.dirname(targetAssetPath));
+          await fs15.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -9466,10 +10228,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 fs14.rm(path17.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs15.rm(path18.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs14.rm(path17.join(paths.wikiDir, "outputs", "assets", path17.basename(deletedPage.path, ".md")), {
+        await fs15.rm(path18.join(paths.wikiDir, "outputs", "assets", path18.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -9559,22 +10321,22 @@ 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 fs14.readFile(path17.join(paths.wikiDir, candidate.path), "utf8");
-  const parsed = matter8(raw);
+  const raw = await fs15.readFile(path18.join(paths.wikiDir, candidate.path), "utf8");
+  const parsed = matter9(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const nextContent = matter8.stringify(parsed.content, {
+  const nextContent = matter9.stringify(parsed.content, {
     ...parsed.data,
     status: "active",
     updated_at: nextUpdatedAt,
-    tags: uniqueStrings2([candidate.kind, ...Array.isArray(parsed.data.tags) ? parsed.data.tags : []]).filter(
+    tags: uniqueStrings3([candidate.kind, ...Array.isArray(parsed.data.tags) ? parsed.data.tags : []]).filter(
       (tag) => tag !== "candidate"
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path17.join(paths.wikiDir, nextPath);
-  await ensureDir(path17.dirname(nextAbsolutePath));
-  await fs14.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs14.rm(path17.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path18.join(paths.wikiDir, nextPath);
+  await ensureDir(path18.dirname(nextAbsolutePath));
+  await fs15.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs15.rm(path18.join(paths.wikiDir, candidate.path), { force: true });
   const 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)
@@ -9618,7 +10380,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs14.rm(path17.join(paths.wikiDir, candidate.path), { force: true });
+  await fs15.rm(path18.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(),
@@ -9656,18 +10418,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path17.join(rootDir, ".obsidian");
+  const obsidianDir = path18.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path17.join(obsidianDir, "app.json"), {
+    writeJsonFile(path18.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path17.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path18.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -9677,7 +10439,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path17.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path18.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -9689,7 +10451,7 @@ async function ensureObsidianWorkspace(rootDir) {
       })),
       localJumps: false
     }),
-    writeJsonFile(path17.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path18.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -9704,11 +10466,11 @@ async function ensureObsidianWorkspace(rootDir) {
 async function initVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path17.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path18.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
-    matter8.stringify(
+    matter9.stringify(
       [
         "# Insights",
         "",
@@ -9740,8 +10502,8 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path17.join(paths.wikiDir, "projects", "index.md"),
-    matter8.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
+    path18.join(paths.wikiDir, "projects", "index.md"),
+    matter9.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
       title: "Projects",
@@ -9762,8 +10524,8 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path17.join(paths.wikiDir, "candidates", "index.md"),
-    matter8.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
+    path18.join(paths.wikiDir, "candidates", "index.md"),
+    matter9.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
       title: "Candidates",
@@ -9787,6 +10549,20 @@ async function initVault(rootDir, options = {}) {
     await ensureObsidianWorkspace(rootDir);
   }
 }
+async function runConfiguredBenchmark(rootDir, config) {
+  if (config.benchmark?.enabled === false) {
+    return { ok: true };
+  }
+  try {
+    await benchmarkVault(rootDir);
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 async function compileVault(rootDir, options = {}) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const { config, paths } = await initWorkspace(rootDir);
@@ -9802,7 +10578,7 @@ async function compileVault(rootDir, options = {}) {
   const currentInsightHashes = pageHashes(storedInsightPages);
   const previousState = await readJsonFile(paths.compileStatePath);
   const rootSchemaChanged = !previousState || previousState.rootSchemaHash !== schemas.root.hash;
-  const effectiveSchemaChanged = !previousState || previousGlobalSchemaHash(previousState) !== schemas.effective.global.hash || uniqueStrings2([...Object.keys(previousState?.effectiveSchemaHashes?.projects ?? {}), ...Object.keys(schemas.effective.projects)]).some(
+  const effectiveSchemaChanged = !previousState || previousGlobalSchemaHash(previousState) !== schemas.effective.global.hash || uniqueStrings3([...Object.keys(previousState?.effectiveSchemaHashes?.projects ?? {}), ...Object.keys(schemas.effective.projects)]).some(
     (projectId) => previousProjectSchemaHash(previousState, projectId) !== effectiveHashForProject(schemas, projectId)
   );
   const nextProjectConfigHash = projectConfigHash(config);
@@ -9835,6 +10611,10 @@ async function compileVault(rootDir, options = {}) {
   }
   if (dirty.length === 0 && !rootSchemaChanged && !effectiveSchemaChanged && !projectConfigChanged && !sourcesChanged && !outputsChanged && !insightsChanged && !pendingCandidatePromotion && artifactsExist && !options.approve) {
     const graph = await readJsonFile(paths.graphPath);
+    const benchmark2 = await runConfiguredBenchmark(rootDir, config);
+    if (graph && benchmark2.ok) {
+      await refreshIndexesAndSearch(rootDir, graph.pages);
+    }
     await recordSession(rootDir, {
       operation: "compile",
       title: `Compiled ${manifests.length} source(s)`,
@@ -9852,7 +10632,8 @@ async function compileVault(rootDir, options = {}) {
         `clean=${manifests.length}`,
         `outputs=${outputPages.length}`,
         `insights=${insightPages.length}`,
-        `schema=${schemas.effective.global.hash.slice(0, 12)}`
+        `schema=${schemas.effective.global.hash.slice(0, 12)}`,
+        `benchmark=${benchmark2.ok ? "ok" : `error:${benchmark2.error}`}`
       ]
     });
     return {
@@ -9879,7 +10660,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path17.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path18.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           return cached;
         }
@@ -9903,22 +10684,22 @@ async function compileVault(rootDir, options = {}) {
       }
       const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
       if (analysisSignature(enriched) !== analysisSignature(analysis)) {
-        await writeJsonFile(path17.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+        await writeJsonFile(path18.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
       }
       return enriched;
     })
   );
   await Promise.all([
-    ensureDir(path17.join(paths.wikiDir, "sources")),
-    ensureDir(path17.join(paths.wikiDir, "code")),
-    ensureDir(path17.join(paths.wikiDir, "concepts")),
-    ensureDir(path17.join(paths.wikiDir, "entities")),
-    ensureDir(path17.join(paths.wikiDir, "outputs")),
-    ensureDir(path17.join(paths.wikiDir, "projects")),
-    ensureDir(path17.join(paths.wikiDir, "insights")),
-    ensureDir(path17.join(paths.wikiDir, "candidates")),
-    ensureDir(path17.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path17.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path18.join(paths.wikiDir, "sources")),
+    ensureDir(path18.join(paths.wikiDir, "code")),
+    ensureDir(path18.join(paths.wikiDir, "concepts")),
+    ensureDir(path18.join(paths.wikiDir, "entities")),
+    ensureDir(path18.join(paths.wikiDir, "outputs")),
+    ensureDir(path18.join(paths.wikiDir, "projects")),
+    ensureDir(path18.join(paths.wikiDir, "insights")),
+    ensureDir(path18.join(paths.wikiDir, "candidates")),
+    ensureDir(path18.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path18.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
@@ -9970,6 +10751,10 @@ async function compileVault(rootDir, options = {}) {
       postPassApprovalDir = staged.approvalDir;
     }
   }
+  const benchmark = options.approve ? { ok: true } : await runConfiguredBenchmark(rootDir, config);
+  if (!options.approve && benchmark.ok) {
+    await refreshIndexesAndSearch(rootDir, sync.allPages);
+  }
   await recordSession(rootDir, {
     operation: "compile",
     title: `Compiled ${manifests.length} source(s)`,
@@ -9991,7 +10776,8 @@ async function compileVault(rootDir, options = {}) {
       `promoted=${sync.promotedPageIds.length}`,
       `staged=${sync.staged}`,
       `postPassApproval=${postPassApprovalId ?? "none"}`,
-      `schema=${schemas.effective.global.hash.slice(0, 12)}`
+      `schema=${schemas.effective.global.hash.slice(0, 12)}`,
+      `benchmark=${benchmark.ok ? "ok" : `error:${benchmark.error}`}`
     ]
   });
   return {
@@ -10060,7 +10846,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path17.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path18.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -10261,7 +11047,7 @@ ${orchestrationNotes.join("\n")}
     citations: allCitations,
     format: outputFormat,
     relatedPageCount: stepPages.length,
-    relatedNodeCount: uniqueStrings2(stepPages.flatMap((page) => page.nodeIds)).length,
+    relatedNodeCount: uniqueStrings3(stepPages.flatMap((page) => page.nodeIds)).length,
     projectId: stepPages[0]?.projectIds[0] ?? null
   });
   const hubInput = {
@@ -10271,7 +11057,7 @@ ${orchestrationNotes.join("\n")}
     citations: allCitations,
     schemaHash: composeVaultSchema(
       schemas.root,
-      uniqueStrings2(stepPages.flatMap((page) => page.projectIds).sort((left, right) => left.localeCompare(right))).map((projectId) => schemas.projects[projectId]).filter((schema) => Boolean(schema?.hash))
+      uniqueStrings3(stepPages.flatMap((page) => page.projectIds).sort((left, right) => left.localeCompare(right))).map((projectId) => schemas.projects[projectId]).filter((schema) => Boolean(schema?.hash))
     ).hash,
     outputFormat,
     outputAssets: hubAssetBundle.outputAssets,
@@ -10316,9 +11102,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path17.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path18.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path17.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path18.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -10331,7 +11117,7 @@ ${orchestrationNotes.join("\n")}
     providerId: provider.id,
     success: true,
     relatedSourceIds: [...relatedSourceIds],
-    relatedPageIds: uniqueStrings2([...relatedPageIds, ...stepPages.map((page) => page.id), hubPage.id]),
+    relatedPageIds: uniqueStrings3([...relatedPageIds, ...stepPages.map((page) => page.id), hubPage.id]),
     relatedNodeIds: [...relatedNodeIds],
     citations: allCitations,
     tokenUsage: tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0 ? {
@@ -10386,7 +11172,7 @@ async function queryGraphVault(rootDir, question, options = {}) {
   return queryGraph(graph, question, searchResults, options);
 }
 async function benchmarkVault(rootDir, options = {}) {
-  const { paths } = await loadVaultConfig(rootDir);
+  const { config, paths } = await loadVaultConfig(rootDir);
   const graph = await ensureCompiledGraph(rootDir);
   const manifests = await listManifests(rootDir);
   const pageContentsById = /* @__PURE__ */ new Map();
@@ -10398,15 +11184,17 @@ async function benchmarkVault(rootDir, options = {}) {
     }
   }
   for (const page of graph.pages) {
-    const absolutePath = path17.join(paths.wikiDir, page.path);
+    const absolutePath = path18.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const parsed = matter8(await fs14.readFile(absolutePath, "utf8"));
+    const parsed = matter9(await fs15.readFile(absolutePath, "utf8"));
     pageContentsById.set(page.id, parsed.content);
   }
+  const configuredQuestions = (config.benchmark?.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
+  const maxQuestions = Math.max(1, options.maxQuestions ?? config.benchmark?.maxQuestions ?? 3);
   const questions = (options.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
-  const sampleQuestions = questions.length ? questions : [...DEFAULT_BENCHMARK_QUESTIONS];
+  const sampleQuestions = (questions.length ? questions : configuredQuestions.length ? configuredQuestions : defaultBenchmarkQuestionsForGraph(graph, maxQuestions)).slice(0, maxQuestions);
   const perQuestion = sampleQuestions.map((question) => {
     const searchResults = searchPages(paths.searchDbPath, question, { limit: 12 });
     const result = queryGraph(graph, question, searchResults, { budget: 12 });
@@ -10416,6 +11204,7 @@ async function benchmarkVault(rootDir, options = {}) {
       queryTokens: metrics.queryTokens,
       reduction: metrics.reduction,
       visitedNodeIds: result.visitedNodeIds,
+      visitedEdgeIds: result.visitedEdgeIds,
       pageIds: result.pageIds
     };
   });
@@ -10448,15 +11237,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path17.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path18.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs14.readFile(absolutePath, "utf8");
-  const parsed = matter8(raw);
+  const raw = await fs15.readFile(absolutePath, "utf8");
+  const parsed = matter9(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(relativePath, path17.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path18.basename(relativePath, path18.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -10492,7 +11281,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: path17.join(paths.wikiDir, page.path),
+          pagePath: path18.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -10503,7 +11292,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: path17.join(paths.wikiDir, page.path),
+            pagePath: path18.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -10514,13 +11303,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path17.join(paths.wikiDir, page.path),
+          pagePath: path18.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path17.join(paths.wikiDir, page.path);
+      const absolutePath = path18.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs14.readFile(absolutePath, "utf8");
+        const content = await fs15.readFile(absolutePath, "utf8");
         if (content.includes("## Claims")) {
           const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
           if (uncited.length) {
@@ -10580,7 +11369,7 @@ async function lintVault(rootDir, options = {}) {
     providerId: provider?.id,
     success: true,
     relatedPageIds: graph.pages.map((page) => page.id),
-    relatedSourceIds: uniqueStrings2(graph.pages.flatMap((page) => page.sourceIds)),
+    relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
     lintFindingCount: findings.length,
     lines: [`findings=${findings.length}`, `deep=${Boolean(options.deep)}`, `web=${Boolean(options.web)}`]
   });
@@ -10600,7 +11389,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.21";
+var SERVER_VERSION = "0.1.22";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -10622,8 +11411,8 @@ async function createMcpServer(rootDir) {
     {
       description: "Search compiled wiki pages using the local full-text index.",
       inputSchema: {
-        query: z7.string().min(1).describe("Search query"),
-        limit: z7.number().int().min(1).max(25).optional().describe("Maximum number of results")
+        query: z8.string().min(1).describe("Search query"),
+        limit: z8.number().int().min(1).max(25).optional().describe("Maximum number of results")
       }
     },
     async ({ query, limit }) => {
@@ -10636,7 +11425,7 @@ async function createMcpServer(rootDir) {
     {
       description: "Read a generated wiki page by its path relative to wiki/.",
       inputSchema: {
-        path: z7.string().min(1).describe("Path relative to wiki/, for example sources/example.md")
+        path: z8.string().min(1).describe("Path relative to wiki/, for example sources/example.md")
       }
     },
     async ({ path: relativePath }) => {
@@ -10652,7 +11441,7 @@ async function createMcpServer(rootDir) {
     {
       description: "List source manifests in the current workspace.",
       inputSchema: {
-        limit: z7.number().int().min(1).max(100).optional().describe("Maximum number of manifests to return")
+        limit: z8.number().int().min(1).max(100).optional().describe("Maximum number of manifests to return")
       }
     },
     async ({ limit }) => {
@@ -10665,9 +11454,9 @@ async function createMcpServer(rootDir) {
     {
       description: "Traverse the local graph from search seeds without calling a model provider.",
       inputSchema: {
-        question: z7.string().min(1).describe("Question or graph search seed"),
-        traversal: z7.enum(["bfs", "dfs"]).optional().describe("Traversal strategy"),
-        budget: z7.number().int().min(3).max(50).optional().describe("Maximum nodes to summarize")
+        question: z8.string().min(1).describe("Question or graph search seed"),
+        traversal: z8.enum(["bfs", "dfs"]).optional().describe("Traversal strategy"),
+        budget: z8.number().int().min(3).max(50).optional().describe("Maximum nodes to summarize")
       }
     },
     async ({ question, traversal, budget }) => {
@@ -10683,7 +11472,7 @@ async function createMcpServer(rootDir) {
     {
       description: "Explain a graph node, its page, community, and neighbors.",
       inputSchema: {
-        target: z7.string().min(1).describe("Node or page label/id")
+        target: z8.string().min(1).describe("Node or page label/id")
       }
     },
     async ({ target }) => {
@@ -10695,7 +11484,7 @@ async function createMcpServer(rootDir) {
     {
       description: "Return the neighbors of a graph node or page target.",
       inputSchema: {
-        target: z7.string().min(1).describe("Node or page label/id")
+        target: z8.string().min(1).describe("Node or page label/id")
       }
     },
     async ({ target }) => {
@@ -10708,8 +11497,8 @@ async function createMcpServer(rootDir) {
     {
       description: "Find the shortest graph path between two targets.",
       inputSchema: {
-        from: z7.string().min(1).describe("Start node/page label or id"),
-        to: z7.string().min(1).describe("End node/page label or id")
+        from: z8.string().min(1).describe("Start node/page label or id"),
+        to: z8.string().min(1).describe("End node/page label or id")
       }
     },
     async ({ from, to }) => {
@@ -10721,7 +11510,7 @@ async function createMcpServer(rootDir) {
     {
       description: "List the highest-connectivity graph nodes.",
       inputSchema: {
-        limit: z7.number().int().min(1).max(25).optional().describe("Maximum nodes to return")
+        limit: z8.number().int().min(1).max(25).optional().describe("Maximum nodes to return")
       }
     },
     async ({ limit }) => {
@@ -10733,9 +11522,9 @@ async function createMcpServer(rootDir) {
     {
       description: "Ask a question against the compiled vault and optionally save the answer.",
       inputSchema: {
-        question: z7.string().min(1).describe("Question to ask the vault"),
-        save: z7.boolean().optional().describe("Persist the answer to wiki/outputs"),
-        format: z7.enum(["markdown", "report", "slides", "chart", "image"]).optional().describe("Output format")
+        question: z8.string().min(1).describe("Question to ask the vault"),
+        save: z8.boolean().optional().describe("Persist the answer to wiki/outputs"),
+        format: z8.enum(["markdown", "report", "slides", "chart", "image"]).optional().describe("Output format")
       }
     },
     async ({ question, save, format }) => {
@@ -10752,7 +11541,7 @@ async function createMcpServer(rootDir) {
     {
       description: "Ingest a local file path or URL into the SwarmVault workspace.",
       inputSchema: {
-        input: z7.string().min(1).describe("Local path or URL to ingest")
+        input: z8.string().min(1).describe("Local path or URL to ingest")
       }
     },
     async ({ input }) => {
@@ -10765,7 +11554,7 @@ async function createMcpServer(rootDir) {
     {
       description: "Compile source manifests into wiki pages, graph data, and search index.",
       inputSchema: {
-        approve: z7.boolean().optional().describe("Stage a review bundle without applying active page changes")
+        approve: z8.boolean().optional().describe("Stage a review bundle without applying active page changes")
       }
     },
     async ({ approve }) => {
@@ -10849,7 +11638,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(path18.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path19.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -10882,8 +11671,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path18.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs15.readFile(absolutePath, "utf8"));
+      const absolutePath = path19.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs16.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -10891,11 +11680,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(path18.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path19.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path18.basename(relativePath, ".md"),
+            name: path19.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -10912,11 +11701,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path18.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path19.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 fs15.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs16.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -10964,13 +11753,13 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs16 from "fs/promises";
-import path19 from "path";
+import fs17 from "fs/promises";
+import path20 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path19.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path20.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path19.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path20.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -11073,13 +11862,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs16.open(leasePath, "wx");
+  const handle = await fs17.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs16.rm(leasePath, { force: true });
+    await fs17.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -11227,15 +12016,15 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/viewer.ts
 import { execFile } from "child_process";
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 import http from "http";
-import path21 from "path";
+import path22 from "path";
 import { promisify } from "util";
-import matter9 from "gray-matter";
+import matter10 from "gray-matter";
 import mime2 from "mime-types";
 
 // src/watch.ts
-import path20 from "path";
+import path21 from "path";
 import process2 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
@@ -11243,15 +12032,15 @@ var BACKOFF_THRESHOLD = 3;
 var CRITICAL_THRESHOLD = 10;
 var REPO_WATCH_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
 function withinRoot2(rootPath, targetPath) {
-  const relative = path20.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path20.isAbsolute(relative);
+  const relative = path21.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative);
 }
 function hasIgnoredRepoSegment(baseDir, targetPath) {
-  const relativePath = path20.relative(baseDir, targetPath);
+  const relativePath = path21.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath.split(path20.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+  return relativePath.split(path21.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
 }
 function workspaceIgnoreRoots(rootDir, paths) {
   return [
@@ -11260,16 +12049,16 @@ function workspaceIgnoreRoots(rootDir, paths) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path20.join(rootDir, ".claude"),
-    path20.join(rootDir, ".cursor"),
-    path20.join(rootDir, ".obsidian")
-  ].map((candidate) => path20.resolve(candidate));
+    path21.join(rootDir, ".claude"),
+    path21.join(rootDir, ".cursor"),
+    path21.join(rootDir, ".obsidian")
+  ].map((candidate) => path21.resolve(candidate));
 }
 async function resolveWatchTargets(rootDir, paths, options) {
-  const targets = /* @__PURE__ */ new Set([path20.resolve(paths.inboxDir)]);
+  const targets = /* @__PURE__ */ new Set([path21.resolve(paths.inboxDir)]);
   if (options.repo) {
     for (const repoRoot of await listTrackedRepoRoots(rootDir)) {
-      targets.add(path20.resolve(repoRoot));
+      targets.add(path21.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
@@ -11399,7 +12188,7 @@ async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   const baseDebounceMs = options.debounceMs ?? 900;
   const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
-  const inboxWatchRoot = path20.resolve(paths.inboxDir);
+  const inboxWatchRoot = path21.resolve(paths.inboxDir);
   let watchTargets = await resolveWatchTargets(rootDir, paths, options);
   let timer;
   let running = false;
@@ -11413,7 +12202,7 @@ async function watchVault(rootDir, options = {}) {
     usePolling: true,
     interval: 100,
     ignored: (targetPath) => {
-      const absolutePath = path20.resolve(targetPath);
+      const absolutePath = path21.resolve(targetPath);
       const primaryTarget = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
@@ -11585,8 +12374,8 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path20.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
-    return path20.relative(baseDir, targetPath) || ".";
+    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path21.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path21.relative(baseDir, targetPath) || ".";
   };
   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) => {
@@ -11627,15 +12416,15 @@ async function getWatchStatus(rootDir) {
 var execFileAsync = promisify(execFile);
 async function readViewerPage(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 parsed = matter9(raw);
+  const raw = await fs18.readFile(absolutePath, "utf8");
+  const parsed = matter10(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,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -11643,12 +12432,12 @@ async function readViewerPage(rootDir, relativePath) {
 }
 async function readViewerAsset(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;
   }
   return {
-    buffer: await fs17.readFile(absolutePath),
+    buffer: await fs18.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -11671,12 +12460,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path21.join(viewerDistDir, "index.html");
+  const indexPath = path22.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path21.dirname(viewerDistDir);
-  if (await fileExists(path21.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path22.dirname(viewerDistDir);
+  if (await fileExists(path22.join(viewerProjectDir, "package.json"))) {
     await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -11693,7 +12482,7 @@ async function startGraphServer(rootDir, port) {
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs17.readFile(paths.graphPath, "utf8"));
+      response.end(await fs18.readFile(paths.graphPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/graph/query") {
@@ -11735,16 +12524,29 @@ async function startGraphServer(rootDir, port) {
       const kind = url.searchParams.get("kind") ?? "all";
       const status = url.searchParams.get("status") ?? "all";
       const project = url.searchParams.get("project") ?? "all";
+      const sourceType = url.searchParams.get("sourceType") ?? "all";
       const results = searchPages(paths.searchDbPath, query, {
         limit: Number.isFinite(limit) ? limit : 10,
         kind,
         status,
-        project
+        project,
+        sourceType
       });
       response.writeHead(200, { "content-type": "application/json" });
       response.end(JSON.stringify(results));
       return;
     }
+    if (url.pathname === "/api/graph-report") {
+      const reportPath = path22.join(paths.wikiDir, "graph", "report.json");
+      if (!await fileExists(reportPath)) {
+        response.writeHead(404, { "content-type": "application/json" });
+        response.end(JSON.stringify({ error: "Graph report artifact not found. Run `swarmvault compile` first." }));
+        return;
+      }
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(await fs18.readFile(reportPath, "utf8"));
+      return;
+    }
     if (url.pathname === "/api/watch-status") {
       response.writeHead(200, { "content-type": "application/json" });
       response.end(JSON.stringify(await getWatchStatus(rootDir)));
@@ -11825,8 +12627,8 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path21.join(paths.viewerDistDir, relativePath);
-    const fallback = path21.join(paths.viewerDistDir, "index.html");
+    const target = path22.join(paths.viewerDistDir, relativePath);
+    const fallback = path22.join(paths.viewerDistDir, "index.html");
     const filePath = await fileExists(target) ? target : fallback;
     if (!await fileExists(filePath)) {
       response.writeHead(503, { "content-type": "text/plain" });
@@ -11834,7 +12636,7 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs17.readFile(filePath));
+    response.end(await fs18.readFile(filePath));
   });
   await new Promise((resolve) => {
     server.listen(effectivePort, resolve);
@@ -11861,7 +12663,7 @@ async function exportGraphHtml(rootDir, outputPath) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path21.join(paths.viewerDistDir, "index.html");
+  const indexPath = path22.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -11874,6 +12676,7 @@ async function exportGraphHtml(rootDir, outputPath) {
         title: loaded.title,
         kind: page.kind,
         status: page.status,
+        sourceType: page.sourceType,
         projectIds: page.projectIds,
         content: loaded.content,
         assets: await Promise.all(
@@ -11885,17 +12688,18 @@ async function exportGraphHtml(rootDir, outputPath) {
       } : null;
     })
   );
-  const rawHtml = await fs17.readFile(indexPath, "utf8");
+  const rawHtml = await fs18.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] ? path21.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path21.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path22.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path22.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 fs17.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs17.readFile(stylePath, "utf8") : "";
-  const embeddedData = JSON.stringify({ graph, pages: pages.filter(Boolean) }, null, 2).replace(/</g, "\\u003c");
+  const script = await fs18.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs18.readFile(stylePath, "utf8") : "";
+  const report = await readJsonFile(path22.join(paths.wikiDir, "graph", "report.json"));
+  const embeddedData = JSON.stringify({ graph, pages: pages.filter(Boolean), report }, null, 2).replace(/</g, "\\u003c");
   const html = [
     "<!doctype html>",
     '<html lang="en">',
@@ -11913,9 +12717,9 @@ async function exportGraphHtml(rootDir, outputPath) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs17.mkdir(path21.dirname(outputPath), { recursive: true });
-  await fs17.writeFile(outputPath, html, "utf8");
-  return path21.resolve(outputPath);
+  await fs18.mkdir(path22.dirname(outputPath), { recursive: true });
+  await fs18.writeFile(outputPath, html, "utf8");
+  return path22.resolve(outputPath);
 }
 export {
   acceptApproval,