@swarmvaultai/engine 0.1.21 → 0.1.22

package/dist/index.js

@@ -593,8 +593,8 @@ 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 ignore from "ignore";
 import { JSDOM } from "jsdom";
@@ -2728,9 +2728,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 +2745,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 +2993,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 +3007,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 +3056,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 +3064,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 +3075,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 +3090,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 +3184,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;
@@ -3007,7 +3236,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 +3245,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 +3273,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) {
@@ -3231,7 +3460,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 +3480,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 +3542,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 +3555,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 +3571,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 +3597,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 +3621,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 +3657,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 +3786,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.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath) {
     return { manifest: existingByOrigin, isNew: false, wasUpdated: false };
   }
   if (existingByHash) {
@@ -3568,27 +3798,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
     });
@@ -3602,15 +3839,17 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     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 +3867,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 });
   }
-  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 });
+  if (manifest.extractedMetadataPath) {
+    await fs9.rm(path9.resolve(rootDir, manifest.extractedMetadataPath), { force: true });
+  }
+  await fs9.rm(path9.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
+  await fs9.rm(path9.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
 }
 function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
   const candidates = [
@@ -3643,14 +3885,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.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 +3911,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 +3945,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 +3961,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 +3969,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 +3992,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 +4016,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 +4024,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 +4044,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 +4061,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 +4084,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 +4108,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 +4133,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,10 +4174,12 @@ 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}`);
@@ -3932,6 +4193,7 @@ async function prepareUrlInput(input, options) {
   let storedExtension = ".bin";
   let title = inputUrl.hostname + inputUrl.pathname;
   let extractedText;
+  let extractionArtifact;
   let attachments;
   let contentHash;
   const logDetails = [];
@@ -3962,6 +4224,7 @@ async function prepareUrlInput(input, options) {
     }
     const converted = localizedHtml === html && !attachments?.length ? initialConversion : await convertHtmlToMarkdown(localizedHtml, input);
     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])
@@ -3973,11 +4236,12 @@ 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),
@@ -3998,6 +4262,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 {
@@ -4010,6 +4287,8 @@ async function prepareUrlInput(input, options) {
     storedExtension,
     payloadBytes,
     extractedText,
+    extractionArtifact,
+    extractionHash: buildExtractionHash(extractedText, extractionArtifact),
     attachments,
     contentHash,
     logDetails
@@ -4023,14 +4302,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 +4343,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 +4365,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,9 +4387,9 @@ 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;
 }
@@ -4167,7 +4449,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 +4465,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 +4486,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 +4497,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 +4540,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 +4550,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 +4590,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 +4606,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 +4682,30 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs14 from "fs/promises";
-import path17 from "path";
+import fs15 from "fs/promises";
+import path18 from "path";
 import matter8 from "gray-matter";
-import { z as z6 } from "zod";
+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 +4794,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 +4841,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 +4868,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: [],
@@ -4714,10 +5081,10 @@ function conflictConfidence(claimA, claimB) {
 }
 
 // src/deep-lint.ts
-import fs10 from "fs/promises";
-import path13 from "path";
+import fs11 from "fs/promises";
+import path14 from "path";
 import matter3 from "gray-matter";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/findings.ts
 function normalizeFindingSeverity(value) {
@@ -4736,25 +5103,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 +5196,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 +5290,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 +5374,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 +5388,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 +5412,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,8 +5448,8 @@ 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 absolutePath = path14.join(paths.wikiDir, page.path);
+      const raw = await fs11.readFile(absolutePath, "utf8").catch(() => "");
       const parsed = matter3(raw);
       return {
         id: page.id,
@@ -5130,7 +5497,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)) {
@@ -6653,49 +7020,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,13 +7214,13 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
-import fs12 from "fs/promises";
-import path15 from "path";
+import fs13 from "fs/promises";
+import path16 from "path";
 import matter6 from "gray-matter";
 
 // src/pages.ts
-import fs11 from "fs/promises";
-import path14 from "path";
+import fs12 from "fs/promises";
+import path15 from "path";
 import matter5 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -6925,7 +7292,7 @@ async function loadExistingManagedPageState(absolutePath, defaults = {}) {
       updatedAt: updatedFallback
     };
   }
-  const content = await fs11.readFile(absolutePath, "utf8");
+  const content = await fs12.readFile(absolutePath, "utf8");
   const parsed = matter5(content);
   return {
     status: normalizePageStatus(parsed.data.status, defaults.status ?? "active"),
@@ -6964,7 +7331,7 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const fallbackCreatedAt = defaults.createdAt ?? now;
   const fallbackUpdatedAt = defaults.updatedAt ?? fallbackCreatedAt;
-  const title = typeof parsed.data.title === "string" ? parsed.data.title : 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);
@@ -7003,18 +7370,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 relativePath = toPosix(path15.relative(wikiDir, absolutePath));
+    const content = await fs12.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 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,27 +7443,27 @@ function relatedOutputsForPage(targetPage, outputPages) {
   return outputPages.map((page) => ({ page, rank: relationRank(page, targetPage) })).filter((item) => item.rank > 0).sort((left, right) => right.rank - left.rank || left.page.title.localeCompare(right.page.title)).map((item) => item.page);
 }
 async function resolveUniqueOutputSlug(wikiDir, baseSlug) {
-  const outputsDir = 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 relativePath = path16.posix.join("outputs", entry.name);
+    const absolutePath = path16.join(outputsDir, entry.name);
+    const content = await fs13.readFile(absolutePath, "utf8");
     const parsed = matter6(content);
     const slug = entry.name.replace(/\.md$/, "");
     const title = typeof parsed.data.title === "string" ? parsed.data.title : slug;
@@ -7109,7 +7476,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,8 +7514,8 @@ async function loadSavedOutputPages(wikiDir) {
 }
 
 // src/search.ts
-import fs13 from "fs/promises";
-import path16 from "path";
+import fs14 from "fs/promises";
+import path17 from "path";
 import matter7 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
@@ -7168,7 +7535,7 @@ function normalizeStatus(value) {
   return value === "draft" || value === "candidate" || value === "active" || value === "archived" ? 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;");
@@ -7198,8 +7565,8 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
     "INSERT INTO pages (id, path, title, body, kind, status, 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 absolutePath = path17.join(wikiDir, page.path);
+    const content = await fs14.readFile(absolutePath, "utf8");
     const parsed = matter7(content);
     insertPage.run(
       page.id,
@@ -7302,7 +7669,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}`;
@@ -7640,7 +8007,7 @@ 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) {
@@ -7666,10 +8033,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) {
@@ -7843,7 +8210,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 +8248,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
@@ -8325,7 +8692,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash) {
   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,
@@ -8345,7 +8712,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash) {
       )
     );
   }
