@swarmvaultai/engine 0.1.4 → 0.1.5

package/dist/index.js

@@ -1,9 +1,19 @@
+// src/agents.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
 // src/config.ts
-import path2 from "path";
 import fs2 from "fs/promises";
+import path2 from "path";
 import { fileURLToPath } from "url";
 import { z as z2 } from "zod";
 
+// src/types.ts
+import { z } from "zod";
+var providerCapabilitySchema = z.enum(["responses", "chat", "structured", "tools", "vision", "embeddings", "streaming", "local"]);
+var providerTypeSchema = z.enum(["heuristic", "openai", "ollama", "anthropic", "gemini", "openai-compatible", "custom"]);
+var webSearchProviderTypeSchema = z.enum(["http-json", "custom"]);
+
 // src/utils.ts
 import crypto from "crypto";
 import fs from "fs/promises";
@@ -110,28 +120,6 @@ async function listFilesRecursive(rootDir) {
   return files;
 }
 
-// src/types.ts
-import { z } from "zod";
-var providerCapabilitySchema = z.enum([
-  "responses",
-  "chat",
-  "structured",
-  "tools",
-  "vision",
-  "embeddings",
-  "streaming",
-  "local"
-]);
-var providerTypeSchema = z.enum([
-  "heuristic",
-  "openai",
-  "ollama",
-  "anthropic",
-  "gemini",
-  "openai-compatible",
-  "custom"
-]);
-
 // src/config.ts
 var PRIMARY_CONFIG_FILENAME = "swarmvault.config.json";
 var LEGACY_CONFIG_FILENAME = "vault.config.json";
@@ -148,6 +136,22 @@ var providerConfigSchema = z2.object({
   capabilities: z2.array(providerCapabilitySchema).optional(),
   apiStyle: z2.enum(["responses", "chat"]).optional()
 });
