@swarmvaultai/engine 0.1.19 → 0.1.21

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-NCSZ4AKP.js";
+} from "./chunk-QMW7OISM.js";
 
 // src/agents.ts
 import fs from "fs/promises";
@@ -39,6 +39,7 @@ function buildManagedBlock(target) {
     "- Treat `raw/` as immutable source input.",
     "- Treat `wiki/` as generated markdown owned by the agent and compiler workflow.",
     "- Read `wiki/graph/report.md` before broad file searching when it exists; otherwise start with `wiki/index.md`.",
+    "- For graph questions, prefer `swarmvault graph query`, `swarmvault graph path`, and `swarmvault graph explain` before broad grep/glob searching.",
     "- 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.",
@@ -50,6 +51,33 @@ function buildManagedBlock(target) {
   }
   return body;
 }
+var claudeHookMatcher = "Glob|Grep";
+var claudeHookCommand = "if [ -f wiki/graph/report.md ]; then echo 'swarmvault: Graph report exists. Read wiki/graph/report.md before broad raw-file searching.'; fi";
+async function installClaudeHook(rootDir) {
+  const settingsPath = path.join(rootDir, ".claude", "settings.json");
+  await ensureDir(path.dirname(settingsPath));
+  let settings = {};
+  if (await fileExists(settingsPath)) {
+    try {
+      settings = JSON.parse(await fs.readFile(settingsPath, "utf8"));
+    } catch {
+      settings = {};
+    }
+  }
+  const hooks = settings.hooks ?? {};
+  const preToolUse = hooks.PreToolUse ?? [];
+  const exists = preToolUse.some((entry) => entry.matcher === claudeHookMatcher && JSON.stringify(entry).includes("swarmvault:"));
+  if (!exists) {
+    preToolUse.push({
+      matcher: claudeHookMatcher,
+      hooks: [{ type: "command", command: claudeHookCommand }]
+    });
+  }
+  settings.hooks = { ...hooks, PreToolUse: preToolUse };
+  await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+  return settingsPath;
+}
 function targetPathForAgent(rootDir, agent) {
   switch (agent) {
     case "codex":
@@ -87,7 +115,7 @@ async function upsertManagedBlock(filePath, block) {
 ${block}
 `, "utf8");
 }
-async function installAgent(rootDir, agent) {
+async function installAgent(rootDir, agent, options = {}) {
   await initWorkspace(rootDir);
   const target = targetPathForAgent(rootDir, agent);
   switch (agent) {
@@ -99,6 +127,9 @@ async function installAgent(rootDir, agent) {
       return target;
     case "claude": {
       await upsertManagedBlock(target, buildManagedBlock("claude"));
+      if (options.claudeHook) {
+        await installClaudeHook(rootDir);
+      }
       return target;
     }
     case "gemini": {
@@ -125,12 +156,445 @@ async function installConfiguredAgents(rootDir) {
       dedupedTargets.set(target, agent);
     }
   }
-  return Promise.all([...dedupedTargets.values()].map((agent) => installAgent(rootDir, agent)));
+  return Promise.all(
+    [...dedupedTargets.values()].map(
+      (agent) => installAgent(rootDir, agent, {
+        claudeHook: agent === "claude"
+      })
+    )
+  );
+}
+
+// src/graph-export.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var NODE_COLORS = {
+  source: "#f59e0b",
+  module: "#fb7185",
+  symbol: "#8b5cf6",
+  rationale: "#14b8a6",
+  concept: "#0ea5e9",
+  entity: "#22c55e"
+};
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function cypherEscape(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function relationType(relation) {
+  const normalized = relation.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "RELATED_TO";
+}
+function graphPageById(graph) {
+  return new Map(graph.pages.map((page) => [page.id, page]));
+}
+function graphNodeById(graph) {
+  return new Map(graph.nodes.map((node) => [node.id, node]));
+}
+function sortedCommunities(graph) {
+  const known = (graph.communities ?? []).map((community) => ({
+    ...community,
+    nodeIds: [...community.nodeIds].sort((left, right) => left.localeCompare(right))
+  }));
+  const knownIds = new Set(known.flatMap((community) => community.nodeIds));
+  const unassigned = graph.nodes.filter((node) => !knownIds.has(node.id)).sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id)).map((node) => node.id);
+  if (unassigned.length) {
+    known.push({
+      id: "community:unassigned",
+      label: "Unassigned",
+      nodeIds: unassigned
+    });
+  }
+  return known.sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id));
+}
+function layoutGraph(graph) {
+  const communities = sortedCommunities(graph);
+  const width = 1600;
+  const height = Math.max(900, 420 * Math.max(1, Math.ceil(communities.length / 3)));
+  const columns = Math.max(1, Math.ceil(Math.sqrt(Math.max(1, communities.length))));
+  const nodesById = graphNodeById(graph);
+  const positioned = [];
+  communities.forEach((community, index) => {
+    const col = index % columns;
+    const row = Math.floor(index / columns);
+    const centerX = 240 + col * 460;
+    const centerY = 220 + row * 360;
+    const members = community.nodeIds.map((nodeId) => nodesById.get(nodeId)).filter((node) => Boolean(node)).sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id));
+    const radius = Math.max(40, 36 * Math.sqrt(members.length));
+    members.forEach((node, memberIndex) => {
+      const angle = Math.PI * 2 * memberIndex / Math.max(1, members.length);
+      positioned.push({
+        node,
+        x: centerX + Math.cos(angle) * radius,
+        y: centerY + Math.sin(angle) * radius
+      });
+    });
+  });
+  return { width, height, nodes: positioned };
+}
+function nodeShape(positioned) {
+  const { node, x, y } = positioned;
+  const fill = NODE_COLORS[node.type] ?? "#94a3b8";
+  if (node.type === "module") {
+    return `<rect x="${(x - 32).toFixed(1)}" y="${(y - 18).toFixed(1)}" width="64" height="36" rx="10" fill="${fill}" stroke="#0f172a" stroke-width="2" />`;
+  }
+  if (node.type === "symbol") {
+    const points = [
+      `${x.toFixed(1)},${(y - 18).toFixed(1)}`,
+      `${(x + 18).toFixed(1)},${y.toFixed(1)}`,
+      `${x.toFixed(1)},${(y + 18).toFixed(1)}`,
+      `${(x - 18).toFixed(1)},${y.toFixed(1)}`
+    ].join(" ");
+    return `<polygon points="${points}" fill="${fill}" stroke="#0f172a" stroke-width="2" />`;
+  }
+  if (node.type === "rationale") {
+    const points = [
+      `${(x - 18).toFixed(1)},${(y - 10).toFixed(1)}`,
+      `${x.toFixed(1)},${(y - 20).toFixed(1)}`,
+      `${(x + 18).toFixed(1)},${(y - 10).toFixed(1)}`,
+      `${(x + 18).toFixed(1)},${(y + 10).toFixed(1)}`,
+      `${x.toFixed(1)},${(y + 20).toFixed(1)}`,
+      `${(x - 18).toFixed(1)},${(y + 10).toFixed(1)}`
+    ].join(" ");
+    return `<polygon points="${points}" fill="${fill}" stroke="#0f172a" stroke-width="2" />`;
+  }
+  return `<circle cx="${x.toFixed(1)}" cy="${y.toFixed(1)}" r="${node.isGodNode ? 24 : 18}" fill="${fill}" stroke="#0f172a" stroke-width="${node.isGodNode ? 3 : 2}" />`;
+}
+function nodeTitle(node, page) {
+  return [
+    node.label,
+    `id=${node.id}`,
+    `type=${node.type}`,
+    node.communityId ? `community=${node.communityId}` : "",
+    page ? `page=${page.path}` : "",
+    node.degree !== void 0 ? `degree=${node.degree}` : "",
+    node.bridgeScore !== void 0 ? `bridge=${node.bridgeScore}` : ""
+  ].filter(Boolean).join("\n");
+}
+function renderSvg(graph) {
+  const layout = layoutGraph(graph);
+  const pageById2 = graphPageById(graph);
+  const positionedById = new Map(layout.nodes.map((item) => [item.node.id, item]));
+  const communityLabels = sortedCommunities(graph).map((community, index) => {
+    const col = index % Math.max(1, Math.ceil(Math.sqrt(Math.max(1, sortedCommunities(graph).length))));
+    const row = Math.floor(index / Math.max(1, Math.ceil(Math.sqrt(Math.max(1, sortedCommunities(graph).length)))));
+    return {
+      label: community.label,
+      x: 240 + col * 460,
+      y: 90 + row * 360
+    };
+  });
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${layout.width}" height="${layout.height}" viewBox="0 0 ${layout.width} ${layout.height}" role="img" aria-labelledby="title desc">`,
+    '  <title id="title">SwarmVault Graph Export</title>',
+    `  <desc id="desc">Nodes=${graph.nodes.length}, edges=${graph.edges.length}, communities=${graph.communities?.length ?? 0}</desc>`,
+    "  <defs>",
+    '    <marker id="arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">',
+    '      <path d="M 0 0 L 10 5 L 0 10 z" fill="#64748b" />',
+    "    </marker>",
+    "  </defs>",
+    '  <rect width="100%" height="100%" fill="#020617" />'
+  ];
+  for (const community of communityLabels) {
+    lines.push(
+      `  <text x="${community.x.toFixed(1)}" y="${community.y.toFixed(1)}" fill="#cbd5e1" font-family="Avenir Next, Segoe UI, sans-serif" font-size="16" text-anchor="middle">${xmlEscape(community.label)}</text>`
+    );
+  }
+  for (const edge of [...graph.edges].sort((left, right) => left.id.localeCompare(right.id))) {
+    const source = positionedById.get(edge.source);
+    const target = positionedById.get(edge.target);
+    if (!source || !target) {
+      continue;
+    }
+    lines.push(
+      `  <g data-edge-id="${xmlEscape(edge.id)}" data-relation="${xmlEscape(edge.relation)}" data-evidence-class="${xmlEscape(edge.evidenceClass)}">`,
+      `    <title>${xmlEscape(
+        `${source.node.label} --${edge.relation}/${edge.evidenceClass}/${edge.confidence.toFixed(2)}--> ${target.node.label}`
+      )}</title>`,
+      `    <line x1="${source.x.toFixed(1)}" y1="${source.y.toFixed(1)}" x2="${target.x.toFixed(1)}" y2="${target.y.toFixed(1)}" stroke="#64748b" stroke-opacity="0.55" stroke-width="${Math.max(
+        1.5,
+        Math.min(4, edge.confidence * 3)
+      ).toFixed(1)}" marker-end="url(#arrow)" />`,
+      "  </g>"
+    );
+  }
+  for (const positioned of layout.nodes) {
+    const page = positioned.node.pageId ? pageById2.get(positioned.node.pageId) : void 0;
+    lines.push(
+      `  <g data-node-id="${xmlEscape(positioned.node.id)}" data-node-type="${xmlEscape(positioned.node.type)}" data-community-id="${xmlEscape(positioned.node.communityId ?? "")}">`,
+      `    <title>${xmlEscape(nodeTitle(positioned.node, page))}</title>`,
+      `    ${nodeShape(positioned)}`,
+      `    <text x="${positioned.x.toFixed(1)}" y="${(positioned.y + 34).toFixed(1)}" fill="#e2e8f0" font-family="Avenir Next, Segoe UI, sans-serif" font-size="11" text-anchor="middle">${xmlEscape(positioned.node.label)}</text>`,
+      "  </g>"
+    );
+  }
+  lines.push("</svg>", "");
+  return lines.join("\n");
+}
+function graphMlData(value) {
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  return String(value);
+}
+function renderGraphMl(graph) {
+  const pageById2 = graphPageById(graph);
+  const keys = [
+    { id: "n_label", for: "node", name: "label", type: "string" },
+    { id: "n_type", for: "node", name: "type", type: "string" },
+    { id: "n_page", for: "node", name: "pageId", type: "string" },
+    { id: "n_page_path", for: "node", name: "pagePath", type: "string" },
+    { id: "n_language", for: "node", name: "language", type: "string" },
+    { id: "n_symbol_kind", for: "node", name: "symbolKind", type: "string" },
+    { id: "n_project_ids", for: "node", name: "projectIds", type: "string" },
+    { id: "n_source_ids", for: "node", name: "sourceIds", type: "string" },
+    { id: "n_community", for: "node", name: "communityId", type: "string" },
+    { id: "n_degree", for: "node", name: "degree", type: "double" },
+    { id: "n_bridge", for: "node", name: "bridgeScore", type: "double" },
+    { id: "e_relation", for: "edge", name: "relation", type: "string" },
+    { id: "e_status", for: "edge", name: "status", type: "string" },
+    { id: "e_evidence", for: "edge", name: "evidenceClass", type: "string" },
+    { id: "e_confidence", for: "edge", name: "confidence", type: "double" },
+    { id: "e_provenance", for: "edge", name: "provenance", type: "string" }
+  ];
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">'
+  ];
+  for (const key of keys) {
+    lines.push(`  <key id="${key.id}" for="${key.for}" attr.name="${key.name}" attr.type="${key.type}" />`);
+  }
+  lines.push('  <graph id="swarmvault" edgedefault="directed">');
+  for (const node of [...graph.nodes].sort((left, right) => left.id.localeCompare(right.id))) {
+    const page = node.pageId ? pageById2.get(node.pageId) : void 0;
+    lines.push(`    <node id="${xmlEscape(node.id)}">`);
+    const dataEntries = [
+      ["n_label", node.label],
+      ["n_type", node.type],
+      ["n_page", node.pageId],
+      ["n_page_path", page?.path],
+      ["n_language", node.language],
+      ["n_symbol_kind", node.symbolKind],
+      ["n_project_ids", node.projectIds],
+      ["n_source_ids", node.sourceIds],
+      ["n_community", node.communityId],
+      ["n_degree", node.degree],
+      ["n_bridge", node.bridgeScore]
+    ];
+    for (const [key, value] of dataEntries) {
+      if (value === void 0) {
+        continue;
+      }
+      lines.push(`      <data key="${key}">${xmlEscape(graphMlData(value))}</data>`);
+    }
+    lines.push("    </node>");
+  }
+  for (const edge of [...graph.edges].sort((left, right) => left.id.localeCompare(right.id))) {
+    lines.push(`    <edge id="${xmlEscape(edge.id)}" source="${xmlEscape(edge.source)}" target="${xmlEscape(edge.target)}">`);
+    for (const [key, value] of [
+      ["e_relation", edge.relation],
+      ["e_status", edge.status],
+      ["e_evidence", edge.evidenceClass],
+      ["e_confidence", edge.confidence],
+      ["e_provenance", edge.provenance]
+    ]) {
+      lines.push(`      <data key="${key}">${xmlEscape(graphMlData(value))}</data>`);
+    }
+    lines.push("    </edge>");
+  }
+  lines.push("  </graph>", "</graphml>", "");
+  return lines.join("\n");
+}
+function renderCypher(graph) {
+  const pageById2 = graphPageById(graph);
+  const lines = ["// Neo4j Cypher import generated by SwarmVault", ""];
+  for (const node of [...graph.nodes].sort((left, right) => left.id.localeCompare(right.id))) {
+    const page = node.pageId ? pageById2.get(node.pageId) : void 0;
+    const props = [
+      `id: '${cypherEscape(node.id)}'`,
+      `label: '${cypherEscape(node.label)}'`,
+      `type: '${cypherEscape(node.type)}'`,
+      `sourceIds: '${cypherEscape(JSON.stringify(node.sourceIds))}'`,
+      `projectIds: '${cypherEscape(JSON.stringify(node.projectIds))}'`,
+      node.pageId ? `pageId: '${cypherEscape(node.pageId)}'` : "",
+      page?.path ? `pagePath: '${cypherEscape(page.path)}'` : "",
+      node.language ? `language: '${cypherEscape(node.language)}'` : "",
+      node.symbolKind ? `symbolKind: '${cypherEscape(node.symbolKind)}'` : "",
+      node.communityId ? `communityId: '${cypherEscape(node.communityId)}'` : "",
+      node.degree !== void 0 ? `degree: ${node.degree}` : "",
+      node.bridgeScore !== void 0 ? `bridgeScore: ${node.bridgeScore}` : "",
+      node.isGodNode !== void 0 ? `isGodNode: ${node.isGodNode}` : ""
+    ].filter(Boolean).join(", ");
+    lines.push(`MERGE (n:SwarmNode {id: '${cypherEscape(node.id)}'}) SET n += { ${props} };`);
+  }
+  lines.push("");
+  for (const edge of [...graph.edges].sort((left, right) => left.id.localeCompare(right.id))) {
+    lines.push(
+      `MATCH (a:SwarmNode {id: '${cypherEscape(edge.source)}'}), (b:SwarmNode {id: '${cypherEscape(edge.target)}'})`,
+      `MERGE (a)-[r:${relationType(edge.relation)} {id: '${cypherEscape(edge.id)}'}]->(b)`,
+      `SET r += { relation: '${cypherEscape(edge.relation)}', status: '${cypherEscape(edge.status)}', evidenceClass: '${cypherEscape(
+        edge.evidenceClass
+      )}', confidence: ${edge.confidence}, provenance: '${cypherEscape(JSON.stringify(edge.provenance))}' };`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function loadGraph(rootDir) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
+  }
+  return graph;
+}
+async function writeGraphExport(outputPath, content) {
+  await ensureDir(path2.dirname(outputPath));
+  await fs2.writeFile(outputPath, content, "utf8");
+  return path2.resolve(outputPath);
+}
+async function exportGraphFormat(rootDir, format, outputPath) {
+  const graph = await loadGraph(rootDir);
+  const rendered = format === "svg" ? renderSvg(graph) : format === "graphml" ? renderGraphMl(graph) : renderCypher(graph);
+  const resolvedPath = await writeGraphExport(outputPath, rendered);
+  return { format, outputPath: resolvedPath };
+}
+
+// src/hooks.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+var hookStart = "# >>> swarmvault hook >>>";
+var hookEnd = "# <<< swarmvault hook <<<";
+async function findNearestGitRoot(startPath) {
+  let current = path3.resolve(startPath);
+  try {
+    const stat = await fs3.stat(current);
+    if (!stat.isDirectory()) {
+      current = path3.dirname(current);
+    }
+  } catch {
+    current = path3.dirname(current);
+  }
+  while (true) {
+    if (await fileExists(path3.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function managedHookBlock(vaultRoot) {
+  return [
+    hookStart,
+    `cd ${shellQuote(vaultRoot)} || exit 0`,
+    "if command -v swarmvault >/dev/null 2>&1; then",
+    "  swarmvault watch --repo --once >/dev/null 2>&1 || printf '[swarmvault hook] refresh failed\\n' >&2",
+    "fi",
+    hookEnd,
+    ""
+  ].join("\n");
+}
+function hookPath(repoRoot, hookName) {
+  return path3.join(repoRoot, ".git", "hooks", hookName);
+}
+async function readHookStatus(filePath) {
+  if (!await fileExists(filePath)) {
+    return "not_installed";
+  }
+  const content = await fs3.readFile(filePath, "utf8");
+  return content.includes(hookStart) && content.includes(hookEnd) ? "installed" : "other_content";
+}
+async function upsertHookFile(filePath, block) {
+  const existing = await fileExists(filePath) ? await fs3.readFile(filePath, "utf8") : "";
+  let next;
+  const startIndex = existing.indexOf(hookStart);
+  const endIndex = existing.indexOf(hookEnd);
+  if (startIndex !== -1 && endIndex !== -1) {
+    next = `${existing.slice(0, startIndex)}${block}${existing.slice(endIndex + hookEnd.length)}`.trimEnd();
+  } else if (existing.trim().length > 0) {
+    next = `${existing.trimEnd()}
+
+${block}`.trimEnd();
+  } else {
+    next = `#!/bin/sh
+${block}`.trimEnd();
+  }
+  await ensureDir(path3.dirname(filePath));
+  await fs3.writeFile(filePath, `${next}
+`, { mode: 493, encoding: "utf8" });
+  await fs3.chmod(filePath, 493);
+}
+async function removeHookBlock(filePath) {
+  if (!await fileExists(filePath)) {
+    return;
+  }
+  const existing = await fs3.readFile(filePath, "utf8");
+  const startIndex = existing.indexOf(hookStart);
+  const endIndex = existing.indexOf(hookEnd);
+  if (startIndex === -1 || endIndex === -1) {
+    return;
+  }
+  const next = `${existing.slice(0, startIndex)}${existing.slice(endIndex + hookEnd.length)}`.trim();
+  if (!next || next === "#!/bin/sh") {
+    await fs3.rm(filePath, { force: true });
+    return;
+  }
+  await fs3.writeFile(filePath, `${next}
+`, "utf8");
+}
+async function getGitHookStatus(rootDir) {
+  const repoRoot = await findNearestGitRoot(rootDir);
+  if (!repoRoot) {
+    return {
+      repoRoot: null,
+      postCommit: "not_installed",
+      postCheckout: "not_installed"
+    };
+  }
+  return {
+    repoRoot,
+    postCommit: await readHookStatus(hookPath(repoRoot, "post-commit")),
+    postCheckout: await readHookStatus(hookPath(repoRoot, "post-checkout"))
+  };
+}
+async function installGitHooks(rootDir) {
+  const repoRoot = await findNearestGitRoot(rootDir);
+  if (!repoRoot) {
+    throw new Error("No git repository found above the current vault.");
+  }
+  const block = managedHookBlock(path3.resolve(rootDir));
+  await upsertHookFile(hookPath(repoRoot, "post-commit"), block);
+  await upsertHookFile(hookPath(repoRoot, "post-checkout"), block);
+  return getGitHookStatus(rootDir);
+}
+async function uninstallGitHooks(rootDir) {
+  const repoRoot = await findNearestGitRoot(rootDir);
+  if (!repoRoot) {
+    return {
+      repoRoot: null,
+      postCommit: "not_installed",
+      postCheckout: "not_installed"
+    };
+  }
+  await removeHookBlock(hookPath(repoRoot, "post-commit"));
+  await removeHookBlock(hookPath(repoRoot, "post-checkout"));
+  return getGitHookStatus(rootDir);
 }
 
 // src/ingest.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import { Readability } from "@mozilla/readability";
 import ignore from "ignore";
 import { JSDOM } from "jsdom";
@@ -138,16 +602,16 @@ import mime from "mime-types";
 import TurndownService from "turndown";
 
 // src/code-analysis.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 import ts from "typescript";
 
 // src/code-tree-sitter.ts
-import fs2 from "fs/promises";
+import fs4 from "fs/promises";
 import { createRequire } from "module";
-import path2 from "path";
+import path4 from "path";
 var require2 = createRequire(import.meta.url);
-var TREE_SITTER_PACKAGE_ROOT = path2.dirname(path2.dirname(require2.resolve("@vscode/tree-sitter-wasm")));
+var TREE_SITTER_PACKAGE_ROOT = path4.dirname(path4.dirname(require2.resolve("@vscode/tree-sitter-wasm")));
 var RATIONALE_MARKERS = ["NOTE:", "IMPORTANT:", "HACK:", "WHY:", "RATIONALE:"];
 function stripKnownCommentPrefix(line) {
   let next = line.trim();
@@ -169,7 +633,9 @@ var grammarFileByLanguage = {
   csharp: "tree-sitter-c-sharp.wasm",
   c: "tree-sitter-cpp.wasm",
   cpp: "tree-sitter-cpp.wasm",
-  php: "tree-sitter-php.wasm"
+  php: "tree-sitter-php.wasm",
+  ruby: "tree-sitter-ruby.wasm",
+  powershell: "tree-sitter-powershell.wasm"
 };
 async function getTreeSitterModule() {
   if (!treeSitterModulePromise) {
@@ -182,7 +648,7 @@ async function getTreeSitterModule() {
 async function ensureTreeSitterInit(module) {
   if (!treeSitterInitPromise) {
     treeSitterInitPromise = module.Parser.init({
-      locateFile: () => path2.join(TREE_SITTER_PACKAGE_ROOT, "wasm", "tree-sitter.wasm")
+      locateFile: () => path4.join(TREE_SITTER_PACKAGE_ROOT, "wasm", "tree-sitter.wasm")
     });
   }
   return treeSitterInitPromise;
@@ -195,7 +661,7 @@ async function loadLanguage(language) {
   const loader = (async () => {
     const module = await getTreeSitterModule();
     await ensureTreeSitterInit(module);
-    const bytes = await fs2.readFile(path2.join(TREE_SITTER_PACKAGE_ROOT, "wasm", grammarFileByLanguage[language]));
+    const bytes = await fs4.readFile(path4.join(TREE_SITTER_PACKAGE_ROOT, "wasm", grammarFileByLanguage[language]));
     return module.Language.load(bytes);
   })();
   languageCache.set(language, loader);
@@ -212,16 +678,16 @@ function stripCodeExtension(filePath) {
   return filePath.replace(/\.(?:[cm]?jsx?|tsx?|mts|cts|py|go|rs|java|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i, "");
 }
 function manifestModuleName(manifest, language) {
-  const repoPath = manifest.repoRelativePath ?? path2.basename(manifest.originalPath ?? manifest.storedPath);
+  const repoPath = manifest.repoRelativePath ?? path4.basename(manifest.originalPath ?? manifest.storedPath);
   const normalized = toPosix(stripCodeExtension(repoPath)).replace(/^\.\/+/, "");
   if (!normalized) {
     return void 0;
   }
   if (language === "python") {
     const dotted = normalized.replace(/\/__init__$/i, "").replace(/\//g, ".").replace(/^src\./, "");
-    return dotted || path2.posix.basename(normalized);
+    return dotted || path4.posix.basename(normalized);
   }
-  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path2.posix.basename(normalized) : normalized;
+  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path4.posix.basename(normalized) : normalized;
 }
 function singleLineSignature(value) {
   return truncate(
@@ -397,11 +863,29 @@ function extractIdentifier(node) {
   if (!node) {
     return void 0;
   }
-  if (["identifier", "field_identifier", "type_identifier", "name", "package_identifier"].includes(node.type)) {
+  if ([
+    "identifier",
+    "field_identifier",
+    "type_identifier",
+    "name",
+    "package_identifier",
+    "constant",
+    "simple_name",
+    "function_name"
+  ].includes(node.type)) {
     return node.text.trim();
   }
   const preferred = node.childForFieldName("name") ?? node.namedChildren.find(
-    (child) => child && ["identifier", "field_identifier", "type_identifier", "name", "package_identifier"].includes(child.type)
+    (child) => child && [
+      "identifier",
+      "field_identifier",
+      "type_identifier",
+      "name",
+      "package_identifier",
+      "constant",
+      "simple_name",
+      "function_name"
+    ].includes(child.type)
   ) ?? node.namedChildren.at(-1) ?? null;
   return preferred ? extractIdentifier(preferred) : void 0;
 }
@@ -574,6 +1058,49 @@ function parseCppInclude(text) {
     reExport: false
   };
 }
+function rubyStringContent(node) {
+  if (!node) {
+    return void 0;
+  }
+  const contentNode = node.descendantsOfType(["string_content", "simple_symbol", "bare_string"]).find((item) => item !== null) ?? null;
+  return contentNode?.text.trim() || void 0;
+}
+function parsePowerShellImport(commandNode) {
+  const commandName = commandNode.descendantsOfType(["command_name", "command_name_expr"]).find((item) => item !== null)?.text.trim();
+  const genericTokens = commandNode.descendantsOfType("generic_token").filter((item) => item !== null).map((item) => item.text.trim());
+  if (commandNode.namedChildren.some((child) => child?.type === "command_invokation_operator")) {
+    const specifier = commandName?.trim();
+    if (specifier) {
+      return {
+        specifier,
+        importedSymbols: [],
+        isExternal: false,
+        reExport: false
+      };
+    }
+  }
+  if (!commandName) {
+    return void 0;
+  }
+  const lowerName = commandName.toLowerCase();
+  if (lowerName === "using" && genericTokens.length >= 2 && genericTokens[0]?.toLowerCase() === "module") {
+    return {
+      specifier: genericTokens[1],
+      importedSymbols: [],
+      isExternal: !genericTokens[1]?.startsWith("."),
+      reExport: false
+    };
+  }
+  if (lowerName === "import-module" && genericTokens[0]) {
+    return {
+      specifier: genericTokens[0],
+      importedSymbols: [],
+      isExternal: !genericTokens[0].startsWith("."),
+      reExport: false
+    };
+  }
+  return void 0;
+}
 function pythonCodeAnalysis(manifest, rootNode, diagnostics) {
   const imports = [];
   const draftSymbols = [];
@@ -976,6 +1503,161 @@ function phpCodeAnalysis(manifest, rootNode, diagnostics) {
     namespace: namespaceName
   });
 }
+function rubyCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  let namespaceName;
+  const visitStatements = (node, scopeName, namespaceParts = []) => {
+    if (!node) {
+      return;
+    }
+    for (const child of node.namedChildren) {
+      if (!child) {
+        continue;
+      }
+      if (child.type === "call") {
+        const callee = extractIdentifier(child.namedChildren.at(0) ?? null);
+        if (callee === "require" || callee === "require_relative") {
+          const specifier = rubyStringContent(child.childForFieldName("arguments") ?? child.namedChildren.at(1) ?? null);
+          if (specifier) {
+            imports.push({
+              specifier,
+              importedSymbols: [],
+              isExternal: callee === "require" && !specifier.startsWith("."),
+              reExport: false
+            });
+          }
+        }
+        continue;
+      }
+      if (child.type === "module") {
+        const moduleName = extractIdentifier(child.childForFieldName("name") ?? child.namedChildren.at(0) ?? null);
+        if (!moduleName) {
+          continue;
+        }
+        const nextNamespace = [...namespaceParts, moduleName];
+        namespaceName ??= nextNamespace.join("::");
+        visitStatements(findNamedChild(child, "body_statement"), void 0, nextNamespace);
+        continue;
+      }
+      if (child.type === "class") {
+        const className = extractIdentifier(child.childForFieldName("name") ?? child.namedChildren.at(0) ?? null);
+        if (!className) {
+          continue;
+        }
+        const body = findNamedChild(child, "body_statement");
+        const mixins = body ? body.namedChildren.filter((item) => item !== null && item.type === "call").filter((item) => extractIdentifier(item.namedChildren.at(0) ?? null) === "include").flatMap(
+          (item) => item.descendantsOfType(["constant", "identifier"]).filter((descendant) => descendant !== null).slice(1).map((descendant) => normalizeSymbolReference(descendant.text)).filter(Boolean)
+        ) : [];
+        draftSymbols.push({
+          name: scopeName ? `${scopeName}::${className}` : className,
+          kind: "class",
+          signature: singleLineSignature(child.text),
+          exported: true,
+          callNames: [],
+          extendsNames: descendantTypeNames(child.childForFieldName("superclass")),
+          implementsNames: uniqueBy(mixins, (item) => item),
+          bodyText: body?.text
+        });
+        exportLabels.push(scopeName ? `${scopeName}::${className}` : className);
+        visitStatements(body, scopeName ? `${scopeName}::${className}` : className, namespaceParts);
+        continue;
+      }
+      if (child.type === "method") {
+        const methodName = extractIdentifier(child.childForFieldName("name") ?? child.namedChildren.at(0) ?? null);
+        if (!methodName) {
+          continue;
+        }
+        const symbolName = scopeName ? `${scopeName}#${methodName}` : methodName;
+        draftSymbols.push({
+          name: symbolName,
+          kind: "function",
+          signature: singleLineSignature(child.text),
+          exported: true,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: nodeText(findNamedChild(child, "body_statement") ?? child.childForFieldName("body"))
+        });
+        exportLabels.push(symbolName);
+      }
+    }
+  };
+  visitStatements(rootNode, void 0, []);
+  return finalizeCodeAnalysis(manifest, "ruby", imports, draftSymbols, exportLabels, diagnostics, {
+    namespace: namespaceName
+  });
+}
+function powershellCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  for (const child of rootNode.descendantsOfType(["command", "class_statement", "function_statement"]).filter((item) => item !== null)) {
+    if (child.type === "command") {
+      const parsed = parsePowerShellImport(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "class_statement") {
+      const names = child.namedChildren.filter((item) => item !== null && item.type === "simple_name").map((item) => item.text.trim());
+      const className = names[0];
+      if (!className) {
+        continue;
+      }
+      draftSymbols.push({
+        name: className,
+        kind: "class",
+        signature: singleLineSignature(child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: names.slice(1, 2),
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      exportLabels.push(className);
+      for (const methodNode of child.descendantsOfType("class_method_definition").filter((item) => item !== null)) {
+        const methodName = methodNode.descendantsOfType("simple_name").filter((item) => item !== null).map((item) => item.text.trim())[0];
+        if (!methodName) {
+          continue;
+        }
+        const symbolName = `${className}.${methodName}`;
+        draftSymbols.push({
+          name: symbolName,
+          kind: "function",
+          signature: singleLineSignature(methodNode.text),
+          exported: true,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: nodeText(findNamedChild(methodNode, "script_block") ?? methodNode.childForFieldName("body")) || methodNode.text
+        });
+        exportLabels.push(symbolName);
+      }
+      continue;
+    }
+    if (child.type === "function_statement") {
+      const functionName = extractIdentifier(findNamedChild(child, "function_name") ?? child.childForFieldName("name"));
+      if (!functionName) {
+        continue;
+      }
+      draftSymbols.push({
+        name: functionName,
+        kind: "function",
+        signature: singleLineSignature(child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "script_block") ?? child.childForFieldName("body")) || child.text
+      });
+      exportLabels.push(functionName);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "powershell", imports, draftSymbols, exportLabels, diagnostics);
+}
 function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
   const imports = [];
   const draftSymbols = [];
@@ -1094,6 +1776,10 @@ async function analyzeTreeSitterCode(manifest, content, language) {
         return { code: csharpCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
       case "php":
         return { code: phpCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "ruby":
+        return { code: rubyCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "powershell":
+        return { code: powershellCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
       case "c":
       case "cpp":
         return { code: cFamilyCodeAnalysis(manifest, language, tree.rootNode, diagnostics), rationales };
@@ -1355,16 +2041,16 @@ function stripCodeExtension2(filePath) {
   return filePath.replace(/\.(?:[cm]?jsx?|tsx?|mts|cts|py|go|rs|java|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i, "");
 }
 function manifestModuleName2(manifest, language) {
-  const repoPath = manifest.repoRelativePath ?? path3.basename(manifest.originalPath ?? manifest.storedPath);
+  const repoPath = manifest.repoRelativePath ?? path5.basename(manifest.originalPath ?? manifest.storedPath);
   const normalized = toPosix(stripCodeExtension2(repoPath)).replace(/^\.\/+/, "");
   if (!normalized) {
     return void 0;
   }
   if (language === "python") {
     const dotted = normalized.replace(/\/__init__$/i, "").replace(/\//g, ".").replace(/^src\./, "");
-    return dotted || path3.posix.basename(normalized);
+    return dotted || path5.posix.basename(normalized);
   }
-  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path3.posix.basename(normalized) : normalized;
+  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path5.posix.basename(normalized) : normalized;
 }
 function finalizeCodeAnalysis2(manifest, language, imports, draftSymbols, exportLabels, diagnostics, metadata) {
   const topLevelNames = new Set(draftSymbols.map((symbol) => symbol.name));
@@ -1657,7 +2343,7 @@ function analyzeTypeScriptLikeCode(manifest, content) {
   };
 }
 function inferCodeLanguage(filePath, mimeType = "") {
-  const extension = path3.extname(filePath).toLowerCase();
+  const extension = path5.extname(filePath).toLowerCase();
   if (extension === ".ts" || extension === ".mts" || extension === ".cts") {
     return "typescript";
   }
@@ -1688,6 +2374,12 @@ function inferCodeLanguage(filePath, mimeType = "") {
   if (extension === ".php") {
     return "php";
   }
+  if (extension === ".rb") {
+    return "ruby";
+  }
+  if (extension === ".ps1" || extension === ".psm1" || extension === ".psd1") {
+    return "powershell";
+  }
   if (extension === ".c") {
     return "c";
   }
@@ -1700,12 +2392,12 @@ function modulePageTitle(manifest) {
   return `${manifest.title} module`;
 }
 function importResolutionCandidates(basePath, specifier, extensions) {
-  const resolved = path3.posix.normalize(path3.posix.join(path3.posix.dirname(basePath), specifier));
-  if (path3.posix.extname(resolved)) {
+  const resolved = path5.posix.normalize(path5.posix.join(path5.posix.dirname(basePath), specifier));
+  if (path5.posix.extname(resolved)) {
     return [resolved];
   }
-  const direct = extensions.map((extension) => path3.posix.normalize(`${resolved}${extension}`));
-  const indexFiles = extensions.map((extension) => path3.posix.normalize(path3.posix.join(resolved, `index${extension}`)));
+  const direct = extensions.map((extension) => path5.posix.normalize(`${resolved}${extension}`));
+  const indexFiles = extensions.map((extension) => path5.posix.normalize(path5.posix.join(resolved, `index${extension}`)));
   return uniqueBy([resolved, ...direct, ...indexFiles], (candidate) => candidate);
 }
 function normalizeAlias(value) {
@@ -1724,32 +2416,32 @@ function recordAlias(target, value) {
 }
 function manifestBasenameWithoutExtension(manifest) {
   const target = manifest.repoRelativePath ?? manifest.originalPath ?? manifest.storedPath;
-  return path3.posix.basename(stripCodeExtension2(normalizeAlias(target)));
+  return path5.posix.basename(stripCodeExtension2(normalizeAlias(target)));
 }
 async function readNearestGoModulePath(startPath, cache) {
-  let current = path3.resolve(startPath);
+  let current = path5.resolve(startPath);
   try {
-    const stat = await fs3.stat(current);
+    const stat = await fs5.stat(current);
     if (!stat.isDirectory()) {
-      current = path3.dirname(current);
+      current = path5.dirname(current);
     }
   } catch {
-    current = path3.dirname(current);
+    current = path5.dirname(current);
   }
   while (true) {
     if (cache.has(current)) {
       const cached = cache.get(current);
       return cached === null ? void 0 : cached;
     }
-    const goModPath = path3.join(current, "go.mod");
-    if (await fs3.access(goModPath).then(() => true).catch(() => false)) {
-      const content = await fs3.readFile(goModPath, "utf8");
+    const goModPath = path5.join(current, "go.mod");
+    if (await fs5.access(goModPath).then(() => true).catch(() => false)) {
+      const content = await fs5.readFile(goModPath, "utf8");
       const match = content.match(/^\s*module\s+(\S+)/m);
       const modulePath = match?.[1]?.trim() ?? null;
       cache.set(current, modulePath);
       return modulePath ?? void 0;
     }
-    const parent = path3.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) {
       cache.set(current, null);
       return void 0;
@@ -1784,6 +2476,10 @@ function candidateExtensionsFor(language) {
       return [".cs"];
     case "php":
       return [".php"];
+    case "ruby":
+      return [".rb"];
+    case "powershell":
+      return [".ps1", ".psm1", ".psd1"];
     case "c":
       return [".c", ".h"];
     case "cpp":
@@ -1826,10 +2522,10 @@ async function buildCodeIndex(rootDir, manifests, analyses) {
         if (normalizedNamespace) {
           recordAlias(aliases, normalizedNamespace);
         }
-        const originalPath = manifest.originalPath ? path3.resolve(manifest.originalPath) : path3.resolve(rootDir, manifest.storedPath);
+        const originalPath = manifest.originalPath ? path5.resolve(manifest.originalPath) : path5.resolve(rootDir, manifest.storedPath);
         const goModulePath = await readNearestGoModulePath(originalPath, goModuleCache);
         if (goModulePath && repoRelativePath) {
-          const dir = path3.posix.dirname(repoRelativePath);
+          const dir = path5.posix.dirname(repoRelativePath);
           const packageAlias = dir === "." ? goModulePath : `${goModulePath}/${dir}`;
           recordAlias(aliases, packageAlias);
         }
@@ -1846,6 +2542,10 @@ async function buildCodeIndex(rootDir, manifests, analyses) {
           recordAlias(aliases, `${normalizedNamespace}\\${basename}`);
         }
         break;
+      case "ruby":
+      case "powershell":
+        recordAlias(aliases, basename);
+        break;
       default:
         break;
     }
@@ -1901,10 +2601,10 @@ function resolvePythonRelativeAliases(repoRelativePath, specifier) {
   const dotMatch = specifier.match(/^\.+/);
   const depth = dotMatch ? dotMatch[0].length : 0;
   const relativeModule = specifier.slice(depth).replace(/\./g, "/");
-  const baseDir = path3.posix.dirname(repoRelativePath);
-  const parentDir = path3.posix.normalize(path3.posix.join(baseDir, ...Array(Math.max(depth - 1, 0)).fill("..")));
-  const moduleBase = relativeModule ? path3.posix.join(parentDir, relativeModule) : parentDir;
-  return uniqueBy([`${moduleBase}.py`, path3.posix.join(moduleBase, "__init__.py")], (item) => item);
+  const baseDir = path5.posix.dirname(repoRelativePath);
+  const parentDir = path5.posix.normalize(path5.posix.join(baseDir, ...Array(Math.max(depth - 1, 0)).fill("..")));
+  const moduleBase = relativeModule ? path5.posix.join(parentDir, relativeModule) : parentDir;
+  return uniqueBy([`${moduleBase}.py`, path5.posix.join(moduleBase, "__init__.py")], (item) => item);
 }
 function resolveRustAliases(manifest, specifier) {
   const repoRelativePath = manifest.repoRelativePath ? normalizeAlias(manifest.repoRelativePath) : "";
@@ -1945,13 +2645,20 @@ function findImportCandidates(manifest, codeImport, lookup) {
     case "csharp":
       return aliasMatches(lookup, codeImport.specifier);
     case "php":
+    case "ruby":
+    case "powershell":
       if (repoRelativePath && isLocalIncludeSpecifier(codeImport.specifier)) {
         return repoPathMatches(
           lookup,
           ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))
         );
       }
-      return aliasMatches(lookup, codeImport.specifier, codeImport.specifier.replace(/\\/g, "/"));
+      return aliasMatches(
+        lookup,
+        codeImport.specifier,
+        codeImport.specifier.replace(/\\/g, "/"),
+        stripCodeExtension2(codeImport.specifier.replace(/\\/g, "/"))
+      );
     case "rust":
       return aliasMatches(lookup, codeImport.specifier, ...resolveRustAliases(manifest, codeImport.specifier));
     case "c":
@@ -1977,6 +2684,8 @@ function importLooksLocal(manifest, codeImport, candidates) {
     case "rust":
       return /^(crate|self|super)::/.test(codeImport.specifier);
     case "php":
+    case "ruby":
+    case "powershell":
     case "c":
     case "cpp":
       return !codeImport.isExternal;
@@ -2036,18 +2745,18 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
 }
 
 // src/logs.ts
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 import matter from "gray-matter";
 async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.sessionsDir);
   const timestamp = startedAt.replace(/[:.]/g, "-");
   const baseName = `${timestamp}-${operation}-${slugify(title)}`;
-  let candidate = path4.join(paths.sessionsDir, `${baseName}.md`);
+  let candidate = path6.join(paths.sessionsDir, `${baseName}.md`);
   let counter = 2;
   while (await fileExists(candidate)) {
-    candidate = path4.join(paths.sessionsDir, `${baseName}-${counter}.md`);
+    candidate = path6.join(paths.sessionsDir, `${baseName}-${counter}.md`);
     counter++;
   }
   return candidate;
@@ -2055,11 +2764,11 @@ async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
 async function appendLogEntry(rootDir, action, title, lines = []) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.wikiDir);
-  const logPath = path4.join(paths.wikiDir, "log.md");
+  const logPath = path6.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 fs4.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs4.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs6.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs6.writeFile(logPath, `${existing}${entry}
 `, "utf8");
 }
 async function recordSession(rootDir, input) {
@@ -2069,8 +2778,8 @@ async function recordSession(rootDir, input) {
   const finishedAtIso = new Date(input.finishedAt ?? input.startedAt).toISOString();
   const durationMs = Math.max(0, new Date(finishedAtIso).getTime() - new Date(startedAtIso).getTime());
   const sessionPath = await resolveUniqueSessionPath(rootDir, input.operation, input.title, startedAtIso);
-  const sessionId = path4.basename(sessionPath, ".md");
-  const relativeSessionPath = path4.relative(rootDir, sessionPath).split(path4.sep).join(path4.posix.sep);
+  const sessionId = path6.basename(sessionPath, ".md");
+  const relativeSessionPath = path6.relative(rootDir, sessionPath).split(path6.sep).join(path6.posix.sep);
   const frontmatter = Object.fromEntries(
     Object.entries({
       session_id: sessionId,
@@ -2118,7 +2827,7 @@ async function recordSession(rootDir, input) {
     frontmatter
   );
   await writeFileIfChanged(sessionPath, content);
-  const logPath = path4.join(paths.wikiDir, "log.md");
+  const logPath = path6.join(paths.wikiDir, "log.md");
   const timestamp = startedAtIso.slice(0, 19).replace("T", " ");
   const entry = [
     `## [${timestamp}] ${input.operation} | ${input.title}`,
@@ -2126,8 +2835,8 @@ async function recordSession(rootDir, input) {
     ...(input.lines ?? []).map((line) => `- ${line}`),
     ""
   ].join("\n");
-  const existing = await fileExists(logPath) ? await fs4.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs4.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs6.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs6.writeFile(logPath, `${existing}${entry}
 `, "utf8");
   return { sessionPath, sessionId };
 }
@@ -2136,10 +2845,136 @@ async function appendWatchRun(rootDir, run) {
   await appendJsonLine(paths.jobsLogPath, run);
 }
 
-// src/ingest.ts
-var DEFAULT_MAX_ASSET_SIZE = 10 * 1024 * 1024;
-var DEFAULT_MAX_DIRECTORY_FILES = 5e3;
-var BUILT_IN_REPO_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
+// src/watch-state.ts
+import fs7 from "fs/promises";
+import path7 from "path";
+import matter2 from "gray-matter";
+function pendingEntryKey(entry) {
+  return entry.path;
+}
+function sortPending(entries) {
+  return [...entries].sort(
+    (left, right) => left.path.localeCompare(right.path) || left.detectedAt.localeCompare(right.detectedAt) || left.id.localeCompare(right.id)
+  );
+}
+function normalizeRelativePath(rootDir, filePath) {
+  if (!filePath) {
+    return void 0;
+  }
+  return toPosix(path7.relative(rootDir, path7.resolve(filePath)));
+}
+async function readPendingSemanticRefresh(rootDir) {
+  const { paths } = await initWorkspace(rootDir);
+  const entries = await readJsonFile(paths.pendingSemanticRefreshPath);
+  return Array.isArray(entries) ? sortPending(entries) : [];
+}
+async function writePendingSemanticRefresh(rootDir, entries) {
+  const { paths } = await initWorkspace(rootDir);
+  await ensureDir(paths.watchDir);
+  const normalized = sortPending(entries);
+  await writeJsonFile(paths.pendingSemanticRefreshPath, normalized);
+  return normalized;
+}
+async function mergePendingSemanticRefresh(rootDir, entries) {
+  const existing = await readPendingSemanticRefresh(rootDir);
+  const merged = new Map(existing.map((entry) => [pendingEntryKey(entry), entry]));
+  for (const entry of entries) {
+    merged.set(pendingEntryKey(entry), entry);
+  }
+  return writePendingSemanticRefresh(rootDir, [...merged.values()]);
+}
+async function clearPendingSemanticRefreshEntries(rootDir, targets) {
+  const existing = await readPendingSemanticRefresh(rootDir);
+  const relativePath = targets.relativePath ?? normalizeRelativePath(rootDir, targets.originalPath);
+  return writePendingSemanticRefresh(
+    rootDir,
+    existing.filter((entry) => {
+      if (targets.sourceId && entry.sourceId === targets.sourceId) {
+        return false;
+      }
+      if (relativePath && entry.path === relativePath) {
+        return false;
+      }
+      return true;
+    })
+  );
+}
+async function readWatchStatusArtifact(rootDir) {
+  const { paths } = await initWorkspace(rootDir);
+  return readJsonFile(paths.watchStatusPath);
+}
+async function writeWatchStatusArtifact(rootDir, status) {
+  const { paths } = await initWorkspace(rootDir);
+  await ensureDir(paths.watchDir);
+  await writeJsonFile(paths.watchStatusPath, status);
+}
+async function markPagesStaleForSources(rootDir, sourceIds) {
+  const uniqueSourceIds = [...new Set(sourceIds.filter(Boolean))];
+  if (!uniqueSourceIds.length) {
+    return [];
+  }
+  const { paths } = await initWorkspace(rootDir);
+  const graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    return [];
+  }
+  const affectedSourceIds = new Set(uniqueSourceIds);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let graphChanged = false;
+  const affectedPagePaths = [];
+  const nextPages = graph.pages.map((page) => {
+    if (page.freshness === "stale" || !page.sourceIds.some((sourceId) => affectedSourceIds.has(sourceId))) {
+      return page;
+    }
+    graphChanged = true;
+    affectedPagePaths.push(page.path);
+    return {
+      ...page,
+      freshness: "stale",
+      updatedAt: now
+    };
+  });
+  const nextNodes = graph.nodes.map((node) => {
+    if (node.freshness === "stale" || !node.sourceIds.some((sourceId) => affectedSourceIds.has(sourceId))) {
+      return node;
+    }
+    graphChanged = true;
+    return {
+      ...node,
+      freshness: "stale"
+    };
+  });
+  if (graphChanged) {
+    await writeJsonFile(paths.graphPath, {
+      ...graph,
+      nodes: nextNodes,
+      pages: nextPages
+    });
+  }
+  for (const page of nextPages) {
+    if (page.freshness !== "stale" || !page.sourceIds.some((sourceId) => affectedSourceIds.has(sourceId))) {
+      continue;
+    }
+    const absolutePath = path7.join(paths.wikiDir, page.path);
+    if (!await fileExists(absolutePath)) {
+      continue;
+    }
+    const raw = await fs7.readFile(absolutePath, "utf8");
+    const parsed = matter2(raw);
+    if (parsed.data.freshness === "stale") {
+      continue;
+    }
+    parsed.data.freshness = "stale";
+    parsed.data.updated_at = now;
+    await writeFileIfChanged(absolutePath, matter2.stringify(parsed.content, parsed.data));
+  }
+  return affectedPagePaths;
+}
+
+// src/ingest.ts
+var DEFAULT_MAX_ASSET_SIZE = 10 * 1024 * 1024;
+var DEFAULT_MAX_DIRECTORY_FILES = 5e3;
+var BUILT_IN_REPO_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
 function inferKind(mimeType, filePath) {
   if (inferCodeLanguage(filePath, mimeType)) {
     return "code";
@@ -2172,7 +3007,7 @@ function normalizeIngestOptions(options) {
   return {
     includeAssets: options?.includeAssets ?? true,
     maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE)),
-    repoRoot: options?.repoRoot ? path5.resolve(options.repoRoot) : void 0,
+    repoRoot: options?.repoRoot ? path8.resolve(options.repoRoot) : void 0,
     include: (options?.include ?? []).map((pattern) => pattern.trim()).filter(Boolean),
     exclude: (options?.exclude ?? []).map((pattern) => pattern.trim()).filter(Boolean),
     maxFiles: Math.max(1, Math.floor(options?.maxFiles ?? DEFAULT_MAX_DIRECTORY_FILES)),
@@ -2181,27 +3016,27 @@ function normalizeIngestOptions(options) {
 }
 function matchesAnyGlob(relativePath, patterns) {
   return patterns.some(
-    (pattern) => path5.matchesGlob(relativePath, pattern) || path5.matchesGlob(path5.posix.basename(relativePath), pattern)
+    (pattern) => path8.matchesGlob(relativePath, pattern) || path8.matchesGlob(path8.posix.basename(relativePath), pattern)
   );
 }
 function supportedDirectoryKind(sourceKind) {
   return sourceKind !== "binary";
 }
-async function findNearestGitRoot(startPath) {
-  let current = path5.resolve(startPath);
+async function findNearestGitRoot2(startPath) {
+  let current = path8.resolve(startPath);
   try {
-    const stat = await fs5.stat(current);
+    const stat = await fs8.stat(current);
     if (!stat.isDirectory()) {
-      current = path5.dirname(current);
+      current = path8.dirname(current);
     }
   } catch {
-    current = path5.dirname(current);
+    current = path8.dirname(current);
   }
   while (true) {
-    if (await fileExists(path5.join(current, ".git"))) {
+    if (await fileExists(path8.join(current, ".git"))) {
       return current;
     }
-    const parent = path5.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -2209,14 +3044,26 @@ async function findNearestGitRoot(startPath) {
   }
 }
 function withinRoot(rootPath, targetPath) {
-  const relative = path5.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+  const relative = path8.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
+}
+function repoRootFromManifest(manifest) {
+  if (manifest.originType !== "file" || !manifest.originalPath || !manifest.repoRelativePath) {
+    return null;
+  }
+  const repoDir = path8.posix.dirname(manifest.repoRelativePath);
+  const fileDir = path8.dirname(path8.resolve(manifest.originalPath));
+  if (repoDir === "." || !repoDir) {
+    return fileDir;
+  }
+  const segments = repoDir.split("/").filter(Boolean);
+  return path8.resolve(fileDir, ...segments.map(() => ".."));
 }
 function repoRelativePathFor(absolutePath, repoRoot) {
   if (!repoRoot || !withinRoot(repoRoot, absolutePath)) {
     return void 0;
   }
-  const relative = toPosix(path5.relative(repoRoot, absolutePath));
+  const relative = toPosix(path8.relative(repoRoot, absolutePath));
   return relative && !relative.startsWith("..") ? relative : void 0;
 }
 function normalizeOriginUrl(input) {
@@ -2226,6 +3073,150 @@ function normalizeOriginUrl(input) {
     return input;
   }
 }
+function isHttpUrl(input) {
+  return /^https?:\/\//i.test(input);
+}
+function stripLeadingLabel(value, label) {
+  return value.startsWith(label) ? value.slice(label.length).trim() : value.trim();
+}
+function arxivIdFromInput(input) {
+  const trimmed = input.trim();
+  if (/^\d{4}\.\d{4,5}(v\d+)?$/i.test(trimmed)) {
+    return trimmed;
+  }
+  try {
+    const url = new URL(trimmed);
+    const match = url.pathname.match(/(\d{4}\.\d{4,5}(?:v\d+)?)/i);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function isTweetUrl(input) {
+  try {
+    const url = new URL(input);
+    return url.hostname.includes("x.com") || url.hostname.includes("twitter.com");
+  } catch {
+    return false;
+  }
+}
+function markdownFrontmatter(value) {
+  const lines = ["---"];
+  for (const [key, rawValue] of Object.entries(value)) {
+    if (!rawValue) {
+      continue;
+    }
+    lines.push(`${key}: "${rawValue.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`);
+  }
+  lines.push("---", "");
+  return lines;
+}
+function prepareCapturedMarkdownInput(input) {
+  return {
+    title: input.title,
+    originType: "url",
+    sourceKind: "markdown",
+    url: normalizeOriginUrl(input.url),
+    mimeType: "text/markdown",
+    storedExtension: ".md",
+    payloadBytes: Buffer.from(input.markdown, "utf8"),
+    extractedText: input.markdown,
+    logDetails: input.logDetails
+  };
+}
+async function fetchText(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+function domTextFromHtml(html, baseUrl) {
+  const dom = new JSDOM(`<body>${html}</body>`, { url: baseUrl });
+  return normalizeWhitespace(dom.window.document.body.textContent ?? "");
+}
+async function captureArxivMarkdown(input, options) {
+  const arxivId = arxivIdFromInput(input);
+  if (!arxivId) {
+    throw new Error(`Could not determine an arXiv id from ${input}`);
+  }
+  const normalizedUrl = `https://arxiv.org/abs/${arxivId}`;
+  const html = await fetchText(normalizedUrl);
+  const dom = new JSDOM(html, { url: normalizedUrl });
+  const document = dom.window.document;
+  const metaTitle = document.querySelector('meta[name="citation_title"]')?.getAttribute("content")?.trim();
+  const headingTitle = document.querySelector("h1.title")?.textContent?.trim();
+  const title = stripLeadingLabel(metaTitle ?? headingTitle ?? arxivId, "Title:");
+  const authors = [...document.querySelectorAll('meta[name="citation_author"]')].map((node) => node.getAttribute("content")?.trim()).filter((value) => Boolean(value));
+  const authorsText = authors.join(", ") || stripLeadingLabel(document.querySelector(".authors")?.textContent?.trim() ?? "", "Authors:");
+  const abstract = stripLeadingLabel(document.querySelector("blockquote.abstract")?.textContent?.trim() ?? "", "Abstract:");
+  const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const markdown = [
+    ...markdownFrontmatter({
+      capture_type: "arxiv",
+      source_url: normalizedUrl,
+      arxiv_id: arxivId,
+      author: options.author,
+      contributor: options.contributor,
+      captured_at: capturedAt
+    }),
+    `# ${title}`,
+    "",
+    `- arXiv: ${arxivId}`,
+    ...authorsText ? [`- Authors: ${authorsText}`] : [],
+    ...options.author ? [`- Added By: ${options.author}`] : [],
+    ...options.contributor ? [`- Contributor: ${options.contributor}`] : [],
+    "",
+    "## Abstract",
+    "",
+    abstract || "Abstract not available from the fetched arXiv page.",
+    "",
+    "## Source",
+    "",
+    `- URL: ${normalizedUrl}`,
+    ""
+  ].join("\n");
+  return { title, normalizedUrl, markdown };
+}
+async function captureTweetMarkdown(input, options) {
+  const normalizedUrl = normalizeOriginUrl(input);
+  const canonicalUrl = normalizedUrl.replace("x.com", "twitter.com");
+  const oembedUrl = `https://publish.twitter.com/oembed?url=${encodeURIComponent(canonicalUrl)}&omit_script=true`;
+  const response = await fetch(oembedUrl);
+  let postText = "";
+  let postAuthor = "";
+  if (response.ok) {
+    const payload = await response.json();
+    postText = payload.html ? domTextFromHtml(payload.html, canonicalUrl) : "";
+    postAuthor = payload.author_name?.trim() ?? "";
+  }
+  const title = postAuthor ? `X Post by ${postAuthor}` : "X Post";
+  const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const markdown = [
+    ...markdownFrontmatter({
+      capture_type: "tweet",
+      source_url: normalizedUrl,
+      author: options.author,
+      contributor: options.contributor,
+      captured_at: capturedAt
+    }),
+    `# ${title}`,
+    "",
+    ...postAuthor ? [`- Post Author: ${postAuthor}`] : [],
+    ...options.author ? [`- Added By: ${options.author}`] : [],
+    ...options.contributor ? [`- Contributor: ${options.contributor}`] : [],
+    "",
+    "## Content",
+    "",
+    postText || `Captured the post link at ${normalizedUrl}. Rich text was unavailable from the public oEmbed response.`,
+    "",
+    "## Source",
+    "",
+    `- URL: ${normalizedUrl}`,
+    ""
+  ].join("\n");
+  return { title, normalizedUrl, markdown };
+}
 function manifestMatchesOrigin(manifest, prepared) {
   if (prepared.originType === "url") {
     return Boolean(prepared.url && manifest.url && normalizeOriginUrl(manifest.url) === normalizeOriginUrl(prepared.url));
@@ -2240,7 +3231,7 @@ function buildCompositeHash(payloadBytes, attachments = []) {
   return sha256(`${sha256(payloadBytes)}|${attachmentSignature}`);
 }
 function sanitizeAssetRelativePath(value) {
-  const normalized = path5.posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = path8.posix.normalize(value.replace(/\\/g, "/"));
   const segments = normalized.split("/").filter(Boolean).map((segment) => {
     if (segment === ".") {
       return "";
@@ -2260,7 +3251,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("#") || path5.isAbsolute(candidate)) {
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path8.isAbsolute(candidate)) {
     return null;
   }
   return candidate.replace(/\\/g, "/");
@@ -2322,12 +3313,12 @@ async function convertHtmlToMarkdown(html, url) {
   };
 }
 async function readManifestByHash(manifestsDir, contentHash) {
-  const entries = await fs5.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs8.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path5.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path8.join(manifestsDir, entry.name));
     if (manifest?.contentHash === contentHash) {
       return manifest;
     }
@@ -2335,12 +3326,12 @@ async function readManifestByHash(manifestsDir, contentHash) {
   return null;
 }
 async function readManifestByOrigin(manifestsDir, prepared) {
-  const entries = await fs5.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs8.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path5.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path8.join(manifestsDir, entry.name));
     if (manifest && manifestMatchesOrigin(manifest, prepared)) {
       return manifest;
     }
@@ -2351,12 +3342,12 @@ async function loadGitignoreMatcher(repoRoot, enabled) {
   if (!enabled) {
     return null;
   }
-  const gitignorePath = path5.join(repoRoot, ".gitignore");
+  const gitignorePath = path8.join(repoRoot, ".gitignore");
   if (!await fileExists(gitignorePath)) {
     return null;
   }
   const matcher = ignore();
-  matcher.add(await fs5.readFile(gitignorePath, "utf8"));
+  matcher.add(await fs8.readFile(gitignorePath, "utf8"));
   return matcher;
 }
 function builtInIgnoreReason(relativePath) {
@@ -2377,23 +3368,23 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
     if (!currentDir) {
       continue;
     }
-    const entries = await fs5.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs8.readdir(currentDir, { withFileTypes: true });
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const absolutePath = path5.join(currentDir, entry.name);
-      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path5.relative(inputDir, absolutePath));
+      const absolutePath = path8.join(currentDir, entry.name);
+      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path8.relative(inputDir, absolutePath));
       const relativePath = relativeToRepo || entry.name;
       const builtInReason = builtInIgnoreReason(relativePath);
       if (builtInReason) {
-        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: builtInReason });
+        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: builtInReason });
         continue;
       }
       if (matcher?.ignores(relativePath)) {
-        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "gitignore" });
+        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "gitignore" });
         continue;
       }
       if (matchesAnyGlob(relativePath, options.exclude)) {
-        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "exclude_glob" });
+        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "exclude_glob" });
         continue;
       }
       if (entry.isDirectory()) {
@@ -2401,21 +3392,21 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
         continue;
       }
       if (!entry.isFile()) {
-        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
+        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
         continue;
       }
       if (options.include.length > 0 && !matchesAnyGlob(relativePath, options.include)) {
-        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "include_glob" });
+        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "include_glob" });
         continue;
       }
       const mimeType = guessMimeType(absolutePath);
       const sourceKind = inferKind(mimeType, absolutePath);
       if (!supportedDirectoryKind(sourceKind)) {
-        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
         continue;
       }
       if (files.length >= options.maxFiles) {
-        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "max_files" });
+        skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "max_files" });
         continue;
       }
       files.push(absolutePath);
@@ -2437,12 +3428,12 @@ function resolveUrlMimeType(input, response) {
 function buildRemoteAssetRelativePath(assetUrl, mimeType) {
   const url = new URL(assetUrl);
   const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
-  const extension = path5.posix.extname(normalized);
-  const directory = path5.posix.dirname(normalized);
-  const basename = extension ? path5.posix.basename(normalized, extension) : path5.posix.basename(normalized);
+  const extension = path8.posix.extname(normalized);
+  const directory = path8.posix.dirname(normalized);
+  const basename = extension ? path8.posix.basename(normalized, extension) : path8.posix.basename(normalized);
   const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
   const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
-  return directory === "." ? hashedName : path5.posix.join(directory, hashedName);
+  return directory === "." ? hashedName : path8.posix.join(directory, hashedName);
 }
 async function readResponseBytesWithinLimit(response, maxBytes) {
   const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
@@ -2577,27 +3568,27 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   const previous = existingByOrigin ?? void 0;
   const sourceId = previous?.sourceId ?? `${slugify(prepared.title)}-${contentHash.slice(0, 8)}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const storedPath = path5.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
-  const extractedTextPath = prepared.extractedText ? path5.join(paths.extractsDir, `${sourceId}.md`) : void 0;
-  const attachmentsDir = path5.join(paths.rawAssetsDir, sourceId);
+  const storedPath = path8.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
+  const extractedTextPath = prepared.extractedText ? path8.join(paths.extractsDir, `${sourceId}.md`) : void 0;
+  const attachmentsDir = path8.join(paths.rawAssetsDir, sourceId);
   if (previous?.storedPath) {
-    await fs5.rm(path5.resolve(rootDir, previous.storedPath), { force: true });
+    await fs8.rm(path8.resolve(rootDir, previous.storedPath), { force: true });
   }
   if (previous?.extractedTextPath) {
-    await fs5.rm(path5.resolve(rootDir, previous.extractedTextPath), { force: true });
+    await fs8.rm(path8.resolve(rootDir, previous.extractedTextPath), { force: true });
   }
-  await fs5.rm(attachmentsDir, { recursive: true, force: true });
-  await fs5.writeFile(storedPath, prepared.payloadBytes);
+  await fs8.rm(attachmentsDir, { recursive: true, force: true });
+  await fs8.writeFile(storedPath, prepared.payloadBytes);
   if (prepared.extractedText && extractedTextPath) {
-    await fs5.writeFile(extractedTextPath, prepared.extractedText, "utf8");
+    await fs8.writeFile(extractedTextPath, prepared.extractedText, "utf8");
   }
   const manifestAttachments = [];
   for (const attachment of attachments) {
-    const absoluteAttachmentPath = path5.join(attachmentsDir, attachment.relativePath);
-    await ensureDir(path5.dirname(absoluteAttachmentPath));
-    await fs5.writeFile(absoluteAttachmentPath, attachment.bytes);
+    const absoluteAttachmentPath = path8.join(attachmentsDir, attachment.relativePath);
+    await ensureDir(path8.dirname(absoluteAttachmentPath));
+    await fs8.writeFile(absoluteAttachmentPath, attachment.bytes);
     manifestAttachments.push({
-      path: toPosix(path5.relative(rootDir, absoluteAttachmentPath)),
+      path: toPosix(path8.relative(rootDir, absoluteAttachmentPath)),
       mimeType: attachment.mimeType,
       originalPath: attachment.originalPath
     });
@@ -2611,15 +3602,15 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     originalPath: prepared.originalPath,
     repoRelativePath: prepared.repoRelativePath,
     url: prepared.url,
-    storedPath: toPosix(path5.relative(rootDir, storedPath)),
-    extractedTextPath: extractedTextPath ? toPosix(path5.relative(rootDir, extractedTextPath)) : void 0,
+    storedPath: toPosix(path8.relative(rootDir, storedPath)),
+    extractedTextPath: extractedTextPath ? toPosix(path8.relative(rootDir, extractedTextPath)) : void 0,
     mimeType: prepared.mimeType,
     contentHash,
     createdAt: previous?.createdAt ?? now,
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
   };
-  await writeJsonFile(path5.join(paths.manifestsDir, `${sourceId}.json`), manifest);
+  await writeJsonFile(path8.join(paths.manifestsDir, `${sourceId}.json`), manifest);
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
@@ -2627,21 +3618,292 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     `updated=${previous ? "true" : "false"}`,
     ...prepared.logDetails ?? []
   ]);
+  if (manifest.originalPath || manifest.repoRelativePath || manifest.sourceId) {
+    await clearPendingSemanticRefreshEntries(rootDir, {
+      sourceId: manifest.sourceId,
+      originalPath: manifest.originalPath,
+      relativePath: manifest.repoRelativePath
+    });
+  }
   return { manifest, isNew: !previous, wasUpdated: Boolean(previous) };
 }
+async function removeManifestArtifacts(rootDir, manifest, paths) {
+  await fs8.rm(path8.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
+  await fs8.rm(path8.resolve(rootDir, manifest.storedPath), { force: true });
+  if (manifest.extractedTextPath) {
+    await fs8.rm(path8.resolve(rootDir, manifest.extractedTextPath), { force: true });
+  }
+  await fs8.rm(path8.join(paths.rawAssetsDir, manifest.sourceId), { recursive: true, force: true });
+  await fs8.rm(path8.join(paths.analysesDir, `${manifest.sourceId}.json`), { force: true });
+}
+function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
+  const candidates = [
+    paths.rawDir,
+    paths.wikiDir,
+    paths.stateDir,
+    paths.agentDir,
+    paths.inboxDir,
+    path8.join(rootDir, ".claude"),
+    path8.join(rootDir, ".cursor"),
+    path8.join(rootDir, ".obsidian")
+  ];
+  return candidates.map((candidate) => path8.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
+}
+function preparedMatchesManifest(manifest, prepared, contentHash) {
+  return manifest.contentHash === contentHash && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
+}
+function shouldDeferWatchSemanticRefresh(sourceKind) {
+  return sourceKind === "markdown" || sourceKind === "text" || sourceKind === "html" || sourceKind === "pdf" || sourceKind === "image";
+}
+function pendingSemanticRefreshId(changeType, repoRoot, relativePath) {
+  return `pending:${changeType}:${sha256(`${toPosix(repoRoot)}:${relativePath}`).slice(0, 12)}`;
+}
+async function listTrackedRepoRoots(rootDir) {
+  const manifests = await listManifests(rootDir);
+  return [...new Set(manifests.map((manifest) => repoRootFromManifest(manifest)).filter((item) => Boolean(item)))].sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+async function syncTrackedRepos(rootDir, options, repoRoots) {
+  const { paths } = await initWorkspace(rootDir);
+  const normalizedOptions = normalizeIngestOptions(options);
+  const manifests = await listManifests(rootDir);
+  const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
+    (item) => path8.resolve(item)
+  );
+  const uniqueRoots = [...new Set(trackedRoots)].sort((left, right) => left.localeCompare(right));
+  const manifestsByRepoRoot = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    const repoRoot = repoRootFromManifest(manifest);
+    if (!repoRoot || !uniqueRoots.includes(path8.resolve(repoRoot))) {
+      continue;
+    }
+    const key = path8.resolve(repoRoot);
+    const bucket = manifestsByRepoRoot.get(key) ?? [];
+    bucket.push(manifest);
+    manifestsByRepoRoot.set(key, bucket);
+  }
+  const imported = [];
+  const updated = [];
+  const removed = [];
+  const skipped = [];
+  let scannedCount = 0;
+  for (const repoRoot of uniqueRoots) {
+    const repoManifests = manifestsByRepoRoot.get(repoRoot) ?? [];
+    if (!await fileExists(repoRoot)) {
+      for (const manifest of repoManifests) {
+        await removeManifestArtifacts(rootDir, manifest, paths);
+        removed.push(manifest);
+      }
+      continue;
+    }
+    const ignoreRoots = repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot);
+    const collected = await collectDirectoryFiles(rootDir, repoRoot, repoRoot, normalizedOptions);
+    const files = collected.files.filter((absolutePath) => !ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath)));
+    skipped.push(
+      ...collected.skipped,
+      ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
+        path: toPosix(path8.relative(rootDir, absolutePath)),
+        reason: "workspace_generated"
+      }))
+    );
+    scannedCount += files.length;
+    const currentPaths = new Set(files.map((absolutePath) => path8.resolve(absolutePath)));
+    for (const absolutePath of files) {
+      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
+      const result = await persistPreparedInput(rootDir, prepared, paths);
+      if (result.isNew) {
+        imported.push(result.manifest);
+      } else if (result.wasUpdated) {
+        updated.push(result.manifest);
+      }
+    }
+    for (const manifest of repoManifests) {
+      const originalPath = manifest.originalPath ? path8.resolve(manifest.originalPath) : null;
+      if (originalPath && !currentPaths.has(originalPath)) {
+        await removeManifestArtifacts(rootDir, manifest, paths);
+        removed.push(manifest);
+      }
+    }
+  }
+  if (uniqueRoots.length > 0) {
+    await appendLogEntry(rootDir, "sync_repo", uniqueRoots.map((repoRoot) => toPosix(path8.relative(rootDir, repoRoot)) || ".").join(","), [
+      `repo_roots=${uniqueRoots.length}`,
+      `scanned=${scannedCount}`,
+      `imported=${imported.length}`,
+      `updated=${updated.length}`,
+      `removed=${removed.length}`,
+      `skipped=${skipped.length}`
+    ]);
+  }
+  return {
+    repoRoots: uniqueRoots,
+    scannedCount,
+    imported,
+    updated,
+    removed,
+    skipped
+  };
+}
+async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
+  const { paths } = await initWorkspace(rootDir);
+  const normalizedOptions = normalizeIngestOptions(options);
+  const manifests = await listManifests(rootDir);
+  const trackedRoots = (repoRoots && repoRoots.length > 0 ? repoRoots : await listTrackedRepoRoots(rootDir)).map(
+    (item) => path8.resolve(item)
+  );
+  const uniqueRoots = [...new Set(trackedRoots)].sort((left, right) => left.localeCompare(right));
+  const manifestsByRepoRoot = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    const repoRoot = repoRootFromManifest(manifest);
+    if (!repoRoot || !uniqueRoots.includes(path8.resolve(repoRoot))) {
+      continue;
+    }
+    const key = path8.resolve(repoRoot);
+    const bucket = manifestsByRepoRoot.get(key) ?? [];
+    bucket.push(manifest);
+    manifestsByRepoRoot.set(key, bucket);
+  }
+  const imported = [];
+  const updated = [];
+  const removed = [];
+  const skipped = [];
+  const pendingSemanticRefresh = [];
+  const staleSourceIds = /* @__PURE__ */ new Set();
+  let scannedCount = 0;
+  for (const repoRoot of uniqueRoots) {
+    const repoManifests = manifestsByRepoRoot.get(repoRoot) ?? [];
+    const manifestsByOriginalPath = new Map(
+      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path8.resolve(manifest.originalPath), manifest])
+    );
+    if (!await fileExists(repoRoot)) {
+      for (const manifest of repoManifests) {
+        if (shouldDeferWatchSemanticRefresh(manifest.sourceKind)) {
+          pendingSemanticRefresh.push({
+            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? manifest.storedPath),
+            repoRoot,
+            path: toPosix(path8.relative(rootDir, manifest.originalPath ?? manifest.storedPath)),
+            changeType: "removed",
+            detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            sourceId: manifest.sourceId,
+            sourceKind: manifest.sourceKind
+          });
+          staleSourceIds.add(manifest.sourceId);
+        } else {
+          await removeManifestArtifacts(rootDir, manifest, paths);
+          removed.push(manifest);
+        }
+      }
+      continue;
+    }
+    const ignoreRoots = repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot);
+    const collected = await collectDirectoryFiles(rootDir, repoRoot, repoRoot, normalizedOptions);
+    const files = collected.files.filter((absolutePath) => !ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath)));
+    skipped.push(
+      ...collected.skipped,
+      ...collected.files.filter((absolutePath) => ignoreRoots.some((ignoreRoot) => withinRoot(ignoreRoot, absolutePath))).map((absolutePath) => ({
+        path: toPosix(path8.relative(rootDir, absolutePath)),
+        reason: "workspace_generated"
+      }))
+    );
+    scannedCount += files.length;
+    const currentPaths = new Set(files.map((absolutePath) => path8.resolve(absolutePath)));
+    for (const absolutePath of files) {
+      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
+      if (shouldDeferWatchSemanticRefresh(prepared.sourceKind)) {
+        const existing = manifestsByOriginalPath.get(path8.resolve(absolutePath));
+        const contentHash = buildCompositeHash(prepared.payloadBytes, prepared.attachments);
+        const changed = !existing || !preparedMatchesManifest(existing, prepared, contentHash);
+        if (changed) {
+          pendingSemanticRefresh.push({
+            id: pendingSemanticRefreshId(
+              existing ? "modified" : "added",
+              repoRoot,
+              prepared.repoRelativePath ?? toPosix(path8.relative(repoRoot, absolutePath))
+            ),
+            repoRoot,
+            path: toPosix(path8.relative(rootDir, absolutePath)),
+            changeType: existing ? "modified" : "added",
+            detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            sourceId: existing?.sourceId,
+            sourceKind: prepared.sourceKind
+          });
+          if (existing?.sourceId) {
+            staleSourceIds.add(existing.sourceId);
+          }
+        }
+        continue;
+      }
+      const result = await persistPreparedInput(rootDir, prepared, paths);
+      if (result.isNew) {
+        imported.push(result.manifest);
+      } else if (result.wasUpdated) {
+        updated.push(result.manifest);
+      }
+    }
+    for (const manifest of repoManifests) {
+      const originalPath = manifest.originalPath ? path8.resolve(manifest.originalPath) : null;
+      if (originalPath && !currentPaths.has(originalPath)) {
+        if (shouldDeferWatchSemanticRefresh(manifest.sourceKind)) {
+          pendingSemanticRefresh.push({
+            id: pendingSemanticRefreshId("removed", repoRoot, manifest.repoRelativePath ?? toPosix(path8.relative(repoRoot, originalPath))),
+            repoRoot,
+            path: toPosix(path8.relative(rootDir, originalPath)),
+            changeType: "removed",
+            detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            sourceId: manifest.sourceId,
+            sourceKind: manifest.sourceKind
+          });
+          staleSourceIds.add(manifest.sourceId);
+        } else {
+          await removeManifestArtifacts(rootDir, manifest, paths);
+          removed.push(manifest);
+        }
+      }
+    }
+  }
+  if (uniqueRoots.length > 0) {
+    await appendLogEntry(
+      rootDir,
+      "sync_repo_watch",
+      uniqueRoots.map((repoRoot) => toPosix(path8.relative(rootDir, repoRoot)) || ".").join(","),
+      [
+        `repo_roots=${uniqueRoots.length}`,
+        `scanned=${scannedCount}`,
+        `imported=${imported.length}`,
+        `updated=${updated.length}`,
+        `removed=${removed.length}`,
+        `pending_semantic_refresh=${pendingSemanticRefresh.length}`,
+        `skipped=${skipped.length}`
+      ]
+    );
+  }
+  return {
+    repoRoots: uniqueRoots,
+    scannedCount,
+    imported,
+    updated,
+    removed,
+    skipped,
+    pendingSemanticRefresh: pendingSemanticRefresh.filter(
+      (entry, index, items) => index === items.findIndex((candidate) => candidate.id === entry.id)
+    ),
+    staleSourceIds: [...staleSourceIds]
+  };
+}
 async function prepareFileInput(_rootDir, absoluteInput, repoRoot) {
-  const payloadBytes = await fs5.readFile(absoluteInput);
+  const payloadBytes = await fs8.readFile(absoluteInput);
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
   const language = inferCodeLanguage(absoluteInput, mimeType);
-  const storedExtension = path5.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
+  const storedExtension = path8.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
   let title;
   let extractedText;
   if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
     extractedText = payloadBytes.toString("utf8");
-    title = titleFromText(path5.basename(absoluteInput, path5.extname(absoluteInput)), extractedText);
+    title = titleFromText(path8.basename(absoluteInput, path8.extname(absoluteInput)), extractedText);
   } else {
-    title = path5.basename(absoluteInput, path5.extname(absoluteInput));
+    title = path8.basename(absoluteInput, path8.extname(absoluteInput));
   }
   return {
     title,
@@ -2711,7 +3973,7 @@ async function prepareUrlInput(input, options) {
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path5.extname(inputUrl.pathname);
+    const extension = path8.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = payloadBytes.toString("utf8");
@@ -2761,14 +4023,14 @@ async function collectInboxAttachmentRefs(inputDir, files) {
     if (sourceKind !== "markdown") {
       continue;
     }
-    const content = await fs5.readFile(absolutePath, "utf8");
+    const content = await fs8.readFile(absolutePath, "utf8");
     const refs = extractMarkdownReferences(content);
     if (!refs.length) {
       continue;
     }
     const sourceRefs = [];
     for (const ref of refs) {
-      const resolved = path5.resolve(path5.dirname(absolutePath), ref);
+      const resolved = path8.resolve(path8.dirname(absolutePath), ref);
       if (!resolved.startsWith(inputDir) || !await fileExists(resolved)) {
         continue;
       }
@@ -2802,12 +4064,12 @@ function rewriteMarkdownReferences(content, replacements) {
   });
 }
 async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs5.readFile(absolutePath);
+  const originalBytes = await fs8.readFile(absolutePath);
   const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path5.basename(absolutePath, path5.extname(absolutePath)), originalText);
+  const title = titleFromText(path8.basename(absolutePath, path8.extname(absolutePath)), originalText);
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
-    const bytes = await fs5.readFile(attachmentRef.absolutePath);
+    const bytes = await fs8.readFile(attachmentRef.absolutePath);
     attachments.push({
       relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
       mimeType: guessMimeType(attachmentRef.absolutePath),
@@ -2830,7 +4092,7 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     sourceKind: "markdown",
     originalPath: toPosix(absolutePath),
     mimeType: "text/markdown",
-    storedExtension: path5.extname(absolutePath) || ".md",
+    storedExtension: path8.extname(absolutePath) || ".md",
     payloadBytes: Buffer.from(rewrittenText, "utf8"),
     extractedText: rewrittenText,
     attachments,
@@ -2843,17 +4105,70 @@ function isSupportedInboxKind(sourceKind) {
 async function ingestInput(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInput = path5.resolve(rootDir, input);
-  const repoRoot = /^https?:\/\//i.test(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot(absoluteInput).then((value) => value ?? path5.dirname(absoluteInput));
-  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input, normalizedOptions) : await prepareFileInput(rootDir, absoluteInput, repoRoot);
+  const absoluteInput = path8.resolve(rootDir, input);
+  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path8.dirname(absoluteInput));
+  const prepared = isHttpUrl(input) ? await prepareUrlInput(input, normalizedOptions) : await prepareFileInput(rootDir, absoluteInput, repoRoot);
   const result = await persistPreparedInput(rootDir, prepared, paths);
   return result.manifest;
 }
+async function addInput(rootDir, input, options = {}) {
+  const { paths } = await initWorkspace(rootDir);
+  if (!isHttpUrl(input) && !arxivIdFromInput(input)) {
+    throw new Error("`swarmvault add` only supports URLs and bare arXiv ids in the current release.");
+  }
+  let prepared = null;
+  let captureType = "url";
+  let normalizedUrl = input;
+  let fallback = false;
+  try {
+    if (arxivIdFromInput(input)) {
+      const captured = await captureArxivMarkdown(input, options);
+      prepared = prepareCapturedMarkdownInput({
+        title: captured.title,
+        url: captured.normalizedUrl,
+        markdown: captured.markdown,
+        logDetails: ["capture_type=arxiv"]
+      });
+      captureType = "arxiv";
+      normalizedUrl = captured.normalizedUrl;
+    } else if (isTweetUrl(input)) {
+      const captured = await captureTweetMarkdown(input, options);
+      prepared = prepareCapturedMarkdownInput({
+        title: captured.title,
+        url: captured.normalizedUrl,
+        markdown: captured.markdown,
+        logDetails: ["capture_type=tweet"]
+      });
+      captureType = "tweet";
+      normalizedUrl = captured.normalizedUrl;
+    }
+  } catch {
+    fallback = true;
+  }
+  if (!prepared) {
+    normalizedUrl = arxivIdFromInput(input) ? `https://arxiv.org/abs/${arxivIdFromInput(input)}` : normalizeOriginUrl(input);
+    return {
+      captureType: "url",
+      manifest: await ingestInput(rootDir, normalizedUrl, options),
+      normalizedUrl,
+      title: normalizedUrl,
+      fallback: true
+    };
+  }
+  const result = await persistPreparedInput(rootDir, prepared, paths);
+  return {
+    captureType,
+    manifest: result.manifest,
+    normalizedUrl,
+    title: prepared.title,
+    fallback
+  };
+}
 async function ingestDirectory(rootDir, inputDir, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const absoluteInputDir = path5.resolve(rootDir, inputDir);
-  const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot(absoluteInputDir) ?? absoluteInputDir;
+  const absoluteInputDir = path8.resolve(rootDir, inputDir);
+  const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot2(absoluteInputDir) ?? absoluteInputDir;
   if (!await fileExists(absoluteInputDir)) {
     throw new Error(`Directory not found: ${absoluteInputDir}`);
   }
@@ -2868,11 +4183,11 @@ async function ingestDirectory(rootDir, inputDir, options) {
     } else if (result.wasUpdated) {
       updated.push(result.manifest);
     } else {
-      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "duplicate_content" });
     }
   }
-  await appendLogEntry(rootDir, "ingest_directory", toPosix(path5.relative(rootDir, absoluteInputDir)) || ".", [
-    `repo_root=${toPosix(path5.relative(rootDir, repoRoot)) || "."}`,
+  await appendLogEntry(rootDir, "ingest_directory", toPosix(path8.relative(rootDir, absoluteInputDir)) || ".", [
+    `repo_root=${toPosix(path8.relative(rootDir, repoRoot)) || "."}`,
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `updated=${updated.length}`,
@@ -2889,7 +4204,7 @@ async function ingestDirectory(rootDir, inputDir, options) {
 }
 async function importInbox(rootDir, inputDir) {
   const { paths } = await initWorkspace(rootDir);
-  const effectiveInputDir = path5.resolve(rootDir, inputDir ?? paths.inboxDir);
+  const effectiveInputDir = path8.resolve(rootDir, inputDir ?? paths.inboxDir);
   if (!await fileExists(effectiveInputDir)) {
     throw new Error(`Inbox directory not found: ${effectiveInputDir}`);
   }
@@ -2900,31 +4215,31 @@ async function importInbox(rootDir, inputDir) {
   const skipped = [];
   let attachmentCount = 0;
   for (const absolutePath of files) {
-    const basename = path5.basename(absolutePath);
+    const basename = path8.basename(absolutePath);
     if (basename.startsWith(".")) {
-      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "hidden_file" });
+      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "hidden_file" });
       continue;
     }
     if (claimedAttachments.has(absolutePath)) {
-      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
+      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
     if (!isSupportedInboxKind(sourceKind)) {
-      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+      skipped.push({ path: toPosix(path8.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(path5.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path8.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
     attachmentCount += result.manifest.attachments?.length ?? 0;
     imported.push(result.manifest);
   }
-  await appendLogEntry(rootDir, "inbox_import", toPosix(path5.relative(rootDir, effectiveInputDir)) || ".", [
+  await appendLogEntry(rootDir, "inbox_import", toPosix(path8.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `attachments=${attachmentCount}`,
@@ -2943,9 +4258,9 @@ async function listManifests(rootDir) {
   if (!await fileExists(paths.manifestsDir)) {
     return [];
   }
-  const entries = await fs5.readdir(paths.manifestsDir);
+  const entries = await fs8.readdir(paths.manifestsDir);
   const manifests = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path5.join(paths.manifestsDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path8.join(paths.manifestsDir, entry)))
   );
   return manifests.filter((manifest) => Boolean(manifest));
 }
@@ -2953,28 +4268,28 @@ async function readExtractedText(rootDir, manifest) {
   if (!manifest.extractedTextPath) {
     return void 0;
   }
-  const absolutePath = path5.resolve(rootDir, manifest.extractedTextPath);
+  const absolutePath = path8.resolve(rootDir, manifest.extractedTextPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
-  return fs5.readFile(absolutePath, "utf8");
+  return fs8.readFile(absolutePath, "utf8");
 }
 
 // src/mcp.ts
-import fs12 from "fs/promises";
-import path15 from "path";
+import fs15 from "fs/promises";
+import path18 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z7 } from "zod";
 
 // src/schema.ts
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 function normalizeSchemaContent(content) {
   return content.trim() ? content.trim() : defaultVaultSchema().trim();
 }
 async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
-  const content = await fileExists(schemaPath) ? await fs6.readFile(schemaPath, "utf8") : fallback;
+  const content = await fileExists(schemaPath) ? await fs9.readFile(schemaPath, "utf8") : fallback;
   const normalized = normalizeSchemaContent(content);
   return {
     path: schemaPath,
@@ -2983,7 +4298,7 @@ async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
   };
 }
 function resolveProjectSchemaPath(rootDir, schemaPath) {
-  return path6.resolve(rootDir, schemaPath);
+  return path9.resolve(rootDir, schemaPath);
 }
 function composeVaultSchema(root, projectSchemas = []) {
   if (!projectSchemas.length) {
@@ -2999,7 +4314,7 @@ function composeVaultSchema(root, projectSchemas = []) {
       (schema) => [
         `## Project Schema`,
         "",
-        `Path: ${toPosix(path6.relative(path6.dirname(root.path), schema.path) || schema.path)}`,
+        `Path: ${toPosix(path9.relative(path9.dirname(root.path), schema.path) || schema.path)}`,
         "",
         schema.content
       ].join("\n")
@@ -3075,13 +4390,13 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs11 from "fs/promises";
-import path14 from "path";
-import matter7 from "gray-matter";
+import fs14 from "fs/promises";
+import path17 from "path";
+import matter8 from "gray-matter";
 import { z as z6 } from "zod";
 
 // src/analysis.ts
-import path7 from "path";
+import path10 from "path";
 import { z } from "zod";
 var ANALYSIS_FORMAT_VERSION = 4;
 var sourceAnalysisSchema = z.object({
@@ -3260,7 +4575,7 @@ ${truncate(text, 18e3)}`
   };
 }
 async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path7.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cachePath = path10.join(paths.analysesDir, `${manifest.sourceId}.json`);
   const cached = await readJsonFile(cachePath);
   if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && cached.sourceHash === manifest.contentHash && cached.schemaHash === schema.hash) {
     return cached;
@@ -3300,30 +4615,112 @@ function analysisSignature(analysis) {
   return sha256(JSON.stringify(analysis));
 }
 
-// src/confidence.ts
-function nodeConfidence(sourceCount) {
-  return Math.min(0.5 + sourceCount * 0.15, 0.95);
+// src/benchmark.ts
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_BENCHMARK_QUESTIONS = [
+  "How does this vault connect the main concepts?",
+  "Which pages bridge the biggest communities?",
+  "What are the core abstractions in this vault?",
+  "Where are the biggest knowledge gaps?",
+  "What evidence should I read first?"
+];
+function nodeMap(graph) {
+  return new Map(graph.nodes.map((node) => [node.id, node]));
 }
-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;
+function pageMap(graph) {
+  return new Map(graph.pages.map((page) => [page.id, page]));
 }
-function conflictConfidence(claimA, claimB) {
-  return Math.min(claimA.confidence, claimB.confidence);
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));
 }
-
-// src/deep-lint.ts
-import fs7 from "fs/promises";
-import path10 from "path";
-import matter2 from "gray-matter";
-import { z as z4 } from "zod";
-
-// src/findings.ts
-function normalizeFindingSeverity(value) {
+function estimateCorpusWords(texts) {
+  return texts.reduce((total, text) => total + normalizeWhitespace(text).split(/\s+/).filter(Boolean).length, 0);
+}
+function benchmarkQueryTokens(graph, queryResult, pageContentsById) {
+  const nodesById = nodeMap(graph);
+  const pagesById = pageMap(graph);
+  const edgeIds = new Set(queryResult.visitedEdgeIds);
+  const lines = [];
+  for (const pageId of queryResult.pageIds) {
+    const page = pagesById.get(pageId);
+    if (!page) {
+      continue;
+    }
+    const content = normalizeWhitespace(pageContentsById.get(pageId) ?? "").slice(0, 280);
+    lines.push(`PAGE ${page.title} path=${page.path} kind=${page.kind}`);
+    if (content) {
+      lines.push(`PAGE_BODY ${content}`);
+    }
+  }
+  for (const nodeId of queryResult.visitedNodeIds) {
+    const node = nodesById.get(nodeId);
+    if (!node) {
+      continue;
+    }
+    lines.push(`NODE ${node.label} type=${node.type} community=${node.communityId ?? "unassigned"} page=${node.pageId ?? "none"}`);
+  }
+  for (const edge of graph.edges) {
+    if (!edgeIds.has(edge.id)) {
+      continue;
+    }
+    const source = nodesById.get(edge.source)?.label ?? edge.source;
+    const target = nodesById.get(edge.target)?.label ?? edge.target;
+    lines.push(`EDGE ${source} --${edge.relation}/${edge.evidenceClass}/${edge.confidence.toFixed(2)}--> ${target}`);
+  }
+  const queryTokens = estimateTokens(lines.join("\n"));
+  return {
+    question: queryResult.question,
+    queryTokens,
+    reduction: 0,
+    visitedNodeIds: queryResult.visitedNodeIds,
+    pageIds: queryResult.pageIds
+  };
+}
+function buildBenchmarkArtifact(input) {
+  const corpusTokens = Math.max(1, Math.round(input.corpusWords * (100 / 75)));
+  const perQuestion = input.perQuestion.filter((entry) => entry.queryTokens > 0).map((entry) => ({
+    ...entry,
+    reduction: Number(Math.max(0, 1 - entry.queryTokens / Math.max(1, corpusTokens)).toFixed(3))
+  }));
+  const avgQueryTokens = perQuestion.length ? Math.max(1, Math.round(perQuestion.reduce((total, entry) => total + entry.queryTokens, 0) / perQuestion.length)) : 0;
+  const reductionRatio = avgQueryTokens ? Number(Math.max(0, 1 - avgQueryTokens / Math.max(1, corpusTokens)).toFixed(3)) : 0;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    corpusWords: input.corpusWords,
+    corpusTokens,
+    nodes: input.graph.nodes.length,
+    edges: input.graph.edges.length,
+    avgQueryTokens,
+    reductionRatio,
+    sampleQuestions: input.questions,
+    perQuestion
+  };
+}
+
+// src/confidence.ts
+function nodeConfidence(sourceCount) {
+  return Math.min(0.5 + sourceCount * 0.15, 0.95);
+}
+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;
+}
+function conflictConfidence(claimA, claimB) {
+  return Math.min(claimA.confidence, claimB.confidence);
+}
+
+// src/deep-lint.ts
+import fs10 from "fs/promises";
+import path13 from "path";
+import matter3 from "gray-matter";
+import { z as z4 } from "zod";
+
+// src/findings.ts
+function normalizeFindingSeverity(value) {
   if (typeof value !== "string") {
     return "info";
   }
@@ -3339,7 +4736,7 @@ function normalizeFindingSeverity(value) {
 
 // src/orchestration.ts
 import { spawn } from "child_process";
-import path8 from "path";
+import path11 from "path";
 import { z as z2 } from "zod";
 var orchestrationRoleResultSchema = z2.object({
   summary: z2.string().optional(),
@@ -3432,7 +4829,7 @@ async function runProviderRole(rootDir, role, roleConfig, input) {
 }
 async function runCommandRole(rootDir, role, executor, input) {
   const [command, ...args] = executor.command;
-  const cwd = executor.cwd ? path8.resolve(rootDir, executor.cwd) : rootDir;
+  const cwd = executor.cwd ? path11.resolve(rootDir, executor.cwd) : rootDir;
   const child = spawn(command, args, {
     cwd,
     env: {
@@ -3526,7 +4923,7 @@ function summarizeRoleQuestions(results) {
 }
 
 // src/web-search/registry.ts
-import path9 from "path";
+import path12 from "path";
 import { pathToFileURL } from "url";
 import { z as z3 } from "zod";
 
@@ -3624,7 +5021,7 @@ async function createWebSearchAdapter(id, config, rootDir) {
       if (!config.module) {
         throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
       }
-      const resolvedModule = path9.isAbsolute(config.module) ? config.module : path9.resolve(rootDir, config.module);
+      const resolvedModule = path12.isAbsolute(config.module) ? config.module : path12.resolve(rootDir, config.module);
       const loaded = await import(pathToFileURL(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
@@ -3684,9 +5081,9 @@ async function loadContextPages(rootDir, graph) {
   );
   return Promise.all(
     contextPages.slice(0, 18).map(async (page) => {
-      const absolutePath = path10.join(paths.wikiDir, page.path);
-      const raw = await fs7.readFile(absolutePath, "utf8").catch(() => "");
-      const parsed = matter2(raw);
+      const absolutePath = path13.join(paths.wikiDir, page.path);
+      const raw = await fs10.readFile(absolutePath, "utf8").catch(() => "");
+      const parsed = matter3(raw);
       return {
         id: page.id,
         title: page.title,
@@ -3733,7 +5130,7 @@ function heuristicDeepFindings(contextPages, structuralFindings, graph) {
       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
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path13.basename(finding.pagePath, ".md")}?` : void 0
     });
   }
   for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
@@ -4214,7 +5611,7 @@ function topGodNodes(graph, limit = 10) {
 }
 
 // src/markdown.ts
-import matter3 from "gray-matter";
+import matter4 from "gray-matter";
 function uniqueStrings(values) {
   return uniqueBy(values.filter(Boolean), (value) => value);
 }
@@ -4381,7 +5778,7 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
       compiledFrom: metadata.compiledFrom,
       managedBy: metadata.managedBy
     },
-    content: matter3.stringify(body, frontmatter)
+    content: matter4.stringify(body, frontmatter)
   };
 }
 function buildModulePage(input) {
@@ -4528,7 +5925,7 @@ function buildModulePage(input) {
       compiledFrom: metadata.compiledFrom,
       managedBy: metadata.managedBy
     },
-    content: matter3.stringify(body, frontmatter)
+    content: matter4.stringify(body, frontmatter)
   };
 }
 function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHashes, schemaHash, metadata, relativePath, relatedOutputs = [], decorations) {
@@ -4599,7 +5996,7 @@ function buildAggregatePage(kind, name, descriptions, sourceAnalyses, sourceHash
       compiledFrom: metadata.compiledFrom,
       managedBy: metadata.managedBy
     },
-    content: matter3.stringify(body, frontmatter)
+    content: matter4.stringify(body, frontmatter)
   };
 }
 function buildIndexPage(pages, schemaHash, metadata, projectPages = []) {
@@ -4675,7 +6072,7 @@ function buildIndexPage(pages, schemaHash, metadata, projectPages = []) {
 }
 function buildSectionIndex(kind, pages, schemaHash, metadata, projectIds = []) {
   const title = kind.charAt(0).toUpperCase() + kind.slice(1);
-  return matter3.stringify(
+  return matter4.stringify(
     [`# ${title}`, "", ...pages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`), ""].join("\n"),
     {
       page_id: `${kind}:index`,
@@ -4770,6 +6167,15 @@ function buildGraphReportPage(input) {
     `- Pages: ${input.graph.pages.length}`,
     `- Communities: ${input.graph.communities?.length ?? 0}`,
     "",
+    ...input.benchmark ? [
+      "## Benchmark",
+      "",
+      `- Corpus Tokens: ${input.benchmark.corpusTokens}`,
+      `- Avg Query Tokens: ${input.benchmark.avgQueryTokens}`,
+      `- Reduction Ratio: ${(input.benchmark.reductionRatio * 100).toFixed(1)}%`,
+      `- Sample Questions: ${input.benchmark.sampleQuestions.length}`,
+      ""
+    ] : [],
     "## God Nodes",
     "",
     ...godNodes.length ? godNodes.map((node) => `- ${graphNodeLink(node, pagesById)} (${nodeSummary(node)})`) : ["- No high-connectivity nodes detected."],
@@ -4822,7 +6228,7 @@ function buildGraphReportPage(input) {
       compiledFrom: input.metadata.compiledFrom,
       managedBy: input.metadata.managedBy
     },
-    content: matter3.stringify(body, frontmatter)
+    content: matter4.stringify(body, frontmatter)
   };
 }
 function buildCommunitySummaryPage(input) {
@@ -4904,11 +6310,11 @@ function buildCommunitySummaryPage(input) {
       compiledFrom: input.metadata.compiledFrom,
       managedBy: input.metadata.managedBy
     },
-    content: matter3.stringify(body, frontmatter)
+    content: matter4.stringify(body, frontmatter)
   };
 }
 function buildProjectsIndex(projectPages, schemaHash, metadata) {
-  return matter3.stringify(
+  return matter4.stringify(
     [
       "# Projects",
       "",
@@ -4938,7 +6344,7 @@ function buildProjectsIndex(projectPages, schemaHash, metadata) {
 }
 function buildProjectIndex(input) {
   const title = `Project: ${input.projectId}`;
-  return matter3.stringify(
+  return matter4.stringify(
     [
       `# ${title}`,
       "",
@@ -5051,7 +6457,7 @@ function buildOutputPage(input) {
       outputFormat: input.outputFormat,
       outputAssets
     },
-    content: matter3.stringify(
+    content: matter4.stringify(
       (input.outputFormat === "slides" ? [
         input.answer,
         "",
@@ -5177,7 +6583,7 @@ function buildExploreHubPage(input) {
       outputFormat: input.outputFormat,
       outputAssets
     },
-    content: matter3.stringify(
+    content: matter4.stringify(
       (input.outputFormat === "slides" ? [
         `# ${title}`,
         "",
@@ -5441,14 +6847,14 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
-import fs9 from "fs/promises";
-import path12 from "path";
-import matter5 from "gray-matter";
+import fs12 from "fs/promises";
+import path15 from "path";
+import matter6 from "gray-matter";
 
 // src/pages.ts
-import fs8 from "fs/promises";
-import path11 from "path";
-import matter4 from "gray-matter";
+import fs11 from "fs/promises";
+import path14 from "path";
+import matter5 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
@@ -5519,8 +6925,8 @@ async function loadExistingManagedPageState(absolutePath, defaults = {}) {
       updatedAt: updatedFallback
     };
   }
-  const content = await fs8.readFile(absolutePath, "utf8");
-  const parsed = matter4(content);
+  const content = await fs11.readFile(absolutePath, "utf8");
+  const parsed = matter5(content);
   return {
     status: normalizePageStatus(parsed.data.status, defaults.status ?? "active"),
     managedBy: normalizePageManager(parsed.data.managed_by, defaults.managedBy ?? "system"),
@@ -5554,11 +6960,11 @@ function inferPageKind(relativePath, explicitKind = void 0) {
   return "index";
 }
 function parseStoredPage(relativePath, content, defaults = {}) {
-  const parsed = matter4(content);
+  const parsed = matter5(content);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const fallbackCreatedAt = defaults.createdAt ?? now;
   const fallbackUpdatedAt = defaults.updatedAt ?? fallbackCreatedAt;
-  const title = typeof parsed.data.title === "string" ? parsed.data.title : path11.basename(relativePath, ".md");
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path14.basename(relativePath, ".md");
   const kind = inferPageKind(relativePath, parsed.data.kind);
   const sourceIds = normalizeStringArray(parsed.data.source_ids);
   const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -5597,18 +7003,18 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   };
 }
 async function loadInsightPages(wikiDir) {
-  const insightsDir = path11.join(wikiDir, "insights");
+  const insightsDir = path14.join(wikiDir, "insights");
   if (!await fileExists(insightsDir)) {
     return [];
   }
-  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path11.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
+  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path14.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
   const insights = [];
   for (const absolutePath of files) {
-    const relativePath = toPosix(path11.relative(wikiDir, absolutePath));
-    const content = await fs8.readFile(absolutePath, "utf8");
-    const parsed = matter4(content);
-    const stats = await fs8.stat(absolutePath);
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : path11.basename(absolutePath, ".md");
+    const relativePath = toPosix(path14.relative(wikiDir, absolutePath));
+    const content = await fs11.readFile(absolutePath, "utf8");
+    const parsed = matter5(content);
+    const stats = await fs11.stat(absolutePath);
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path14.basename(absolutePath, ".md");
     const sourceIds = normalizeStringArray(parsed.data.source_ids);
     const projectIds = normalizeProjectIds(parsed.data.project_ids);
     const nodeIds = normalizeStringArray(parsed.data.node_ids);
@@ -5670,28 +7076,28 @@ function relatedOutputsForPage(targetPage, outputPages) {
   return outputPages.map((page) => ({ page, rank: relationRank(page, targetPage) })).filter((item) => item.rank > 0).sort((left, right) => right.rank - left.rank || left.page.title.localeCompare(right.page.title)).map((item) => item.page);
 }
 async function resolveUniqueOutputSlug(wikiDir, baseSlug) {
-  const outputsDir = path12.join(wikiDir, "outputs");
+  const outputsDir = path15.join(wikiDir, "outputs");
   const root = baseSlug || "output";
   let candidate = root;
   let counter = 2;
-  while (await fileExists(path12.join(outputsDir, `${candidate}.md`))) {
+  while (await fileExists(path15.join(outputsDir, `${candidate}.md`))) {
     candidate = `${root}-${counter}`;
     counter++;
   }
   return candidate;
 }
 async function loadSavedOutputPages(wikiDir) {
-  const outputsDir = path12.join(wikiDir, "outputs");
-  const entries = await fs9.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
+  const outputsDir = path15.join(wikiDir, "outputs");
+  const entries = await fs12.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 = path12.posix.join("outputs", entry.name);
-    const absolutePath = path12.join(outputsDir, entry.name);
-    const content = await fs9.readFile(absolutePath, "utf8");
-    const parsed = matter5(content);
+    const relativePath = path15.posix.join("outputs", entry.name);
+    const absolutePath = path15.join(outputsDir, entry.name);
+    const content = await fs12.readFile(absolutePath, "utf8");
+    const parsed = matter6(content);
     const 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}`;
@@ -5703,7 +7109,7 @@ async function loadSavedOutputPages(wikiDir) {
     const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
     const backlinks = normalizeStringArray(parsed.data.backlinks);
     const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
-    const stats = await fs9.stat(absolutePath);
+    const stats = await fs12.stat(absolutePath);
     const createdAt = typeof parsed.data.created_at === "string" ? parsed.data.created_at : stats.birthtimeMs > 0 ? stats.birthtime.toISOString() : stats.mtime.toISOString();
     const updatedAt = typeof parsed.data.updated_at === "string" ? parsed.data.updated_at : stats.mtime.toISOString();
     outputs.push({
@@ -5741,9 +7147,9 @@ async function loadSavedOutputPages(wikiDir) {
 }
 
 // src/search.ts
-import fs10 from "fs/promises";
-import path13 from "path";
-import matter6 from "gray-matter";
+import fs13 from "fs/promises";
+import path16 from "path";
+import matter7 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
   if (!builtin?.DatabaseSync) {
@@ -5762,7 +7168,7 @@ function normalizeStatus(value) {
   return value === "draft" || value === "candidate" || value === "active" || value === "archived" ? value : void 0;
 }
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path13.dirname(dbPath));
+  await ensureDir(path16.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -5792,9 +7198,9 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
     "INSERT INTO pages (id, path, title, body, kind, status, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
   );
   for (const page of pages) {
-    const absolutePath = path13.join(wikiDir, page.path);
-    const content = await fs10.readFile(absolutePath, "utf8");
-    const parsed = matter6(content);
+    const absolutePath = path16.join(wikiDir, page.path);
+    const content = await fs13.readFile(absolutePath, "utf8");
+    const parsed = matter7(content);
     insertPage.run(
       page.id,
       page.path,
@@ -5896,7 +7302,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path14.join("outputs", "assets", slug, fileName));
+  return toPosix(path17.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -6036,7 +7442,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-JFEW5RUP.js");
+  const { createProvider: createProvider2 } = await import("./registry-X5PMZTZY.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -6234,7 +7640,7 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path14.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path17.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
@@ -6260,10 +7666,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path14.isAbsolute(rawPath)) {
+  if (!path17.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path14.relative(rootDir, rawPath));
+  const relative = toPosix(path17.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -6291,9 +7697,9 @@ function scopedProjectIdsFromSources(sourceIds, sourceProjects) {
   const projectIds = uniqueStrings2(sourceIds.map((sourceId) => sourceProjects[sourceId] ?? "").filter(Boolean));
   return projectIds.length === 1 ? projectIds : [];
 }
-function schemaProjectIdsFromPages(pageIds, pageMap) {
+function schemaProjectIdsFromPages(pageIds, pageMap2) {
   return uniqueStrings2(
-    pageIds.flatMap((pageId) => pageMap.get(pageId)?.projectIds ?? []).filter(Boolean).sort((left, right) => left.localeCompare(right))
+    pageIds.flatMap((pageId) => pageMap2.get(pageId)?.projectIds ?? []).filter(Boolean).sort((left, right) => left.localeCompare(right))
   );
 }
 function categoryTagsForSchema(schema, texts) {
@@ -6317,12 +7723,12 @@ function previousProjectSchemaHash(previousState, projectId) {
   }
   return previousState?.effectiveSchemaHashes?.projects?.[projectId] ?? previousState?.projectSchemaHashes?.[projectId] ?? previousGlobalSchemaHash(previousState);
 }
-function expectedSchemaHashForPage(page, schemas, pageMap, sourceProjects) {
+function expectedSchemaHashForPage(page, schemas, pageMap2, sourceProjects) {
   if (page.kind === "source" || page.kind === "module" || page.kind === "concept" || page.kind === "entity") {
     return effectiveHashForProject(schemas, scopedProjectIdsFromSources(page.sourceIds, sourceProjects)[0] ?? null);
   }
   if (page.kind === "output") {
-    const projectIds = schemaProjectIdsFromPages(page.relatedPageIds, pageMap);
+    const projectIds = schemaProjectIdsFromPages(page.relatedPageIds, pageMap2);
     if (projectIds.length) {
       return composeVaultSchema(
         schemas.root,
@@ -6437,7 +7843,7 @@ function pageHashes(pages) {
   return Object.fromEntries(pages.map((page) => [page.page.id, page.contentHash]));
 }
 async function buildManagedGraphPage(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs11.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs14.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -6475,7 +7881,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs11.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs14.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -6916,9 +8322,10 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
   };
 }
 async function buildGraphOrientationPages(graph, paths, schemaHash) {
+  const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
-    const absolutePath = path14.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
+    const absolutePath = path17.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
     communityRecords.push(
       await buildManagedGraphPage(
         absolutePath,
@@ -6938,7 +8345,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash) {
       )
     );
   }
-  const reportAbsolutePath = path14.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path17.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -6950,13 +8357,14 @@ async function buildGraphOrientationPages(graph, paths, schemaHash) {
       graph,
       schemaHash,
       metadata,
-      communityPages: communityRecords.map((record) => record.page)
+      communityPages: communityRecords.map((record) => record.page),
+      benchmark
     })
   );
   return [reportRecord, ...communityRecords];
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path14.resolve(wikiDir, relativePath);
+  const absolutePath = path17.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -7018,34 +8426,29 @@ async function requiredCompileArtifactsExist(paths) {
     paths.graphPath,
     paths.codeIndexPath,
     paths.searchDbPath,
-    path14.join(paths.wikiDir, "index.md"),
-    path14.join(paths.wikiDir, "sources", "index.md"),
-    path14.join(paths.wikiDir, "code", "index.md"),
-    path14.join(paths.wikiDir, "concepts", "index.md"),
-    path14.join(paths.wikiDir, "entities", "index.md"),
-    path14.join(paths.wikiDir, "outputs", "index.md"),
-    path14.join(paths.wikiDir, "projects", "index.md"),
-    path14.join(paths.wikiDir, "candidates", "index.md")
+    path17.join(paths.wikiDir, "index.md"),
+    path17.join(paths.wikiDir, "sources", "index.md"),
+    path17.join(paths.wikiDir, "code", "index.md"),
+    path17.join(paths.wikiDir, "concepts", "index.md"),
+    path17.join(paths.wikiDir, "entities", "index.md"),
+    path17.join(paths.wikiDir, "outputs", "index.md"),
+    path17.join(paths.wikiDir, "projects", "index.md"),
+    path17.join(paths.wikiDir, "candidates", "index.md")
   ];
   const checks = await Promise.all(requiredPaths.map((filePath) => fileExists(filePath)));
   return checks.every(Boolean);
 }
-async function loadCachedAnalyses(paths, manifests) {
-  return Promise.all(
-    manifests.map(async (manifest) => {
-      const cached = await readJsonFile(path14.join(paths.analysesDir, `${manifest.sourceId}.json`));
-      if (!cached) {
-        throw new Error(`Missing cached analysis for ${manifest.sourceId}. Run \`swarmvault compile\` first.`);
-      }
-      return cached;
-    })
+async function loadAvailableCachedAnalyses(paths, manifests) {
+  const analyses = await Promise.all(
+    manifests.map(async (manifest) => readJsonFile(path17.join(paths.analysesDir, `${manifest.sourceId}.json`)))
   );
+  return analyses.filter((analysis) => Boolean(analysis));
 }
 function approvalManifestPath(paths, approvalId) {
-  return path14.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path17.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path14.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path17.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
@@ -7055,7 +8458,7 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs11.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs14.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph) {
@@ -7070,7 +8473,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path14.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path17.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -7103,7 +8506,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path14.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path17.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
@@ -7115,16 +8518,16 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
 }
 async function stageApprovalBundle(paths, changedFiles, deletedPaths, previousGraph, graph) {
   const approvalId = `compile-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path14.join(paths.approvalsDir, approvalId);
+  const approvalDir = path17.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path14.join(approvalDir, "wiki"));
-  await ensureDir(path14.join(approvalDir, "state"));
+  await ensureDir(path17.join(approvalDir, "wiki"));
+  await ensureDir(path17.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path14.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path14.dirname(targetPath));
-    await fs11.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path17.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path17.dirname(targetPath));
+    await fs14.writeFile(targetPath, file.content, "utf8");
   }
-  await fs11.writeFile(path14.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs14.writeFile(path17.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7184,7 +8587,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path14.join(paths.wikiDir, preview.path),
+      path17.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -7229,7 +8632,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path14.join(paths.wikiDir, modulePreview.path),
+          path17.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -7262,8 +8665,8 @@ async function syncVaultArtifacts(rootDir, input) {
       const promoted = previousEntry?.status === "active" || promoteCandidates && shouldPromoteCandidate(previousEntry, sourceIds);
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const fallbackPaths = [
-        path14.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path14.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path17.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path17.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -7280,7 +8683,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path14.join(paths.wikiDir, relativePath),
+        path17.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -7361,7 +8764,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path14.join(paths.wikiDir, "projects", "index.md"),
+      path17.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -7385,7 +8788,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path14.join(paths.wikiDir, projectIndexRef.path),
+        path17.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -7413,7 +8816,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path14.join(paths.wikiDir, "index.md"),
+      path17.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -7444,7 +8847,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path14.join(paths.wikiDir, relativePath),
+        path17.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -7455,12 +8858,12 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const nextPagePaths = new Set(records.map((record) => record.page.path));
   const obsoleteGraphPaths = (previousGraph?.pages ?? []).filter((page) => page.kind !== "output" && page.kind !== "insight").map((page) => page.path).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path14.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path17.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
   const obsoletePaths = uniqueStrings2([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path14.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs11.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path17.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs14.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -7485,7 +8888,7 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs11.rm(path14.join(paths.wikiDir, relativePath), { force: true });
+    await fs14.rm(path17.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
   await writeJsonFile(paths.codeIndexPath, input.codeIndex);
@@ -7556,17 +8959,17 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path14.join(paths.wikiDir, "sources")),
-    ensureDir(path14.join(paths.wikiDir, "code")),
-    ensureDir(path14.join(paths.wikiDir, "concepts")),
-    ensureDir(path14.join(paths.wikiDir, "entities")),
-    ensureDir(path14.join(paths.wikiDir, "outputs")),
-    ensureDir(path14.join(paths.wikiDir, "graph")),
-    ensureDir(path14.join(paths.wikiDir, "graph", "communities")),
-    ensureDir(path14.join(paths.wikiDir, "projects")),
-    ensureDir(path14.join(paths.wikiDir, "candidates"))
+    ensureDir(path17.join(paths.wikiDir, "sources")),
+    ensureDir(path17.join(paths.wikiDir, "code")),
+    ensureDir(path17.join(paths.wikiDir, "concepts")),
+    ensureDir(path17.join(paths.wikiDir, "entities")),
+    ensureDir(path17.join(paths.wikiDir, "outputs")),
+    ensureDir(path17.join(paths.wikiDir, "graph")),
+    ensureDir(path17.join(paths.wikiDir, "graph", "communities")),
+    ensureDir(path17.join(paths.wikiDir, "projects")),
+    ensureDir(path17.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path14.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path17.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -7587,7 +8990,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       outputs: pages.filter((page) => page.kind === "output" && page.projectIds.includes(project.id)),
       candidates: pages.filter((page) => page.status === "candidate" && page.projectIds.includes(project.id))
     };
-    const absolutePath = path14.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path17.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -7605,7 +9008,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path14.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path17.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -7626,7 +9029,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ["candidates/index.md", "candidates", pagesWithGraph.filter((page) => page.status === "candidate")],
     ["graph/index.md", "graph", pagesWithGraph.filter((page) => page.kind === "graph_report" || page.kind === "community_summary")]
   ]) {
-    const absolutePath = path14.join(paths.wikiDir, relativePath);
+    const absolutePath = path17.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -7640,20 +9043,20 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     );
   }
   for (const record of graphOrientationRecords) {
-    await writeFileIfChanged(path14.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path17.join(paths.wikiDir, record.page.path), record.content);
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path14.relative(paths.wikiDir, absolutePath)));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path17.relative(paths.wikiDir, absolutePath)));
   const allowedProjectIndexPaths = /* @__PURE__ */ new Set([
     "projects/index.md",
     ...configuredProjects.map((project) => `projects/${project.id}/index.md`)
   ]);
   await Promise.all(
-    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs11.rm(path14.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs14.rm(path17.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingGraphPages = (await listFilesRecursive(path14.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path14.relative(paths.wikiDir, absolutePath)));
+  const existingGraphPages = (await listFilesRecursive(path17.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path17.relative(paths.wikiDir, absolutePath)));
   const allowedGraphPages = /* @__PURE__ */ new Set(["graph/index.md", ...graphOrientationRecords.map((record) => record.page.path)]);
   await Promise.all(
-    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs11.rm(path14.join(paths.wikiDir, relativePath), { force: true }))
+    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs14.rm(path17.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
@@ -7673,7 +9076,7 @@ async function prepareOutputPageSave(rootDir, input) {
       confidence: 0.74
     }
   });
-  const absolutePath = path14.join(paths.wikiDir, output.page.path);
+  const absolutePath = path17.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -7685,15 +9088,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path14.dirname(prepared.savedPath));
-  await fs11.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path17.dirname(prepared.savedPath));
+  await fs14.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path14.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path14.dirname(assetPath));
+    const assetPath = path17.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path17.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs11.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs14.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs11.writeFile(assetPath, assetFile.content);
+      await fs14.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -7714,7 +9117,7 @@ async function prepareExploreHubSave(rootDir, input) {
       confidence: 0.76
     }
   });
-  const absolutePath = path14.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path17.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -7726,15 +9129,15 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path14.dirname(prepared.savedPath));
-  await fs11.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path17.dirname(prepared.savedPath));
+  await fs14.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path14.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path14.dirname(assetPath));
+    const assetPath = path17.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path17.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs11.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs14.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs11.writeFile(assetPath, assetFile.content);
+      await fs14.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -7751,17 +9154,17 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     }))
   ]);
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path14.join(paths.approvalsDir, approvalId);
+  const approvalDir = path17.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path14.join(approvalDir, "wiki"));
-  await ensureDir(path14.join(approvalDir, "state"));
+  await ensureDir(path17.join(approvalDir, "wiki"));
+  await ensureDir(path17.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path14.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path14.dirname(targetPath));
+    const targetPath = path17.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path17.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs11.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs14.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs11.writeFile(targetPath, file.content, "utf8");
+      await fs14.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -7775,7 +9178,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs11.writeFile(path14.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs14.writeFile(path17.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7797,17 +9200,17 @@ async function executeQuery(rootDir, question, format) {
     await compileVault(rootDir, {});
   }
   const graph = await readJsonFile(paths.graphPath);
-  const pageMap = new Map((graph?.pages ?? []).map((page) => [page.id, page]));
+  const pageMap2 = new Map((graph?.pages ?? []).map((page) => [page.id, page]));
   const sourceProjects = Object.fromEntries(
     (graph?.pages ?? []).filter((page) => page.kind === "source" && page.sourceIds.length).map((page) => [page.sourceIds[0], page.projectIds[0] ?? null])
   );
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path14.join(paths.wikiDir, result.path);
+      const absolutePath = path17.join(paths.wikiDir, result.path);
       try {
-        const content = await fs11.readFile(absolutePath, "utf8");
-        const parsed = matter7(content);
+        const content = await fs14.readFile(absolutePath, "utf8");
+        const parsed = matter8(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
       } catch {
@@ -7821,14 +9224,14 @@ ${result.snippet}`;
     (item) => item
   );
   const relatedNodeIds = uniqueBy(
-    relatedPageIds.flatMap((pageId) => pageMap.get(pageId)?.nodeIds ?? []),
+    relatedPageIds.flatMap((pageId) => pageMap2.get(pageId)?.nodeIds ?? []),
     (item) => item
   );
   const relatedSourceIds = uniqueBy(
-    relatedPageIds.flatMap((pageId) => pageMap.get(pageId)?.sourceIds ?? []),
+    relatedPageIds.flatMap((pageId) => pageMap2.get(pageId)?.sourceIds ?? []),
     (item) => item
   );
-  const schemaProjectIds = schemaProjectIdsFromPages(relatedPageIds, pageMap);
+  const schemaProjectIds = schemaProjectIdsFromPages(relatedPageIds, pageMap2);
   const querySchema = composeVaultSchema(
     schemas.root,
     schemaProjectIds.map((projectId) => schemas.projects[projectId]).filter((schema) => Boolean(schema?.hash))
@@ -7915,7 +9318,7 @@ async function refreshVaultAfterOutputSave(rootDir) {
   const schemas = await loadVaultSchemas(rootDir);
   const manifests = await listManifests(rootDir);
   const sourceProjects = resolveSourceProjects(rootDir, manifests, config);
-  const cachedAnalyses = manifests.length ? await loadCachedAnalyses(paths, manifests) : [];
+  const cachedAnalyses = manifests.length ? await loadAvailableCachedAnalyses(paths, manifests) : [];
   const codeIndex = await buildCodeIndex(rootDir, manifests, cachedAnalyses);
   const analyses = cachedAnalyses.map((analysis) => {
     const manifest = manifests.find((item) => item.sourceId === analysis.sourceId);
@@ -7988,7 +9391,7 @@ function sortGraphPages(pages) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs11.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs14.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -8004,8 +9407,8 @@ async function readApproval(rootDir, approvalId) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs11.readFile(path14.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs11.readFile(path14.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs14.readFile(path17.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs14.readFile(path17.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       return {
         ...entry,
         currentContent,
@@ -8033,26 +9436,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path14.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs11.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path14.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path14.dirname(targetAbsolutePath));
-      await fs11.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path17.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs14.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path17.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path17.dirname(targetAbsolutePath));
+      await fs14.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs11.rm(path14.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs14.rm(path17.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       const nextPage = bundleGraph?.pages.find((page) => page.id === entry.pageId && page.path === entry.nextPath) ?? parseStoredPage(entry.nextPath, stagedContent);
       if (nextPage.kind === "output" && nextPage.outputAssets?.length) {
-        const outputAssetDir = path14.join(paths.wikiDir, "outputs", "assets", path14.basename(nextPage.path, ".md"));
-        await fs11.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path17.join(paths.wikiDir, "outputs", "assets", path17.basename(nextPage.path, ".md"));
+        await fs14.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path14.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path17.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path14.join(paths.wikiDir, asset.path);
-          await ensureDir(path14.dirname(targetAssetPath));
-          await fs11.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path17.join(paths.wikiDir, asset.path);
+          await ensureDir(path17.dirname(targetAssetPath));
+          await fs14.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -8063,10 +9466,10 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
     } else {
       const deletedPage = nextPages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? bundleGraph?.pages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? null;
       if (entry.previousPath) {
-        await fs11.rm(path14.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs14.rm(path17.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs11.rm(path14.join(paths.wikiDir, "outputs", "assets", path14.basename(deletedPage.path, ".md")), {
+        await fs14.rm(path17.join(paths.wikiDir, "outputs", "assets", path17.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -8156,10 +9559,10 @@ async function promoteCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  const raw = await fs11.readFile(path14.join(paths.wikiDir, candidate.path), "utf8");
-  const parsed = matter7(raw);
+  const raw = await fs14.readFile(path17.join(paths.wikiDir, candidate.path), "utf8");
+  const parsed = matter8(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const nextContent = matter7.stringify(parsed.content, {
+  const nextContent = matter8.stringify(parsed.content, {
     ...parsed.data,
     status: "active",
     updated_at: nextUpdatedAt,
@@ -8168,10 +9571,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path14.join(paths.wikiDir, nextPath);
-  await ensureDir(path14.dirname(nextAbsolutePath));
-  await fs11.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs11.rm(path14.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path17.join(paths.wikiDir, nextPath);
+  await ensureDir(path17.dirname(nextAbsolutePath));
+  await fs14.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs14.rm(path17.join(paths.wikiDir, candidate.path), { force: true });
   const nextPage = parseStoredPage(nextPath, nextContent, { createdAt: candidate.createdAt, updatedAt: nextUpdatedAt });
   const nextPages = sortGraphPages(
     (graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path).concat(nextPage)
@@ -8215,7 +9618,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs11.rm(path14.join(paths.wikiDir, candidate.path), { force: true });
+  await fs14.rm(path17.join(paths.wikiDir, candidate.path), { force: true });
   const nextPages = sortGraphPages((graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path));
   const nextGraph = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8253,18 +9656,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path14.join(rootDir, ".obsidian");
+  const obsidianDir = path17.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path14.join(obsidianDir, "app.json"), {
+    writeJsonFile(path17.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path14.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path17.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -8274,7 +9677,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path14.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path17.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -8286,7 +9689,7 @@ async function ensureObsidianWorkspace(rootDir) {
       })),
       localJumps: false
     }),
-    writeJsonFile(path14.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path17.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -8301,11 +9704,11 @@ async function ensureObsidianWorkspace(rootDir) {
 async function initVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path14.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path17.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
-    matter7.stringify(
+    matter8.stringify(
       [
         "# Insights",
         "",
@@ -8337,8 +9740,8 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path14.join(paths.wikiDir, "projects", "index.md"),
-    matter7.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
+    path17.join(paths.wikiDir, "projects", "index.md"),
+    matter8.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
       title: "Projects",
@@ -8359,8 +9762,8 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path14.join(paths.wikiDir, "candidates", "index.md"),
-    matter7.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
+    path17.join(paths.wikiDir, "candidates", "index.md"),
+    matter8.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
       title: "Candidates",
@@ -8476,7 +9879,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path14.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path17.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           return cached;
         }
@@ -8500,22 +9903,22 @@ async function compileVault(rootDir, options = {}) {
       }
       const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
       if (analysisSignature(enriched) !== analysisSignature(analysis)) {
-        await writeJsonFile(path14.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+        await writeJsonFile(path17.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
       }
       return enriched;
     })
   );
   await Promise.all([
-    ensureDir(path14.join(paths.wikiDir, "sources")),
-    ensureDir(path14.join(paths.wikiDir, "code")),
-    ensureDir(path14.join(paths.wikiDir, "concepts")),
-    ensureDir(path14.join(paths.wikiDir, "entities")),
-    ensureDir(path14.join(paths.wikiDir, "outputs")),
-    ensureDir(path14.join(paths.wikiDir, "projects")),
-    ensureDir(path14.join(paths.wikiDir, "insights")),
-    ensureDir(path14.join(paths.wikiDir, "candidates")),
-    ensureDir(path14.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path14.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path17.join(paths.wikiDir, "sources")),
+    ensureDir(path17.join(paths.wikiDir, "code")),
+    ensureDir(path17.join(paths.wikiDir, "concepts")),
+    ensureDir(path17.join(paths.wikiDir, "entities")),
+    ensureDir(path17.join(paths.wikiDir, "outputs")),
+    ensureDir(path17.join(paths.wikiDir, "projects")),
+    ensureDir(path17.join(paths.wikiDir, "insights")),
+    ensureDir(path17.join(paths.wikiDir, "candidates")),
+    ensureDir(path17.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path17.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
@@ -8657,7 +10060,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path14.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path17.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -8913,9 +10316,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path14.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path17.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path14.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path17.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -8982,6 +10385,50 @@ async function queryGraphVault(rootDir, question, options = {}) {
   const searchResults = searchPages(paths.searchDbPath, question, { limit: Math.max(5, options.budget ?? 10) });
   return queryGraph(graph, question, searchResults, options);
 }
+async function benchmarkVault(rootDir, options = {}) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const graph = await ensureCompiledGraph(rootDir);
+  const manifests = await listManifests(rootDir);
+  const pageContentsById = /* @__PURE__ */ new Map();
+  let corpusWords = 0;
+  for (const manifest of manifests) {
+    const extractedText = await readExtractedText(rootDir, manifest);
+    if (extractedText) {
+      corpusWords += estimateCorpusWords([extractedText]);
+    }
+  }
+  for (const page of graph.pages) {
+    const absolutePath = path17.join(paths.wikiDir, page.path);
+    if (!await fileExists(absolutePath)) {
+      continue;
+    }
+    const parsed = matter8(await fs14.readFile(absolutePath, "utf8"));
+    pageContentsById.set(page.id, parsed.content);
+  }
+  const questions = (options.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
+  const sampleQuestions = questions.length ? questions : [...DEFAULT_BENCHMARK_QUESTIONS];
+  const perQuestion = sampleQuestions.map((question) => {
+    const searchResults = searchPages(paths.searchDbPath, question, { limit: 12 });
+    const result = queryGraph(graph, question, searchResults, { budget: 12 });
+    const metrics = benchmarkQueryTokens(graph, result, pageContentsById);
+    return {
+      question,
+      queryTokens: metrics.queryTokens,
+      reduction: metrics.reduction,
+      visitedNodeIds: result.visitedNodeIds,
+      pageIds: result.pageIds
+    };
+  });
+  const artifact = buildBenchmarkArtifact({
+    graph,
+    corpusWords,
+    questions: sampleQuestions,
+    perQuestion
+  });
+  await writeJsonFile(paths.benchmarkPath, artifact);
+  await refreshIndexesAndSearch(rootDir, graph.pages);
+  return artifact;
+}
 async function pathGraphVault(rootDir, from, to) {
   const graph = await ensureCompiledGraph(rootDir);
   return shortestGraphPath(graph, from, to);
@@ -9001,15 +10448,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path14.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path17.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs11.readFile(absolutePath, "utf8");
-  const parsed = matter7(raw);
+  const raw = await fs14.readFile(absolutePath, "utf8");
+  const parsed = matter8(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path14.basename(relativePath, path14.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(relativePath, path17.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -9033,19 +10480,19 @@ async function getWorkspaceInfo(rootDir) {
 }
 function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sourceProjects) {
   const manifestMap = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
-  const pageMap = new Map(graph.pages.map((page) => [page.id, page]));
+  const pageMap2 = new Map(graph.pages.map((page) => [page.id, page]));
   return Promise.all(
     graph.pages.map(async (page) => {
       const findings = [];
       if (page.kind === "insight") {
         return findings;
       }
-      if (page.schemaHash !== expectedSchemaHashForPage(page, schemas, pageMap, sourceProjects)) {
+      if (page.schemaHash !== expectedSchemaHashForPage(page, schemas, pageMap2, sourceProjects)) {
         findings.push({
           severity: "warning",
           code: "stale_page",
           message: `Page ${page.title} is stale because the vault schema changed.`,
-          pagePath: path14.join(paths.wikiDir, page.path),
+          pagePath: path17.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -9056,7 +10503,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
             severity: "warning",
             code: "stale_page",
             message: `Page ${page.title} is stale because source ${sourceId} changed.`,
-            pagePath: path14.join(paths.wikiDir, page.path),
+            pagePath: path17.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -9067,13 +10514,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path14.join(paths.wikiDir, page.path),
+          pagePath: path17.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path14.join(paths.wikiDir, page.path);
+      const absolutePath = path17.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs11.readFile(absolutePath, "utf8");
+        const content = await fs14.readFile(absolutePath, "utf8");
         if (content.includes("## Claims")) {
           const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
           if (uncited.length) {
@@ -9153,7 +10600,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.19";
+var SERVER_VERSION = "0.1.21";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -9402,7 +10849,7 @@ async function createMcpServer(rootDir) {
     },
     async () => {
       const { paths } = await loadVaultConfig(rootDir);
-      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path15.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path18.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -9435,8 +10882,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path15.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs12.readFile(absolutePath, "utf8"));
+      const absolutePath = path18.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs15.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -9444,11 +10891,11 @@ async function createMcpServer(rootDir) {
     new ResourceTemplate("swarmvault://sessions/{path}", {
       list: async () => {
         const { paths } = await loadVaultConfig(rootDir);
-        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path15.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path18.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path15.basename(relativePath, ".md"),
+            name: path18.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -9465,11 +10912,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path15.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path18.resolve(paths.sessionsDir, relativePath);
       if (!absolutePath.startsWith(paths.sessionsDir) || !await fileExists(absolutePath)) {
         return asTextResource(`swarmvault://sessions/${encodedPath}`, `Session not found: ${relativePath}`);
       }
-      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs12.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs15.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -9517,13 +10964,13 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs13 from "fs/promises";
-import path16 from "path";
+import fs16 from "fs/promises";
+import path19 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path16.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path19.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path16.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path19.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -9626,13 +11073,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs13.open(leasePath, "wx");
+  const handle = await fs16.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs13.rm(leasePath, { force: true });
+    await fs16.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -9780,24 +11227,415 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/viewer.ts
 import { execFile } from "child_process";
-import fs14 from "fs/promises";
+import fs17 from "fs/promises";
 import http from "http";
-import path17 from "path";
+import path21 from "path";
 import { promisify } from "util";
-import matter8 from "gray-matter";
+import matter9 from "gray-matter";
 import mime2 from "mime-types";
+
+// src/watch.ts
+import path20 from "path";
+import process2 from "process";
+import chokidar from "chokidar";
+var MAX_BACKOFF_MS = 3e4;
+var BACKOFF_THRESHOLD = 3;
+var CRITICAL_THRESHOLD = 10;
+var REPO_WATCH_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
+function withinRoot2(rootPath, targetPath) {
+  const relative = path20.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path20.isAbsolute(relative);
+}
+function hasIgnoredRepoSegment(baseDir, targetPath) {
+  const relativePath = path20.relative(baseDir, targetPath);
+  if (!relativePath || relativePath.startsWith("..")) {
+    return false;
+  }
+  return relativePath.split(path20.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+}
+function workspaceIgnoreRoots(rootDir, paths) {
+  return [
+    paths.rawDir,
+    paths.wikiDir,
+    paths.stateDir,
+    paths.agentDir,
+    paths.inboxDir,
+    path20.join(rootDir, ".claude"),
+    path20.join(rootDir, ".cursor"),
+    path20.join(rootDir, ".obsidian")
+  ].map((candidate) => path20.resolve(candidate));
+}
+async function resolveWatchTargets(rootDir, paths, options) {
+  const targets = /* @__PURE__ */ new Set([path20.resolve(paths.inboxDir)]);
+  if (options.repo) {
+    for (const repoRoot of await listTrackedRepoRoots(rootDir)) {
+      targets.add(path20.resolve(repoRoot));
+    }
+  }
+  return [...targets].sort((left, right) => left.localeCompare(right));
+}
+async function performWatchCycle(rootDir, paths, options) {
+  const imported = await importInbox(rootDir, paths.inboxDir);
+  const repoSync = options.repo ? await syncTrackedReposForWatch(rootDir) : null;
+  const compile = await compileVault(rootDir);
+  const pendingSemanticRefresh = repoSync ? await mergePendingSemanticRefresh(rootDir, repoSync.pendingSemanticRefresh) : await readPendingSemanticRefresh(rootDir);
+  const stalePagePaths = await markPagesStaleForSources(
+    rootDir,
+    pendingSemanticRefresh.map((entry) => entry.sourceId).filter((sourceId) => Boolean(sourceId))
+  );
+  const lintFindingCount = options.lint ? (await lintVault(rootDir)).length : void 0;
+  return {
+    watchedRepoRoots: repoSync?.repoRoots ?? [],
+    importedCount: imported.imported.length,
+    scannedCount: imported.scannedCount,
+    attachmentCount: imported.attachmentCount,
+    repoImportedCount: repoSync?.imported.length ?? 0,
+    repoUpdatedCount: repoSync?.updated.length ?? 0,
+    repoRemovedCount: repoSync?.removed.length ?? 0,
+    repoScannedCount: repoSync?.scannedCount ?? 0,
+    pendingSemanticRefreshCount: pendingSemanticRefresh.length,
+    pendingSemanticRefreshPaths: pendingSemanticRefresh.map((entry) => entry.path),
+    changedPages: [.../* @__PURE__ */ new Set([...compile.changedPages, ...stalePagePaths])],
+    lintFindingCount
+  };
+}
+async function runWatchCycle(rootDir, options = {}) {
+  const { paths } = await initWorkspace(rootDir);
+  const startedAt = /* @__PURE__ */ new Date();
+  let success = true;
+  let error;
+  let result = {
+    watchedRepoRoots: [],
+    importedCount: 0,
+    scannedCount: 0,
+    attachmentCount: 0,
+    repoImportedCount: 0,
+    repoUpdatedCount: 0,
+    repoRemovedCount: 0,
+    repoScannedCount: 0,
+    pendingSemanticRefreshCount: 0,
+    pendingSemanticRefreshPaths: [],
+    changedPages: []
+  };
+  try {
+    result = await performWatchCycle(rootDir, paths, options);
+    return result;
+  } catch (caught) {
+    success = false;
+    error = caught instanceof Error ? caught.message : String(caught);
+    throw caught;
+  } finally {
+    const finishedAt = /* @__PURE__ */ new Date();
+    await recordSession(rootDir, {
+      operation: "watch",
+      title: `Watch cycle for ${paths.inboxDir}${options.repo ? " and tracked repos" : ""}`,
+      startedAt: startedAt.toISOString(),
+      finishedAt: finishedAt.toISOString(),
+      success,
+      error,
+      changedPages: result.changedPages,
+      lintFindingCount: result.lintFindingCount,
+      lines: [
+        "reasons=once",
+        `imported=${result.importedCount}`,
+        `scanned=${result.scannedCount}`,
+        `attachments=${result.attachmentCount}`,
+        `repo_scanned=${result.repoScannedCount}`,
+        `repo_imported=${result.repoImportedCount}`,
+        `repo_updated=${result.repoUpdatedCount}`,
+        `repo_removed=${result.repoRemovedCount}`,
+        `pending_semantic_refresh=${result.pendingSemanticRefreshCount}`,
+        `lint=${result.lintFindingCount ?? 0}`
+      ]
+    });
+    await appendWatchRun(rootDir, {
+      startedAt: startedAt.toISOString(),
+      finishedAt: finishedAt.toISOString(),
+      durationMs: finishedAt.getTime() - startedAt.getTime(),
+      inputDir: paths.inboxDir,
+      reasons: ["once"],
+      importedCount: result.importedCount + result.repoImportedCount + result.repoUpdatedCount,
+      scannedCount: result.scannedCount + result.repoScannedCount,
+      attachmentCount: result.attachmentCount,
+      changedPages: result.changedPages,
+      repoImportedCount: result.repoImportedCount,
+      repoUpdatedCount: result.repoUpdatedCount,
+      repoRemovedCount: result.repoRemovedCount,
+      repoScannedCount: result.repoScannedCount,
+      pendingSemanticRefreshCount: result.pendingSemanticRefreshCount,
+      pendingSemanticRefreshPaths: result.pendingSemanticRefreshPaths,
+      lintFindingCount: result.lintFindingCount,
+      success,
+      error
+    });
+    await writeWatchStatusArtifact(rootDir, {
+      generatedAt: finishedAt.toISOString(),
+      watchedRepoRoots: result.watchedRepoRoots,
+      lastRun: {
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: finishedAt.getTime() - startedAt.getTime(),
+        inputDir: paths.inboxDir,
+        reasons: ["once"],
+        importedCount: result.importedCount + result.repoImportedCount + result.repoUpdatedCount,
+        scannedCount: result.scannedCount + result.repoScannedCount,
+        attachmentCount: result.attachmentCount,
+        changedPages: result.changedPages,
+        repoImportedCount: result.repoImportedCount,
+        repoUpdatedCount: result.repoUpdatedCount,
+        repoRemovedCount: result.repoRemovedCount,
+        repoScannedCount: result.repoScannedCount,
+        pendingSemanticRefreshCount: result.pendingSemanticRefreshCount,
+        pendingSemanticRefreshPaths: result.pendingSemanticRefreshPaths,
+        lintFindingCount: result.lintFindingCount,
+        success,
+        error
+      },
+      pendingSemanticRefresh: await readPendingSemanticRefresh(rootDir)
+    });
+  }
+}
+async function watchVault(rootDir, options = {}) {
+  const { paths } = await initWorkspace(rootDir);
+  const baseDebounceMs = options.debounceMs ?? 900;
+  const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
+  const inboxWatchRoot = path20.resolve(paths.inboxDir);
+  let watchTargets = await resolveWatchTargets(rootDir, paths, options);
+  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(watchTargets, {
+    ignoreInitial: true,
+    usePolling: true,
+    interval: 100,
+    ignored: (targetPath) => {
+      const absolutePath = path20.resolve(targetPath);
+      const primaryTarget = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
+      if (!primaryTarget) {
+        return false;
+      }
+      if (primaryTarget !== inboxWatchRoot && ignoredRoots.some((ignoreRoot) => withinRoot2(ignoreRoot, absolutePath))) {
+        return true;
+      }
+      return hasIgnoredRepoSegment(primaryTarget, absolutePath);
+    },
+    awaitWriteFinish: {
+      stabilityThreshold: Math.max(250, Math.floor(baseDebounceMs / 2)),
+      pollInterval: 100
+    }
+  });
+  const syncWatchTargets = async () => {
+    const nextTargets = await resolveWatchTargets(rootDir, paths, options);
+    const nextSet = new Set(nextTargets);
+    const currentSet = new Set(watchTargets);
+    const toRemove = watchTargets.filter((target) => !nextSet.has(target));
+    const toAdd = nextTargets.filter((target) => !currentSet.has(target));
+    if (toRemove.length > 0) {
+      await watcher.unwatch(toRemove);
+    }
+    if (toAdd.length > 0) {
+      await watcher.add(toAdd);
+    }
+    watchTargets = nextTargets;
+  };
+  const schedule = (reason) => {
+    if (closed) {
+      return;
+    }
+    reasons.add(reason);
+    pending = true;
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      void runCycle();
+    }, currentDebounceMs);
+  };
+  const runCycle = async () => {
+    if (running || closed || !pending) {
+      return;
+    }
+    pending = false;
+    running = true;
+    const startedAt = /* @__PURE__ */ new Date();
+    const runReasons = [...reasons];
+    reasons.clear();
+    let importedCount = 0;
+    let scannedCount = 0;
+    let attachmentCount = 0;
+    let repoImportedCount = 0;
+    let repoUpdatedCount = 0;
+    let repoRemovedCount = 0;
+    let repoScannedCount = 0;
+    let watchedRepoRoots = [];
+    let pendingSemanticRefreshCount = 0;
+    let pendingSemanticRefreshPaths = [];
+    let changedPages = [];
+    let lintFindingCount;
+    let success = true;
+    let error;
+    try {
+      const result = await performWatchCycle(rootDir, paths, options);
+      importedCount = result.importedCount;
+      scannedCount = result.scannedCount;
+      attachmentCount = result.attachmentCount;
+      repoImportedCount = result.repoImportedCount;
+      repoUpdatedCount = result.repoUpdatedCount;
+      repoRemovedCount = result.repoRemovedCount;
+      repoScannedCount = result.repoScannedCount;
+      watchedRepoRoots = result.watchedRepoRoots;
+      pendingSemanticRefreshCount = result.pendingSemanticRefreshCount;
+      pendingSemanticRefreshPaths = result.pendingSemanticRefreshPaths;
+      changedPages = result.changedPages;
+      lintFindingCount = result.lintFindingCount;
+      consecutiveFailures = 0;
+      currentDebounceMs = baseDebounceMs;
+      await syncWatchTargets();
+    } 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 recordSession(rootDir, {
+        operation: "watch",
+        title: `Watch cycle for ${paths.inboxDir}${options.repo ? " and tracked repos" : ""}`,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        success,
+        error,
+        changedPages,
+        lintFindingCount,
+        lines: [
+          `reasons=${runReasons.join(",") || "none"}`,
+          `imported=${importedCount}`,
+          `scanned=${scannedCount}`,
+          `attachments=${attachmentCount}`,
+          `repo_scanned=${repoScannedCount}`,
+          `repo_imported=${repoImportedCount}`,
+          `repo_updated=${repoUpdatedCount}`,
+          `repo_removed=${repoRemovedCount}`,
+          `lint=${lintFindingCount ?? 0}`
+        ]
+      });
+      await appendWatchRun(rootDir, {
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: finishedAt.getTime() - startedAt.getTime(),
+        inputDir: paths.inboxDir,
+        reasons: runReasons,
+        importedCount: importedCount + repoImportedCount + repoUpdatedCount,
+        scannedCount: scannedCount + repoScannedCount,
+        attachmentCount,
+        changedPages,
+        repoImportedCount,
+        repoUpdatedCount,
+        repoRemovedCount,
+        repoScannedCount,
+        pendingSemanticRefreshCount,
+        pendingSemanticRefreshPaths,
+        lintFindingCount,
+        success,
+        error
+      });
+      await writeWatchStatusArtifact(rootDir, {
+        generatedAt: finishedAt.toISOString(),
+        watchedRepoRoots,
+        lastRun: {
+          startedAt: startedAt.toISOString(),
+          finishedAt: finishedAt.toISOString(),
+          durationMs: finishedAt.getTime() - startedAt.getTime(),
+          inputDir: paths.inboxDir,
+          reasons: runReasons,
+          importedCount: importedCount + repoImportedCount + repoUpdatedCount,
+          scannedCount: scannedCount + repoScannedCount,
+          attachmentCount,
+          changedPages,
+          repoImportedCount,
+          repoUpdatedCount,
+          repoRemovedCount,
+          repoScannedCount,
+          pendingSemanticRefreshCount,
+          pendingSemanticRefreshPaths,
+          lintFindingCount,
+          success,
+          error
+        },
+        pendingSemanticRefresh: await readPendingSemanticRefresh(rootDir)
+      });
+      running = false;
+      if (pending && !closed) {
+        schedule("queued");
+      }
+    }
+  };
+  const reasonForPath = (targetPath) => {
+    const baseDir = watchTargets.filter((watchTarget) => withinRoot2(watchTarget, path20.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path20.relative(baseDir, targetPath) || ".";
+  };
+  watcher.on("add", (filePath) => schedule(`add:${reasonForPath(filePath)}`)).on("change", (filePath) => schedule(`change:${reasonForPath(filePath)}`)).on("unlink", (filePath) => schedule(`unlink:${reasonForPath(filePath)}`)).on("addDir", (dirPath) => schedule(`addDir:${reasonForPath(dirPath)}`)).on("unlinkDir", (dirPath) => schedule(`unlinkDir:${reasonForPath(dirPath)}`)).on("error", (caught) => schedule(`error:${caught instanceof Error ? caught.message : String(caught)}`));
+  await new Promise((resolve, reject) => {
+    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;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      await watcher.close();
+    }
+  };
+}
+async function getWatchStatus(rootDir) {
+  const persisted = await readWatchStatusArtifact(rootDir);
+  const watchedRepoRoots = await listTrackedRepoRoots(rootDir);
+  const pendingSemanticRefresh = await readPendingSemanticRefresh(rootDir);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    watchedRepoRoots,
+    lastRun: persisted?.lastRun,
+    pendingSemanticRefresh
+  };
+}
+
+// src/viewer.ts
 var execFileAsync = promisify(execFile);
 async function readViewerPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path17.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path21.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs14.readFile(absolutePath, "utf8");
-  const parsed = matter8(raw);
+  const raw = await fs17.readFile(absolutePath, "utf8");
+  const parsed = matter9(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(relativePath, path17.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path21.basename(relativePath, path21.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -9805,12 +11643,12 @@ async function readViewerPage(rootDir, relativePath) {
 }
 async function readViewerAsset(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path17.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path21.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs14.readFile(absolutePath),
+    buffer: await fs17.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -9833,12 +11671,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path17.join(viewerDistDir, "index.html");
+  const indexPath = path21.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path17.dirname(viewerDistDir);
-  if (await fileExists(path17.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path21.dirname(viewerDistDir);
+  if (await fileExists(path21.join(viewerProjectDir, "package.json"))) {
     await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -9855,7 +11693,7 @@ async function startGraphServer(rootDir, port) {
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs14.readFile(paths.graphPath, "utf8"));
+      response.end(await fs17.readFile(paths.graphPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/graph/query") {
@@ -9907,6 +11745,11 @@ async function startGraphServer(rootDir, port) {
       response.end(JSON.stringify(results));
       return;
     }
+    if (url.pathname === "/api/watch-status") {
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify(await getWatchStatus(rootDir)));
+      return;
+    }
     if (url.pathname === "/api/page") {
       const relativePath2 = url.searchParams.get("path") ?? "";
       const page = await readViewerPage(rootDir, relativePath2);
@@ -9982,8 +11825,8 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path17.join(paths.viewerDistDir, relativePath);
-    const fallback = path17.join(paths.viewerDistDir, "index.html");
+    const target = path21.join(paths.viewerDistDir, relativePath);
+    const fallback = path21.join(paths.viewerDistDir, "index.html");
     const filePath = await fileExists(target) ? target : fallback;
     if (!await fileExists(filePath)) {
       response.writeHead(503, { "content-type": "text/plain" });
@@ -9991,7 +11834,7 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs14.readFile(filePath));
+    response.end(await fs17.readFile(filePath));
   });
   await new Promise((resolve) => {
     server.listen(effectivePort, resolve);
@@ -10018,7 +11861,7 @@ async function exportGraphHtml(rootDir, outputPath) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path17.join(paths.viewerDistDir, "index.html");
+  const indexPath = path21.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -10042,16 +11885,16 @@ async function exportGraphHtml(rootDir, outputPath) {
       } : null;
     })
   );
-  const rawHtml = await fs14.readFile(indexPath, "utf8");
+  const rawHtml = await fs17.readFile(indexPath, "utf8");
   const scriptMatch = rawHtml.match(/<script type="module" crossorigin src="([^"]+)"><\/script>/);
   const styleMatch = rawHtml.match(/<link rel="stylesheet" crossorigin href="([^"]+)">/);
-  const scriptPath = scriptMatch?.[1] ? path17.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path17.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path21.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path21.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
   if (!scriptPath || !await fileExists(scriptPath)) {
     throw new Error("Viewer script bundle not found. Run `pnpm build` first.");
   }
-  const script = await fs14.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs14.readFile(stylePath, "utf8") : "";
+  const script = await fs17.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs17.readFile(stylePath, "utf8") : "";
   const embeddedData = JSON.stringify({ graph, pages: pages.filter(Boolean) }, null, 2).replace(/</g, "\\u003c");
   const html = [
     "<!doctype html>",
@@ -10070,163 +11913,16 @@ async function exportGraphHtml(rootDir, outputPath) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs14.mkdir(path17.dirname(outputPath), { recursive: true });
-  await fs14.writeFile(outputPath, html, "utf8");
-  return path17.resolve(outputPath);
-}
-
-// src/watch.ts
-import path18 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 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,
-    usePolling: true,
-    interval: 100,
-    awaitWriteFinish: {
-      stabilityThreshold: Math.max(250, Math.floor(baseDebounceMs / 2)),
-      pollInterval: 100
-    }
-  });
-  const schedule = (reason) => {
-    if (closed) {
-      return;
-    }
-    reasons.add(reason);
-    pending = true;
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      void runCycle();
-    }, currentDebounceMs);
-  };
-  const runCycle = async () => {
-    if (running || closed || !pending) {
-      return;
-    }
-    pending = false;
-    running = true;
-    const startedAt = /* @__PURE__ */ new Date();
-    const runReasons = [...reasons];
-    reasons.clear();
-    let importedCount = 0;
-    let scannedCount = 0;
-    let attachmentCount = 0;
-    let changedPages = [];
-    let lintFindingCount;
-    let success = true;
-    let error;
-    try {
-      const imported = await importInbox(rootDir, paths.inboxDir);
-      importedCount = imported.imported.length;
-      scannedCount = imported.scannedCount;
-      attachmentCount = imported.attachmentCount;
-      const compile = await compileVault(rootDir);
-      changedPages = compile.changedPages;
-      if (options.lint) {
-        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 recordSession(rootDir, {
-        operation: "watch",
-        title: `Watch cycle for ${paths.inboxDir}`,
-        startedAt: startedAt.toISOString(),
-        finishedAt: finishedAt.toISOString(),
-        success,
-        error,
-        changedPages,
-        lintFindingCount,
-        lines: [
-          `reasons=${runReasons.join(",") || "none"}`,
-          `imported=${importedCount}`,
-          `scanned=${scannedCount}`,
-          `attachments=${attachmentCount}`,
-          `lint=${lintFindingCount ?? 0}`
-        ]
-      });
-      await appendWatchRun(rootDir, {
-        startedAt: startedAt.toISOString(),
-        finishedAt: finishedAt.toISOString(),
-        durationMs: finishedAt.getTime() - startedAt.getTime(),
-        inputDir: paths.inboxDir,
-        reasons: runReasons,
-        importedCount,
-        scannedCount,
-        attachmentCount,
-        changedPages,
-        lintFindingCount,
-        success,
-        error
-      });
-      running = false;
-      if (pending && !closed) {
-        schedule("queued");
-      }
-    }
-  };
-  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;
-      if (timer) {
-        clearTimeout(timer);
-      }
-      await watcher.close();
-    }
-  };
-}
-function toWatchReason(baseDir, targetPath) {
-  return path18.relative(baseDir, targetPath) || ".";
+  await fs17.mkdir(path21.dirname(outputPath), { recursive: true });
+  await fs17.writeFile(outputPath, html, "utf8");
+  return path21.resolve(outputPath);
 }
 export {
   acceptApproval,
+  addInput,
   archiveCandidate,
   assertProviderCapability,
+  benchmarkVault,
   bootstrapDemo,
   compileVault,
   createMcpServer,
@@ -10236,8 +11932,11 @@ export {
   defaultVaultSchema,
   explainGraphVault,
   exploreVault,
+  exportGraphFormat,
   exportGraphHtml,
+  getGitHookStatus,
   getProviderForTask,
+  getWatchStatus,
   getWebSearchAdapterForTask,
   getWorkspaceInfo,
   importInbox,
@@ -10247,6 +11946,7 @@ export {
   initWorkspace,
   installAgent,
   installConfiguredAgents,
+  installGitHooks,
   lintVault,
   listApprovals,
   listCandidates,
@@ -10254,6 +11954,7 @@ export {
   listManifests,
   listPages,
   listSchedules,
+  listTrackedRepoRoots,
   loadVaultConfig,
   loadVaultSchema,
   loadVaultSchemas,
@@ -10267,9 +11968,13 @@ export {
   rejectApproval,
   resolvePaths,
   runSchedule,
+  runWatchCycle,
   searchVault,
   serveSchedules,
   startGraphServer,
   startMcpServer,
+  syncTrackedRepos,
+  syncTrackedReposForWatch,
+  uninstallGitHooks,
   watchVault
 };