-  const reportAbsolutePath = path17.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path18.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -8364,7 +8731,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash) {
   return [reportRecord, ...communityRecords];
 }
 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 +8793,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 +8825,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 +8840,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 +8873,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 +8885,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 +8954,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 +8999,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,
@@ -8665,8 +9032,8 @@ async function syncVaultArtifacts(rootDir, input) {
       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 +9050,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",
@@ -8764,7 +9131,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 +9155,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 +9183,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 +9214,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 +9225,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 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 = uniqueStrings2([...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,7 +9255,7 @@ 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(paths.codeIndexPath, input.codeIndex);
@@ -8959,17 +9326,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 +9357,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 +9375,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 +9396,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(
@@ -9043,20 +9410,20 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     );
   }
   for (const record of graphOrientationRecords) {
-    await writeFileIfChanged(path17.join(paths.wikiDir, record.page.path), record.content);
+    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)));
+  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 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", ...graphOrientationRecords.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);
 }
@@ -9076,7 +9443,7 @@ async function prepareOutputPageSave(rootDir, input) {
       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 +9455,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 };
@@ -9117,7 +9484,7 @@ async function prepareExploreHubSave(rootDir, input) {
       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 +9496,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 +9521,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 +9545,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,9 +9574,9 @@ async function executeQuery(rootDir, question, format) {
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path17.join(paths.wikiDir, result.path);
+      const absolutePath = path18.join(paths.wikiDir, result.path);
       try {
-        const content = await fs14.readFile(absolutePath, "utf8");
+        const content = await fs15.readFile(absolutePath, "utf8");
         const parsed = matter8(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
@@ -9307,8 +9674,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 +9758,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 +9774,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 +9803,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 +9833,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,7 +9926,7 @@ async function promoteCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  const raw = await fs14.readFile(path17.join(paths.wikiDir, candidate.path), "utf8");
+  const raw = await fs15.readFile(path18.join(paths.wikiDir, candidate.path), "utf8");
   const parsed = matter8(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const nextContent = matter8.stringify(parsed.content, {
@@ -9571,10 +9938,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   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 +9985,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 +10023,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 +10044,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 +10056,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,7 +10071,7 @@ 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,
@@ -9740,7 +10107,7 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path17.join(paths.wikiDir, "projects", "index.md"),
+    path18.join(paths.wikiDir, "projects", "index.md"),
     matter8.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
@@ -9762,7 +10129,7 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path17.join(paths.wikiDir, "candidates", "index.md"),
+    path18.join(paths.wikiDir, "candidates", "index.md"),
     matter8.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
@@ -9879,7 +10246,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 +10270,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,
@@ -10060,7 +10427,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;
@@ -10316,9 +10683,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);
   }
@@ -10398,11 +10765,11 @@ 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 = matter8(await fs15.readFile(absolutePath, "utf8"));
     pageContentsById.set(page.id, parsed.content);
   }
   const questions = (options.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
@@ -10448,15 +10815,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 raw = await fs15.readFile(absolutePath, "utf8");
   const parsed = matter8(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 +10859,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 +10870,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 +10881,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) {
@@ -10600,7 +10967,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 +10989,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 +11003,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 +11019,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 +11032,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 +11050,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 +11062,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 +11075,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 +11088,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 +11100,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 +11119,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 +11132,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 +11216,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 +11249,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 +11258,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 +11279,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 +11331,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 +11440,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 +11594,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 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 +11610,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 +11627,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 +11766,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 +11780,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 +11952,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 +11994,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 raw = await fs18.readFile(absolutePath, "utf8");
   const parsed = matter9(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path21.basename(relativePath, path21.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path22.basename(relativePath, path22.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -11643,12 +12010,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 +12038,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 +12060,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") {
@@ -11825,8 +12192,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 +12201,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 +12228,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.");
   }
@@ -11885,16 +12252,16 @@ 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 script = await fs18.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs18.readFile(stylePath, "utf8") : "";
   const embeddedData = JSON.stringify({ graph, pages: pages.filter(Boolean) }, null, 2).replace(/</g, "\\u003c");
   const html = [
     "<!doctype html>",
@@ -11913,9 +12280,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,