+var webSearchProviderConfigSchema = z2.object({
+  type: webSearchProviderTypeSchema,
+  endpoint: z2.string().url().optional(),
+  method: z2.enum(["GET", "POST"]).optional(),
+  apiKeyEnv: z2.string().min(1).optional(),
+  apiKeyHeader: z2.string().min(1).optional(),
+  apiKeyPrefix: z2.string().optional(),
+  headers: z2.record(z2.string(), z2.string()).optional(),
+  queryParam: z2.string().min(1).optional(),
+  limitParam: z2.string().min(1).optional(),
+  resultsPath: z2.string().min(1).optional(),
+  titleField: z2.string().min(1).optional(),
+  urlField: z2.string().min(1).optional(),
+  snippetField: z2.string().min(1).optional(),
+  module: z2.string().min(1).optional()
+});
 var vaultConfigSchema = z2.object({
   workspace: z2.object({
     rawDir: z2.string().min(1),
@@ -166,7 +170,13 @@ var vaultConfigSchema = z2.object({
   viewer: z2.object({
     port: z2.number().int().positive()
   }),
-  agents: z2.array(z2.enum(["codex", "claude", "cursor"])).default(["codex", "claude", "cursor"])
+  agents: z2.array(z2.enum(["codex", "claude", "cursor"])).default(["codex", "claude", "cursor"]),
+  webSearch: z2.object({
+    providers: z2.record(z2.string(), webSearchProviderConfigSchema),
+    tasks: z2.object({
+      deepLintProvider: z2.string().min(1)
+    })
+  }).optional()
 });
 function defaultVaultConfig() {
   return {
@@ -333,25 +343,101 @@ async function initWorkspace(rootDir) {
   return { config, paths };
 }
 
+// src/agents.ts
+var managedStart = "<!-- swarmvault:managed:start -->";
+var managedEnd = "<!-- swarmvault:managed:end -->";
+var legacyManagedStart = "<!-- vault:managed:start -->";
+var legacyManagedEnd = "<!-- vault:managed:end -->";
+function buildManagedBlock(agent) {
+  const body = [
+    managedStart,
+    `# SwarmVault Rules (${agent})`,
+    "",
+    "- Read `swarmvault.schema.md` before compile or query style work. If only `schema.md` exists, treat it as the legacy schema path.",
+    "- Treat `raw/` as immutable source input.",
+    "- Treat `wiki/` as generated markdown owned by the agent and compiler workflow.",
+    "- Read `wiki/index.md` before broad file searching when answering SwarmVault questions.",
+    "- Preserve frontmatter fields including `page_id`, `source_ids`, `node_ids`, `freshness`, and `source_hashes`.",
+    "- Save high-value answers back into `wiki/outputs/` instead of leaving them only in chat.",
+    "- Prefer `swarmvault ingest`, `swarmvault compile`, `swarmvault query`, and `swarmvault lint` for SwarmVault maintenance tasks.",
+    managedEnd,
+    ""
+  ].join("\n");
+  if (agent === "cursor") {
+    return body;
+  }
+  return body;
+}
+async function upsertManagedBlock(filePath, block) {
+  const existing = await fileExists(filePath) ? await fs3.readFile(filePath, "utf8") : "";
+  if (!existing) {
+    await ensureDir(path3.dirname(filePath));
+    await fs3.writeFile(filePath, `${block}
+`, "utf8");
+    return;
+  }
+  const startIndex = existing.includes(managedStart) ? existing.indexOf(managedStart) : existing.indexOf(legacyManagedStart);
+  const endIndex = existing.includes(managedEnd) ? existing.indexOf(managedEnd) : existing.indexOf(legacyManagedEnd);
+  if (startIndex !== -1 && endIndex !== -1) {
+    const next = `${existing.slice(0, startIndex)}${block}${existing.slice(endIndex + managedEnd.length)}`;
+    await fs3.writeFile(filePath, next, "utf8");
+    return;
+  }
+  await fs3.writeFile(filePath, `${existing.trimEnd()}
+
+${block}
+`, "utf8");
+}
+async function installAgent(rootDir, agent) {
+  await initWorkspace(rootDir);
+  const block = buildManagedBlock(agent);
+  switch (agent) {
+    case "codex": {
+      const target = path3.join(rootDir, "AGENTS.md");
+      await upsertManagedBlock(target, block);
+      return target;
+    }
+    case "claude": {
+      const target = path3.join(rootDir, "CLAUDE.md");
+      await upsertManagedBlock(target, block);
+      return target;
+    }
+    case "cursor": {
+      const rulesDir = path3.join(rootDir, ".cursor", "rules");
+      await ensureDir(rulesDir);
+      const target = path3.join(rulesDir, "swarmvault.mdc");
+      await fs3.writeFile(target, `${block}
+`, "utf8");
+      return target;
+    }
+    default:
+      throw new Error(`Unsupported agent ${String(agent)}`);
+  }
+}
+async function installConfiguredAgents(rootDir) {
+  const { config } = await initWorkspace(rootDir);
+  return Promise.all(config.agents.map((agent) => installAgent(rootDir, agent)));
+}
+
 // src/ingest.ts
-import fs4 from "fs/promises";
-import path4 from "path";
-import { JSDOM } from "jsdom";
-import TurndownService from "turndown";
+import fs5 from "fs/promises";
+import path5 from "path";
 import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
 import mime from "mime-types";
+import TurndownService from "turndown";
 
 // src/logs.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 async function appendLogEntry(rootDir, action, title, lines = []) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.wikiDir);
-  const logPath = path3.join(paths.wikiDir, "log.md");
+  const logPath = path4.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 fs3.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs3.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs4.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs4.writeFile(logPath, `${existing}${entry}
 `, "utf8");
 }
 async function appendWatchRun(rootDir, run) {
@@ -393,7 +479,7 @@ function buildCompositeHash(payloadBytes, attachments = []) {
   return sha256(`${sha256(payloadBytes)}|${attachmentSignature}`);
 }
 function sanitizeAssetRelativePath(value) {
-  const normalized = path4.posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = path5.posix.normalize(value.replace(/\\/g, "/"));
   const segments = normalized.split("/").filter(Boolean).map((segment) => {
     if (segment === ".") {
       return "";
@@ -413,7 +499,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("#") || path4.isAbsolute(candidate)) {
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path5.isAbsolute(candidate)) {
     return null;
   }
   return candidate.replace(/\\/g, "/");
@@ -441,12 +527,12 @@ async function convertHtmlToMarkdown(html, url) {
   };
 }
 async function readManifestByHash(manifestsDir, contentHash) {
-  const entries = await fs4.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs5.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path4.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path5.join(manifestsDir, entry.name));
     if (manifest?.contentHash === contentHash) {
       return manifest;
     }
@@ -466,20 +552,20 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const sourceId = `${slugify(prepared.title)}-${contentHash.slice(0, 8)}`;
-  const storedPath = path4.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
-  await fs4.writeFile(storedPath, prepared.payloadBytes);
+  const storedPath = path5.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
+  await fs5.writeFile(storedPath, prepared.payloadBytes);
   let extractedTextPath;
   if (prepared.extractedText) {
-    extractedTextPath = path4.join(paths.extractsDir, `${sourceId}.md`);
-    await fs4.writeFile(extractedTextPath, prepared.extractedText, "utf8");
+    extractedTextPath = path5.join(paths.extractsDir, `${sourceId}.md`);
+    await fs5.writeFile(extractedTextPath, prepared.extractedText, "utf8");
   }
   const manifestAttachments = [];
   for (const attachment of attachments) {
-    const absoluteAttachmentPath = path4.join(paths.rawAssetsDir, sourceId, attachment.relativePath);
-    await ensureDir(path4.dirname(absoluteAttachmentPath));
-    await fs4.writeFile(absoluteAttachmentPath, attachment.bytes);
+    const absoluteAttachmentPath = path5.join(paths.rawAssetsDir, sourceId, attachment.relativePath);
+    await ensureDir(path5.dirname(absoluteAttachmentPath));
+    await fs5.writeFile(absoluteAttachmentPath, attachment.bytes);
     manifestAttachments.push({
-      path: toPosix(path4.relative(rootDir, absoluteAttachmentPath)),
+      path: toPosix(path5.relative(rootDir, absoluteAttachmentPath)),
       mimeType: attachment.mimeType,
       originalPath: attachment.originalPath
     });
@@ -491,15 +577,15 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     sourceKind: prepared.sourceKind,
     originalPath: prepared.originalPath,
     url: prepared.url,
-    storedPath: toPosix(path4.relative(rootDir, storedPath)),
-    extractedTextPath: extractedTextPath ? toPosix(path4.relative(rootDir, extractedTextPath)) : void 0,
+    storedPath: toPosix(path5.relative(rootDir, storedPath)),
+    extractedTextPath: extractedTextPath ? toPosix(path5.relative(rootDir, extractedTextPath)) : void 0,
     mimeType: prepared.mimeType,
     contentHash,
     createdAt: now,
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
   };
-  await writeJsonFile(path4.join(paths.manifestsDir, `${sourceId}.json`), manifest);
+  await writeJsonFile(path5.join(paths.manifestsDir, `${sourceId}.json`), manifest);
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
@@ -507,18 +593,18 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   ]);
   return { manifest, isNew: true };
 }
-async function prepareFileInput(rootDir, absoluteInput) {
-  const payloadBytes = await fs4.readFile(absoluteInput);
+async function prepareFileInput(_rootDir, absoluteInput) {
+  const payloadBytes = await fs5.readFile(absoluteInput);
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
-  const storedExtension = path4.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
+  const storedExtension = path5.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
   let title;
   let extractedText;
   if (sourceKind === "markdown" || sourceKind === "text") {
     extractedText = payloadBytes.toString("utf8");
-    title = titleFromText(path4.basename(absoluteInput, path4.extname(absoluteInput)), extractedText);
+    title = titleFromText(path5.basename(absoluteInput, path5.extname(absoluteInput)), extractedText);
   } else {
-    title = path4.basename(absoluteInput, path4.extname(absoluteInput));
+    title = path5.basename(absoluteInput, path5.extname(absoluteInput));
   }
   return {
     title,
@@ -552,7 +638,7 @@ async function prepareUrlInput(input) {
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path4.extname(new URL(input).pathname);
+    const extension = path5.extname(new URL(input).pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text") {
       extractedText = payloadBytes.toString("utf8");
@@ -578,14 +664,14 @@ async function collectInboxAttachmentRefs(inputDir, files) {
     if (sourceKind !== "markdown") {
       continue;
     }
-    const content = await fs4.readFile(absolutePath, "utf8");
+    const content = await fs5.readFile(absolutePath, "utf8");
     const refs = extractMarkdownReferences(content);
     if (!refs.length) {
       continue;
     }
     const sourceRefs = [];
     for (const ref of refs) {
-      const resolved = path4.resolve(path4.dirname(absolutePath), ref);
+      const resolved = path5.resolve(path5.dirname(absolutePath), ref);
       if (!resolved.startsWith(inputDir) || !await fileExists(resolved)) {
         continue;
       }
@@ -619,12 +705,12 @@ function rewriteMarkdownReferences(content, replacements) {
   });
 }
 async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs4.readFile(absolutePath);
+  const originalBytes = await fs5.readFile(absolutePath);
   const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path4.basename(absolutePath, path4.extname(absolutePath)), originalText);
+  const title = titleFromText(path5.basename(absolutePath, path5.extname(absolutePath)), originalText);
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
-    const bytes = await fs4.readFile(attachmentRef.absolutePath);
+    const bytes = await fs5.readFile(attachmentRef.absolutePath);
     attachments.push({
       relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
       mimeType: guessMimeType(attachmentRef.absolutePath),
@@ -647,7 +733,7 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     sourceKind: "markdown",
     originalPath: toPosix(absolutePath),
     mimeType: "text/markdown",
-    storedExtension: path4.extname(absolutePath) || ".md",
+    storedExtension: path5.extname(absolutePath) || ".md",
     payloadBytes: Buffer.from(rewrittenText, "utf8"),
     extractedText: rewrittenText,
     attachments,
@@ -659,50 +745,48 @@ function isSupportedInboxKind(sourceKind) {
 }
 async function ingestInput(rootDir, input) {
   const { paths } = await initWorkspace(rootDir);
-  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input) : await prepareFileInput(rootDir, path4.resolve(rootDir, input));
+  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input) : await prepareFileInput(rootDir, path5.resolve(rootDir, input));
   const result = await persistPreparedInput(rootDir, prepared, paths);
   return result.manifest;
 }
 async function importInbox(rootDir, inputDir) {
   const { paths } = await initWorkspace(rootDir);
-  const effectiveInputDir = path4.resolve(rootDir, inputDir ?? paths.inboxDir);
+  const effectiveInputDir = path5.resolve(rootDir, inputDir ?? paths.inboxDir);
   if (!await fileExists(effectiveInputDir)) {
     throw new Error(`Inbox directory not found: ${effectiveInputDir}`);
   }
   const files = (await listFilesRecursive(effectiveInputDir)).sort();
   const refsBySource = await collectInboxAttachmentRefs(effectiveInputDir, files);
-  const claimedAttachments = new Set(
-    [...refsBySource.values()].flatMap((refs) => refs.map((ref) => ref.absolutePath))
-  );
+  const claimedAttachments = new Set([...refsBySource.values()].flatMap((refs) => refs.map((ref) => ref.absolutePath)));
   const imported = [];
   const skipped = [];
   let attachmentCount = 0;
   for (const absolutePath of files) {
-    const basename = path4.basename(absolutePath);
+    const basename = path5.basename(absolutePath);
     if (basename.startsWith(".")) {
-      skipped.push({ path: toPosix(path4.relative(rootDir, absolutePath)), reason: "hidden_file" });
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "hidden_file" });
       continue;
     }
     if (claimedAttachments.has(absolutePath)) {
-      skipped.push({ path: toPosix(path4.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
     if (!isSupportedInboxKind(sourceKind)) {
-      skipped.push({ path: toPosix(path4.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+      skipped.push({ path: toPosix(path5.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(path4.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
     attachmentCount += result.manifest.attachments?.length ?? 0;
     imported.push(result.manifest);
   }
-  await appendLogEntry(rootDir, "inbox_import", toPosix(path4.relative(rootDir, effectiveInputDir)) || ".", [
+  await appendLogEntry(rootDir, "inbox_import", toPosix(path5.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `attachments=${attachmentCount}`,
@@ -721,9 +805,9 @@ async function listManifests(rootDir) {
   if (!await fileExists(paths.manifestsDir)) {
     return [];
   }
-  const entries = await fs4.readdir(paths.manifestsDir);
+  const entries = await fs5.readdir(paths.manifestsDir);
   const manifests = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path4.join(paths.manifestsDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path5.join(paths.manifestsDir, entry)))
   );
   return manifests.filter((manifest) => Boolean(manifest));
 }
@@ -731,33 +815,62 @@ async function readExtractedText(rootDir, manifest) {
   if (!manifest.extractedTextPath) {
     return void 0;
   }
-  const absolutePath = path4.resolve(rootDir, manifest.extractedTextPath);
+  const absolutePath = path5.resolve(rootDir, manifest.extractedTextPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
-  return fs4.readFile(absolutePath, "utf8");
+  return fs5.readFile(absolutePath, "utf8");
+}
+
+// src/mcp.ts
+import fs12 from "fs/promises";
+import path14 from "path";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z9 } from "zod";
+
+// src/schema.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+async function loadVaultSchema(rootDir) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const schemaPath = paths.schemaPath;
+  const content = await fileExists(schemaPath) ? await fs6.readFile(schemaPath, "utf8") : defaultVaultSchema();
+  const normalized = content.trim() ? content.trim() : defaultVaultSchema().trim();
+  return {
+    path: schemaPath,
+    content: normalized,
+    hash: sha256(normalized),
+    isLegacyPath: path6.basename(schemaPath) === LEGACY_SCHEMA_FILENAME && path6.basename(schemaPath) !== PRIMARY_SCHEMA_FILENAME
+  };
+}
+function buildSchemaPrompt(schema, instruction) {
+  return [instruction, "", `Vault schema path: ${schema.path}`, "", "Vault schema instructions:", schema.content].join("\n");
 }
 
 // src/vault.ts
-import fs9 from "fs/promises";
-import path10 from "path";
-import matter3 from "gray-matter";
+import fs11 from "fs/promises";
+import path13 from "path";
+import matter5 from "gray-matter";
+import { z as z8 } from "zod";
 
 // src/analysis.ts
-import path5 from "path";
+import path7 from "path";
 import { z as z3 } from "zod";
 var sourceAnalysisSchema = z3.object({
   title: z3.string().min(1),
   summary: z3.string().min(1),
   concepts: z3.array(z3.object({ name: z3.string().min(1), description: z3.string().default("") })).max(12).default([]),
   entities: z3.array(z3.object({ name: z3.string().min(1), description: z3.string().default("") })).max(12).default([]),
-  claims: z3.array(z3.object({
-    text: z3.string().min(1),
-    confidence: z3.number().min(0).max(1).default(0.6),
-    status: z3.enum(["extracted", "inferred", "conflicted", "stale"]).default("extracted"),
-    polarity: z3.enum(["positive", "negative", "neutral"]).default("neutral"),
-    citation: z3.string().min(1)
-  })).max(8).default([]),
+  claims: z3.array(
+    z3.object({
+      text: z3.string().min(1),
+      confidence: z3.number().min(0).max(1).default(0.6),
+      status: z3.enum(["extracted", "inferred", "conflicted", "stale"]).default("extracted"),
+      polarity: z3.enum(["positive", "negative", "neutral"]).default("neutral"),
+      citation: z3.string().min(1)
+    })
+  ).max(8).default([]),
   questions: z3.array(z3.string()).max(6).default([])
 });
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -812,7 +925,10 @@ function extractTopTerms(text, count) {
 }
 function extractEntities(text, count) {
   const matches = text.match(/\b[A-Z][A-Za-z0-9-]+(?:\s+[A-Z][A-Za-z0-9-]+){0,2}\b/g) ?? [];
-  return uniqueBy(matches.map((value) => normalizeWhitespace(value)), (value) => value.toLowerCase()).slice(0, count);
+  return uniqueBy(
+    matches.map((value) => normalizeWhitespace(value)),
+    (value) => value.toLowerCase()
+  ).slice(0, count);
 }
 function detectPolarity(text) {
   if (/\b(no|not|never|cannot|can't|won't|without)\b/i.test(text)) {
@@ -913,7 +1029,7 @@ ${truncate(text, 18e3)}`
   };
 }
 async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path5.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cachePath = path7.join(paths.analysesDir, `${manifest.sourceId}.json`);
   const cached = await readJsonFile(cachePath);
   if (cached && cached.sourceHash === manifest.contentHash && cached.schemaHash === schema.hash) {
     return cached;
@@ -949,352 +1065,42 @@ function analysisSignature(analysis) {
   return sha256(JSON.stringify(analysis));
 }
 
-// src/agents.ts
-import fs5 from "fs/promises";
-import path6 from "path";
-var managedStart = "<!-- swarmvault:managed:start -->";
-var managedEnd = "<!-- swarmvault:managed:end -->";
-var legacyManagedStart = "<!-- vault:managed:start -->";
-var legacyManagedEnd = "<!-- vault:managed:end -->";
-function buildManagedBlock(agent) {
-  const body = [
-    managedStart,
-    `# SwarmVault Rules (${agent})`,
-    "",
-    "- Read `swarmvault.schema.md` before compile or query style work. If only `schema.md` exists, treat it as the legacy schema path.",
-    "- Treat `raw/` as immutable source input.",
-    "- Treat `wiki/` as generated markdown owned by the agent and compiler workflow.",
-    "- Read `wiki/index.md` before broad file searching when answering SwarmVault questions.",
-    "- Preserve frontmatter fields including `page_id`, `source_ids`, `node_ids`, `freshness`, and `source_hashes`.",
-    "- Save high-value answers back into `wiki/outputs/` instead of leaving them only in chat.",
-    "- Prefer `swarmvault ingest`, `swarmvault compile`, `swarmvault query`, and `swarmvault lint` for SwarmVault maintenance tasks.",
-    managedEnd,
-    ""
-  ].join("\n");
-  if (agent === "cursor") {
-    return body;
-  }
-  return body;
-}
-async function upsertManagedBlock(filePath, block) {
-  const existing = await fileExists(filePath) ? await fs5.readFile(filePath, "utf8") : "";
-  if (!existing) {
-    await ensureDir(path6.dirname(filePath));
-    await fs5.writeFile(filePath, `${block}
-`, "utf8");
-    return;
-  }
-  const startIndex = existing.includes(managedStart) ? existing.indexOf(managedStart) : existing.indexOf(legacyManagedStart);
-  const endIndex = existing.includes(managedEnd) ? existing.indexOf(managedEnd) : existing.indexOf(legacyManagedEnd);
-  if (startIndex !== -1 && endIndex !== -1) {
-    const next = `${existing.slice(0, startIndex)}${block}${existing.slice(endIndex + managedEnd.length)}`;
-    await fs5.writeFile(filePath, next, "utf8");
-    return;
-  }
-  await fs5.writeFile(filePath, `${existing.trimEnd()}
-
-${block}
-`, "utf8");
+// src/confidence.ts
+function nodeConfidence(sourceCount) {
+  return Math.min(0.5 + sourceCount * 0.15, 0.95);
 }
-async function installAgent(rootDir, agent) {
-  const { paths } = await initWorkspace(rootDir);
-  const block = buildManagedBlock(agent);
-  switch (agent) {
-    case "codex": {
-      const target = path6.join(rootDir, "AGENTS.md");
-      await upsertManagedBlock(target, block);
-      return target;
-    }
-    case "claude": {
-      const target = path6.join(rootDir, "CLAUDE.md");
-      await upsertManagedBlock(target, block);
-      return target;
-    }
-    case "cursor": {
-      const rulesDir = path6.join(rootDir, ".cursor", "rules");
-      await ensureDir(rulesDir);
-      const target = path6.join(rulesDir, "swarmvault.mdc");
-      await fs5.writeFile(target, `${block}
-`, "utf8");
-      return target;
-    }
-    default:
-      throw new Error(`Unsupported agent ${String(agent)}`);
+function edgeConfidence(claims, conceptName) {
+  const lower = conceptName.toLowerCase();
+  const relevant = claims.filter((c) => c.text.toLowerCase().includes(lower));
+  if (!relevant.length) {
+    return 0.5;
   }
+  return relevant.reduce((sum, c) => sum + c.confidence, 0) / relevant.length;
 }
-async function installConfiguredAgents(rootDir) {
-  const { config } = await initWorkspace(rootDir);
-  return Promise.all(config.agents.map((agent) => installAgent(rootDir, agent)));
+function conflictConfidence(claimA, claimB) {
+  return Math.min(claimA.confidence, claimB.confidence);
 }
 
-// src/markdown.ts
+// src/deep-lint.ts
+import fs8 from "fs/promises";
+import path10 from "path";
 import matter from "gray-matter";
-function pagePathFor(kind, slug) {
-  switch (kind) {
-    case "source":
-      return `sources/${slug}.md`;
-    case "concept":
-      return `concepts/${slug}.md`;
-    case "entity":
-      return `entities/${slug}.md`;
-    case "output":
-      return `outputs/${slug}.md`;
-    default:
-      return `${slug}.md`;
-  }
-}
-function buildSourcePage(manifest, analysis, schemaHash) {
-  const relativePath = pagePathFor("source", manifest.sourceId);
-  const pageId = `source:${manifest.sourceId}`;
-  const nodeIds = [
-    `source:${manifest.sourceId}`,
-    ...analysis.concepts.map((item) => item.id),
-    ...analysis.entities.map((item) => item.id)
-  ];
-  const backlinks = [
-    ...analysis.concepts.map((item) => `concept:${slugify(item.name)}`),
-    ...analysis.entities.map((item) => `entity:${slugify(item.name)}`)
-  ];
-  const frontmatter = {
-    page_id: pageId,
-    kind: "source",
-    title: analysis.title,
-    tags: ["source"],
-    source_ids: [manifest.sourceId],
-    node_ids: nodeIds,
-    freshness: "fresh",
-    confidence: 0.8,
-    updated_at: analysis.producedAt,
-    backlinks,
-    schema_hash: schemaHash,
-    source_hashes: {
-      [manifest.sourceId]: manifest.contentHash
-    }
-  };
-  const body = [
-    `# ${analysis.title}`,
-    "",
-    `Source ID: \`${manifest.sourceId}\``,
-    manifest.url ? `Source URL: ${manifest.url}` : `Source Path: \`${manifest.originalPath ?? manifest.storedPath}\``,
-    "",
-    "## Summary",
-    "",
-    analysis.summary,
-    "",
-    "## Concepts",
-    "",
-    ...analysis.concepts.length ? analysis.concepts.map((item) => `- [[${pagePathFor("concept", slugify(item.name)).replace(/\.md$/, "")}|${item.name}]]: ${item.description}`) : ["- None detected."],
-    "",
-    "## Entities",
-    "",
-    ...analysis.entities.length ? analysis.entities.map((item) => `- [[${pagePathFor("entity", slugify(item.name)).replace(/\.md$/, "")}|${item.name}]]: ${item.description}`) : ["- None detected."],
-    "",
-    "## Claims",
-    "",
-    ...analysis.claims.length ? analysis.claims.map((claim) => `- ${claim.text} [source:${claim.citation}]`) : ["- No claims extracted."],
-    "",
-    "## Questions",
-    "",
-    ...analysis.questions.length ? analysis.questions.map((question) => `- ${question}`) : ["- No follow-up questions yet."],
-    ""
-  ].join("\n");
-  return {
-    page: {
-      id: pageId,
-      path: relativePath,
-      title: analysis.title,
-      kind: "source",
-      sourceIds: [manifest.sourceId],
-      nodeIds,
-      freshness: "fresh",
-      confidence: 0.8,
-      backlinks,
-      schemaHash,
-      sourceHashes: { [manifest.sourceId]: manifest.contentHash }
-    },
-    content: matter.stringify(body, frontmatter)
-  };
-}
-function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHashes, schemaHash) {
-  const slug = slugify(name);
-  const relativePath = pagePathFor(kind, slug);
-  const pageId = `${kind}:${slug}`;
-  const sourceIds = sourceAnalyses.map((item) => item.sourceId);
-  const otherPages = sourceAnalyses.map((item) => `source:${item.sourceId}`);
-  const summary = descriptions.find(Boolean) ?? `${kind} aggregated from ${sourceIds.length} source(s).`;
-  const frontmatter = {
-    page_id: pageId,
-    kind,
-    title: name,
-    tags: [kind],
-    source_ids: sourceIds,
-    node_ids: [pageId],
-    freshness: "fresh",
-    confidence: 0.72,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    backlinks: otherPages,
-    schema_hash: schemaHash,
-    source_hashes: sourceHashes
-  };
-  const body = [
-    `# ${name}`,
-    "",
-    "## Summary",
-    "",
-    summary,
-    "",
-    "## Seen In",
-    "",
-    ...sourceAnalyses.map((item) => `- [[${pagePathFor("source", item.sourceId).replace(/\.md$/, "")}|${item.title}]]`),
-    "",
-    "## Source Claims",
-    "",
-    ...sourceAnalyses.flatMap(
-      (item) => item.claims.filter((claim) => claim.text.toLowerCase().includes(name.toLowerCase())).map((claim) => `- ${claim.text} [source:${claim.citation}]`)
-    ),
-    ""
-  ].join("\n");
-  return {
-    page: {
-      id: pageId,
-      path: relativePath,
-      title: name,
-      kind,
-      sourceIds,
-      nodeIds: [pageId],
-      freshness: "fresh",
-      confidence: 0.72,
-      backlinks: otherPages,
-      schemaHash,
-      sourceHashes
-    },
-    content: matter.stringify(body, frontmatter)
-  };
-}
-function buildIndexPage(pages, schemaHash) {
-  const sources = pages.filter((page) => page.kind === "source");
-  const concepts = pages.filter((page) => page.kind === "concept");
-  const entities = pages.filter((page) => page.kind === "entity");
-  return [
-    "---",
-    "page_id: index",
-    "kind: index",
-    "title: SwarmVault Index",
-    "tags:",
-    "  - index",
-    "source_ids: []",
-    "node_ids: []",
-    "freshness: fresh",
-    "confidence: 1",
-    `updated_at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "backlinks: []",
-    `schema_hash: ${schemaHash}`,
-    "source_hashes: {}",
-    "---",
-    "",
-    "# SwarmVault Index",
-    "",
-    "## Sources",
-    "",
-    ...sources.length ? sources.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No sources yet."],
-    "",
-    "## Concepts",
-    "",
-    ...concepts.length ? concepts.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No concepts yet."],
-    "",
-    "## Entities",
-    "",
-    ...entities.length ? entities.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No entities yet."],
-    ""
-  ].join("\n");
-}
-function buildSectionIndex(kind, pages, schemaHash) {
-  const title = kind.charAt(0).toUpperCase() + kind.slice(1);
-  return matter.stringify(
-    [
-      `# ${title}`,
-      "",
-      ...pages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`),
-      ""
-    ].join("\n"),
-    {
-      page_id: `${kind}:index`,
-      kind: "index",
-      title,
-      tags: ["index", kind],
-      source_ids: [],
-      node_ids: [],
-      freshness: "fresh",
-      confidence: 1,
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      backlinks: [],
-      schema_hash: schemaHash,
-      source_hashes: {}
-    }
-  );
-}
-function buildOutputPage(question, answer, citations, schemaHash) {
-  const slug = slugify(question);
-  const pageId = `output:${slug}`;
-  const pathValue = pagePathFor("output", slug);
-  const frontmatter = {
-    page_id: pageId,
-    kind: "output",
-    title: question,
-    tags: ["output"],
-    source_ids: citations,
-    node_ids: [],
-    freshness: "fresh",
-    confidence: 0.74,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    backlinks: citations.map((sourceId) => `source:${sourceId}`),
-    schema_hash: schemaHash,
-    source_hashes: {}
-  };
-  return {
-    page: {
-      id: pageId,
-      path: pathValue,
-      title: question,
-      kind: "output",
-      sourceIds: citations,
-      nodeIds: [],
-      freshness: "fresh",
-      confidence: 0.74,
-      backlinks: citations.map((sourceId) => `source:${sourceId}`),
-      schemaHash,
-      sourceHashes: {}
-    },
-    content: matter.stringify(
-      [
-        `# ${question}`,
-        "",
-        answer,
-        "",
-        "## Citations",
-        "",
-        ...citations.map((citation) => `- [source:${citation}]`),
-        ""
-      ].join("\n"),
-      frontmatter
-    )
-  };
-}
-
-// src/providers/registry.ts
-import path7 from "path";
-import { pathToFileURL } from "url";
-import { z as z5 } from "zod";
-
-// src/providers/base.ts
-import fs6 from "fs/promises";
-import { z as z4 } from "zod";
-var BaseProviderAdapter = class {
-  constructor(id, type, model, capabilities) {
-    this.id = id;
-    this.type = type;
-    this.model = model;
-    this.capabilities = new Set(capabilities);
+import { z as z7 } from "zod";
+
+// src/providers/registry.ts
+import path8 from "path";
+import { pathToFileURL } from "url";
+import { z as z5 } from "zod";
+
+// src/providers/base.ts
+import fs7 from "fs/promises";
+import { z as z4 } from "zod";
+var BaseProviderAdapter = class {
+  constructor(id, type, model, capabilities) {
+    this.id = id;
+    this.type = type;
+    this.model = model;
+    this.capabilities = new Set(capabilities);
   }
   id;
   type;
@@ -1316,162 +1122,42 @@ ${schemaDescription}`
     return Promise.all(
       attachments.map(async (attachment) => ({
         mimeType: attachment.mimeType,
-        base64: await fs6.readFile(attachment.filePath, "base64")
+        base64: await fs7.readFile(attachment.filePath, "base64")
       }))
     );
   }
 };
 
-// src/providers/heuristic.ts
-function summarizePrompt(prompt) {
-  const cleaned = normalizeWhitespace(prompt);
-  if (!cleaned) {
-    return "No prompt content provided.";
-  }
-  return firstSentences(cleaned, 2) || cleaned.slice(0, 280);
-}
-var HeuristicProviderAdapter = class extends BaseProviderAdapter {
-  constructor(id, model) {
-    super(id, "heuristic", model, ["chat", "structured", "vision", "local"]);
-  }
-  async generateText(request) {
-    const attachmentHint = request.attachments?.length ? ` Attachments: ${request.attachments.length}.` : "";
-    return {
-      text: `Heuristic provider response.${attachmentHint} ${summarizePrompt(request.prompt)}`.trim()
-    };
-  }
-};
-
-// src/providers/openai-compatible.ts
-function buildAuthHeaders(apiKey) {
-  return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
-}
-var OpenAiCompatibleProviderAdapter = class extends BaseProviderAdapter {
-  baseUrl;
+// src/providers/anthropic.ts
+var AnthropicProviderAdapter = class extends BaseProviderAdapter {
   apiKey;
   headers;
-  apiStyle;
-  constructor(id, type, model, options) {
-    super(id, type, model, options.capabilities);
-    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+  baseUrl;
+  constructor(id, model, options) {
+    super(id, "anthropic", model, ["chat", "structured", "tools", "vision", "streaming"]);
     this.apiKey = options.apiKey;
     this.headers = options.headers;
-    this.apiStyle = options.apiStyle ?? "responses";
+    this.baseUrl = (options.baseUrl ?? "https://api.anthropic.com").replace(/\/+$/, "");
   }
   async generateText(request) {
-    if (this.apiStyle === "chat") {
-      return this.generateViaChatCompletions(request);
-    }
-    return this.generateViaResponses(request);
-  }
-  async generateViaResponses(request) {
     const encodedAttachments = await this.encodeAttachments(request.attachments);
-    const input = encodedAttachments.length ? [
-      {
-        role: "user",
-        content: [
-          { type: "input_text", text: request.prompt },
-          ...encodedAttachments.map((item) => ({
-            type: "input_image",
-            image_url: `data:${item.mimeType};base64,${item.base64}`
-          }))
-        ]
-      }
-    ] : request.prompt;
-    const response = await fetch(`${this.baseUrl}/responses`, {
+    const content = [
+      { type: "text", text: request.prompt },
+      ...encodedAttachments.map((item) => ({
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: item.mimeType,
+          data: item.base64
+        }
+      }))
+    ];
+    const response = await fetch(`${this.baseUrl}/v1/messages`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
-        ...buildAuthHeaders(this.apiKey),
-        ...this.headers
-      },
-      body: JSON.stringify({
-        model: this.model,
-        input,
-        instructions: request.system,
-        max_output_tokens: request.maxOutputTokens
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Provider ${this.id} failed: ${response.status} ${response.statusText}`);
-    }
-    const payload = await response.json();
-    return {
-      text: payload.output_text ?? "",
-      usage: payload.usage ? { inputTokens: payload.usage.input_tokens, outputTokens: payload.usage.output_tokens } : void 0
-    };
-  }
-  async generateViaChatCompletions(request) {
-    const encodedAttachments = await this.encodeAttachments(request.attachments);
-    const content = encodedAttachments.length ? [
-      { type: "text", text: request.prompt },
-      ...encodedAttachments.map((item) => ({
-        type: "image_url",
-        image_url: {
-          url: `data:${item.mimeType};base64,${item.base64}`
-        }
-      }))
-    ] : request.prompt;
-    const messages = [
-      ...request.system ? [{ role: "system", content: request.system }] : [],
-      { role: "user", content }
-    ];
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...buildAuthHeaders(this.apiKey),
-        ...this.headers
-      },
-      body: JSON.stringify({
-        model: this.model,
-        messages,
-        max_tokens: request.maxOutputTokens
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Provider ${this.id} failed: ${response.status} ${response.statusText}`);
-    }
-    const payload = await response.json();
-    const contentValue = payload.choices?.[0]?.message?.content;
-    const text = Array.isArray(contentValue) ? contentValue.map((item) => item.text ?? "").join("\n") : contentValue ?? "";
-    return {
-      text,
-      usage: payload.usage ? { inputTokens: payload.usage.prompt_tokens, outputTokens: payload.usage.completion_tokens } : void 0
-    };
-  }
-};
-
-// src/providers/anthropic.ts
-var AnthropicProviderAdapter = class extends BaseProviderAdapter {
-  apiKey;
-  headers;
-  baseUrl;
-  constructor(id, model, options) {
-    super(id, "anthropic", model, ["chat", "structured", "tools", "vision", "streaming"]);
-    this.apiKey = options.apiKey;
-    this.headers = options.headers;
-    this.baseUrl = (options.baseUrl ?? "https://api.anthropic.com").replace(/\/+$/, "");
-  }
-  async generateText(request) {
-    const encodedAttachments = await this.encodeAttachments(request.attachments);
-    const content = [
-      { type: "text", text: request.prompt },
-      ...encodedAttachments.map((item) => ({
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: item.mimeType,
-          data: item.base64
-        }
-      }))
-    ];
-    const response = await fetch(`${this.baseUrl}/v1/messages`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "anthropic-version": "2023-06-01",
-        ...this.apiKey ? { "x-api-key": this.apiKey } : {},
+        "anthropic-version": "2023-06-01",
+        ...this.apiKey ? { "x-api-key": this.apiKey } : {},
         ...this.headers
       },
       body: JSON.stringify({
@@ -1549,90 +1235,922 @@ ${request.system}` }] : [],
   }
 };
 
-// src/providers/registry.ts
-var customModuleSchema = z5.object({
-  createAdapter: z5.function({
-    input: [z5.string(), z5.custom(), z5.string()],
-    output: z5.promise(z5.custom())
-  })
-});
-function resolveCapabilities(config, fallback) {
-  return config.capabilities?.length ? config.capabilities : fallback;
+// src/providers/heuristic.ts
+function summarizePrompt(prompt) {
+  const cleaned = normalizeWhitespace(prompt);
+  if (!cleaned) {
+    return "No prompt content provided.";
+  }
+  return firstSentences(cleaned, 2) || cleaned.slice(0, 280);
+}
+var HeuristicProviderAdapter = class extends BaseProviderAdapter {
+  constructor(id, model) {
+    super(id, "heuristic", model, ["chat", "structured", "vision", "local"]);
+  }
+  async generateText(request) {
+    const attachmentHint = request.attachments?.length ? ` Attachments: ${request.attachments.length}.` : "";
+    return {
+      text: `Heuristic provider response.${attachmentHint} ${summarizePrompt(request.prompt)}`.trim()
+    };
+  }
+};
+
+// src/providers/openai-compatible.ts
+function buildAuthHeaders(apiKey) {
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+}
+var OpenAiCompatibleProviderAdapter = class extends BaseProviderAdapter {
+  baseUrl;
+  apiKey;
+  headers;
+  apiStyle;
+  constructor(id, type, model, options) {
+    super(id, type, model, options.capabilities);
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.headers = options.headers;
+    this.apiStyle = options.apiStyle ?? "responses";
+  }
+  async generateText(request) {
+    if (this.apiStyle === "chat") {
+      return this.generateViaChatCompletions(request);
+    }
+    return this.generateViaResponses(request);
+  }
+  async generateViaResponses(request) {
+    const encodedAttachments = await this.encodeAttachments(request.attachments);
+    const input = encodedAttachments.length ? [
+      {
+        role: "user",
+        content: [
+          { type: "input_text", text: request.prompt },
+          ...encodedAttachments.map((item) => ({
+            type: "input_image",
+            image_url: `data:${item.mimeType};base64,${item.base64}`
+          }))
+        ]
+      }
+    ] : request.prompt;
+    const response = await fetch(`${this.baseUrl}/responses`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...buildAuthHeaders(this.apiKey),
+        ...this.headers
+      },
+      body: JSON.stringify({
+        model: this.model,
+        input,
+        instructions: request.system,
+        max_output_tokens: request.maxOutputTokens
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Provider ${this.id} failed: ${response.status} ${response.statusText}`);
+    }
+    const payload = await response.json();
+    return {
+      text: payload.output_text ?? "",
+      usage: payload.usage ? { inputTokens: payload.usage.input_tokens, outputTokens: payload.usage.output_tokens } : void 0
+    };
+  }
+  async generateViaChatCompletions(request) {
+    const encodedAttachments = await this.encodeAttachments(request.attachments);
+    const content = encodedAttachments.length ? [
+      { type: "text", text: request.prompt },
+      ...encodedAttachments.map((item) => ({
+        type: "image_url",
+        image_url: {
+          url: `data:${item.mimeType};base64,${item.base64}`
+        }
+      }))
+    ] : request.prompt;
+    const messages = [...request.system ? [{ role: "system", content: request.system }] : [], { role: "user", content }];
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...buildAuthHeaders(this.apiKey),
+        ...this.headers
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages,
+        max_tokens: request.maxOutputTokens
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Provider ${this.id} failed: ${response.status} ${response.statusText}`);
+    }
+    const payload = await response.json();
+    const contentValue = payload.choices?.[0]?.message?.content;
+    const text = Array.isArray(contentValue) ? contentValue.map((item) => item.text ?? "").join("\n") : contentValue ?? "";
+    return {
+      text,
+      usage: payload.usage ? { inputTokens: payload.usage.prompt_tokens, outputTokens: payload.usage.completion_tokens } : void 0
+    };
+  }
+};
+
+// src/providers/registry.ts
+var customModuleSchema = z5.object({
+  createAdapter: z5.function({
+    input: [z5.string(), z5.custom(), z5.string()],
+    output: z5.promise(z5.custom())
+  })
+});
+function resolveCapabilities(config, fallback) {
+  return config.capabilities?.length ? config.capabilities : fallback;
+}
+function envOrUndefined(name) {
+  return name ? process.env[name] : void 0;
+}
+async function createProvider(id, config, rootDir) {
+  switch (config.type) {
+    case "heuristic":
+      return new HeuristicProviderAdapter(id, config.model);
+    case "openai":
+      return new OpenAiCompatibleProviderAdapter(id, "openai", config.model, {
+        baseUrl: config.baseUrl ?? "https://api.openai.com/v1",
+        apiKey: envOrUndefined(config.apiKeyEnv),
+        headers: config.headers,
+        apiStyle: config.apiStyle ?? "responses",
+        capabilities: resolveCapabilities(config, ["responses", "chat", "structured", "tools", "vision", "streaming"])
+      });
+    case "ollama":
+      return new OpenAiCompatibleProviderAdapter(id, "ollama", config.model, {
+        baseUrl: config.baseUrl ?? "http://localhost:11434/v1",
+        apiKey: envOrUndefined(config.apiKeyEnv) ?? "ollama",
+        headers: config.headers,
+        apiStyle: config.apiStyle ?? "responses",
+        capabilities: resolveCapabilities(config, ["responses", "chat", "structured", "tools", "vision", "streaming", "local"])
+      });
+    case "openai-compatible":
+      return new OpenAiCompatibleProviderAdapter(id, "openai-compatible", config.model, {
+        baseUrl: config.baseUrl ?? "http://localhost:8000/v1",
+        apiKey: envOrUndefined(config.apiKeyEnv),
+        headers: config.headers,
+        apiStyle: config.apiStyle ?? "responses",
+        capabilities: resolveCapabilities(config, ["chat", "structured"])
+      });
+    case "anthropic":
+      return new AnthropicProviderAdapter(id, config.model, {
+        apiKey: envOrUndefined(config.apiKeyEnv),
+        headers: config.headers,
+        baseUrl: config.baseUrl
+      });
+    case "gemini":
+      return new GeminiProviderAdapter(id, config.model, {
+        apiKey: envOrUndefined(config.apiKeyEnv),
+        baseUrl: config.baseUrl
+      });
+    case "custom": {
+      if (!config.module) {
+        throw new Error(`Provider ${id} is type "custom" but no module path was configured.`);
+      }
+      const resolvedModule = path8.isAbsolute(config.module) ? config.module : path8.resolve(rootDir, config.module);
+      const loaded = await import(pathToFileURL(resolvedModule).href);
+      const parsed = customModuleSchema.parse(loaded);
+      return parsed.createAdapter(id, config, rootDir);
+    }
+    default:
+      throw new Error(`Unsupported provider type ${String(config.type)}`);
+  }
+}
+async function getProviderForTask(rootDir, task) {
+  const { config } = await loadVaultConfig(rootDir);
+  const providerId = config.tasks[task];
+  const providerConfig = config.providers[providerId];
+  if (!providerConfig) {
+    throw new Error(`No provider configured with id "${providerId}" for task "${task}".`);
+  }
+  return createProvider(providerId, providerConfig, rootDir);
+}
+function assertProviderCapability(provider, capability) {
+  if (!provider.capabilities.has(capability)) {
+    throw new Error(`Provider ${provider.id} does not support required capability "${capability}".`);
+  }
+}
+
+// src/web-search/registry.ts
+import path9 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { z as z6 } from "zod";
+
+// src/web-search/http-json.ts
+function deepGet(value, pathValue) {
+  if (!pathValue) {
+    return value;
+  }
+  return pathValue.split(".").filter(Boolean).reduce((current, segment) => {
+    if (current && typeof current === "object" && segment in current) {
+      return current[segment];
+    }
+    return void 0;
+  }, value);
+}
+function envOrUndefined2(name) {
+  return name ? process.env[name] : void 0;
+}
+var HttpJsonWebSearchAdapter = class {
+  constructor(id, config) {
+    this.id = id;
+    this.config = config;
+  }
+  id;
+  config;
+  type = "http-json";
+  async search(query, limit = 5) {
+    if (!this.config.endpoint) {
+      throw new Error(`Web search provider ${this.id} is missing an endpoint.`);
+    }
+    const method = this.config.method ?? "GET";
+    const queryParam = this.config.queryParam ?? "q";
+    const limitParam = this.config.limitParam ?? "limit";
+    const headers = {
+      accept: "application/json",
+      ...this.config.headers
+    };
+    const apiKey = envOrUndefined2(this.config.apiKeyEnv);
+    if (apiKey) {
+      headers[this.config.apiKeyHeader ?? "Authorization"] = `${this.config.apiKeyPrefix ?? "Bearer "}${apiKey}`;
+    }
+    const endpoint = new URL(this.config.endpoint);
+    let body;
+    if (method === "GET") {
+      endpoint.searchParams.set(queryParam, query);
+      endpoint.searchParams.set(limitParam, String(limit));
+    } else {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify({
+        [queryParam]: query,
+        [limitParam]: limit
+      });
+    }
+    const response = await fetch(endpoint, {
+      method,
+      headers,
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`Web search provider ${this.id} failed: ${response.status} ${response.statusText}`);
+    }
+    const payload = await response.json();
+    const rawResults = deepGet(payload, this.config.resultsPath ?? "results");
+    if (!Array.isArray(rawResults)) {
+      return [];
+    }
+    return rawResults.map((item) => {
+      const title = deepGet(item, this.config.titleField ?? "title");
+      const url = deepGet(item, this.config.urlField ?? "url");
+      const snippet = deepGet(item, this.config.snippetField ?? "snippet");
+      if (typeof title !== "string" || typeof url !== "string") {
+        return null;
+      }
+      return {
+        title,
+        url,
+        snippet: typeof snippet === "string" ? snippet : ""
+      };
+    }).filter((item) => item !== null);
+  }
+};
+
+// src/web-search/registry.ts
+var customWebSearchModuleSchema = z6.object({
+  createAdapter: z6.function({
+    input: [z6.string(), z6.custom(), z6.string()],
+    output: z6.promise(z6.custom())
+  })
+});
+async function createWebSearchAdapter(id, config, rootDir) {
+  switch (config.type) {
+    case "http-json":
+      return new HttpJsonWebSearchAdapter(id, config);
+    case "custom": {
+      if (!config.module) {
+        throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
+      }
+      const resolvedModule = path9.isAbsolute(config.module) ? config.module : path9.resolve(rootDir, config.module);
+      const loaded = await import(pathToFileURL2(resolvedModule).href);
+      const parsed = customWebSearchModuleSchema.parse(loaded);
+      return parsed.createAdapter(id, config, rootDir);
+    }
+    default:
+      throw new Error(`Unsupported web search provider type ${String(config.type)}`);
+  }
+}
+async function getWebSearchAdapterForTask(rootDir, task) {
+  const { config } = await loadVaultConfig(rootDir);
+  const webSearchConfig = config.webSearch;
+  if (!webSearchConfig) {
+    throw new Error("No web search providers are configured. Add a webSearch block to swarmvault.config.json.");
+  }
+  const providerId = webSearchConfig.tasks[task];
+  const providerConfig = webSearchConfig.providers[providerId];
+  if (!providerConfig) {
+    throw new Error(`No web search provider configured with id "${providerId}" for task "${task}".`);
+  }
+  return createWebSearchAdapter(providerId, providerConfig, rootDir);
+}
+
+// src/deep-lint.ts
+var deepLintResponseSchema = z7.object({
+  findings: z7.array(
+    z7.object({
+      severity: z7.enum(["error", "warning", "info"]).default("info"),
+      code: z7.enum(["coverage_gap", "contradiction_candidate", "missing_citation", "candidate_page", "follow_up_question"]),
+      message: z7.string().min(1),
+      relatedSourceIds: z7.array(z7.string()).default([]),
+      relatedPageIds: z7.array(z7.string()).default([]),
+      suggestedQuery: z7.string().optional()
+    })
+  ).max(20)
+});
+async function loadContextPages(rootDir, graph) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const contextPages = graph.pages.filter(
+    (page) => page.kind === "source" || page.kind === "concept" || page.kind === "entity"
+  );
+  return Promise.all(
+    contextPages.slice(0, 18).map(async (page) => {
+      const absolutePath = path10.join(paths.wikiDir, page.path);
+      const raw = await fs8.readFile(absolutePath, "utf8").catch(() => "");
+      const parsed = matter(raw);
+      return {
+        id: page.id,
+        title: page.title,
+        path: page.path,
+        kind: page.kind,
+        sourceIds: page.sourceIds,
+        excerpt: truncate(normalizeWhitespace(parsed.content), 1400)
+      };
+    })
+  );
+}
+function heuristicDeepFindings(contextPages, structuralFindings) {
+  const findings = [];
+  for (const page of contextPages) {
+    if (page.excerpt.includes("No claims extracted.")) {
+      findings.push({
+        severity: "warning",
+        code: "coverage_gap",
+        message: `Page ${page.title} has no extracted claims yet.`,
+        pagePath: page.path,
+        relatedSourceIds: page.sourceIds,
+        relatedPageIds: [page.id],
+        suggestedQuery: `What evidence or claims should ${page.title} contain?`
+      });
+    }
+  }
+  for (const finding of structuralFindings.filter((item) => item.code === "uncited_claims").slice(0, 5)) {
+    findings.push({
+      severity: "warning",
+      code: "missing_citation",
+      message: finding.message,
+      pagePath: finding.pagePath,
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path10.basename(finding.pagePath, ".md")}?` : void 0
+    });
+  }
+  for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
+    findings.push({
+      severity: "info",
+      code: "follow_up_question",
+      message: `Investigate what broader implications ${page.title} has for the rest of the vault.`,
+      pagePath: page.path,
+      relatedSourceIds: page.sourceIds,
+      relatedPageIds: [page.id],
+      suggestedQuery: `What broader implications does ${page.title} have?`
+    });
+  }
+  return uniqueBy(findings, (item) => `${item.code}:${item.message}`);
+}
+async function runDeepLint(rootDir, structuralFindings, options = {}) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    return [];
+  }
+  const schema = await loadVaultSchema(rootDir);
+  const provider = await getProviderForTask(rootDir, "lintProvider");
+  const manifests = await listManifests(rootDir);
+  const contextPages = await loadContextPages(rootDir, graph);
+  let findings;
+  if (provider.type === "heuristic") {
+    findings = heuristicDeepFindings(contextPages, structuralFindings);
+  } else {
+    const response = await provider.generateStructured(
+      {
+        system: "You are an auditor for a local-first LLM knowledge vault. Return advisory findings only. Do not propose direct file edits.",
+        prompt: [
+          "Review this SwarmVault state and return high-signal advisory findings.",
+          "",
+          "Schema:",
+          schema.content,
+          "",
+          "Vault summary:",
+          `- sources: ${manifests.length}`,
+          `- pages: ${graph.pages.length}`,
+          `- structural_findings: ${structuralFindings.length}`,
+          "",
+          "Structural findings:",
+          structuralFindings.map((item) => `- [${item.severity}] ${item.code}: ${item.message}`).join("\n") || "- none",
+          "",
+          "Page context:",
+          contextPages.map(
+            (page) => [
+              `## ${page.title}`,
+              `page_id: ${page.id}`,
+              `path: ${page.path}`,
+              `kind: ${page.kind}`,
+              `source_ids: ${page.sourceIds.join(",") || "none"}`,
+              page.excerpt
+            ].join("\n")
+          ).join("\n\n---\n\n")
+        ].join("\n")
+      },
+      deepLintResponseSchema
+    );
+    findings = response.findings.map((item) => ({
+      severity: item.severity,
+      code: item.code,
+      message: item.message,
+      relatedSourceIds: item.relatedSourceIds,
+      relatedPageIds: item.relatedPageIds,
+      suggestedQuery: item.suggestedQuery
+    }));
+  }
+  if (!options.web) {
+    return findings;
+  }
+  const webSearch = await getWebSearchAdapterForTask(rootDir, "deepLintProvider");
+  const queryCache = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const query = finding.suggestedQuery ?? finding.message;
+    if (!queryCache.has(query)) {
+      queryCache.set(query, await webSearch.search(query, 3));
+    }
+    finding.evidence = queryCache.get(query);
+  }
+  return findings;
+}
+
+// src/markdown.ts
+import matter2 from "gray-matter";
+function pagePathFor(kind, slug) {
+  switch (kind) {
+    case "source":
+      return `sources/${slug}.md`;
+    case "concept":
+      return `concepts/${slug}.md`;
+    case "entity":
+      return `entities/${slug}.md`;
+    case "output":
+      return `outputs/${slug}.md`;
+    default:
+      return `${slug}.md`;
+  }
+}
+function pageLink(page) {
+  return `[[${page.path.replace(/\.md$/, "")}|${page.title}]]`;
+}
+function relatedOutputsSection(relatedOutputs) {
+  if (!relatedOutputs.length) {
+    return [];
+  }
+  return ["## Related Outputs", "", ...relatedOutputs.map((page) => `- ${pageLink(page)}`), ""];
+}
+function buildSourcePage(manifest, analysis, schemaHash, confidence = 1, relatedOutputs = []) {
+  const relativePath = pagePathFor("source", manifest.sourceId);
+  const pageId = `source:${manifest.sourceId}`;
+  const nodeIds = [`source:${manifest.sourceId}`, ...analysis.concepts.map((item) => item.id), ...analysis.entities.map((item) => item.id)];
+  const backlinks = [
+    ...analysis.concepts.map((item) => `concept:${slugify(item.name)}`),
+    ...analysis.entities.map((item) => `entity:${slugify(item.name)}`),
+    ...relatedOutputs.map((page) => page.id)
+  ];
+  const frontmatter = {
+    page_id: pageId,
+    kind: "source",
+    title: analysis.title,
+    tags: ["source"],
+    source_ids: [manifest.sourceId],
+    node_ids: nodeIds,
+    freshness: "fresh",
+    confidence,
+    updated_at: analysis.producedAt,
+    backlinks,
+    schema_hash: schemaHash,
+    source_hashes: {
+      [manifest.sourceId]: manifest.contentHash
+    }
+  };
+  const body = [
+    `# ${analysis.title}`,
+    "",
+    `Source ID: \`${manifest.sourceId}\``,
+    manifest.url ? `Source URL: ${manifest.url}` : `Source Path: \`${manifest.originalPath ?? manifest.storedPath}\``,
+    "",
+    "## Summary",
+    "",
+    analysis.summary,
+    "",
+    "## Concepts",
+    "",
+    ...analysis.concepts.length ? analysis.concepts.map(
+      (item) => `- [[${pagePathFor("concept", slugify(item.name)).replace(/\.md$/, "")}|${item.name}]]: ${item.description}`
+    ) : ["- None detected."],
+    "",
+    "## Entities",
+    "",
+    ...analysis.entities.length ? analysis.entities.map(
+      (item) => `- [[${pagePathFor("entity", slugify(item.name)).replace(/\.md$/, "")}|${item.name}]]: ${item.description}`
+    ) : ["- None detected."],
+    "",
+    "## Claims",
+    "",
+    ...analysis.claims.length ? analysis.claims.map((claim) => `- ${claim.text} [source:${claim.citation}]`) : ["- No claims extracted."],
+    "",
+    "## Questions",
+    "",
+    ...analysis.questions.length ? analysis.questions.map((question) => `- ${question}`) : ["- No follow-up questions yet."],
+    "",
+    ...relatedOutputsSection(relatedOutputs),
+    ""
+  ].join("\n");
+  return {
+    page: {
+      id: pageId,
+      path: relativePath,
+      title: analysis.title,
+      kind: "source",
+      sourceIds: [manifest.sourceId],
+      nodeIds,
+      freshness: "fresh",
+      confidence,
+      backlinks,
+      schemaHash,
+      sourceHashes: { [manifest.sourceId]: manifest.contentHash },
+      relatedPageIds: relatedOutputs.map((page) => page.id),
+      relatedNodeIds: [],
+      relatedSourceIds: []
+    },
+    content: matter2.stringify(body, frontmatter)
+  };
+}
+function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHashes, schemaHash, confidence = 0.72, relatedOutputs = []) {
+  const slug = slugify(name);
+  const relativePath = pagePathFor(kind, slug);
+  const pageId = `${kind}:${slug}`;
+  const sourceIds = sourceAnalyses.map((item) => item.sourceId);
+  const otherPages = [...sourceAnalyses.map((item) => `source:${item.sourceId}`), ...relatedOutputs.map((page) => page.id)];
+  const summary = descriptions.find(Boolean) ?? `${kind} aggregated from ${sourceIds.length} source(s).`;
+  const frontmatter = {
+    page_id: pageId,
+    kind,
+    title: name,
+    tags: [kind],
+    source_ids: sourceIds,
+    node_ids: [pageId],
+    freshness: "fresh",
+    confidence,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    backlinks: otherPages,
+    schema_hash: schemaHash,
+    source_hashes: sourceHashes
+  };
+  const body = [
+    `# ${name}`,
+    "",
+    "## Summary",
+    "",
+    summary,
+    "",
+    "## Seen In",
+    "",
+    ...sourceAnalyses.map((item) => `- [[${pagePathFor("source", item.sourceId).replace(/\.md$/, "")}|${item.title}]]`),
+    "",
+    "## Source Claims",
+    "",
+    ...sourceAnalyses.flatMap(
+      (item) => item.claims.filter((claim) => claim.text.toLowerCase().includes(name.toLowerCase())).map((claim) => `- ${claim.text} [source:${claim.citation}]`)
+    ),
+    "",
+    ...relatedOutputsSection(relatedOutputs),
+    ""
+  ].join("\n");
+  return {
+    page: {
+      id: pageId,
+      path: relativePath,
+      title: name,
+      kind,
+      sourceIds,
+      nodeIds: [pageId],
+      freshness: "fresh",
+      confidence,
+      backlinks: otherPages,
+      schemaHash,
+      sourceHashes,
+      relatedPageIds: relatedOutputs.map((page) => page.id),
+      relatedNodeIds: [],
+      relatedSourceIds: []
+    },
+    content: matter2.stringify(body, frontmatter)
+  };
+}
+function buildIndexPage(pages, schemaHash) {
+  const sources = pages.filter((page) => page.kind === "source");
+  const concepts = pages.filter((page) => page.kind === "concept");
+  const entities = pages.filter((page) => page.kind === "entity");
+  const outputs = pages.filter((page) => page.kind === "output");
+  return [
+    "---",
+    "page_id: index",
+    "kind: index",
+    "title: SwarmVault Index",
+    "tags:",
+    "  - index",
+    "source_ids: []",
+    "node_ids: []",
+    "freshness: fresh",
+    "confidence: 1",
+    `updated_at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "backlinks: []",
+    `schema_hash: ${schemaHash}`,
+    "source_hashes: {}",
+    "---",
+    "",
+    "# SwarmVault Index",
+    "",
+    "## Sources",
+    "",
+    ...sources.length ? sources.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No sources yet."],
+    "",
+    "## Concepts",
+    "",
+    ...concepts.length ? concepts.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No concepts yet."],
+    "",
+    "## Entities",
+    "",
+    ...entities.length ? entities.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No entities yet."],
+    "",
+    "## Outputs",
+    "",
+    ...outputs.length ? outputs.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No saved outputs yet."],
+    ""
+  ].join("\n");
+}
+function buildSectionIndex(kind, pages, schemaHash) {
+  const title = kind.charAt(0).toUpperCase() + kind.slice(1);
+  return matter2.stringify(
+    [`# ${title}`, "", ...pages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`), ""].join("\n"),
+    {
+      page_id: `${kind}:index`,
+      kind: "index",
+      title,
+      tags: ["index", kind],
+      source_ids: [],
+      node_ids: [],
+      freshness: "fresh",
+      confidence: 1,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      backlinks: [],
+      schema_hash: schemaHash,
+      source_hashes: {}
+    }
+  );
+}
+function buildOutputPage(input) {
+  const slug = input.slug ?? slugify(input.question);
+  const pageId = `output:${slug}`;
+  const pathValue = pagePathFor("output", slug);
+  const relatedPageIds = input.relatedPageIds ?? [];
+  const relatedNodeIds = input.relatedNodeIds ?? [];
+  const relatedSourceIds = input.relatedSourceIds ?? input.citations;
+  const backlinks = [.../* @__PURE__ */ new Set([...relatedPageIds, ...relatedSourceIds.map((sourceId) => `source:${sourceId}`)])];
+  const frontmatter = {
+    page_id: pageId,
+    kind: "output",
+    title: input.title ?? input.question,
+    tags: ["output"],
+    source_ids: input.citations,
+    node_ids: relatedNodeIds,
+    freshness: "fresh",
+    confidence: 0.74,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    backlinks,
+    schema_hash: input.schemaHash,
+    source_hashes: {},
+    related_page_ids: relatedPageIds,
+    related_node_ids: relatedNodeIds,
+    related_source_ids: relatedSourceIds,
+    origin: input.origin,
+    question: input.question
+  };
+  return {
+    page: {
+      id: pageId,
+      path: pathValue,
+      title: input.title ?? input.question,
+      kind: "output",
+      sourceIds: input.citations,
+      nodeIds: relatedNodeIds,
+      freshness: "fresh",
+      confidence: 0.74,
+      backlinks,
+      schemaHash: input.schemaHash,
+      sourceHashes: {},
+      relatedPageIds,
+      relatedNodeIds,
+      relatedSourceIds,
+      origin: input.origin,
+      question: input.question
+    },
+    content: matter2.stringify(
+      [
+        `# ${input.title ?? input.question}`,
+        "",
+        input.answer,
+        "",
+        "## Related Pages",
+        "",
+        ...relatedPageIds.length ? relatedPageIds.map((pageId2) => `- \`${pageId2}\``) : ["- None recorded."],
+        "",
+        "## Citations",
+        "",
+        ...input.citations.map((citation) => `- [source:${citation}]`),
+        ""
+      ].join("\n"),
+      frontmatter
+    )
+  };
+}
+function buildExploreHubPage(input) {
+  const slug = input.slug ?? `explore-${slugify(input.question)}`;
+  const pageId = `output:${slug}`;
+  const pathValue = pagePathFor("output", slug);
+  const relatedPageIds = input.stepPages.map((page) => page.id);
+  const relatedSourceIds = [...new Set(input.citations)];
+  const relatedNodeIds = [...new Set(input.stepPages.flatMap((page) => page.nodeIds))];
+  const backlinks = [.../* @__PURE__ */ new Set([...relatedPageIds, ...relatedSourceIds.map((sourceId) => `source:${sourceId}`)])];
+  const title = `Explore: ${input.question}`;
+  const frontmatter = {
+    page_id: pageId,
+    kind: "output",
+    title,
+    tags: ["output", "explore"],
+    source_ids: relatedSourceIds,
+    node_ids: relatedNodeIds,
+    freshness: "fresh",
+    confidence: 0.76,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    backlinks,
+    schema_hash: input.schemaHash,
+    source_hashes: {},
+    related_page_ids: relatedPageIds,
+    related_node_ids: relatedNodeIds,
+    related_source_ids: relatedSourceIds,
+    origin: "explore",
+    question: input.question
+  };
+  return {
+    page: {
+      id: pageId,
+      path: pathValue,
+      title,
+      kind: "output",
+      sourceIds: relatedSourceIds,
+      nodeIds: relatedNodeIds,
+      freshness: "fresh",
+      confidence: 0.76,
+      backlinks,
+      schemaHash: input.schemaHash,
+      sourceHashes: {},
+      relatedPageIds,
+      relatedNodeIds,
+      relatedSourceIds,
+      origin: "explore",
+      question: input.question
+    },
+    content: matter2.stringify(
+      [
+        `# ${title}`,
+        "",
+        "## Root Question",
+        "",
+        input.question,
+        "",
+        "## Steps",
+        "",
+        ...input.stepPages.length ? input.stepPages.map((page) => `- ${pageLink(page)}`) : ["- No steps recorded."],
+        "",
+        "## Follow-Up Questions",
+        "",
+        ...input.followUpQuestions.length ? input.followUpQuestions.map((question) => `- ${question}`) : ["- No follow-up questions generated."],
+        "",
+        "## Citations",
+        "",
+        ...relatedSourceIds.map((citation) => `- [source:${citation}]`),
+        ""
+      ].join("\n"),
+      frontmatter
+    )
+  };
+}
+
+// src/outputs.ts
+import fs9 from "fs/promises";
+import path11 from "path";
+import matter3 from "gray-matter";
+function normalizeStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
-function envOrUndefined(name) {
-  return name ? process.env[name] : void 0;
+function normalizeSourceHashes(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string")
+  );
 }
-async function createProvider(id, config, rootDir) {
-  switch (config.type) {
-    case "heuristic":
-      return new HeuristicProviderAdapter(id, config.model);
-    case "openai":
-      return new OpenAiCompatibleProviderAdapter(id, "openai", config.model, {
-        baseUrl: config.baseUrl ?? "https://api.openai.com/v1",
-        apiKey: envOrUndefined(config.apiKeyEnv),
-        headers: config.headers,
-        apiStyle: config.apiStyle ?? "responses",
-        capabilities: resolveCapabilities(config, ["responses", "chat", "structured", "tools", "vision", "streaming"])
-      });
-    case "ollama":
-      return new OpenAiCompatibleProviderAdapter(id, "ollama", config.model, {
-        baseUrl: config.baseUrl ?? "http://localhost:11434/v1",
-        apiKey: envOrUndefined(config.apiKeyEnv) ?? "ollama",
-        headers: config.headers,
-        apiStyle: config.apiStyle ?? "responses",
-        capabilities: resolveCapabilities(config, ["responses", "chat", "structured", "tools", "vision", "streaming", "local"])
-      });
-    case "openai-compatible":
-      return new OpenAiCompatibleProviderAdapter(id, "openai-compatible", config.model, {
-        baseUrl: config.baseUrl ?? "http://localhost:8000/v1",
-        apiKey: envOrUndefined(config.apiKeyEnv),
-        headers: config.headers,
-        apiStyle: config.apiStyle ?? "responses",
-        capabilities: resolveCapabilities(config, ["chat", "structured"])
-      });
-    case "anthropic":
-      return new AnthropicProviderAdapter(id, config.model, {
-        apiKey: envOrUndefined(config.apiKeyEnv),
-        headers: config.headers,
-        baseUrl: config.baseUrl
-      });
-    case "gemini":
-      return new GeminiProviderAdapter(id, config.model, {
-        apiKey: envOrUndefined(config.apiKeyEnv),
-        baseUrl: config.baseUrl
-      });
-    case "custom": {
-      if (!config.module) {
-        throw new Error(`Provider ${id} is type "custom" but no module path was configured.`);
-      }
-      const resolvedModule = path7.isAbsolute(config.module) ? config.module : path7.resolve(rootDir, config.module);
-      const loaded = await import(pathToFileURL(resolvedModule).href);
-      const parsed = customModuleSchema.parse(loaded);
-      return parsed.createAdapter(id, config, rootDir);
-    }
-    default:
-      throw new Error(`Unsupported provider type ${String(config.type)}`);
+function relationRank(outputPage, targetPage) {
+  if (outputPage.relatedPageIds.includes(targetPage.id)) {
+    return 3;
+  }
+  if (outputPage.relatedNodeIds.some((nodeId) => targetPage.nodeIds.includes(nodeId))) {
+    return 2;
   }
+  if (outputPage.relatedSourceIds.some((sourceId) => targetPage.sourceIds.includes(sourceId))) {
+    return 1;
+  }
+  return 0;
 }
-async function getProviderForTask(rootDir, task) {
-  const { config } = await loadVaultConfig(rootDir);
-  const providerId = config.tasks[task];
-  const providerConfig = config.providers[providerId];
-  if (!providerConfig) {
-    throw new Error(`No provider configured with id "${providerId}" for task "${task}".`);
+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 = path11.join(wikiDir, "outputs");
+  const root = baseSlug || "output";
+  let candidate = root;
+  let counter = 2;
+  while (await fileExists(path11.join(outputsDir, `${candidate}.md`))) {
+    candidate = `${root}-${counter}`;
+    counter++;
   }
-  return createProvider(providerId, providerConfig, rootDir);
+  return candidate;
 }
-function assertProviderCapability(provider, capability) {
-  if (!provider.capabilities.has(capability)) {
-    throw new Error(`Provider ${provider.id} does not support required capability "${capability}".`);
+async function loadSavedOutputPages(wikiDir) {
+  const outputsDir = path11.join(wikiDir, "outputs");
+  const entries = await fs9.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 = path11.posix.join("outputs", entry.name);
+    const absolutePath = path11.join(outputsDir, entry.name);
+    const content = await fs9.readFile(absolutePath, "utf8");
+    const parsed = matter3(content);
+    const slug = entry.name.replace(/\.md$/, "");
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : slug;
+    const pageId = typeof parsed.data.page_id === "string" ? parsed.data.page_id : `output:${slug}`;
+    const sourceIds = normalizeStringArray(parsed.data.source_ids);
+    const nodeIds = normalizeStringArray(parsed.data.node_ids);
+    const relatedPageIds = normalizeStringArray(parsed.data.related_page_ids);
+    const relatedNodeIds = normalizeStringArray(parsed.data.related_node_ids);
+    const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
+    const backlinks = normalizeStringArray(parsed.data.backlinks);
+    outputs.push({
+      page: {
+        id: pageId,
+        path: relativePath,
+        title,
+        kind: "output",
+        sourceIds,
+        nodeIds,
+        freshness: parsed.data.freshness === "stale" ? "stale" : "fresh",
+        confidence: typeof parsed.data.confidence === "number" ? parsed.data.confidence : 0.74,
+        backlinks,
+        schemaHash: typeof parsed.data.schema_hash === "string" ? parsed.data.schema_hash : "",
+        sourceHashes: normalizeSourceHashes(parsed.data.source_hashes),
+        relatedPageIds,
+        relatedNodeIds,
+        relatedSourceIds,
+        origin: typeof parsed.data.origin === "string" ? parsed.data.origin : void 0,
+        question: typeof parsed.data.question === "string" ? parsed.data.question : void 0
+      },
+      content,
+      contentHash: sha256(content)
+    });
   }
+  return outputs.sort((left, right) => left.page.title.localeCompare(right.page.title));
 }
 
 // src/search.ts
-import fs7 from "fs/promises";
-import path8 from "path";
-import matter2 from "gray-matter";
+import fs10 from "fs/promises";
+import path12 from "path";
+import matter4 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
   if (!builtin?.DatabaseSync) {
@@ -1645,7 +2163,7 @@ function toFtsQuery(query) {
   return tokens.join(" OR ");
 }
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path8.dirname(dbPath));
+  await ensureDir(path12.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -1667,9 +2185,9 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
   `);
   const insertPage = db.prepare("INSERT INTO pages (id, path, title, body) VALUES (?, ?, ?, ?)");
   for (const page of pages) {
-    const absolutePath = path8.join(wikiDir, page.path);
-    const content = await fs7.readFile(absolutePath, "utf8");
-    const parsed = matter2(content);
+    const absolutePath = path12.join(wikiDir, page.path);
+    const content = await fs10.readFile(absolutePath, "utf8");
+    const parsed = matter4(content);
     insertPage.run(page.id, page.path, page.title, parsed.content);
   }
   db.exec("INSERT INTO page_search (rowid, title, body) SELECT rowid, title, body FROM pages;");
@@ -1706,32 +2224,6 @@ function searchPages(dbPath, query, limit = 5) {
   }));
 }
 
-// src/schema.ts
-import fs8 from "fs/promises";
-import path9 from "path";
-async function loadVaultSchema(rootDir) {
-  const { paths } = await loadVaultConfig(rootDir);
-  const schemaPath = paths.schemaPath;
-  const content = await fileExists(schemaPath) ? await fs8.readFile(schemaPath, "utf8") : defaultVaultSchema();
-  const normalized = content.trim() ? content.trim() : defaultVaultSchema().trim();
-  return {
-    path: schemaPath,
-    content: normalized,
-    hash: sha256(normalized),
-    isLegacyPath: path9.basename(schemaPath) === LEGACY_SCHEMA_FILENAME && path9.basename(schemaPath) !== PRIMARY_SCHEMA_FILENAME
-  };
-}
-function buildSchemaPrompt(schema, instruction) {
-  return [
-    instruction,
-    "",
-    `Vault schema path: ${schema.path}`,
-    "",
-    "Vault schema instructions:",
-    schema.content
-  ].join("\n");
-}
-
 // src/vault.ts
 function buildGraph(manifests, analyses, pages) {
   const sourceNodes = manifests.map((manifest) => ({
@@ -1749,14 +2241,15 @@ function buildGraph(manifests, analyses, pages) {
   for (const analysis of analyses) {
     for (const concept of analysis.concepts) {
       const existing = conceptMap.get(concept.id);
+      const sourceIds = [.../* @__PURE__ */ new Set([...existing?.sourceIds ?? [], analysis.sourceId])];
       conceptMap.set(concept.id, {
         id: concept.id,
         type: "concept",
         label: concept.name,
         pageId: `concept:${slugify(concept.name)}`,
         freshness: "fresh",
-        confidence: 0.7,
-        sourceIds: [.../* @__PURE__ */ new Set([...existing?.sourceIds ?? [], analysis.sourceId])]
+        confidence: nodeConfidence(sourceIds.length),
+        sourceIds
       });
       edges.push({
         id: `${analysis.sourceId}->${concept.id}`,
@@ -1764,20 +2257,21 @@ function buildGraph(manifests, analyses, pages) {
         target: concept.id,
         relation: "mentions",
         status: "extracted",
-        confidence: 0.72,
+        confidence: edgeConfidence(analysis.claims, concept.name),
         provenance: [analysis.sourceId]
       });
     }
     for (const entity of analysis.entities) {
       const existing = entityMap.get(entity.id);
+      const sourceIds = [.../* @__PURE__ */ new Set([...existing?.sourceIds ?? [], analysis.sourceId])];
       entityMap.set(entity.id, {
         id: entity.id,
         type: "entity",
         label: entity.name,
         pageId: `entity:${slugify(entity.name)}`,
         freshness: "fresh",
-        confidence: 0.7,
-        sourceIds: [.../* @__PURE__ */ new Set([...existing?.sourceIds ?? [], analysis.sourceId])]
+        confidence: nodeConfidence(sourceIds.length),
+        sourceIds
       });
       edges.push({
         id: `${analysis.sourceId}->${entity.id}`,
@@ -1785,22 +2279,46 @@ function buildGraph(manifests, analyses, pages) {
         target: entity.id,
         relation: "mentions",
         status: "extracted",
-        confidence: 0.72,
+        confidence: edgeConfidence(analysis.claims, entity.name),
         provenance: [analysis.sourceId]
       });
     }
-    const conflictClaims = analysis.claims.filter((claim) => claim.polarity === "negative");
-    for (const claim of conflictClaims) {
-      const related = analyses.filter((item) => item.sourceId !== analysis.sourceId).flatMap((item) => item.claims.filter((other) => other.polarity === "positive" && other.text.split(" ").some((word) => claim.text.includes(word))));
-      for (const other of related) {
+  }
+  const conceptClaims = /* @__PURE__ */ new Map();
+  for (const analysis of analyses) {
+    for (const claim of analysis.claims) {
+      for (const concept of analysis.concepts) {
+        if (claim.text.toLowerCase().includes(concept.name.toLowerCase())) {
+          const key = concept.id;
+          const list = conceptClaims.get(key) ?? [];
+          list.push({ claim, sourceId: analysis.sourceId });
+          conceptClaims.set(key, list);
+        }
+      }
+    }
+  }
+  const conflictEdgeKeys = /* @__PURE__ */ new Set();
+  for (const [, claimsForConcept] of conceptClaims) {
+    const positive = claimsForConcept.filter((item) => item.claim.polarity === "positive");
+    const negative = claimsForConcept.filter((item) => item.claim.polarity === "negative");
+    for (const positiveClaim of positive) {
+      for (const negativeClaim of negative) {
+        if (positiveClaim.sourceId === negativeClaim.sourceId) {
+          continue;
+        }
+        const edgeKey = [positiveClaim.sourceId, negativeClaim.sourceId].sort().join("|");
+        if (conflictEdgeKeys.has(edgeKey)) {
+          continue;
+        }
+        conflictEdgeKeys.add(edgeKey);
         edges.push({
-          id: `${claim.id}->${other.id}`,
-          source: `source:${analysis.sourceId}`,
-          target: `source:${other.citation}`,
+          id: `conflict:${positiveClaim.claim.id}->${negativeClaim.claim.id}`,
+          source: `source:${positiveClaim.sourceId}`,
+          target: `source:${negativeClaim.sourceId}`,
           relation: "conflicted_with",
           status: "conflicted",
-          confidence: 0.6,
-          provenance: [analysis.sourceId, other.citation]
+          confidence: conflictConfidence(positiveClaim.claim, negativeClaim.claim),
+          provenance: [positiveClaim.sourceId, negativeClaim.sourceId]
         });
       }
     }
@@ -1814,7 +2332,7 @@ function buildGraph(manifests, analyses, pages) {
   };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path10.resolve(wikiDir, relativePath);
+  const absolutePath = path13.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -1839,6 +2357,216 @@ function aggregateItems(analyses, kind) {
   }
   return [...grouped.values()];
 }
+function emptyGraphPage(input) {
+  return {
+    id: input.id,
+    path: input.path,
+    title: input.title,
+    kind: input.kind,
+    sourceIds: input.sourceIds,
+    nodeIds: input.nodeIds,
+    freshness: "fresh",
+    confidence: input.confidence,
+    backlinks: [],
+    schemaHash: input.schemaHash,
+    sourceHashes: input.sourceHashes,
+    relatedPageIds: [],
+    relatedNodeIds: [],
+    relatedSourceIds: []
+  };
+}
+function outputHashes(outputPages) {
+  return Object.fromEntries(outputPages.map((page) => [page.page.id, page.contentHash]));
+}
+function recordsEqual(left, right) {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  return leftKeys.every((key) => left[key] === right[key]);
+}
+async function requiredCompileArtifactsExist(paths) {
+  const requiredPaths = [
+    paths.graphPath,
+    paths.searchDbPath,
+    path13.join(paths.wikiDir, "index.md"),
+    path13.join(paths.wikiDir, "sources", "index.md"),
+    path13.join(paths.wikiDir, "concepts", "index.md"),
+    path13.join(paths.wikiDir, "entities", "index.md"),
+    path13.join(paths.wikiDir, "outputs", "index.md")
+  ];
+  const checks = await Promise.all(requiredPaths.map((filePath) => fileExists(filePath)));
+  return checks.every(Boolean);
+}
+async function refreshIndexesAndSearch(rootDir, schemaHash, pages) {
+  const { paths } = await loadVaultConfig(rootDir);
+  await ensureDir(path13.join(paths.wikiDir, "outputs"));
+  await writeFileIfChanged(path13.join(paths.wikiDir, "index.md"), buildIndexPage(pages, schemaHash));
+  await writeFileIfChanged(
+    path13.join(paths.wikiDir, "outputs", "index.md"),
+    buildSectionIndex(
+      "outputs",
+      pages.filter((page) => page.kind === "output"),
+      schemaHash
+    )
+  );
+  await rebuildSearchIndex(paths.searchDbPath, pages, paths.wikiDir);
+}
+async function upsertGraphPages(rootDir, pages) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const graph = await readJsonFile(paths.graphPath);
+  const manifests = await listManifests(rootDir);
+  const nonOutputPages = graph?.pages.filter((page) => page.kind !== "output") ?? [];
+  const nextGraph = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes: graph?.nodes ?? [],
+    edges: graph?.edges ?? [],
+    sources: graph?.sources ?? manifests,
+    pages: [...nonOutputPages, ...pages]
+  };
+  await writeJsonFile(paths.graphPath, nextGraph);
+}
+async function persistOutputPage(rootDir, input) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const slug = await resolveUniqueOutputSlug(paths.wikiDir, input.slug ?? slugify(input.question));
+  const output = buildOutputPage({ ...input, slug });
+  const absolutePath = path13.join(paths.wikiDir, output.page.path);
+  await ensureDir(path13.dirname(absolutePath));
+  await fs11.writeFile(absolutePath, output.content, "utf8");
+  const storedOutputs = await loadSavedOutputPages(paths.wikiDir);
+  const outputPages = storedOutputs.map((page) => page.page);
+  await upsertGraphPages(rootDir, outputPages);
+  const graph = await readJsonFile(paths.graphPath);
+  await refreshIndexesAndSearch(rootDir, input.schemaHash, graph?.pages ?? outputPages);
+  return { page: output.page, savedTo: absolutePath };
+}
+async function persistExploreHub(rootDir, input) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const slug = await resolveUniqueOutputSlug(paths.wikiDir, input.slug ?? `explore-${slugify(input.question)}`);
+  const hub = buildExploreHubPage({ ...input, slug });
+  const absolutePath = path13.join(paths.wikiDir, hub.page.path);
+  await ensureDir(path13.dirname(absolutePath));
+  await fs11.writeFile(absolutePath, hub.content, "utf8");
+  const storedOutputs = await loadSavedOutputPages(paths.wikiDir);
+  const outputPages = storedOutputs.map((page) => page.page);
+  await upsertGraphPages(rootDir, outputPages);
+  const graph = await readJsonFile(paths.graphPath);
+  await refreshIndexesAndSearch(rootDir, input.schemaHash, graph?.pages ?? outputPages);
+  return { page: hub.page, savedTo: absolutePath };
+}
+async function executeQuery(rootDir, question) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const schema = await loadVaultSchema(rootDir);
+  const provider = await getProviderForTask(rootDir, "queryProvider");
+  if (!await fileExists(paths.searchDbPath) || !await fileExists(paths.graphPath)) {
+    await compileVault(rootDir);
+  }
+  const graph = await readJsonFile(paths.graphPath);
+  const pageMap = new Map((graph?.pages ?? []).map((page) => [page.id, page]));
+  const searchResults = searchPages(paths.searchDbPath, question, 5);
+  const excerpts = await Promise.all(
+    searchResults.map(async (result) => {
+      const absolutePath = path13.join(paths.wikiDir, result.path);
+      try {
+        const content = await fs11.readFile(absolutePath, "utf8");
+        const parsed = matter5(content);
+        return `# ${result.title}
+${truncate(normalizeWhitespace(parsed.content), 1200)}`;
+      } catch {
+        return `# ${result.title}
+${result.snippet}`;
+      }
+    })
+  );
+  const relatedPageIds = uniqueBy(
+    searchResults.map((result) => result.pageId),
+    (item) => item
+  );
+  const relatedNodeIds = uniqueBy(
+    relatedPageIds.flatMap((pageId) => pageMap.get(pageId)?.nodeIds ?? []),
+    (item) => item
+  );
+  const relatedSourceIds = uniqueBy(
+    relatedPageIds.flatMap((pageId) => pageMap.get(pageId)?.sourceIds ?? []),
+    (item) => item
+  );
+  const manifests = await listManifests(rootDir);
+  const rawExcerpts = [];
+  for (const sourceId of relatedSourceIds.slice(0, 5)) {
+    const manifest = manifests.find((item) => item.sourceId === sourceId);
+    if (!manifest) {
+      continue;
+    }
+    const text = await readExtractedText(rootDir, manifest);
+    if (text) {
+      rawExcerpts.push(`# [source:${sourceId}] ${manifest.title}
+${truncate(normalizeWhitespace(text), 800)}`);
+    }
+  }
+  let answer;
+  if (provider.type === "heuristic") {
+    answer = [
+      `Question: ${question}`,
+      "",
+      "Relevant pages:",
+      ...searchResults.map((result) => `- ${result.title} (${result.path})`),
+      "",
+      excerpts.length ? excerpts.join("\n\n") : "No relevant pages found yet.",
+      ...rawExcerpts.length ? ["", "Raw source material:", "", ...rawExcerpts] : []
+    ].join("\n");
+  } else {
+    const context = [
+      "Wiki context:",
+      excerpts.join("\n\n---\n\n"),
+      ...rawExcerpts.length ? ["", "Raw source material:", rawExcerpts.join("\n\n---\n\n")] : []
+    ].join("\n\n");
+    const response = await provider.generateText({
+      system: buildSchemaPrompt(
+        schema,
+        "Answer using the provided context. Prefer raw source material over wiki summaries when they differ. Cite source IDs."
+      ),
+      prompt: `Question: ${question}
+
+${context}`
+    });
+    answer = response.text;
+  }
+  return {
+    answer,
+    citations: relatedSourceIds,
+    relatedPageIds,
+    relatedNodeIds,
+    relatedSourceIds
+  };
+}
+async function generateFollowUpQuestions(rootDir, question, answer) {
+  const provider = await getProviderForTask(rootDir, "queryProvider");
+  const schema = await loadVaultSchema(rootDir);
+  if (provider.type === "heuristic") {
+    return uniqueBy(
+      [
+        `What evidence best supports ${question}?`,
+        `What contradicts ${question}?`,
+        `Which sources should be added to answer ${question} better?`
+      ],
+      (item) => item
+    ).slice(0, 3);
+  }
+  const response = await provider.generateStructured(
+    {
+      system: buildSchemaPrompt(schema, "Propose concise follow-up research questions for the vault. Return only useful next questions."),
+      prompt: `Root question: ${question}
+
+Current answer:
+${answer}`
+    },
+    z8.object({
+      questions: z8.array(z8.string().min(1)).max(5)
+    })
+  );
+  return uniqueBy(response.questions, (item) => item).filter((item) => item !== question);
+}
 async function initVault(rootDir) {
   await initWorkspace(rootDir);
   await installConfiguredAgents(rootDir);
@@ -1848,107 +2576,306 @@ async function compileVault(rootDir) {
   const schema = await loadVaultSchema(rootDir);
   const provider = await getProviderForTask(rootDir, "compileProvider");
   const manifests = await listManifests(rootDir);
-  const analyses = await Promise.all(
-    manifests.map(async (manifest) => analyzeSource(manifest, await readExtractedText(rootDir, manifest), provider, paths, schema))
-  );
+  const storedOutputPages = await loadSavedOutputPages(paths.wikiDir);
+  const outputPages = storedOutputPages.map((page) => page.page);
+  const currentOutputHashes = outputHashes(storedOutputPages);
+  const previousState = await readJsonFile(paths.compileStatePath);
+  const schemaChanged = !previousState || previousState.schemaHash !== schema.hash;
+  const previousSourceHashes = previousState?.sourceHashes ?? {};
+  const previousAnalyses = previousState?.analyses ?? {};
+  const previousOutputHashes = previousState?.outputHashes ?? {};
+  const currentSourceIds = new Set(manifests.map((item) => item.sourceId));
+  const previousSourceIds = new Set(Object.keys(previousSourceHashes));
+  const sourcesChanged = currentSourceIds.size !== previousSourceIds.size || [...currentSourceIds].some((sourceId) => !previousSourceIds.has(sourceId));
+  const outputsChanged = !recordsEqual(currentOutputHashes, previousOutputHashes);
+  const artifactsExist = await requiredCompileArtifactsExist(paths);
+  const dirty = [];
+  const clean = [];
+  for (const manifest of manifests) {
+    const hashChanged = previousSourceHashes[manifest.sourceId] !== manifest.contentHash;
+    const noAnalysis = !previousAnalyses[manifest.sourceId];
+    if (schemaChanged || hashChanged || noAnalysis) {
+      dirty.push(manifest);
+    } else {
+      clean.push(manifest);
+    }
+  }
+  if (dirty.length === 0 && !schemaChanged && !sourcesChanged && !outputsChanged && artifactsExist) {
+    const graph2 = await readJsonFile(paths.graphPath);
+    return {
+      graphPath: paths.graphPath,
+      pageCount: graph2?.pages.length ?? outputPages.length,
+      changedPages: [],
+      sourceCount: manifests.length
+    };
+  }
+  const [dirtyAnalyses, cleanAnalyses] = await Promise.all([
+    Promise.all(
+      dirty.map(async (manifest) => analyzeSource(manifest, await readExtractedText(rootDir, manifest), provider, paths, schema))
+    ),
+    Promise.all(
+      clean.map(async (manifest) => {
+        const cached = await readJsonFile(path13.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        if (cached) {
+          return cached;
+        }
+        return analyzeSource(manifest, await readExtractedText(rootDir, manifest), provider, paths, schema);
+      })
+    )
+  ]);
+  const analyses = [...dirtyAnalyses, ...cleanAnalyses];
   const changedPages = [];
-  const pages = [];
+  const compiledPages = [];
   await Promise.all([
-    ensureDir(path10.join(paths.wikiDir, "sources")),
-    ensureDir(path10.join(paths.wikiDir, "concepts")),
-    ensureDir(path10.join(paths.wikiDir, "entities")),
-    ensureDir(path10.join(paths.wikiDir, "outputs"))
+    ensureDir(path13.join(paths.wikiDir, "sources")),
+    ensureDir(path13.join(paths.wikiDir, "concepts")),
+    ensureDir(path13.join(paths.wikiDir, "entities")),
+    ensureDir(path13.join(paths.wikiDir, "outputs"))
   ]);
   for (const manifest of manifests) {
     const analysis = analyses.find((item) => item.sourceId === manifest.sourceId);
     if (!analysis) {
       continue;
     }
-    const sourcePage = buildSourcePage(manifest, analysis, schema.hash);
-    pages.push(sourcePage.page);
+    const preview = emptyGraphPage({
+      id: `source:${manifest.sourceId}`,
+      path: `sources/${manifest.sourceId}.md`,
+      title: analysis.title,
+      kind: "source",
+      sourceIds: [manifest.sourceId],
+      nodeIds: [`source:${manifest.sourceId}`, ...analysis.concepts.map((item) => item.id), ...analysis.entities.map((item) => item.id)],
+      schemaHash: schema.hash,
+      sourceHashes: { [manifest.sourceId]: manifest.contentHash },
+      confidence: 1
+    });
+    const sourcePage = buildSourcePage(manifest, analysis, schema.hash, 1, relatedOutputsForPage(preview, outputPages));
+    compiledPages.push(sourcePage.page);
     await writePage(paths.wikiDir, sourcePage.page.path, sourcePage.content, changedPages);
   }
   for (const aggregate of aggregateItems(analyses, "concepts")) {
-    const page = buildAggregatePage("concept", aggregate.name, aggregate.descriptions, aggregate.sourceAnalyses, aggregate.sourceHashes, schema.hash);
-    pages.push(page.page);
+    const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
+    const preview = emptyGraphPage({
+      id: `concept:${slugify(aggregate.name)}`,
+      path: `concepts/${slugify(aggregate.name)}.md`,
+      title: aggregate.name,
+      kind: "concept",
+      sourceIds: aggregate.sourceAnalyses.map((item) => item.sourceId),
+      nodeIds: [`concept:${slugify(aggregate.name)}`],
+      schemaHash: schema.hash,
+      sourceHashes: aggregate.sourceHashes,
+      confidence
+    });
+    const page = buildAggregatePage(
+      "concept",
+      aggregate.name,
+      aggregate.descriptions,
+      aggregate.sourceAnalyses,
+      aggregate.sourceHashes,
+      schema.hash,
+      confidence,
+      relatedOutputsForPage(preview, outputPages)
+    );
+    compiledPages.push(page.page);
     await writePage(paths.wikiDir, page.page.path, page.content, changedPages);
   }
   for (const aggregate of aggregateItems(analyses, "entities")) {
-    const page = buildAggregatePage("entity", aggregate.name, aggregate.descriptions, aggregate.sourceAnalyses, aggregate.sourceHashes, schema.hash);
-    pages.push(page.page);
+    const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
+    const preview = emptyGraphPage({
+      id: `entity:${slugify(aggregate.name)}`,
+      path: `entities/${slugify(aggregate.name)}.md`,
+      title: aggregate.name,
+      kind: "entity",
+      sourceIds: aggregate.sourceAnalyses.map((item) => item.sourceId),
+      nodeIds: [`entity:${slugify(aggregate.name)}`],
+      schemaHash: schema.hash,
+      sourceHashes: aggregate.sourceHashes,
+      confidence
+    });
+    const page = buildAggregatePage(
+      "entity",
+      aggregate.name,
+      aggregate.descriptions,
+      aggregate.sourceAnalyses,
+      aggregate.sourceHashes,
+      schema.hash,
+      confidence,
+      relatedOutputsForPage(preview, outputPages)
+    );
+    compiledPages.push(page.page);
     await writePage(paths.wikiDir, page.page.path, page.content, changedPages);
   }
-  const graph = buildGraph(manifests, analyses, pages);
+  const allPages = [...compiledPages, ...outputPages];
+  const graph = buildGraph(manifests, analyses, allPages);
   await writeJsonFile(paths.graphPath, graph);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
     schemaHash: schema.hash,
-    analyses: Object.fromEntries(analyses.map((analysis) => [analysis.sourceId, analysisSignature(analysis)]))
+    analyses: Object.fromEntries(analyses.map((analysis) => [analysis.sourceId, analysisSignature(analysis)])),
+    sourceHashes: Object.fromEntries(manifests.map((manifest) => [manifest.sourceId, manifest.contentHash])),
+    outputHashes: currentOutputHashes
   });
-  await writePage(paths.wikiDir, "index.md", buildIndexPage(pages, schema.hash), changedPages);
-  await writePage(paths.wikiDir, "sources/index.md", buildSectionIndex("sources", pages.filter((page) => page.kind === "source"), schema.hash), changedPages);
-  await writePage(paths.wikiDir, "concepts/index.md", buildSectionIndex("concepts", pages.filter((page) => page.kind === "concept"), schema.hash), changedPages);
-  await writePage(paths.wikiDir, "entities/index.md", buildSectionIndex("entities", pages.filter((page) => page.kind === "entity"), schema.hash), changedPages);
-  await rebuildSearchIndex(paths.searchDbPath, pages, paths.wikiDir);
-  await appendLogEntry(rootDir, "compile", `Compiled ${manifests.length} source(s)`, [`provider=${provider.id}`, `pages=${pages.length}`, `schema=${schema.hash.slice(0, 12)}`]);
+  await writePage(paths.wikiDir, "index.md", buildIndexPage(allPages, schema.hash), changedPages);
+  await writePage(
+    paths.wikiDir,
+    "sources/index.md",
+    buildSectionIndex(
+      "sources",
+      allPages.filter((page) => page.kind === "source"),
+      schema.hash
+    ),
+    changedPages
+  );
+  await writePage(
+    paths.wikiDir,
+    "concepts/index.md",
+    buildSectionIndex(
+      "concepts",
+      allPages.filter((page) => page.kind === "concept"),
+      schema.hash
+    ),
+    changedPages
+  );
+  await writePage(
+    paths.wikiDir,
+    "entities/index.md",
+    buildSectionIndex(
+      "entities",
+      allPages.filter((page) => page.kind === "entity"),
+      schema.hash
+    ),
+    changedPages
+  );
+  await writePage(
+    paths.wikiDir,
+    "outputs/index.md",
+    buildSectionIndex(
+      "outputs",
+      allPages.filter((page) => page.kind === "output"),
+      schema.hash
+    ),
+    changedPages
+  );
+  if (changedPages.length > 0 || outputsChanged || !artifactsExist) {
+    await rebuildSearchIndex(paths.searchDbPath, allPages, paths.wikiDir);
+  }
+  await appendLogEntry(rootDir, "compile", `Compiled ${manifests.length} source(s)`, [
+    `provider=${provider.id}`,
+    `pages=${allPages.length}`,
+    `dirty=${dirty.length}`,
+    `clean=${clean.length}`,
+    `outputs=${outputPages.length}`,
+    `schema=${schema.hash.slice(0, 12)}`
+  ]);
   return {
     graphPath: paths.graphPath,
-    pageCount: pages.length,
+    pageCount: allPages.length,
     changedPages,
     sourceCount: manifests.length
   };
 }
 async function queryVault(rootDir, question, save = false) {
-  const { paths } = await loadVaultConfig(rootDir);
   const schema = await loadVaultSchema(rootDir);
-  const provider = await getProviderForTask(rootDir, "queryProvider");
-  if (!await fileExists(paths.searchDbPath)) {
-    await compileVault(rootDir);
+  const query = await executeQuery(rootDir, question);
+  let savedTo;
+  let savedPageId;
+  if (save) {
+    const saved = await persistOutputPage(rootDir, {
+      question,
+      answer: query.answer,
+      citations: query.citations,
+      schemaHash: schema.hash,
+      relatedPageIds: query.relatedPageIds,
+      relatedNodeIds: query.relatedNodeIds,
+      relatedSourceIds: query.relatedSourceIds,
+      origin: "query"
+    });
+    savedTo = saved.savedTo;
+    savedPageId = saved.page.id;
   }
-  const searchResults = searchPages(paths.searchDbPath, question, 5);
-  const excerpts = await Promise.all(
-    searchResults.map(async (result) => {
-      const absolutePath = path10.join(paths.wikiDir, result.path);
-      const content = await fs9.readFile(absolutePath, "utf8");
-      const parsed = matter3(content);
-      return `# ${result.title}
-${truncate(normalizeWhitespace(parsed.content), 1200)}`;
-    })
-  );
-  let answer;
-  if (provider.type === "heuristic") {
-    answer = [
-      `Question: ${question}`,
-      "",
-      "Relevant pages:",
-      ...searchResults.map((result) => `- ${result.title} (${result.path})`),
-      "",
-      excerpts.length ? excerpts.join("\n\n") : "No relevant pages found yet."
-    ].join("\n");
-  } else {
-    const response = await provider.generateText({
-      system: buildSchemaPrompt(schema, "Answer using the provided SwarmVault excerpts. Cite source ids or page titles when possible."),
-      prompt: `Question: ${question}
-
-Context:
-${excerpts.join("\n\n---\n\n")}`
+  await appendLogEntry(rootDir, "query", question, [
+    `citations=${query.citations.join(",") || "none"}`,
+    `saved=${Boolean(savedTo)}`,
+    `rawSources=${query.relatedSourceIds.length}`
+  ]);
+  return {
+    answer: query.answer,
+    savedTo,
+    savedPageId,
+    citations: query.citations,
+    relatedPageIds: query.relatedPageIds,
+    relatedNodeIds: query.relatedNodeIds,
+    relatedSourceIds: query.relatedSourceIds
+  };
+}
+async function exploreVault(rootDir, question, steps = 3) {
+  const schema = await loadVaultSchema(rootDir);
+  const stepResults = [];
+  const stepPages = [];
+  const visited = /* @__PURE__ */ new Set();
+  const suggestedQuestions = [];
+  let currentQuestion = question;
+  for (let step = 1; step <= Math.max(1, steps); step++) {
+    const normalizedQuestion = normalizeWhitespace(currentQuestion).toLowerCase();
+    if (!normalizedQuestion || visited.has(normalizedQuestion)) {
+      break;
+    }
+    visited.add(normalizedQuestion);
+    const query = await executeQuery(rootDir, currentQuestion);
+    const saved = await persistOutputPage(rootDir, {
+      title: `Explore Step ${step}: ${currentQuestion}`,
+      question: currentQuestion,
+      answer: query.answer,
+      citations: query.citations,
+      schemaHash: schema.hash,
+      relatedPageIds: query.relatedPageIds,
+      relatedNodeIds: query.relatedNodeIds,
+      relatedSourceIds: query.relatedSourceIds,
+      origin: "explore",
+      slug: `explore-${slugify(question)}-step-${step}`
     });
-    answer = response.text;
+    const followUpQuestions = await generateFollowUpQuestions(rootDir, currentQuestion, query.answer);
+    stepResults.push({
+      step,
+      question: currentQuestion,
+      answer: query.answer,
+      savedTo: saved.savedTo,
+      savedPageId: saved.page.id,
+      citations: query.citations,
+      followUpQuestions
+    });
+    stepPages.push(saved.page);
+    suggestedQuestions.push(...followUpQuestions);
+    const nextQuestion = followUpQuestions.find((item) => !visited.has(normalizeWhitespace(item).toLowerCase()));
+    if (!nextQuestion) {
+      break;
+    }
+    currentQuestion = nextQuestion;
   }
-  const citations = uniqueBy(
-    searchResults.filter((result) => result.pageId.startsWith("source:")).map((result) => result.pageId.replace(/^source:/, "")),
+  const allCitations = uniqueBy(
+    stepResults.flatMap((step) => step.citations),
     (item) => item
   );
-  let savedTo;
-  if (save) {
-    const output = buildOutputPage(question, answer, citations, schema.hash);
-    const absolutePath = path10.join(paths.wikiDir, output.page.path);
-    await ensureDir(path10.dirname(absolutePath));
-    await fs9.writeFile(absolutePath, output.content, "utf8");
-    savedTo = absolutePath;
-  }
-  await appendLogEntry(rootDir, "query", question, [`citations=${citations.join(",") || "none"}`, `saved=${Boolean(savedTo)}`]);
-  return { answer, savedTo, citations };
+  const hub = await persistExploreHub(rootDir, {
+    question,
+    stepPages,
+    followUpQuestions: uniqueBy(suggestedQuestions, (item) => item),
+    citations: allCitations,
+    schemaHash: schema.hash,
+    slug: `explore-${slugify(question)}`
+  });
+  await appendLogEntry(rootDir, "explore", question, [
+    `steps=${stepResults.length}`,
+    `hub=${hub.page.id}`,
+    `citations=${allCitations.join(",") || "none"}`
+  ]);
+  return {
+    rootQuestion: question,
+    hubPath: hub.savedTo,
+    hubPageId: hub.page.id,
+    stepCount: stepResults.length,
+    steps: stepResults,
+    suggestedQuestions: uniqueBy(suggestedQuestions, (item) => item)
+  };
 }
 async function searchVault(rootDir, query, limit = 5) {
   const { paths } = await loadVaultConfig(rootDir);
@@ -1964,15 +2891,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path10.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path13.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs9.readFile(absolutePath, "utf8");
-  const parsed = matter3(raw);
+  const raw = await fs11.readFile(absolutePath, "utf8");
+  const parsed = matter5(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path10.basename(relativePath, path10.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path13.basename(relativePath, path13.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -1994,12 +2921,70 @@ async function getWorkspaceInfo(rootDir) {
     pageCount: pages.length
   };
 }
-async function lintVault(rootDir) {
+function structuralLintFindings(_rootDir, paths, graph, schemaHash, manifests) {
+  const manifestMap = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
+  return Promise.all(
+    graph.pages.map(async (page) => {
+      const findings = [];
+      if (page.schemaHash !== schemaHash) {
+        findings.push({
+          severity: "warning",
+          code: "stale_page",
+          message: `Page ${page.title} is stale because the vault schema changed.`,
+          pagePath: path13.join(paths.wikiDir, page.path),
+          relatedPageIds: [page.id]
+        });
+      }
+      for (const [sourceId, knownHash] of Object.entries(page.sourceHashes)) {
+        const manifest = manifestMap.get(sourceId);
+        if (manifest && manifest.contentHash !== knownHash) {
+          findings.push({
+            severity: "warning",
+            code: "stale_page",
+            message: `Page ${page.title} is stale because source ${sourceId} changed.`,
+            pagePath: path13.join(paths.wikiDir, page.path),
+            relatedSourceIds: [sourceId],
+            relatedPageIds: [page.id]
+          });
+        }
+      }
+      if (page.kind !== "index" && page.backlinks.length === 0) {
+        findings.push({
+          severity: "info",
+          code: "orphan_page",
+          message: `Page ${page.title} has no backlinks.`,
+          pagePath: path13.join(paths.wikiDir, page.path),
+          relatedPageIds: [page.id]
+        });
+      }
+      const absolutePath = path13.join(paths.wikiDir, page.path);
+      if (await fileExists(absolutePath)) {
+        const content = await fs11.readFile(absolutePath, "utf8");
+        if (content.includes("## Claims")) {
+          const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
+          if (uncited.length) {
+            findings.push({
+              severity: "warning",
+              code: "uncited_claims",
+              message: `Page ${page.title} contains uncited claim bullets.`,
+              pagePath: absolutePath,
+              relatedPageIds: [page.id]
+            });
+          }
+        }
+      }
+      return findings;
+    })
+  ).then((results) => results.flat());
+}
+async function lintVault(rootDir, options = {}) {
+  if (options.web && !options.deep) {
+    throw new Error("`--web` can only be used together with `--deep`.");
+  }
   const { paths } = await loadVaultConfig(rootDir);
   const schema = await loadVaultSchema(rootDir);
   const manifests = await listManifests(rootDir);
   const graph = await readJsonFile(paths.graphPath);
-  const findings = [];
   if (!graph) {
     return [
       {
@@ -2009,52 +2994,15 @@ async function lintVault(rootDir) {
       }
     ];
   }
-  const manifestMap = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
-  for (const page of graph.pages) {
-    if (page.schemaHash !== schema.hash) {
-      findings.push({
-        severity: "warning",
-        code: "stale_page",
-        message: `Page ${page.title} is stale because the vault schema changed.`,
-        pagePath: path10.join(paths.wikiDir, page.path)
-      });
-    }
-    for (const [sourceId, knownHash] of Object.entries(page.sourceHashes)) {
-      const manifest = manifestMap.get(sourceId);
-      if (manifest && manifest.contentHash !== knownHash) {
-        findings.push({
-          severity: "warning",
-          code: "stale_page",
-          message: `Page ${page.title} is stale because source ${sourceId} changed.`,
-          pagePath: path10.join(paths.wikiDir, page.path)
-        });
-      }
-    }
-    if (page.kind !== "index" && page.backlinks.length === 0) {
-      findings.push({
-        severity: "info",
-        code: "orphan_page",
-        message: `Page ${page.title} has no backlinks.`,
-        pagePath: path10.join(paths.wikiDir, page.path)
-      });
-    }
-    const absolutePath = path10.join(paths.wikiDir, page.path);
-    if (await fileExists(absolutePath)) {
-      const content = await fs9.readFile(absolutePath, "utf8");
-      if (content.includes("## Claims")) {
-        const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
-        if (uncited.length) {
-          findings.push({
-            severity: "warning",
-            code: "uncited_claims",
-            message: `Page ${page.title} contains uncited claim bullets.`,
-            pagePath: absolutePath
-          });
-        }
-      }
-    }
+  const findings = await structuralLintFindings(rootDir, paths, graph, schema.hash, manifests);
+  if (options.deep) {
+    findings.push(...await runDeepLint(rootDir, findings, { web: options.web }));
   }
-  await appendLogEntry(rootDir, "lint", `Linted ${graph.pages.length} page(s)`, [`findings=${findings.length}`]);
+  await appendLogEntry(rootDir, "lint", `Linted ${graph.pages.length} page(s)`, [
+    `findings=${findings.length}`,
+    `deep=${Boolean(options.deep)}`,
+    `web=${Boolean(options.web)}`
+  ]);
   return findings;
 }
 async function bootstrapDemo(rootDir, input) {
@@ -2070,174 +3018,170 @@ async function bootstrapDemo(rootDir, input) {
   };
 }
 
-// src/viewer.ts
-import fs10 from "fs/promises";
-import http from "http";
-import path11 from "path";
-import mime2 from "mime-types";
-async function startGraphServer(rootDir, port) {
-  const { config, paths } = await loadVaultConfig(rootDir);
-  const effectivePort = port ?? config.viewer.port;
-  const server = http.createServer(async (request, response) => {
-    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? `localhost:${effectivePort}`}`);
-    if (url.pathname === "/api/graph") {
-      if (!await fileExists(paths.graphPath)) {
-        response.writeHead(404, { "content-type": "application/json" });
-        response.end(JSON.stringify({ error: "Graph artifact not found. Run `swarmvault compile` first." }));
-        return;
-      }
-      response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs10.readFile(paths.graphPath, "utf8"));
-      return;
-    }
-    const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path11.join(paths.viewerDistDir, relativePath);
-    const fallback = path11.join(paths.viewerDistDir, "index.html");
-    const filePath = await fileExists(target) ? target : fallback;
-    if (!await fileExists(filePath)) {
-      response.writeHead(503, { "content-type": "text/plain" });
-      response.end("Viewer build not found. Run `pnpm build` first.");
-      return;
-    }
-    response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs10.readFile(filePath));
-  });
-  await new Promise((resolve) => {
-    server.listen(effectivePort, resolve);
-  });
-  return {
-    port: effectivePort,
-    close: async () => {
-      await new Promise((resolve, reject) => {
-        server.close((error) => {
-          if (error) {
-            reject(error);
-            return;
-          }
-          resolve();
-        });
-      });
-    }
-  };
-}
-
 // src/mcp.ts
-import fs11 from "fs/promises";
-import path12 from "path";
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z6 } from "zod";
-var SERVER_VERSION = "0.1.4";
+var SERVER_VERSION = "0.1.5";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
     version: SERVER_VERSION,
     websiteUrl: "https://www.swarmvault.ai"
   });
-  server.registerTool("workspace_info", {
-    description: "Return the current SwarmVault workspace paths and high-level counts."
-  }, async () => {
-    const info = await getWorkspaceInfo(rootDir);
-    return asToolText(info);
-  });
-  server.registerTool("search_pages", {
-    description: "Search compiled wiki pages using the local full-text index.",
-    inputSchema: {
-      query: z6.string().min(1).describe("Search query"),
-      limit: z6.number().int().min(1).max(25).optional().describe("Maximum number of results")
-    }
-  }, async ({ query, limit }) => {
-    const results = await searchVault(rootDir, query, limit ?? 5);
-    return asToolText(results);
-  });
-  server.registerTool("read_page", {
-    description: "Read a generated wiki page by its path relative to wiki/.",
-    inputSchema: {
-      path: z6.string().min(1).describe("Path relative to wiki/, for example sources/example.md")
+  server.registerTool(
+    "workspace_info",
+    {
+      description: "Return the current SwarmVault workspace paths and high-level counts."
+    },
+    async () => {
+      const info = await getWorkspaceInfo(rootDir);
+      return asToolText(info);
     }
-  }, async ({ path: relativePath }) => {
-    const page = await readPage(rootDir, relativePath);
-    if (!page) {
-      return asToolError(`Page not found: ${relativePath}`);
+  );
+  server.registerTool(
+    "search_pages",
+    {
+      description: "Search compiled wiki pages using the local full-text index.",
+      inputSchema: {
+        query: z9.string().min(1).describe("Search query"),
+        limit: z9.number().int().min(1).max(25).optional().describe("Maximum number of results")
+      }
+    },
+    async ({ query, limit }) => {
+      const results = await searchVault(rootDir, query, limit ?? 5);
+      return asToolText(results);
     }
-    return asToolText(page);
-  });
-  server.registerTool("list_sources", {
-    description: "List source manifests in the current workspace.",
-    inputSchema: {
-      limit: z6.number().int().min(1).max(100).optional().describe("Maximum number of manifests to return")
-    }
-  }, async ({ limit }) => {
-    const manifests = await listManifests(rootDir);
-    return asToolText(limit ? manifests.slice(0, limit) : manifests);
-  });
-  server.registerTool("query_vault", {
-    description: "Ask a question against the compiled vault and optionally save the answer.",
-    inputSchema: {
-      question: z6.string().min(1).describe("Question to ask the vault"),
-      save: z6.boolean().optional().describe("Persist the answer to wiki/outputs")
-    }
-  }, async ({ question, save }) => {
-    const result = await queryVault(rootDir, question, save ?? false);
-    return asToolText(result);
-  });
-  server.registerTool("ingest_input", {
-    description: "Ingest a local file path or URL into the SwarmVault workspace.",
-    inputSchema: {
-      input: z6.string().min(1).describe("Local path or URL to ingest")
-    }
-  }, async ({ input }) => {
-    const manifest = await ingestInput(rootDir, input);
-    return asToolText(manifest);
-  });
-  server.registerTool("compile_vault", {
-    description: "Compile source manifests into wiki pages, graph data, and search index."
-  }, async () => {
-    const result = await compileVault(rootDir);
-    return asToolText(result);
-  });
-  server.registerTool("lint_vault", {
-    description: "Run anti-drift and vault health checks."
-  }, async () => {
-    const findings = await lintVault(rootDir);
-    return asToolText(findings);
-  });
-  server.registerResource("swarmvault-config", "swarmvault://config", {
-    title: "SwarmVault Config",
-    description: "The resolved SwarmVault config file.",
-    mimeType: "application/json"
-  }, async () => {
-    const { config } = await loadVaultConfig(rootDir);
-    return asTextResource("swarmvault://config", JSON.stringify(config, null, 2));
-  });
-  server.registerResource("swarmvault-graph", "swarmvault://graph", {
-    title: "SwarmVault Graph",
-    description: "The compiled graph artifact for the current workspace.",
-    mimeType: "application/json"
-  }, async () => {
-    const { paths } = await loadVaultConfig(rootDir);
-    const graph = await readJsonFile(paths.graphPath);
-    return asTextResource(
-      "swarmvault://graph",
-      JSON.stringify(graph ?? { error: "Graph artifact not found. Run `swarmvault compile` first." }, null, 2)
-    );
-  });
-  server.registerResource("swarmvault-manifests", "swarmvault://manifests", {
-    title: "SwarmVault Manifests",
-    description: "All source manifests in the workspace.",
-    mimeType: "application/json"
-  }, async () => {
-    const manifests = await listManifests(rootDir);
-    return asTextResource("swarmvault://manifests", JSON.stringify(manifests, null, 2));
-  });
-  server.registerResource("swarmvault-schema", "swarmvault://schema", {
-    title: "SwarmVault Schema",
-    description: "The vault schema file that guides compile and query behavior.",
-    mimeType: "text/markdown"
-  }, async () => {
-    const schema = await loadVaultSchema(rootDir);
-    return asTextResource("swarmvault://schema", schema.content);
-  });
+  );
+  server.registerTool(
+    "read_page",
+    {
+      description: "Read a generated wiki page by its path relative to wiki/.",
+      inputSchema: {
+        path: z9.string().min(1).describe("Path relative to wiki/, for example sources/example.md")
+      }
+    },
+    async ({ path: relativePath }) => {
+      const page = await readPage(rootDir, relativePath);
+      if (!page) {
+        return asToolError(`Page not found: ${relativePath}`);
+      }
+      return asToolText(page);
+    }
+  );
+  server.registerTool(
+    "list_sources",
+    {
+      description: "List source manifests in the current workspace.",
+      inputSchema: {
+        limit: z9.number().int().min(1).max(100).optional().describe("Maximum number of manifests to return")
+      }
+    },
+    async ({ limit }) => {
+      const manifests = await listManifests(rootDir);
+      return asToolText(limit ? manifests.slice(0, limit) : manifests);
+    }
+  );
+  server.registerTool(
+    "query_vault",
+    {
+      description: "Ask a question against the compiled vault and optionally save the answer.",
+      inputSchema: {
+        question: z9.string().min(1).describe("Question to ask the vault"),
+        save: z9.boolean().optional().describe("Persist the answer to wiki/outputs")
+      }
+    },
+    async ({ question, save }) => {
+      const result = await queryVault(rootDir, question, save ?? false);
+      return asToolText(result);
+    }
+  );
+  server.registerTool(
+    "ingest_input",
+    {
+      description: "Ingest a local file path or URL into the SwarmVault workspace.",
+      inputSchema: {
+        input: z9.string().min(1).describe("Local path or URL to ingest")
+      }
+    },
+    async ({ input }) => {
+      const manifest = await ingestInput(rootDir, input);
+      return asToolText(manifest);
+    }
+  );
+  server.registerTool(
+    "compile_vault",
+    {
+      description: "Compile source manifests into wiki pages, graph data, and search index."
+    },
+    async () => {
+      const result = await compileVault(rootDir);
+      return asToolText(result);
+    }
+  );
+  server.registerTool(
+    "lint_vault",
+    {
+      description: "Run anti-drift and vault health checks."
+    },
+    async () => {
+      const findings = await lintVault(rootDir);
+      return asToolText(findings);
+    }
+  );
+  server.registerResource(
+    "swarmvault-config",
+    "swarmvault://config",
+    {
+      title: "SwarmVault Config",
+      description: "The resolved SwarmVault config file.",
+      mimeType: "application/json"
+    },
+    async () => {
+      const { config } = await loadVaultConfig(rootDir);
+      return asTextResource("swarmvault://config", JSON.stringify(config, null, 2));
+    }
+  );
+  server.registerResource(
+    "swarmvault-graph",
+    "swarmvault://graph",
+    {
+      title: "SwarmVault Graph",
+      description: "The compiled graph artifact for the current workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      const { paths } = await loadVaultConfig(rootDir);
+      const graph = await readJsonFile(paths.graphPath);
+      return asTextResource(
+        "swarmvault://graph",
+        JSON.stringify(graph ?? { error: "Graph artifact not found. Run `swarmvault compile` first." }, null, 2)
+      );
+    }
+  );
+  server.registerResource(
+    "swarmvault-manifests",
+    "swarmvault://manifests",
+    {
+      title: "SwarmVault Manifests",
+      description: "All source manifests in the workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      const manifests = await listManifests(rootDir);
+      return asTextResource("swarmvault://manifests", JSON.stringify(manifests, null, 2));
+    }
+  );
+  server.registerResource(
+    "swarmvault-schema",
+    "swarmvault://schema",
+    {
+      title: "SwarmVault Schema",
+      description: "The vault schema file that guides compile and query behavior.",
+      mimeType: "text/markdown"
+    },
+    async () => {
+      const schema = await loadVaultSchema(rootDir);
+      return asTextResource("swarmvault://schema", schema.content);
+    }
+  );
   server.registerResource(
     "swarmvault-pages",
     new ResourceTemplate("swarmvault://pages/{path}", {
@@ -2267,8 +3211,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path12.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs11.readFile(absolutePath, "utf8"));
+      const absolutePath = path14.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs12.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -2315,21 +3259,78 @@ function asTextResource(uri, text) {
   };
 }
 
+// src/viewer.ts
+import fs13 from "fs/promises";
+import http from "http";
+import path15 from "path";
+import mime2 from "mime-types";
+async function startGraphServer(rootDir, port) {
+  const { config, paths } = await loadVaultConfig(rootDir);
+  const effectivePort = port ?? config.viewer.port;
+  const server = http.createServer(async (request, response) => {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? `localhost:${effectivePort}`}`);
+    if (url.pathname === "/api/graph") {
+      if (!await fileExists(paths.graphPath)) {
+        response.writeHead(404, { "content-type": "application/json" });
+        response.end(JSON.stringify({ error: "Graph artifact not found. Run `swarmvault compile` first." }));
+        return;
+      }
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(await fs13.readFile(paths.graphPath, "utf8"));
+      return;
+    }
+    const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
+    const target = path15.join(paths.viewerDistDir, relativePath);
+    const fallback = path15.join(paths.viewerDistDir, "index.html");
+    const filePath = await fileExists(target) ? target : fallback;
+    if (!await fileExists(filePath)) {
+      response.writeHead(503, { "content-type": "text/plain" });
+      response.end("Viewer build not found. Run `pnpm build` first.");
+      return;
+    }
+    response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
+    response.end(await fs13.readFile(filePath));
+  });
+  await new Promise((resolve) => {
+    server.listen(effectivePort, resolve);
+  });
+  return {
+    port: effectivePort,
+    close: async () => {
+      await new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  };
+}
+
 // src/watch.ts
-import path13 from "path";
+import path16 from "path";
+import process2 from "process";
 import chokidar from "chokidar";
+var MAX_BACKOFF_MS = 3e4;
+var BACKOFF_THRESHOLD = 3;
+var CRITICAL_THRESHOLD = 10;
 async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
-  const debounceMs = options.debounceMs ?? 900;
+  const baseDebounceMs = options.debounceMs ?? 900;
   let timer;
   let running = false;
   let pending = false;
   let closed = false;
+  let consecutiveFailures = 0;
+  let currentDebounceMs = baseDebounceMs;
   const reasons = /* @__PURE__ */ new Set();
   const watcher = chokidar.watch(paths.inboxDir, {
     ignoreInitial: true,
     awaitWriteFinish: {
-      stabilityThreshold: Math.max(250, Math.floor(debounceMs / 2)),
+      stabilityThreshold: Math.max(250, Math.floor(baseDebounceMs / 2)),
       pollInterval: 100
     }
   });
@@ -2344,7 +3345,7 @@ async function watchVault(rootDir, options = {}) {
     }
     timer = setTimeout(() => {
       void runCycle();
-    }, debounceMs);
+    }, currentDebounceMs);
   };
   const runCycle = async () => {
     if (running || closed || !pending) {
@@ -2373,9 +3374,23 @@ async function watchVault(rootDir, options = {}) {
         const findings = await lintVault(rootDir);
         lintFindingCount = findings.length;
       }
+      consecutiveFailures = 0;
+      currentDebounceMs = baseDebounceMs;
     } catch (caught) {
       success = false;
       error = caught instanceof Error ? caught.message : String(caught);
+      consecutiveFailures++;
+      pending = true;
+      if (consecutiveFailures >= CRITICAL_THRESHOLD) {
+        process2.stderr.write(
+          `[swarmvault watch] ${consecutiveFailures} consecutive failures. Check vault state. Continuing at max backoff.
+`
+        );
+      }
+      if (consecutiveFailures >= BACKOFF_THRESHOLD) {
+        const multiplier = 2 ** (consecutiveFailures - BACKOFF_THRESHOLD);
+        currentDebounceMs = Math.min(baseDebounceMs * multiplier, MAX_BACKOFF_MS);
+      }
     } finally {
       const finishedAt = /* @__PURE__ */ new Date();
       await appendWatchRun(rootDir, {
@@ -2399,6 +3414,18 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   watcher.on("add", (filePath) => schedule(`add:${toWatchReason(paths.inboxDir, filePath)}`)).on("change", (filePath) => schedule(`change:${toWatchReason(paths.inboxDir, filePath)}`)).on("unlink", (filePath) => schedule(`unlink:${toWatchReason(paths.inboxDir, filePath)}`)).on("addDir", (dirPath) => schedule(`addDir:${toWatchReason(paths.inboxDir, dirPath)}`)).on("unlinkDir", (dirPath) => schedule(`unlinkDir:${toWatchReason(paths.inboxDir, dirPath)}`)).on("error", (caught) => schedule(`error:${caught instanceof Error ? caught.message : String(caught)}`));
+  await new Promise((resolve, reject) => {
+    const handleReady = () => {
+      watcher.off("error", handleError);
+      resolve();
+    };
+    const handleError = (caught) => {
+      watcher.off("ready", handleReady);
+      reject(caught);
+    };
+    watcher.once("ready", handleReady);
+    watcher.once("error", handleError);
+  });
   return {
     close: async () => {
       closed = true;
@@ -2410,7 +3437,7 @@ async function watchVault(rootDir, options = {}) {
   };
 }
 function toWatchReason(baseDir, targetPath) {
-  return path13.relative(baseDir, targetPath) || ".";
+  return path16.relative(baseDir, targetPath) || ".";
 }
 export {
   assertProviderCapability,
@@ -2418,9 +3445,12 @@ export {
   compileVault,
   createMcpServer,
   createProvider,
+  createWebSearchAdapter,
   defaultVaultConfig,
   defaultVaultSchema,
+  exploreVault,
   getProviderForTask,
+  getWebSearchAdapterForTask,
   getWorkspaceInfo,
   importInbox,
   ingestInput,