npm - @swarmvaultai/engine - Versions diffs - 0.7.23 → 0.7.25 - Mend

@swarmvaultai/engine 0.7.23 → 0.7.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/chunk-MB7HPUTR.js +1364 -0
package/dist/chunk-NAIERP4C.js +65 -0
package/dist/hooks/claude.js +0 -0
package/dist/hooks/copilot.js +0 -0
package/dist/hooks/gemini.js +0 -0
package/dist/index.d.ts +80 -4
package/dist/index.js +662 -20
package/dist/registry-UA42LQUQ.js +12 -0
package/dist/token-estimation-TTONKT4O.js +10 -0
package/package.json +9 -8
package/LICENSE +0 -21

package/dist/index.js CHANGED Viewed

@@ -22,7 +22,12 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-2CH2WWS4.js";
+} from "./chunk-MB7HPUTR.js";
+import {
+  estimatePageTokens,
+  estimateTokens,
+  trimToTokenBudget
+} from "./chunk-NAIERP4C.js";
 // src/agents.ts
 import crypto from "crypto";
@@ -450,6 +455,43 @@ async function installConfiguredAgents(rootDir) {
   );
 }
+// src/auto-commit.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function git(rootDir, ...args) {
+  const { stdout } = await execFileAsync("git", args, { cwd: rootDir });
+  return stdout.trim();
+}
+async function isGitRepo(rootDir) {
+  try {
+    await git(rootDir, "rev-parse", "--is-inside-work-tree");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function autoCommitWikiChanges(rootDir, operation, detail, options) {
+  const { config, paths } = await loadVaultConfig(rootDir);
+  if (!options?.force && !config.autoCommit) {
+    return null;
+  }
+  if (!await isGitRepo(rootDir)) {
+    return null;
+  }
+  const wikiRelative = paths.wikiDir.replace(`${rootDir}/`, "");
+  const stateRelative = paths.stateDir.replace(`${rootDir}/`, "");
+  await git(rootDir, "add", wikiRelative, stateRelative).catch(() => {
+  });
+  const status = await git(rootDir, "diff", "--cached", "--stat");
+  if (!status) {
+    return null;
+  }
+  const message = detail ? `vault ${operation}: ${detail}` : `vault ${operation}`;
+  await git(rootDir, "commit", "-m", message);
+  return message;
+}
 // src/graph-export.ts
 import fs2 from "fs/promises";
 import path2 from "path";
@@ -587,6 +629,316 @@ function graphCounts(graph) {
   };
 }
+// src/graph-report-html.ts
+function htmlEscape(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function nodeTypeColor(type) {
+  const colors = {
+    source: "#f59e0b",
+    module: "#fb7185",
+    symbol: "#8b5cf6",
+    rationale: "#14b8a6",
+    concept: "#0ea5e9",
+    entity: "#22c55e"
+  };
+  return colors[type] ?? "#94a3b8";
+}
+function renderGraphReportHtml(graph, report) {
+  const nodesByType = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    nodesByType.set(node.type, (nodesByType.get(node.type) ?? 0) + 1);
+  }
+  const edgesByRelation = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    edgesByRelation.set(edge.relation, (edgesByRelation.get(edge.relation) ?? 0) + 1);
+  }
+  const pagesByKind = /* @__PURE__ */ new Map();
+  for (const page of graph.pages) {
+    const list = pagesByKind.get(page.kind) ?? [];
+    list.push(page);
+    pagesByKind.set(page.kind, list);
+  }
+  const godNodes = (report?.godNodes ?? []).slice(0, 15);
+  const bridgeNodes = (report?.bridgeNodes ?? []).slice(0, 10);
+  const communities = graph.communities ?? [];
+  const warnings = report?.warnings ?? [];
+  const overview = report?.overview ?? {
+    nodes: graph.nodes.length,
+    edges: graph.edges.length,
+    pages: graph.pages.length,
+    communities: communities.length
+  };
+  const sortedEdgeRelations = [...edgesByRelation.entries()].sort((a, b) => b[1] - a[1]);
+  const sortedNodeTypes = [...nodesByType.entries()].sort((a, b) => b[1] - a[1]);
+  const sortedCommunities2 = [...communities].sort((a, b) => b.nodeIds.length - a.nodeIds.length).slice(0, 20);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>SwarmVault Graph Report</title>
+<style>
+:root {
+  --bg: #0f172a;
+  --surface: #1e293b;
+  --surface2: #334155;
+  --text: #e2e8f0;
+  --muted: #94a3b8;
+  --accent: #0ea5e9;
+  --accent2: #8b5cf6;
+  --border: #475569;
+  --success: #22c55e;
+  --warning: #f59e0b;
+  --danger: #ef4444;
+}
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.6;
+  padding: 2rem;
+  max-width: 1200px;
+  margin: 0 auto;
+}
+h1 {
+  font-size: 1.75rem;
+  background: linear-gradient(135deg, var(--accent), var(--accent2));
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  margin-bottom: 0.25rem;
+}
+.subtitle { color: var(--muted); font-size: 0.85rem; margin-bottom: 2rem; }
+h2 {
+  font-size: 1.15rem;
+  color: var(--text);
+  border-bottom: 1px solid var(--border);
+  padding-bottom: 0.5rem;
+  margin: 2rem 0 1rem;
+}
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  gap: 1rem;
+  margin-bottom: 1.5rem;
+}
+.stat-card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 1rem;
+  text-align: center;
+}
+.stat-card .value {
+  font-size: 1.75rem;
+  font-weight: 700;
+  color: var(--accent);
+}
+.stat-card .label {
+  font-size: 0.8rem;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+.badge {
+  display: inline-block;
+  padding: 0.15rem 0.5rem;
+  border-radius: 9999px;
+  font-size: 0.7rem;
+  font-weight: 600;
+  color: #fff;
+}
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-bottom: 1rem;
+}
+th, td {
+  text-align: left;
+  padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid var(--border);
+  font-size: 0.85rem;
+}
+th {
+  color: var(--muted);
+  font-weight: 600;
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+tr:hover { background: var(--surface); }
+.bar-container {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+.bar {
+  height: 8px;
+  border-radius: 4px;
+  background: var(--accent);
+  min-width: 2px;
+}
+.warning-list {
+  list-style: none;
+  padding: 0;
+}
+.warning-list li {
+  padding: 0.5rem 0.75rem;
+  margin-bottom: 0.5rem;
+  background: var(--surface);
+  border-left: 3px solid var(--warning);
+  border-radius: 0 4px 4px 0;
+  font-size: 0.85rem;
+}
+.page-group { margin-bottom: 1.5rem; }
+.page-group-title {
+  font-size: 0.85rem;
+  font-weight: 600;
+  color: var(--accent);
+  text-transform: capitalize;
+  margin-bottom: 0.5rem;
+}
+.page-list {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  gap: 0.5rem;
+}
+.page-item {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 0.5rem 0.75rem;
+  font-size: 0.8rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.page-item .path { color: var(--muted); font-size: 0.7rem; }
+.empty { color: var(--muted); font-style: italic; font-size: 0.85rem; }
+input[type="text"] {
+  width: 100%;
+  padding: 0.5rem 0.75rem;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  color: var(--text);
+  font-size: 0.85rem;
+  margin-bottom: 1rem;
+  outline: none;
+}
+input[type="text"]:focus { border-color: var(--accent); }
+.section { margin-bottom: 1rem; }
+footer { margin-top: 3rem; padding-top: 1rem; border-top: 1px solid var(--border); color: var(--muted); font-size: 0.75rem; text-align: center; }
+</style>
+</head>
+<body>
+<h1>SwarmVault Graph Report</h1>
+<p class="subtitle">Generated ${htmlEscape(report?.generatedAt ?? graph.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString())}</p>
+<div class="stats-grid">
+  <div class="stat-card"><div class="value">${overview.nodes}</div><div class="label">Nodes</div></div>
+  <div class="stat-card"><div class="value">${overview.edges}</div><div class="label">Edges</div></div>
+  <div class="stat-card"><div class="value">${overview.pages}</div><div class="label">Pages</div></div>
+  <div class="stat-card"><div class="value">${overview.communities}</div><div class="label">Communities</div></div>
+  <div class="stat-card"><div class="value">${graph.sources.length}</div><div class="label">Sources</div></div>
+  <div class="stat-card"><div class="value">${(graph.hyperedges ?? []).length}</div><div class="label">Hyperedges</div></div>
+</div>
+<h2>Node Types</h2>
+<table>
+<thead><tr><th>Type</th><th>Count</th><th></th></tr></thead>
+<tbody>
+${sortedNodeTypes.map(([type, count]) => {
+    const maxCount = sortedNodeTypes[0]?.[1] ?? 1;
+    const pct = Math.round(count / maxCount * 100);
+    return `<tr><td><span class="badge" style="background:${nodeTypeColor(type)}">${htmlEscape(type)}</span></td><td>${count}</td><td><div class="bar-container"><div class="bar" style="width:${pct}%;background:${nodeTypeColor(type)}"></div></div></td></tr>`;
+  }).join("\n")}
+</tbody>
+</table>
+<h2>Edge Relations</h2>
+<table>
+<thead><tr><th>Relation</th><th>Count</th><th></th></tr></thead>
+<tbody>
+${sortedEdgeRelations.map(([relation, count]) => {
+    const maxCount = sortedEdgeRelations[0]?.[1] ?? 1;
+    const pct = Math.round(count / maxCount * 100);
+    return `<tr><td>${htmlEscape(relation)}</td><td>${count}</td><td><div class="bar-container"><div class="bar" style="width:${pct}%"></div></div></td></tr>`;
+  }).join("\n")}
+</tbody>
+</table>
+${godNodes.length ? `<h2>God Nodes (Highest Connectivity)</h2>
+<table>
+<thead><tr><th>Label</th><th>Degree</th><th>Bridge Score</th><th></th></tr></thead>
+<tbody>
+${godNodes.map((node) => {
+    const maxDegree = godNodes[0]?.degree ?? 1;
+    const pct = Math.round((node.degree ?? 0) / maxDegree * 100);
+    return `<tr><td>${htmlEscape(node.label)}</td><td>${node.degree ?? 0}</td><td>${(node.bridgeScore ?? 0).toFixed(2)}</td><td><div class="bar-container"><div class="bar" style="width:${pct}%;background:var(--accent2)"></div></div></td></tr>`;
+  }).join("\n")}
+</tbody>
+</table>` : ""}
+${bridgeNodes.length ? `<h2>Bridge Nodes</h2>
+<table>
+<thead><tr><th>Label</th><th>Degree</th><th>Bridge Score</th></tr></thead>
+<tbody>
+${bridgeNodes.map((node) => `<tr><td>${htmlEscape(node.label)}</td><td>${node.degree ?? 0}</td><td>${(node.bridgeScore ?? 0).toFixed(2)}</td></tr>`).join("\n")}
+</tbody>
+</table>` : ""}
+${sortedCommunities2.length ? `<h2>Communities</h2>
+<table>
+<thead><tr><th>Label</th><th>Nodes</th><th></th></tr></thead>
+<tbody>
+${sortedCommunities2.map((c) => {
+    const maxSize = sortedCommunities2[0]?.nodeIds.length ?? 1;
+    const pct = Math.round(c.nodeIds.length / maxSize * 100);
+    return `<tr><td>${htmlEscape(c.label)}</td><td>${c.nodeIds.length}</td><td><div class="bar-container"><div class="bar" style="width:${pct}%;background:var(--success)"></div></div></td></tr>`;
+  }).join("\n")}
+</tbody>
+</table>` : ""}
+${warnings.length ? `<h2>Warnings</h2>
+<ul class="warning-list">
+${warnings.map((w) => `<li>${htmlEscape(w)}</li>`).join("\n")}
+</ul>` : ""}
+<h2>Pages</h2>
+<input type="text" id="page-filter" placeholder="Filter pages..." />
+<div id="pages-container">
+${[...pagesByKind.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(
+    ([kind, pages]) => `<div class="page-group" data-kind="${htmlEscape(kind)}">
+  <div class="page-group-title">${htmlEscape(kind)} (${pages.length})</div>
+  <div class="page-list">
+    ${pages.sort((a, b) => a.title.localeCompare(b.title)).map(
+      (p) => `<div class="page-item" data-title="${htmlEscape(p.title.toLowerCase())}"><strong>${htmlEscape(p.title)}</strong><div class="path">${htmlEscape(p.path)}</div></div>`
+    ).join("\n    ")}
+  </div>
+</div>`
+  ).join("\n")}
+</div>
+<footer>Generated by SwarmVault &middot; ${graph.nodes.length} nodes &middot; ${graph.edges.length} edges &middot; ${graph.pages.length} pages</footer>
+<script>
+document.getElementById("page-filter").addEventListener("input", function(e) {
+  var query = e.target.value.toLowerCase();
+  document.querySelectorAll(".page-item").forEach(function(el) {
+    el.style.display = el.getAttribute("data-title").includes(query) ? "" : "none";
+  });
+  document.querySelectorAll(".page-group").forEach(function(group) {
+    var visible = group.querySelectorAll('.page-item[style=""], .page-item:not([style])').length;
+    group.style.display = visible > 0 || !query ? "" : "none";
+  });
+});
+</script>
+</body>
+</html>`;
+}
 // src/graph-export.ts
 var NODE_COLORS = {
   source: "#f59e0b",
@@ -1220,6 +1572,14 @@ async function exportGraphFormat(rootDir, format, outputPath) {
   const resolvedPath = await writeGraphExport(outputPath, rendered);
   return { format, outputPath: resolvedPath };
 }
+async function exportGraphReportHtml(rootDir, outputPath) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const graph = await loadGraph(rootDir);
+  const report = await readJsonFile(path2.join(paths.wikiDir, "graph", "report.json"));
+  const html = renderGraphReportHtml(graph, report);
+  const resolvedPath = await writeGraphExport(outputPath, html);
+  return { format: "report", outputPath: resolvedPath };
+}
 function safeFileName(label) {
   return label.replace(/[\\/*?:"<>|#^[\]]/g, "").replace(/\s+/g, " ").trim().slice(0, 200) || "unnamed";
 }
@@ -1463,7 +1823,7 @@ function nodeMap(graph) {
 function pageMap(graph) {
   return new Map(graph.pages.map((page) => [page.id, page]));
 }
-function estimateTokens(text) {
+function estimateTokens2(text) {
   return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));
 }
 function estimateCorpusWords(texts) {
@@ -1500,7 +1860,7 @@ function benchmarkQueryTokens(graph, queryResult, pageContentsById) {
     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"));
+  const queryTokens = estimateTokens2(lines.join("\n"));
   return {
     question: queryResult.question,
     queryTokens,
@@ -2217,6 +2577,67 @@ function graphDiff(oldGraph, newGraph) {
   const summary = parts.length ? parts.join("; ") : "No changes";
   return { addedNodes, removedNodes, addedEdges, removedEdges, addedPages, removedPages, summary };
 }
+function blastRadius(graph, target, options) {
+  const maxDepth = Math.max(1, Math.min(options?.maxDepth ?? 3, 10));
+  const resolved = resolveNode(graph, target);
+  const moduleNode = resolved?.type === "module" ? resolved : resolved?.moduleId ? graph.nodes.find((n) => n.id === resolved.moduleId) : void 0;
+  if (!moduleNode) {
+    const normalizedTarget = normalizeTarget(target);
+    const candidate = graph.nodes.filter((n) => n.type === "module").find((n) => normalizeTarget(n.label).includes(normalizedTarget) || normalizeTarget(n.id).includes(normalizedTarget));
+    if (!candidate) {
+      return {
+        target,
+        totalAffected: 0,
+        maxDepth,
+        affectedModules: [],
+        summary: `No module found matching "${target}".`
+      };
+    }
+    return blastRadius(graph, candidate.id, options);
+  }
+  const reverseImports = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (edge.relation === "imports") {
+      const dependents = reverseImports.get(edge.target) ?? [];
+      dependents.push(edge.source);
+      reverseImports.set(edge.target, dependents);
+    }
+  }
+  const affected = [];
+  const seen = /* @__PURE__ */ new Set([moduleNode.id]);
+  const frontier = [{ id: moduleNode.id, depth: 0 }];
+  const nodes = nodeById(graph);
+  while (frontier.length > 0) {
+    const current = frontier.shift();
+    if (current.depth >= maxDepth) {
+      continue;
+    }
+    for (const dependentId of reverseImports.get(current.id) ?? []) {
+      if (seen.has(dependentId)) {
+        continue;
+      }
+      seen.add(dependentId);
+      const dependentNode = nodes.get(dependentId);
+      const nextDepth = current.depth + 1;
+      affected.push({
+        moduleId: dependentId,
+        label: dependentNode?.label ?? dependentId,
+        depth: nextDepth
+      });
+      frontier.push({ id: dependentId, depth: nextDepth });
+    }
+  }
+  affected.sort((a, b) => a.depth - b.depth || a.label.localeCompare(b.label));
+  const summary = affected.length ? `Changing "${moduleNode.label}" affects ${affected.length} module${affected.length === 1 ? "" : "s"} (max depth ${maxDepth}).` : `No modules depend on "${moduleNode.label}".`;
+  return {
+    target,
+    resolvedModuleId: moduleNode.id,
+    affectedModules: affected,
+    totalAffected: affected.length,
+    maxDepth,
+    summary
+  };
+}
 // src/hooks.ts
 import fs4 from "fs/promises";
@@ -14024,6 +14445,33 @@ async function semanticGraphMatches(rootDir, graph, question, limit = 12) {
     score: Math.max(0, Number((cosineSimilarity(queryVector, vectors.get(`${item.kind}:${item.id}`) ?? []) * 100).toFixed(2)))
   })).filter((match) => match.score >= 18).sort((left, right) => right.score - left.score || left.label.localeCompare(right.label)).slice(0, limit);
 }
+async function semanticPageSearch(rootDir, graph, query, limit = 10) {
+  const items = await buildEmbeddableItems(rootDir, graph);
+  const pageItems = items.filter((item) => item.kind === "page");
+  if (!pageItems.length) {
+    return [];
+  }
+  const { provider, vectors } = await resolveVectorsForItems(rootDir, graph.generatedAt, items);
+  if (!provider) {
+    return [];
+  }
+  const [queryVector] = await provider.embedTexts([query]);
+  if (!Array.isArray(queryVector) || queryVector.length === 0) {
+    return [];
+  }
+  const pageMap2 = new Map(graph.pages.map((page) => [page.id, page]));
+  return pageItems.map((item) => {
+    const page = pageMap2.get(item.id);
+    return {
+      pageId: item.id,
+      path: page?.path ?? "",
+      title: item.label,
+      kind: page?.kind ?? "",
+      status: page?.status ?? "",
+      score: cosineSimilarity(queryVector, vectors.get(`page:${item.id}`) ?? [])
+    };
+  }).filter((result) => result.score >= 0.25 && result.path).sort((left, right) => right.score - left.score).slice(0, limit);
+}
 function distinctScope(left, right) {
   const leftSources = new Set(left.sourceIds);
   const rightSources = new Set(right.sourceIds);
@@ -16633,6 +17081,38 @@ ${excerpt.trim()}`.trim();
   db.exec("INSERT INTO page_search (rowid, title, body) SELECT rowid, title, body FROM pages;");
   db.close();
 }
+function mergeSearchResults(ftsResults, semanticHits, limit) {
+  const k = 60;
+  const scores = /* @__PURE__ */ new Map();
+  const resultMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ftsResults.length; i++) {
+    const r = ftsResults[i];
+    scores.set(r.pageId, (scores.get(r.pageId) ?? 0) + 1 / (k + i + 1));
+    resultMap.set(r.pageId, r);
+  }
+  for (let i = 0; i < semanticHits.length; i++) {
+    const hit = semanticHits[i];
+    scores.set(hit.pageId, (scores.get(hit.pageId) ?? 0) + 1 / (k + i + 1));
+    if (!resultMap.has(hit.pageId)) {
+      resultMap.set(hit.pageId, {
+        pageId: hit.pageId,
+        path: hit.path,
+        title: hit.title,
+        snippet: "",
+        rank: -hit.score,
+        kind: hit.kind,
+        status: hit.status,
+        projectIds: [],
+        sourceType: void 0,
+        sourceClass: void 0
+      });
+    }
+  }
+  return [...scores.entries()].sort(([, a], [, b]) => b - a).slice(0, limit).map(([pageId, rrfScore]) => {
+    const result = resultMap.get(pageId);
+    return { ...result, rank: -rrfScore };
+  });
+}
 function searchPages(dbPath, query, limitOrOptions = 5) {
   const options = typeof limitOrOptions === "number" ? { limit: limitOrOptions } : limitOrOptions;
   const ftsQuery = toFtsQuery(query);
@@ -16974,7 +17454,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-MYJX6AEE.js");
+  const { createProvider: createProvider2 } = await import("./registry-UA42LQUQ.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -17485,8 +17965,8 @@ async function buildDashboardRecords(config, paths, graph, schemaHash, report) {
   ).slice(0, 20);
   const sourceSessions = await listGuidedSourceSessions(paths.rootDir);
   const stagedGuideBundles = (await Promise.all(
-    (await fs19.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => await readJsonFile(approvalManifestPath(paths, entry.name)))
-  )).filter((manifest) => Boolean(manifest)).filter((manifest) => manifest.bundleType === "guided_source" || manifest.bundleType === "guided_session").sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 12);
+    (await fs19.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => await readApprovalManifest(paths, entry.name).catch(() => null))
+  )).filter((manifest) => Boolean(manifest)).filter((manifest) => manifest.bundleType === "guided-source" || manifest.bundleType === "guided-session").sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 12);
   const readerFocusPages = uniqueBy([...guidePages, ...briefPages, ...conceptPages, ...entityPages], (page) => page.id).slice(0, 8);
   const diligenceSessions = sourceSessions.filter((session) => session.status === "staged" || session.status === "awaiting_input").slice(0, 8);
   const dashboards = [
@@ -18713,11 +19193,22 @@ function approvalManifestPath(paths, approvalId) {
 function approvalGraphPath(paths, approvalId) {
   return path23.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
+function normalizeApprovalBundleType(raw) {
+  if (!raw) return void 0;
+  const legacy = {
+    generated_output: "generated-output",
+    source_review: "source-review",
+    guided_source: "guided-source",
+    guided_session: "guided-session"
+  };
+  return legacy[raw] ?? raw;
+}
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
   if (!manifest) {
     throw new Error(`Approval bundle not found: ${approvalId}`);
   }
+  manifest.bundleType = normalizeApprovalBundleType(manifest.bundleType);
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
@@ -19560,7 +20051,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages, options = {}) {
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    bundleType: options.bundleType ?? "generated_output",
+    bundleType: options.bundleType ?? "generated-output",
     title: options.title,
     sourceSessionId: options.sourceSessionId,
     entries: await buildApprovalEntries(
@@ -20542,6 +21033,45 @@ async function compileVault(rootDir, options = {}) {
       `benchmark=${benchmark.ok ? "ok" : `error:${benchmark.error}`}`
     ]
   });
+  let tokenStats;
+  if (options.maxTokens && options.maxTokens > 0) {
+    const { estimatePageTokens: estimatePageTokens2, trimToTokenBudget: trimToTokenBudget2 } = await import("./token-estimation-TTONKT4O.js");
+    const nodeDegreeLookup = /* @__PURE__ */ new Map();
+    const graph = await readJsonFile(paths.graphPath);
+    if (graph) {
+      for (const node of graph.nodes) {
+        if (node.pageId && node.degree) {
+          const existing = nodeDegreeLookup.get(node.pageId) ?? 0;
+          nodeDegreeLookup.set(node.pageId, Math.max(existing, node.degree));
+        }
+      }
+    }
+    const estimates = await Promise.all(
+      sync.allPages.map(async (page) => {
+        const fullPath = path23.join(paths.wikiDir, page.path);
+        let content = "";
+        try {
+          content = await fs19.readFile(fullPath, "utf8");
+        } catch {
+        }
+        return estimatePageTokens2(page.id, page.path, page.kind, content, nodeDegreeLookup.get(page.id), page.confidence);
+      })
+    );
+    const budgetResult = trimToTokenBudget2(estimates, options.maxTokens);
+    for (const dropped of budgetResult.dropped) {
+      const fullPath = path23.join(paths.wikiDir, dropped.path);
+      try {
+        await fs19.unlink(fullPath);
+      } catch {
+      }
+    }
+    tokenStats = {
+      estimatedTokens: budgetResult.totalTokens,
+      maxTokens: options.maxTokens,
+      pagesKept: budgetResult.kept.length,
+      pagesDropped: budgetResult.dropped.length
+    };
+  }
   return {
     graphPath: paths.graphPath,
     pageCount: sync.allPages.length,
@@ -20553,7 +21083,8 @@ async function compileVault(rootDir, options = {}) {
     postPassApprovalId,
     postPassApprovalDir,
     promotedPageIds: sync.promotedPageIds,
-    candidatePageCount: sync.candidatePageCount
+    candidatePageCount: sync.candidatePageCount,
+    tokenStats
   };
 }
 async function queryVault(rootDir, options) {
@@ -20910,11 +21441,59 @@ ${orchestrationNotes.join("\n")}
   };
 }
 async function searchVault(rootDir, query, limit = 5) {
-  const { paths } = await loadVaultConfig(rootDir);
+  const { paths, config } = await loadVaultConfig(rootDir);
   if (!await fileExists(paths.searchDbPath)) {
     await compileVault(rootDir, {});
   }
-  return searchPages(paths.searchDbPath, query, limit);
+  const hybrid = config.search?.hybrid !== false;
+  const ftsResults = searchPages(paths.searchDbPath, query, hybrid ? limit * 3 : limit);
+  if (!hybrid || !await fileExists(paths.graphPath)) {
+    return ftsResults.slice(0, limit);
+  }
+  const graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    return ftsResults.slice(0, limit);
+  }
+  const semanticHits = await semanticPageSearch(rootDir, graph, query, limit * 3).catch(() => []);
+  if (!semanticHits.length) {
+    return ftsResults.slice(0, limit);
+  }
+  const merged = mergeSearchResults(ftsResults, semanticHits, limit);
+  if (config.search?.rerank && merged.length > 1) {
+    return rerankSearchResults(rootDir, query, merged, limit);
+  }
+  return merged;
+}
+async function rerankSearchResults(rootDir, query, results, limit) {
+  const provider = await getProviderForTask(rootDir, "queryProvider");
+  const candidates = results.slice(0, Math.min(results.length, 20)).map((r, i) => `[${i}] ${r.title} \u2014 ${r.snippet || r.path}`).join("\n");
+  const prompt = `Given the search query: "${query}"
+Rank these results by relevance (most relevant first).
+${candidates}`;
+  try {
+    const indices = await provider.generateStructured(
+      { prompt, system: "You are a search result ranker." },
+      z7.array(z7.number().int().nonnegative())
+    );
+    const reranked = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const idx of indices) {
+      if (idx >= 0 && idx < results.length && !seen.has(idx)) {
+        seen.add(idx);
+        reranked.push(results[idx]);
+      }
+    }
+    for (let i = 0; i < results.length && reranked.length < limit; i++) {
+      if (!seen.has(i)) {
+        reranked.push(results[i]);
+      }
+    }
+    return reranked.slice(0, limit);
+  } catch {
+    return results.slice(0, limit);
+  }
 }
 async function ensureCompiledGraph(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
@@ -21018,6 +21597,10 @@ async function listGodNodes(rootDir, limit = 10) {
   const graph = await ensureCompiledGraph(rootDir);
   return topGodNodes(graph, limit);
 }
+async function blastRadiusVault(rootDir, target, options) {
+  const graph = await ensureCompiledGraph(rootDir);
+  return blastRadius(graph, target, options);
+}
 async function listPages(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
@@ -21252,7 +21835,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 // src/mcp.ts
-var SERVER_VERSION = "0.7.23";
+var SERVER_VERSION = "0.7.25";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -21402,6 +21985,19 @@ async function createMcpServer(rootDir) {
       return asToolText(await listGodNodes(rootDir, limit ?? 10));
     })
   );
+  server.registerTool(
+    "blast_radius",
+    {
+      description: "Analyze the impact of changing a file or module by tracing reverse import edges.",
+      inputSchema: {
+        target: z8.string().min(1).describe("File path, module label, or module id"),
+        maxDepth: z8.number().int().min(1).max(10).optional().describe("Maximum traversal depth (default 3)")
+      }
+    },
+    safeHandler(async ({ target, maxDepth }) => {
+      return asToolText(await blastRadiusVault(rootDir, target, { maxDepth: maxDepth ?? 3 }));
+    })
+  );
   server.registerTool(
     "query_vault",
     {
@@ -21439,11 +22035,12 @@ async function createMcpServer(rootDir) {
     {
       description: "Compile source manifests into wiki pages, graph data, and search index.",
       inputSchema: {
-        approve: z8.boolean().optional().describe("Stage a review bundle without applying active page changes")
+        approve: z8.boolean().optional().describe("Stage a review bundle without applying active page changes"),
+        maxTokens: z8.number().int().min(1e3).optional().describe("Maximum token budget for wiki output")
       }
     },
-    safeHandler(async ({ approve }) => {
-      const result = await compileVault(rootDir, { approve: approve ?? false });
+    safeHandler(async ({ approve, maxTokens }) => {
+      const result = await compileVault(rootDir, { approve: approve ?? false, maxTokens });
       return asToolText(result);
     })
   );
@@ -23078,7 +23675,7 @@ async function buildSourceGuideStagedPage(rootDir, scope) {
 async function stageSourceReviewForScope(rootDir, scope) {
   const output = await buildSourceReviewStagedPage(rootDir, scope);
   const approval = await stageGeneratedOutputPages(rootDir, [{ page: output.page, content: output.content, label: "source-review" }], {
-    bundleType: "source_review",
+    bundleType: "source-review",
     title: `Source Review: ${scope.title}`
   });
   return {
@@ -23430,7 +24027,7 @@ async function stageSourceGuideForScope(rootDir, scope, options = {}) {
       ...guidedUpdates
     ],
     {
-      bundleType: "guided_session",
+      bundleType: "guided-session",
       title: `Guided Session: ${scope.title}`,
       sourceSessionId: session.sessionId
     }
@@ -23708,11 +24305,11 @@ async function deleteManagedSource(rootDir, id) {
 }
 // src/viewer.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import fs23 from "fs/promises";
 import http from "http";
 import path28 from "path";
-import { promisify } from "util";
+import { promisify as promisify2 } from "util";
 import matter11 from "gray-matter";
 import mime2 from "mime-types";
@@ -24326,7 +24923,7 @@ async function getWatchStatus(rootDir) {
 }
 // src/viewer.ts
-var execFileAsync = promisify(execFile);
+var execFileAsync2 = promisify2(execFile2);
 async function isReadableFile(absolutePath) {
   try {
     const stats = await fs23.stat(absolutePath);
@@ -24393,7 +24990,7 @@ async function ensureViewerDist(viewerDistDir) {
   }
   const viewerProjectDir = path28.dirname(viewerDistDir);
   if (await fileExists(path28.join(viewerProjectDir, "package.json"))) {
-    await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
+    await execFileAsync2("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
 async function startGraphServer(rootDir, port, options = {}) {
@@ -24573,6 +25170,44 @@ async function startGraphServer(rootDir, port, options = {}) {
         response.end(JSON.stringify(result));
         return;
       }
+      if (url.pathname === "/api/clip" && request.method === "POST") {
+        const body = await readJsonBody(request);
+        const clipUrl = typeof body.url === "string" ? body.url.trim() : "";
+        if (!clipUrl) {
+          response.writeHead(400, { "content-type": "application/json" });
+          response.end(JSON.stringify({ error: "Missing url field." }));
+          return;
+        }
+        const manifest = await ingestInput(rootDir, clipUrl);
+        response.writeHead(200, { "content-type": "application/json", "access-control-allow-origin": "*" });
+        response.end(JSON.stringify({ ok: true, sourceId: manifest.sourceId, title: manifest.title }));
+        return;
+      }
+      if (url.pathname === "/api/clip" && request.method === "OPTIONS") {
+        response.writeHead(204, {
+          "access-control-allow-origin": "*",
+          "access-control-allow-methods": "POST, OPTIONS",
+          "access-control-allow-headers": "content-type"
+        });
+        response.end();
+        return;
+      }
+      if (url.pathname === "/api/bookmarklet") {
+        const script = `javascript:void(fetch('http://localhost:${effectivePort}/api/clip',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({url:location.href})}).then(r=>r.json()).then(d=>alert('Clipped: '+(d.title||d.sourceId))).catch(e=>alert('Clip failed: '+e.message)))`;
+        response.writeHead(200, { "content-type": "text/html" });
+        response.end(
+          [
+            "<!doctype html><html><head><title>SwarmVault Clipper</title></head><body>",
+            "<h1>SwarmVault Clipper</h1>",
+            `<p>Drag this link to your bookmarks bar:</p>`,
+            `<p style="font-size:1.5em"><a href="${script.replace(/&/g, "&amp;").replace(/"/g, "&quot;")}">Clip to SwarmVault</a></p>`,
+            `<p>When clicked on any page, it sends the URL to your running SwarmVault instance for ingestion.</p>`,
+            `<p>Server: <code>http://localhost:${effectivePort}</code></p>`,
+            "</body></html>"
+          ].join("\n")
+        );
+        return;
+      }
       const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
       const target = path28.join(paths.viewerDistDir, relativePath);
       const fallback = path28.join(paths.viewerDistDir, "index.html");
@@ -24691,7 +25326,10 @@ export {
   addManagedSource,
   archiveCandidate,
   assertProviderCapability,
+  autoCommitWikiChanges,
   benchmarkVault,
+  blastRadius,
+  blastRadiusVault,
   bootstrapDemo,
   compileVault,
   createMcpServer,
@@ -24700,10 +25338,13 @@ export {
   defaultVaultConfig,
   defaultVaultSchema,
   deleteManagedSource,
+  estimatePageTokens,
+  estimateTokens,
   explainGraphVault,
   exploreVault,
   exportGraphFormat,
   exportGraphHtml,
+  exportGraphReportHtml,
   exportObsidianCanvas,
   exportObsidianVault,
   getGitHookStatus,
@@ -24760,6 +25401,7 @@ export {
   startMcpServer,
   syncTrackedRepos,
   syncTrackedReposForWatch,
+  trimToTokenBudget,
   uninstallGitHooks,
   watchVault
 };