@vibgrate/cli 2026.704.1 → 2026.708.1

package/dist/{chunk-YODVLV37.js → chunk-2J7DPIAL.js}

@@ -1,5 +1,5 @@
-import { langById, shortId, canonicalize, grammarSetVersion, hashString, hashBytes, langForExtension, setGrammarsOverride, parseSource } from './chunk-X5YT263H.js';
-import { writeTextFile, pathExists, readJsonFile, VERSION, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem } from './chunk-RJHYTD62.js';
+import { hashString, langById, shortId, canonicalize, grammarSetVersion, hashBytes, langForExtension, setGrammarsOverride, parseSource } from './chunk-X5YT263H.js';
+import { writeTextFile, pathExists, readJsonFile, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-SRWMZBLG.js';
 import * as fs18 from 'fs';
 import { execFileSync } from 'child_process';
 import * as path18 from 'path';
@@ -1624,6 +1624,7 @@ function resolve4(parses, resolver) {
     }
   }
   const edges = new EdgeSet();
+  const unresolved2 = /* @__PURE__ */ new Map();
   const stats = {
     callsResolved: 0,
     callsUnresolved: 0,
@@ -1672,6 +1673,7 @@ function resolve4(parses, resolver) {
         stats.callsResolved++;
       } else {
         stats.callsUnresolved++;
+        bumpUnresolved(unresolved2, srcId, call.callee, "call", p.rel);
       }
     }
   }
@@ -1683,6 +1685,7 @@ function resolve4(parses, resolver) {
       if (!srcId) continue;
       const target = resolveType(h.superName, p.rel, p.lang, imported, defsByName);
       if (target) edges.add(h.kind, srcId, target.id, "heuristic", 0.85);
+      else bumpUnresolved(unresolved2, srcId, h.superName, h.kind, p.rel);
     }
   }
   const nodes = [...baseNodes.values()].map((n) => ({
@@ -1693,7 +1696,16 @@ function resolve4(parses, resolver) {
     isHub: false,
     tested: null
   }));
-  return { nodes, edges: edges.toArray(), stats };
+  const unresolvedList = [...unresolved2.values()].sort(
+    (a, b) => a.from.localeCompare(b.from) || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
+  );
+  return { nodes, edges: edges.toArray(), unresolved: unresolvedList, stats };
+}
+function bumpUnresolved(map, from, name, kind, fromRel) {
+  const key = `${from}\0${kind}\0${name}`;
+  const existing = map.get(key);
+  if (existing) existing.count++;
+  else map.set(key, { from, name, kind, count: 1, fromRel });
 }
 function addNode(map, n) {
   if (!map.has(n.id)) map.set(n.id, n);
@@ -2036,6 +2048,30 @@ function loadCache(root, opts) {
   };
 }
 
+// src/engine/epistemic.ts
+var SEMANTIC_RESOLVERS = /* @__PURE__ */ new Set(["scip", "stackgraph", "tsc"]);
+function classifyEpistemic(edge, dstKind) {
+  if (SEMANTIC_RESOLVERS.has(edge.resolution)) return "observed";
+  switch (edge.kind) {
+    case "contains":
+      return "observed";
+    case "import":
+      return dstKind === "external" || dstKind === void 0 ? "declared" : "observed";
+    case "test":
+    case "coverage":
+      return "declared";
+    default:
+      return "name-matched";
+  }
+}
+function epistemicBreakdown(edges) {
+  const out = { observed: 0, "name-matched": 0, declared: 0 };
+  for (const e of edges) {
+    if (e.epistemic) out[e.epistemic]++;
+  }
+  return out;
+}
+
 // src/engine/build.ts
 async function buildGraph(options) {
   const start = nowMs();
@@ -2117,6 +2153,7 @@ async function buildGraph(options) {
   const nodeFileById = new Map(resolved.nodes.map((n) => [n.id, n.file]));
   let edges = resolved.edges;
   const resolvers = [...resolved.stats.resolvers];
+  const preciseCoveredFiles = /* @__PURE__ */ new Set();
   let tscStats;
   let tsFiles = options.noTsc ? [] : files.filter((f) => (f.lang.id === "ts" || f.lang.id === "tsx" || f.lang.id === "js") && hashes.has(f.rel)).map((f) => ({ rel: f.rel, abs: f.abs }));
   if (limits.tscMaxFiles > 0 && tsFiles.length > limits.tscMaxFiles) {
@@ -2129,6 +2166,7 @@ async function buildGraph(options) {
     const res = tsResolveEdges(root, tsFiles, resolved.nodes);
     if (res.stats.files > 0) {
       edges = mergePreciseEdges(edges, res.edges, res.coveredFiles, nodeFileById);
+      for (const f of res.coveredFiles) preciseCoveredFiles.add(f);
       if (!resolvers.includes("tsc")) resolvers.unshift("tsc");
       tscStats = res.stats;
     }
@@ -2139,6 +2177,7 @@ async function buildGraph(options) {
   if (scip) {
     const res = scipEdges(scip.index, resolved.nodes, toRepoRel);
     edges = mergePreciseEdges(edges, res.edges, res.coveredFiles, nodeFileById);
+    for (const f of res.coveredFiles) preciseCoveredFiles.add(f);
     if (!resolvers.includes("scip")) resolvers.unshift("scip");
     scipStats = { ...res.stats, tool: scip.tool };
   }
@@ -2151,6 +2190,11 @@ async function buildGraph(options) {
   const languages = [...new Set(parses.map((p) => p.lang))].sort();
   const edgeKinds = [...new Set(analysis.edges.map((e) => e.kind))].sort();
   const corpusHash = computeCorpusHash(parses, hashes);
+  const nodeKindById = new Map(analysis.nodes.map((n) => [n.id, n.kind]));
+  for (const e of analysis.edges) {
+    e.epistemic = classifyEpistemic(e, nodeKindById.get(e.dst));
+  }
+  const toolchain = computeToolchain(grammars, resolvers);
   const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const testsCount = linked.testFiles.length;
   const untestedCount = analysis.nodes.filter(
@@ -2165,7 +2209,8 @@ async function buildGraph(options) {
       grammars: Object.fromEntries(languages.map((l) => [l, grammars])),
       resolver: resolvers,
       deep: options.deep ?? false,
-      corpusHash
+      corpusHash,
+      toolchain
     },
     meta: {
       root: path18.basename(root) === "" ? "." : ".",
@@ -2184,6 +2229,9 @@ async function buildGraph(options) {
     edges: analysis.edges,
     areas: analysis.areas
   };
+  const survivingIds = new Set(analysis.nodes.map((n) => n.id));
+  const unknowns = resolved.unresolved.filter((u) => !preciseCoveredFiles.has(u.fromRel) && survivingIds.has(u.from)).map((u) => ({ from: u.from, name: u.name, kind: u.kind, count: u.count }));
+  if (unknowns.length) graph.unknowns = unknowns;
   if (options.deep) {
     const facts = buildFacts(parses, analysis.nodes, analysis.edges);
     if (facts.length) graph.facts = facts;
@@ -2242,6 +2290,23 @@ function mergePreciseEdges(base, precise, coveredFiles, nodeFileById) {
     (a, b) => a.kind.localeCompare(b.kind) || a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst)
   );
 }
+function computeToolchain(grammars, resolvers) {
+  const sortedResolvers = [...new Set(resolvers)].sort();
+  return {
+    schema: SCHEMA_VERSION,
+    tool: VERSION,
+    grammars,
+    resolvers: sortedResolvers,
+    fingerprint: shortId(
+      canonicalize({
+        schema: SCHEMA_VERSION,
+        tool: VERSION,
+        grammars,
+        resolvers: sortedResolvers
+      })
+    )
+  };
+}
 function computeCorpusHash(parses, hashes) {
   const list = parses.map((p) => [p.rel, hashes.get(p.rel) ?? p.hash]).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
   return hashString(canonicalize(list));
@@ -2249,6 +2314,224 @@ function computeCorpusHash(parses, hashes) {
 function nowMs() {
   return Number(process.hrtime.bigint() / 1000n) / 1e3;
 }
+
+// src/engine/report.ts
+function renderReport(graph) {
+  const { meta, provenance, nodes, edges } = graph;
+  const lines = [];
+  lines.push("# Code Graph Report");
+  lines.push("");
+  lines.push(`Generated by \`vg\` ${provenance.version} \xB7 schema \`${graph.schemaVersion}\``);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`- **Nodes:** ${meta.counts.nodes.toLocaleString("en-US")}`);
+  lines.push(`- **Edges:** ${meta.counts.edges.toLocaleString("en-US")}`);
+  lines.push(`- **Areas:** ${meta.counts.areas.toLocaleString("en-US")}`);
+  lines.push(`- **Languages:** ${meta.languages.join(", ") || "\u2014"}`);
+  lines.push(`- **Clustering:** ${meta.cluster}`);
+  lines.push(`- **Resolvers:** ${provenance.resolver.join(", ")}`);
+  lines.push(`- **Edge kinds:** ${meta.edgeKinds.join(", ") || "\u2014"}`);
+  lines.push("");
+  const fileNodes = nodes.filter((n) => n.kind === "file");
+  const defsByFile = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file" || n.kind === "external") continue;
+    defsByFile.set(n.file, (defsByFile.get(n.file) ?? 0) + 1);
+  }
+  const topFiles = [...defsByFile.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 15);
+  if (topFiles.length) {
+    lines.push("## Largest files (by definitions)");
+    lines.push("");
+    lines.push("| File | Definitions |");
+    lines.push("| --- | ---: |");
+    for (const [file, count] of topFiles) lines.push(`| \`${file}\` | ${count} |`);
+    lines.push("");
+  }
+  const topNodes = nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 15);
+  if (topNodes.length) {
+    lines.push("## Most-connected definitions");
+    lines.push("");
+    lines.push("| Symbol | Kind | File | Importance |");
+    lines.push("| --- | --- | --- | ---: |");
+    for (const n of topNodes) {
+      lines.push(
+        `| \`${n.qualifiedName}\` | ${n.kind} | \`${n.file}\`:${n.span.start} | ${n.importance.toFixed(3)} |`
+      );
+    }
+    lines.push("");
+  }
+  const byKind = /* @__PURE__ */ new Map();
+  for (const e of edges) byKind.set(e.kind, (byKind.get(e.kind) ?? 0) + 1);
+  if (byKind.size) {
+    lines.push("## Edges by kind");
+    lines.push("");
+    lines.push("| Kind | Count |");
+    lines.push("| --- | ---: |");
+    for (const [kind, count] of [...byKind.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+      lines.push(`| ${kind} | ${count} |`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(`_Files: ${fileNodes.length} \xB7 Corpus: \`${provenance.corpusHash.slice(0, 16)}\u2026\`_`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/engine/html.ts
+function renderHtml(graph) {
+  const top = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 50);
+  const rows = top.map(
+    (n) => `<tr><td><code>${esc(n.qualifiedName)}</code></td><td>${esc(n.kind)}</td><td><code>${esc(n.file)}</code>:${n.span.start}</td><td>${n.importance.toFixed(3)}</td></tr>`
+  ).join("\n");
+  const embedded = stableStringify(graph, 0);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>vg \xB7 code graph</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font: 14px/1.5 system-ui, sans-serif; margin: 2rem auto; max-width: 60rem; padding: 0 1rem; }
+  h1 { font-size: 1.4rem; } h2 { font-size: 1.1rem; margin-top: 2rem; }
+  table { border-collapse: collapse; width: 100%; }
+  th, td { text-align: left; padding: 4px 8px; border-bottom: 1px solid #8884; }
+  td:last-child, th:last-child { text-align: right; }
+  .meta { color: #888; } code { font-size: 0.9em; }
+</style>
+</head>
+<body>
+<h1>vg \xB7 code graph</h1>
+<p class="meta">${graph.meta.counts.nodes} nodes \xB7 ${graph.meta.counts.edges} edges \xB7
+${graph.meta.counts.areas} areas \xB7 ${esc(graph.meta.languages.join(", ") || "\u2014")} \xB7
+clustering: ${esc(graph.meta.cluster)} \xB7 vg ${esc(graph.provenance.version)}</p>
+<h2>Most-connected definitions</h2>
+<table>
+<thead><tr><th>Symbol</th><th>Kind</th><th>Location</th><th>Importance</th></tr></thead>
+<tbody>
+${rows}
+</tbody>
+</table>
+<p class="meta">Interactive WebGL view arrives in Phase 1. The full graph is embedded below for tooling.</p>
+<script type="application/json" id="vg-graph">
+${embedded}
+</script>
+</body>
+</html>
+`;
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function vibgrateDir(root) {
+  return path18.join(root, ".vibgrate");
+}
+function defaultGraphPath(root) {
+  return path18.join(vibgrateDir(root), "graph.json");
+}
+function writeArtifacts(graph, options) {
+  const dir = vibgrateDir(options.root);
+  fs18.mkdirSync(dir, { recursive: true });
+  const graphPath = options.graphPath ?? defaultGraphPath(options.root);
+  fs18.mkdirSync(path18.dirname(graphPath), { recursive: true });
+  const tmp = `${graphPath}.${process.pid}.tmp`;
+  try {
+    fs18.writeFileSync(tmp, serializeGraph(graph));
+    fs18.renameSync(tmp, graphPath);
+  } catch (err) {
+    fs18.rmSync(tmp, { force: true });
+    throw err;
+  }
+  const written = { graphPath };
+  if (options.report !== false) {
+    const reportPath = path18.join(dir, "GRAPH_REPORT.md");
+    fs18.writeFileSync(reportPath, renderReport(graph));
+    written.reportPath = reportPath;
+  }
+  if (options.html !== false) {
+    const htmlPath = path18.join(dir, "graph.html");
+    fs18.writeFileSync(htmlPath, renderHtml(graph));
+    written.htmlPath = htmlPath;
+  }
+  if (graph.facts && graph.facts.length) {
+    const factsPath = path18.join(dir, "facts.jsonl");
+    fs18.writeFileSync(factsPath, graph.facts.map((f) => JSON.stringify(f)).join("\n") + "\n");
+    written.factsPath = factsPath;
+  }
+  return written;
+}
+function loadGraph(root, graphPath) {
+  const file = graphPath ?? defaultGraphPath(root);
+  if (!fs18.existsSync(file)) return null;
+  return parseGraph(fs18.readFileSync(file, "utf8"));
+}
+
+// src/engine/verify.ts
+var PINNED = "1970-01-01T00:00:00.000Z";
+async function verifyDeterminism(opts) {
+  const base = { root: opts.root, only: opts.only, exclude: opts.exclude, generatedAt: PINNED };
+  const buildA = await buildGraph({ ...base, noCache: true, jobs: opts.jobs });
+  const a = serializeGraph(buildA.graph);
+  const b = serializeGraph((await buildGraph({ ...base, noCache: true, jobs: 1 })).graph);
+  const cached2 = serializeGraph((await buildGraph({ ...base, noCache: false })).graph);
+  const checks = [
+    { name: "run-to-run determinism", ok: a === b, detail: diffHint(a, b) },
+    { name: "cache safety (incremental == full)", ok: a === cached2, detail: diffHint(a, cached2) }
+  ];
+  const scoped = Boolean(opts.only?.length || opts.exclude?.length);
+  const committed = scoped ? null : loadGraph(opts.root);
+  const committedFp = committed?.provenance.toolchain?.fingerprint;
+  const currentFp = buildA.graph.provenance.toolchain?.fingerprint;
+  if (committedFp && currentFp) {
+    const ok = committedFp === currentFp;
+    checks.push({
+      name: "toolchain fingerprint matches committed graph",
+      ok,
+      detail: ok ? void 0 : `committed toolchain ${committedFp} != current ${currentFp} (grammar/resolver versions differ \u2014 rebuild or align the toolchain)`
+    });
+  }
+  return {
+    ok: checks.every((c) => c.ok),
+    checks,
+    digest: hashString(a)
+  };
+}
+function diffHint(x, y) {
+  if (x === y) return void 0;
+  const xl = x.split("\n");
+  const yl = y.split("\n");
+  const n = Math.max(xl.length, yl.length);
+  for (let i = 0; i < n; i++) {
+    if (xl[i] !== yl[i]) {
+      return `first divergence at line ${i + 1}`;
+    }
+  }
+  return "outputs differ in length";
+}
+
+// src/util/exit.ts
+var ExitCode = {
+  OK: 0,
+  ERROR: 1,
+  GATE_FAILED: 2,
+  NOT_FOUND: 3,
+  NON_DETERMINISTIC: 4,
+  USAGE_ERROR: 5
+};
+var CliError = class extends Error {
+  code;
+  constructor(message, code = ExitCode.ERROR) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+  }
+};
+function usageError(message) {
+  return new CliError(message, ExitCode.USAGE_ERROR);
+}
 var DEFAULT_LOCK_STALE_MS = 15 * 60 * 1e3;
 function isProcessAlive(pid) {
   try {
@@ -2508,220 +2791,71 @@ function readCacheEntries(file, modelId) {
   try {
     const loaded = JSON.parse(fs18.readFileSync(file, "utf8"));
     if (loaded.model === modelId && loaded.entries) return loaded.entries;
-  } catch {
-  }
-  return {};
-}
-async function getNodeEmbeddings(graph, embedder, root, onProgress) {
-  const file = vectorCachePath(root, embedder.id);
-  let cache = { model: embedder.id, entries: {} };
-  if (fs18.existsSync(file)) {
-    try {
-      const loaded = JSON.parse(fs18.readFileSync(file, "utf8"));
-      if (loaded.model === embedder.id && loaded.entries) cache = loaded;
-    } catch {
-    }
-  }
-  const areaLabel = new Map(graph.areas.map((a) => [a.id, a.label]));
-  const targets = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external");
-  const toEmbed = [];
-  const vectors = /* @__PURE__ */ new Map();
-  for (const n of targets) {
-    const text = nodeEmbedText(n, areaLabel.get(n.area));
-    const h = hashString(text);
-    const cached2 = cache.entries[n.id];
-    if (cached2 && cached2.hash === h) vectors.set(n.id, cached2.vec);
-    else toEmbed.push({ id: n.id, text, hash: h });
-  }
-  const persist = () => {
-    try {
-      fs18.mkdirSync(cacheDir(root), { recursive: true });
-      const tmp = `${file}.tmp.${process.pid}`;
-      fs18.writeFileSync(tmp, JSON.stringify(cache));
-      fs18.renameSync(tmp, file);
-    } catch {
-    }
-  };
-  if (toEmbed.length) {
-    const lock = `${file}.lock`;
-    if (!acquireLock(lock)) return vectors;
-    try {
-      onProgress?.(0, toEmbed.length);
-      let lastWrite = Date.now();
-      for (let i = 0; i < toEmbed.length; i += EMBED_CHUNK) {
-        const slice = toEmbed.slice(i, i + EMBED_CHUNK);
-        const vecs = await embedder.embed(slice.map((t) => t.text));
-        slice.forEach((t, j) => {
-          const vec = vecs[j] ?? [];
-          vectors.set(t.id, vec);
-          cache.entries[t.id] = { hash: t.hash, vec };
-        });
-        onProgress?.(Math.min(i + EMBED_CHUNK, toEmbed.length), toEmbed.length);
-        if (Date.now() - lastWrite >= CACHE_WRITE_INTERVAL_MS) {
-          persist();
-          lastWrite = Date.now();
-        }
-      }
-      const live = new Set(targets.map((n) => n.id));
-      for (const id of Object.keys(cache.entries)) if (!live.has(id)) delete cache.entries[id];
-      persist();
-    } finally {
-      releaseLock(lock);
-    }
-  }
-  return vectors;
-}
-function safe(id) {
-  return id.replace(/[^a-z0-9.-]+/gi, "_");
-}
-
-// src/engine/report.ts
-function renderReport(graph) {
-  const { meta, provenance, nodes, edges } = graph;
-  const lines = [];
-  lines.push("# Code Graph Report");
-  lines.push("");
-  lines.push(`Generated by \`vg\` ${provenance.version} \xB7 schema \`${graph.schemaVersion}\``);
-  lines.push("");
-  lines.push("## Summary");
-  lines.push("");
-  lines.push(`- **Nodes:** ${meta.counts.nodes.toLocaleString("en-US")}`);
-  lines.push(`- **Edges:** ${meta.counts.edges.toLocaleString("en-US")}`);
-  lines.push(`- **Areas:** ${meta.counts.areas.toLocaleString("en-US")}`);
-  lines.push(`- **Languages:** ${meta.languages.join(", ") || "\u2014"}`);
-  lines.push(`- **Clustering:** ${meta.cluster}`);
-  lines.push(`- **Resolvers:** ${provenance.resolver.join(", ")}`);
-  lines.push(`- **Edge kinds:** ${meta.edgeKinds.join(", ") || "\u2014"}`);
-  lines.push("");
-  const fileNodes = nodes.filter((n) => n.kind === "file");
-  const defsByFile = /* @__PURE__ */ new Map();
-  for (const n of nodes) {
-    if (n.kind === "file" || n.kind === "external") continue;
-    defsByFile.set(n.file, (defsByFile.get(n.file) ?? 0) + 1);
-  }
-  const topFiles = [...defsByFile.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 15);
-  if (topFiles.length) {
-    lines.push("## Largest files (by definitions)");
-    lines.push("");
-    lines.push("| File | Definitions |");
-    lines.push("| --- | ---: |");
-    for (const [file, count] of topFiles) lines.push(`| \`${file}\` | ${count} |`);
-    lines.push("");
-  }
-  const topNodes = nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 15);
-  if (topNodes.length) {
-    lines.push("## Most-connected definitions");
-    lines.push("");
-    lines.push("| Symbol | Kind | File | Importance |");
-    lines.push("| --- | --- | --- | ---: |");
-    for (const n of topNodes) {
-      lines.push(
-        `| \`${n.qualifiedName}\` | ${n.kind} | \`${n.file}\`:${n.span.start} | ${n.importance.toFixed(3)} |`
-      );
-    }
-    lines.push("");
-  }
-  const byKind = /* @__PURE__ */ new Map();
-  for (const e of edges) byKind.set(e.kind, (byKind.get(e.kind) ?? 0) + 1);
-  if (byKind.size) {
-    lines.push("## Edges by kind");
-    lines.push("");
-    lines.push("| Kind | Count |");
-    lines.push("| --- | ---: |");
-    for (const [kind, count] of [...byKind.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-      lines.push(`| ${kind} | ${count} |`);
-    }
-    lines.push("");
-  }
-  lines.push("---");
-  lines.push("");
-  lines.push(`_Files: ${fileNodes.length} \xB7 Corpus: \`${provenance.corpusHash.slice(0, 16)}\u2026\`_`);
-  lines.push("");
-  return lines.join("\n");
-}
-
-// src/engine/html.ts
-function renderHtml(graph) {
-  const top = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 50);
-  const rows = top.map(
-    (n) => `<tr><td><code>${esc(n.qualifiedName)}</code></td><td>${esc(n.kind)}</td><td><code>${esc(n.file)}</code>:${n.span.start}</td><td>${n.importance.toFixed(3)}</td></tr>`
-  ).join("\n");
-  const embedded = stableStringify(graph, 0);
-  return `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>vg \xB7 code graph</title>
-<style>
-  :root { color-scheme: light dark; }
-  body { font: 14px/1.5 system-ui, sans-serif; margin: 2rem auto; max-width: 60rem; padding: 0 1rem; }
-  h1 { font-size: 1.4rem; } h2 { font-size: 1.1rem; margin-top: 2rem; }
-  table { border-collapse: collapse; width: 100%; }
-  th, td { text-align: left; padding: 4px 8px; border-bottom: 1px solid #8884; }
-  td:last-child, th:last-child { text-align: right; }
-  .meta { color: #888; } code { font-size: 0.9em; }
-</style>
-</head>
-<body>
-<h1>vg \xB7 code graph</h1>
-<p class="meta">${graph.meta.counts.nodes} nodes \xB7 ${graph.meta.counts.edges} edges \xB7
-${graph.meta.counts.areas} areas \xB7 ${esc(graph.meta.languages.join(", ") || "\u2014")} \xB7
-clustering: ${esc(graph.meta.cluster)} \xB7 vg ${esc(graph.provenance.version)}</p>
-<h2>Most-connected definitions</h2>
-<table>
-<thead><tr><th>Symbol</th><th>Kind</th><th>Location</th><th>Importance</th></tr></thead>
-<tbody>
-${rows}
-</tbody>
-</table>
-<p class="meta">Interactive WebGL view arrives in Phase 1. The full graph is embedded below for tooling.</p>
-<script type="application/json" id="vg-graph">
-${embedded}
-</script>
-</body>
-</html>
-`;
-}
-function esc(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function vibgrateDir(root) {
-  return path18.join(root, ".vibgrate");
-}
-function defaultGraphPath(root) {
-  return path18.join(vibgrateDir(root), "graph.json");
-}
-function writeArtifacts(graph, options) {
-  const dir = vibgrateDir(options.root);
-  fs18.mkdirSync(dir, { recursive: true });
-  const graphPath = options.graphPath ?? defaultGraphPath(options.root);
-  fs18.mkdirSync(path18.dirname(graphPath), { recursive: true });
-  const tmp = `${graphPath}.${process.pid}.tmp`;
-  try {
-    fs18.writeFileSync(tmp, serializeGraph(graph));
-    fs18.renameSync(tmp, graphPath);
-  } catch (err) {
-    fs18.rmSync(tmp, { force: true });
-    throw err;
+  } catch {
   }
-  const written = { graphPath };
-  if (options.report !== false) {
-    const reportPath = path18.join(dir, "GRAPH_REPORT.md");
-    fs18.writeFileSync(reportPath, renderReport(graph));
-    written.reportPath = reportPath;
+  return {};
+}
+async function getNodeEmbeddings(graph, embedder, root, onProgress) {
+  const file = vectorCachePath(root, embedder.id);
+  let cache = { model: embedder.id, entries: {} };
+  if (fs18.existsSync(file)) {
+    try {
+      const loaded = JSON.parse(fs18.readFileSync(file, "utf8"));
+      if (loaded.model === embedder.id && loaded.entries) cache = loaded;
+    } catch {
+    }
   }
-  if (options.html !== false) {
-    const htmlPath = path18.join(dir, "graph.html");
-    fs18.writeFileSync(htmlPath, renderHtml(graph));
-    written.htmlPath = htmlPath;
+  const areaLabel = new Map(graph.areas.map((a) => [a.id, a.label]));
+  const targets = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external");
+  const toEmbed = [];
+  const vectors = /* @__PURE__ */ new Map();
+  for (const n of targets) {
+    const text = nodeEmbedText(n, areaLabel.get(n.area));
+    const h = hashString(text);
+    const cached2 = cache.entries[n.id];
+    if (cached2 && cached2.hash === h) vectors.set(n.id, cached2.vec);
+    else toEmbed.push({ id: n.id, text, hash: h });
   }
-  if (graph.facts && graph.facts.length) {
-    const factsPath = path18.join(dir, "facts.jsonl");
-    fs18.writeFileSync(factsPath, graph.facts.map((f) => JSON.stringify(f)).join("\n") + "\n");
-    written.factsPath = factsPath;
+  const persist = () => {
+    try {
+      fs18.mkdirSync(cacheDir(root), { recursive: true });
+      const tmp = `${file}.tmp.${process.pid}`;
+      fs18.writeFileSync(tmp, JSON.stringify(cache));
+      fs18.renameSync(tmp, file);
+    } catch {
+    }
+  };
+  if (toEmbed.length) {
+    const lock = `${file}.lock`;
+    if (!acquireLock(lock)) return vectors;
+    try {
+      onProgress?.(0, toEmbed.length);
+      let lastWrite = Date.now();
+      for (let i = 0; i < toEmbed.length; i += EMBED_CHUNK) {
+        const slice = toEmbed.slice(i, i + EMBED_CHUNK);
+        const vecs = await embedder.embed(slice.map((t) => t.text));
+        slice.forEach((t, j) => {
+          const vec = vecs[j] ?? [];
+          vectors.set(t.id, vec);
+          cache.entries[t.id] = { hash: t.hash, vec };
+        });
+        onProgress?.(Math.min(i + EMBED_CHUNK, toEmbed.length), toEmbed.length);
+        if (Date.now() - lastWrite >= CACHE_WRITE_INTERVAL_MS) {
+          persist();
+          lastWrite = Date.now();
+        }
+      }
+      const live = new Set(targets.map((n) => n.id));
+      for (const id of Object.keys(cache.entries)) if (!live.has(id)) delete cache.entries[id];
+      persist();
+    } finally {
+      releaseLock(lock);
+    }
   }
-  return written;
+  return vectors;
+}
+function safe(id) {
+  return id.replace(/[^a-z0-9.-]+/gi, "_");
 }
 var SNAPSHOT_VERSION = "vg-freshness/1";
 function snapshotPath(root) {
@@ -2824,62 +2958,6 @@ function pruneScope(scope) {
   return out;
 }
 
-// src/util/exit.ts
-var ExitCode = {
-  OK: 0,
-  ERROR: 1,
-  GATE_FAILED: 2,
-  NOT_FOUND: 3,
-  NON_DETERMINISTIC: 4,
-  USAGE_ERROR: 5
-};
-var CliError = class extends Error {
-  code;
-  constructor(message, code = ExitCode.ERROR) {
-    super(message);
-    this.name = "CliError";
-    this.code = code;
-  }
-};
-function usageError(message) {
-  return new CliError(message, ExitCode.USAGE_ERROR);
-}
-function loadGraph(root, graphPath) {
-  const file = graphPath ?? defaultGraphPath(root);
-  if (!fs18.existsSync(file)) return null;
-  return parseGraph(fs18.readFileSync(file, "utf8"));
-}
-
-// src/engine/verify.ts
-var PINNED = "1970-01-01T00:00:00.000Z";
-async function verifyDeterminism(opts) {
-  const base = { root: opts.root, only: opts.only, exclude: opts.exclude, generatedAt: PINNED };
-  const a = serializeGraph((await buildGraph({ ...base, noCache: true, jobs: opts.jobs })).graph);
-  const b = serializeGraph((await buildGraph({ ...base, noCache: true, jobs: 1 })).graph);
-  const cached2 = serializeGraph((await buildGraph({ ...base, noCache: false })).graph);
-  const checks = [
-    { name: "run-to-run determinism", ok: a === b, detail: diffHint(a, b) },
-    { name: "cache safety (incremental == full)", ok: a === cached2, detail: diffHint(a, cached2) }
-  ];
-  return {
-    ok: checks.every((c) => c.ok),
-    checks,
-    digest: hashString(a)
-  };
-}
-function diffHint(x, y) {
-  if (x === y) return void 0;
-  const xl = x.split("\n");
-  const yl = y.split("\n");
-  const n = Math.max(xl.length, yl.length);
-  for (let i = 0; i < n; i++) {
-    if (xl[i] !== yl[i]) {
-      return `first divergence at line ${i + 1}`;
-    }
-  }
-  return "outputs differ in length";
-}
-
 // src/engine/relations.ts
 var GraphIndex = class {
   constructor(graph) {
@@ -5409,33 +5487,155 @@ function boundList(items, max) {
   return { items: items.slice(0, max), total: items.length };
 }
 var NODE_EDGE_CAP = 50;
+var IGNORE_DIRS = /* @__PURE__ */ new Set([".git", ".vibgrate", "node_modules", "dist", "build", "out", "target", "vendor", "__pycache__"]);
+var MAX_FILE_BYTES = 1e6;
+var MAX_FILES_SCANNED = 2e4;
+var PREVIEW_CHARS = 120;
+function searchSymbols(graph, root, query, limit) {
+  const q2 = query.trim();
+  if (!q2) return { matches: [], moreAvailable: false, hint: "query is required" };
+  const nodes = findNodes(graph, q2).filter((n) => n.kind !== "file");
+  const symbolHits = nodes.slice(0, limit).map((n, i) => ({
+    kind: n.kind,
+    name: n.qualifiedName,
+    file: n.file,
+    line: n.span.start,
+    score: Math.round((1 - i / Math.max(nodes.length, 1)) * 100) / 100
+  }));
+  const spare = limit - symbolHits.length;
+  const textHits = [];
+  let truncatedScan = false;
+  if (spare > 0) {
+    const seen = new Set(symbolHits.map((h) => `${h.file}:${h.line}`));
+    truncatedScan = scanFiles(root, q2, spare, seen, textHits);
+  }
+  const matches = [...symbolHits, ...textHits];
+  if (matches.length === 0) {
+    return {
+      matches,
+      moreAvailable: false,
+      hint: "no symbol or text match \u2014 for meaning-level questions (symptoms, relationships, what-breaks-if) use query_graph"
+    };
+  }
+  return { matches, moreAvailable: nodes.length > symbolHits.length || truncatedScan };
+}
+function scanFiles(root, needle, budget, seen, out) {
+  const lower = needle.toLowerCase();
+  let scanned = 0;
+  const stack = [root];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const e of entries) {
+      if (e.name.startsWith(".") || IGNORE_DIRS.has(e.name)) continue;
+      const abs = path18.join(dir, e.name);
+      if (e.isDirectory()) {
+        stack.push(abs);
+        continue;
+      }
+      if (++scanned > MAX_FILES_SCANNED) return true;
+      let text;
+      try {
+        if (fs18.statSync(abs).size > MAX_FILE_BYTES) continue;
+        text = fs18.readFileSync(abs, "utf8");
+      } catch {
+        continue;
+      }
+      if (!text.toLowerCase().includes(lower)) continue;
+      const rel2 = path18.relative(root, abs);
+      const lines = text.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (!lines[i].toLowerCase().includes(lower)) continue;
+        const key = `${rel2}:${i + 1}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push({ kind: "text", file: rel2, line: i + 1, preview: lines[i].trim().slice(0, PREVIEW_CHARS) });
+        if (out.length >= budget) return true;
+      }
+    }
+  }
+  return false;
+}
 
 // src/mcp/tools.ts
-var embedderPromise;
-function sharedEmbedder(local) {
-  if (!embedderPromise) embedderPromise = loadEmbedder({ local });
-  return embedderPromise;
+var warmEmbedder = null;
+var bgWarmStarted = false;
+function warmEmbedderInBackground(local) {
+  if (local || bgWarmStarted || isModelReady()) return;
+  bgWarmStarted = true;
+  loadEmbedder({}).then((e) => {
+    if (e) warmEmbedder = Promise.resolve(e);
+  }).catch(() => {
+    bgWarmStarted = false;
+  });
+}
+function readyEmbedder(local) {
+  if (warmEmbedder) return warmEmbedder;
+  if (local) return warmEmbedder = loadEmbedder({ local, noDownload: true });
+  if (isModelReady()) return warmEmbedder = loadEmbedder({ noDownload: true });
+  warmEmbedderInBackground(local);
+  return Promise.resolve(null);
+}
+async function retrieve(graph, question, budget, ctx) {
+  let mode = "lexical";
+  try {
+    const q2 = await withTimeout(
+      (async () => {
+        const embedder = await readyEmbedder(ctx.local);
+        if (!embedder) return null;
+        const nodeVectors = await getNodeEmbeddings(graph, embedder, ctx.root);
+        const r = await queryGraphSemantic(graph, question, { budget, embedder, nodeVectors });
+        mode = `semantic (${embedder.id})`;
+        return r;
+      })(),
+      SEMANTIC_BUDGET_MS,
+      "semantic path over budget"
+    );
+    if (q2) return { q: q2, mode };
+  } catch {
+  }
+  return { q: queryGraph(graph, question, { budget }), mode: "lexical" };
 }
+var SEMANTIC_BUDGET_MS = (() => {
+  const n = Number(process.env.VG_SEMANTIC_BUDGET_MS);
+  return Number.isFinite(n) && n > 0 ? n : 4e3;
+})();
 var obj = (properties, required = []) => ({
   type: "object",
   properties,
-  required,
+  ...required.length ? { required } : {},
   additionalProperties: false
 });
+var RESPONSE_FORMAT = { type: "string", enum: ["concise", "detailed"] };
+var isDetailed = (args) => args.response_format === "detailed";
+var CONCISE_MATCHES = 5;
+var EPISTEMIC_TIERS = ["observed", "name-matched", "declared"];
+var EDGE_FILTER_SCHEMA = {
+  min_edge_confidence: { type: "number", description: "0..1 \u2014 drop edges below this confidence" },
+  epistemic: { type: "string", enum: EPISTEMIC_TIERS, description: "keep only edges of this evidence tier" }
+};
+function edgeRecordFilter(args) {
+  const min = numOrU(args.min_edge_confidence);
+  const tier = EPISTEMIC_TIERS.includes(String(args.epistemic)) ? String(args.epistemic) : void 0;
+  if (min == null && !tier) return () => true;
+  return (x) => (min == null || x.edge.confidence >= min) && (!tier || x.edge.epistemic === tier);
+}
 var TOOLS = [
-  {
-    name: "get_graph_summary",
-    description: "High-level summary of the code map: counts, languages, clustering, top areas and hubs.",
-    inputSchema: obj({}),
-    handler: (graph) => summarize(graph)
-  },
   {
     name: "orient",
-    description: "ONE-SHOT orientation before changing code: the map summary + the most relevant nodes for your question + the blast radius of the top hit, in a single call. Prefer this over separate get_graph_summary + query_graph + impact_of \u2014 same answer, far fewer round-trips (each round-trip re-bills the whole conversation).",
+    description: "Start here: one call returns the map overview, ranked matches for your question, and the top hit\u2019s blast radius \u2014 replaces summary+query+impact round-trips.",
     inputSchema: obj(
       {
-        question: { type: "string", description: "what you are about to do or look for" },
-        budget: { type: "number", description: "approx token budget for the context block (default 1500)" }
+        question: { type: "string", maxLength: 300 },
+        scope: { type: "string", description: "path prefix to orient within" },
+        budget: { type: "number", description: "token budget in detailed mode (default 1500)" },
+        response_format: RESPONSE_FORMAT
       },
       ["question"]
     ),
@@ -5443,73 +5643,103 @@ var TOOLS = [
       const question = String(args.question ?? "");
       if (!question) return { error: "bad_request", message: "question is required" };
       const budget = numOr(args.budget, 1500);
-      const embedder = await sharedEmbedder(ctx.local);
-      let q2;
-      let mode = "lexical";
-      if (embedder) {
-        const nodeVectors = await getNodeEmbeddings(graph, embedder, ctx.root);
-        q2 = await queryGraphSemantic(graph, question, { budget, embedder, nodeVectors });
-        mode = `semantic (${embedder.id})`;
-      } else {
-        q2 = queryGraph(graph, question, { budget });
-      }
+      const { q: q2, mode } = await retrieve(graph, question, budget, ctx);
+      const rawScope = String(args.scope ?? "").trim();
+      const scope = rawScope === "." || rawScope === "./" ? "" : rawScope.replace(/^\.\//, "");
+      const scoped = scope ? q2.matches.filter((m) => m.node.file.startsWith(scope)) : q2.matches;
+      const detailed = isDetailed(args);
       let topImpact = null;
-      const top = q2.matches[0]?.node;
-      if (top) {
+      const top = scoped[0]?.node;
+      if (detailed && top) {
         const r = impactOf(graph, top.id, { depth: 3 });
         topImpact = { node: top.qualifiedName, direct: r.direct, transitive: r.transitive, affected: r.affected.slice(0, 10).map(stripId) };
       }
+      const shown = detailed ? scoped : scoped.slice(0, CONCISE_MATCHES);
       return {
-        summary: summarize(graph),
+        summary: summarize(graph, detailed ? 10 : CONCISE_MATCHES),
         mode,
-        context: q2.context,
-        matches: q2.matches.map((m) => ({ name: m.node.qualifiedName, kind: m.node.kind, file: m.node.file, line: m.node.span.start, score: m.score })),
-        topImpact
+        // The fact-annotated context block is detail: concise callers navigate
+        // by the ranked matches and fetch nodes on demand (plan P2).
+        ...detailed ? { context: q2.context } : {},
+        matches: shown.map((m) => ({ name: m.node.qualifiedName, kind: m.node.kind, file: m.node.file, line: m.node.span.start, score: m.score })),
+        // A neutral availability flag, not a directive to keep querying: a
+        // retrieval tool that coaches "narrow the question / see more" nudges the
+        // over-navigation that re-bills the whole context on every extra step.
+        ...scoped.length > shown.length ? { moreAvailable: true } : {},
+        ...detailed ? { topImpact } : {}
       };
     }
   },
+  {
+    name: "search_symbols",
+    description: "Find a known name or string fast: ranked symbol lookup with literal file-search fallthrough. Use first for most discovery; use query_graph for meaning.",
+    inputSchema: obj(
+      {
+        query: { type: "string", maxLength: 120 },
+        limit: { type: "number", description: "default 8, max 20" }
+      },
+      ["query"]
+    ),
+    handler: (graph, args, ctx) => {
+      const limit = Math.min(20, numOr(args.limit, 8));
+      return searchSymbols(graph, ctx.root, String(args.query ?? ""), limit);
+    }
+  },
   {
     name: "query_graph",
-    description: "Ask the map a natural-language question; returns a budget-bounded, fact-annotated context block plus ranked matches.",
+    description: "Find code by meaning when you don\u2019t know the name: symptoms, relationships, what-breaks-if. For a known name or literal string use search_symbols.",
     inputSchema: obj(
       {
-        question: { type: "string", description: "the question" },
-        budget: { type: "number", description: "approx token budget (default 2000)" }
+        question: { type: "string", maxLength: 300 },
+        limit: { type: "number", description: "ranked matches to return (default 5)" },
+        offset: { type: "number" },
+        budget: { type: "number", description: "context-block token budget in detailed mode (default 2000)" },
+        response_format: RESPONSE_FORMAT
       },
       ["question"]
     ),
     handler: async (graph, args, ctx) => {
       const question = String(args.question ?? "");
       const budget = numOr(args.budget, 2e3);
-      let r;
-      let mode = "lexical";
-      const embedder = await sharedEmbedder(ctx.local);
-      if (embedder) {
-        const nodeVectors = await getNodeEmbeddings(graph, embedder, ctx.root);
-        r = await queryGraphSemantic(graph, question, { budget, embedder, nodeVectors });
-        mode = `semantic (${embedder.id})`;
-      } else {
-        r = queryGraph(graph, question, { budget });
+      const { q: r, mode } = await retrieve(graph, question, budget, ctx);
+      if (r.matches.length === 0) {
+        return { mode, matches: [], hint: "no semantic match \u2014 for a known name or literal string use search_symbols; otherwise rephrase around the behaviour you observe" };
       }
+      const limit = numOr(args.limit, CONCISE_MATCHES);
+      const offset = Math.max(0, numOrU(args.offset) ?? 0);
+      const page = r.matches.slice(offset, offset + limit);
       return {
         mode,
-        context: r.context,
-        tokensEstimate: r.tokensEstimate,
-        matches: r.matches.map((m) => ({ name: m.node.qualifiedName, kind: m.node.kind, file: m.node.file, line: m.node.span.start, score: m.score }))
+        summary: `${r.matches.length} match${r.matches.length === 1 ? "" : "es"}; top: ${r.matches[0].node.qualifiedName}`,
+        // The fact-annotated context block is detail (plan P2): ranked matches
+        // first, fetch nodes on demand.
+        ...isDetailed(args) ? { context: r.context, tokensEstimate: r.tokensEstimate } : {},
+        matches: page.map((m) => ({ name: m.node.qualifiedName, kind: m.node.kind, file: m.node.file, line: m.node.span.start, score: m.score })),
+        // Neutral pagination fact (nextOffset if the model genuinely needs more),
+        // not a "narrow the question" nudge that invites another discovery round.
+        ...offset + page.length < r.matches.length ? { moreAvailable: true, nextOffset: offset + page.length } : {}
       };
     }
   },
   {
     name: "get_node",
-    description: "Explain a node: kind, signature, callers, callees, area, importance. Resolves by qualified/short name, file:line, glob, or id.",
+    description: "Inspect one symbol: signature, callers, callees, area. Accepts name, file:line, glob or id.",
     inputSchema: obj(
-      { name: { type: "string" }, pick: { type: "number", description: "choose nth candidate when ambiguous" } },
+      {
+        name: { type: "string" },
+        pick: { type: "number", description: "nth candidate if ambiguous" },
+        ...EDGE_FILTER_SCHEMA,
+        response_format: RESPONSE_FORMAT
+      },
       ["name"]
     ),
     handler: (graph, args, ctx) => {
       const { node, candidates } = resolveOne(graph, String(args.name ?? ""), numOrU(args.pick));
       if (!node) return unresolved(candidates);
       const index = new GraphIndex(graph);
+      const edgeOk = edgeRecordFilter(args);
+      const calleeRecs = index.callees(node.id).filter(edgeOk);
+      const callerRecs = index.callers(node.id).filter(edgeOk);
       const base = {
         name: node.qualifiedName,
         kind: node.kind,
@@ -5521,10 +5751,11 @@ var TOOLS = [
         area: node.area
       };
       if (ctx?.dedup && ctx.seen?.has(node.id)) {
-        return { ...base, repeat: true, callsTotal: uniqueNames(index.callees(node.id).map((x) => x.node.qualifiedName)).length, calledByTotal: uniqueNames(index.callers(node.id).map((x) => x.node.qualifiedName)).length };
+        return { ...base, repeat: true, callsTotal: uniqueNames(calleeRecs.map((x) => x.node.qualifiedName)).length, calledByTotal: uniqueNames(callerRecs.map((x) => x.node.qualifiedName)).length };
       }
-      const calls = boundList(uniqueNames(index.callees(node.id).map((x) => x.node.qualifiedName)), NODE_EDGE_CAP);
-      const calledBy = boundList(uniqueNames(index.callers(node.id).map((x) => x.node.qualifiedName)), NODE_EDGE_CAP);
+      const edgeCap = isDetailed(args) ? NODE_EDGE_CAP : CONCISE_MATCHES;
+      const calls = boundList(uniqueNames(calleeRecs.map((x) => x.node.qualifiedName)), edgeCap);
+      const calledBy = boundList(uniqueNames(callerRecs.map((x) => x.node.qualifiedName)), edgeCap);
       ctx?.seen?.add(node.id);
       return {
         ...base,
@@ -5537,13 +5768,13 @@ var TOOLS = [
   },
   {
     name: "find_path",
-    description: "Shortest connection between two nodes (how A reaches B).",
+    description: "Shortest connection from a to b.",
     inputSchema: obj(
       {
         a: { type: "string" },
         b: { type: "string" },
-        pick_a: { type: "number", description: "choose nth candidate for a when ambiguous" },
-        pick_b: { type: "number", description: "choose nth candidate for b when ambiguous" }
+        pick_a: { type: "number" },
+        pick_b: { type: "number" }
       },
       ["a", "b"]
     ),
@@ -5560,25 +5791,85 @@ var TOOLS = [
   },
   {
     name: "impact_of",
-    description: "What breaks if a node changes: the reverse-reachability blast radius with per-result depth and confidence.",
+    description: "Blast radius of a change: what breaks if this symbol changes \u2014 dependents, files, covering tests, risk.",
     inputSchema: obj(
       {
         name: { type: "string" },
-        depth: { type: "number", description: "max depth (default 4)" },
-        pick: { type: "number", description: "choose nth candidate when ambiguous" }
+        change_type: { type: "string", enum: ["modify", "delete", "rename", "add_dependency"] },
+        depth: { type: "number", description: "default 4" },
+        pick: { type: "number", description: "nth candidate if ambiguous" },
+        min_edge_confidence: { type: "number", description: "0..1 \u2014 drop dependents below this (decayed) confidence" },
+        response_format: RESPONSE_FORMAT
       },
       ["name"]
     ),
     handler: (graph, args) => {
       const { node, candidates } = resolveOne(graph, String(args.name ?? ""), numOrU(args.pick));
       if (!node) return unresolved(candidates);
+      const changeType = ["modify", "delete", "rename", "add_dependency"].includes(String(args.change_type)) ? String(args.change_type) : "modify";
       const r = impactOf(graph, node.id, { depth: numOr(args.depth, 4) });
-      return { root: r.root.name, direct: r.direct, transitive: r.transitive, affected: r.affected.slice(0, 100).map(stripId) };
+      const minConf = numOrU(args.min_edge_confidence);
+      if (minConf != null) {
+        const kept = r.affected.filter((a) => a.confidence >= minConf);
+        r.affected = kept;
+        r.direct = kept.filter((i) => i.depth === 1).length;
+        r.transitive = kept.filter((i) => i.depth > 1).length;
+        r.minEdgeConfidence = kept.length ? Math.min(...kept.map((i) => i.confidence)) : 1;
+      }
+      const tests = coveringTests(graph, node);
+      const filesAffected = [...new Set(r.affected.map((a) => a.file))];
+      const heavyChange = changeType === "delete" || changeType === "rename";
+      const riskLevel = node.isHub || r.direct >= 10 || r.transitive >= 50 || heavyChange && r.direct >= 3 ? "high" : r.direct >= 3 || r.transitive >= 10 ? "medium" : "low";
+      const summary = `${changeType} ${r.root.name}: ${r.direct} direct dependent${r.direct === 1 ? "" : "s"}, ${r.transitive} transitive across ${filesAffected.length} file${filesAffected.length === 1 ? "" : "s"}; ${tests.length} covering test${tests.length === 1 ? "" : "s"} \u2014 ${riskLevel} risk.`;
+      return {
+        root: r.root.name,
+        changeType,
+        directCallers: r.direct,
+        transitiveCount: r.transitive,
+        filesAffected: filesAffected.slice(0, 20),
+        testsAffected: tests.length,
+        riskLevel,
+        summary,
+        // The full row set is detail; concise callers act on the contract above.
+        ...isDetailed(args) ? { affected: r.affected.slice(0, 100).map(stripId) } : r.affected.length > 0 ? { hint: 'response_format:"detailed" lists the affected nodes' } : {}
+      };
+    }
+  },
+  {
+    name: "tests_for",
+    description: "Which tests cover this symbol \u2014 is a change here tested?",
+    inputSchema: obj(
+      {
+        name: { type: "string" },
+        pick: { type: "number", description: "nth candidate if ambiguous" },
+        response_format: RESPONSE_FORMAT
+      },
+      ["name"]
+    ),
+    handler: (graph, args) => {
+      const { node, candidates } = resolveOne(graph, String(args.name ?? ""), numOrU(args.pick));
+      if (!node) return unresolved(candidates);
+      const covers = coveringTests(graph, node);
+      return {
+        node: node.qualifiedName,
+        tested: node.tested,
+        coverage: node.coverage ?? null,
+        testCount: covers.length,
+        covers: isDetailed(args) ? covers : covers.slice(0, 10),
+        ...covers.length > 10 && !isDetailed(args) ? { moreAvailable: true } : {},
+        ...covers.length === 0 ? { hint: "no covering tests found \u2014 a change here lands untested" } : {}
+      };
     }
   },
+  {
+    name: "get_graph_summary",
+    description: "Code map overview: counts, languages, top areas and hubs.",
+    inputSchema: obj({}),
+    handler: (graph) => summarize(graph)
+  },
   {
     name: "list_areas",
-    description: "The natural code groupings (communities), each labelled, sized, with cohesion.",
+    description: "Code areas (communities) by size.",
     inputSchema: obj({ limit: { type: "number" } }),
     // Strip `members` (raw content-hash id arrays): a model cannot use them and
     // on a large repo they ballooned this result past 20k tokens.
@@ -5586,23 +5877,13 @@ var TOOLS = [
   },
   {
     name: "list_hubs",
-    description: "The most-depended-on code (centrality outliers).",
+    description: "Most-depended-on symbols.",
     inputSchema: obj({ limit: { type: "number" } }),
     handler: (graph, args) => graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance).slice(0, numOr(args.limit, 20)).map((n) => ({ name: n.qualifiedName, kind: n.kind, file: n.file, line: n.span.start, importance: n.importance, isHub: n.isHub }))
   },
-  {
-    name: "tests_for",
-    description: "Which tests cover a node (static call linkage + runtime coverage), with the linkage basis.",
-    inputSchema: obj({ name: { type: "string" }, pick: { type: "number", description: "choose nth candidate when ambiguous" } }, ["name"]),
-    handler: (graph, args) => {
-      const { node, candidates } = resolveOne(graph, String(args.name ?? ""), numOrU(args.pick));
-      if (!node) return unresolved(candidates);
-      return { node: node.qualifiedName, tested: node.tested, coverage: node.coverage ?? null, covers: coveringTests(graph, node) };
-    }
-  },
   {
     name: "get_facts",
-    description: "The deterministic open facts for a node (contract/invariant/characterization). Requires a --deep build.",
+    description: "Deterministic facts for a node (contract/invariant); needs a --deep build.",
     inputSchema: obj({ name: { type: "string" } }, ["name"]),
     handler: (graph, args) => {
       const { node, candidates } = resolveOne(graph, String(args.name ?? ""));
@@ -5613,7 +5894,7 @@ var TOOLS = [
   },
   {
     name: "guide_node",
-    description: "Cited relevant standards/practices for a node (OWASP/CWE), honest about recommended vs conjectured.",
+    description: "Cited standards/practices for a node (OWASP/CWE).",
     inputSchema: obj({ name: { type: "string" } }, ["name"]),
     handler: (graph, args) => {
       const { node, candidates } = resolveOne(graph, String(args.name ?? ""));
@@ -5627,17 +5908,17 @@ var TOOLS = [
   },
   {
     name: "check_drift",
-    description: 'Offline dependency inventory across npm/pypi/go (currency enrichment is the CLI\u2019s --online opt-in). Pass attribute:true to add git "who added this / who set the version" attribution for npm deps.',
+    description: "Offline dependency inventory (npm/pypi/go); attribute:true adds git who-added attribution.",
     inputSchema: obj(
-      { attribute: { type: "boolean", description: "enrich npm deps with git introduction attribution (requires git; slower)" } },
+      { attribute: { type: "boolean" } },
       []
     ),
     handler: (_graph, args, ctx) => attributedInventory(ctx.root, { attribute: args.attribute === true })
   },
   {
     name: "vuln_attribution",
-    description: "Who introduced each open vulnerability and how long you have been exposed, plus CRA remediation metrics: open exposure windows, SLA breaches, and real remediation time (MTTR) reconstructed from vulnerable versions that were later bumped out or removed in git history. Offline read of the last `vg scan --vulns`.",
-    inputSchema: obj({ package: { type: "string", description: "optional: restrict to one package" } }, []),
+    description: "Who introduced each open vulnerability, exposure windows, and CRA remediation metrics (MTTR, SLA breaches). Reads the last `vg scan --vulns`.",
+    inputSchema: obj({ package: { type: "string", description: "restrict to one package" } }, []),
     handler: (_graph, args, ctx) => {
       const data = loadVulnerabilities(ctx.root);
       if (!data) {
@@ -5666,9 +5947,9 @@ var TOOLS = [
   },
   {
     name: "list_vulnerabilities",
-    description: "Known vulnerabilities for installed dependencies, from the last `vg scan --vulns`. Offline read of the local scan artifact (no network); reports advisory id/CVE, severity, CVSS, and the fixed version.",
+    description: "Known vulnerabilities from the last `vg scan --vulns`: id/CVE, severity, CVSS, fixed version.",
     inputSchema: obj(
-      { severity: { type: "string", enum: ["low", "moderate", "high", "critical"], description: "optional minimum severity to include" } },
+      { severity: { type: "string", enum: ["low", "moderate", "high", "critical"], description: "minimum severity" } },
       []
     ),
     handler: (_graph, args, ctx) => {
@@ -5704,11 +5985,11 @@ var TOOLS = [
   },
   {
     name: "upgrade_impact",
-    description: 'A local "what breaks if I upgrade this" brief for a package: major-version distance + interim majors to step through, source blast radius (how many files import it), open vulnerabilities the upgrade would fix, and a recommended posture. Offline; richest after `vg scan`. Pass changelog:true to also fetch breaking-change signals from the package\'s GitHub releases (online; ignored under --local).',
+    description: "What breaks if you upgrade a package: major distance, import blast radius, vulns fixed, recommended posture. changelog:true adds GitHub breaking-change signals (online).",
     inputSchema: obj(
       {
-        package: { type: "string", description: "package name to assess" },
-        changelog: { type: "boolean", description: "also fetch breaking-change signals from GitHub releases between your version and latest (online; ignored under --local)" }
+        package: { type: "string" },
+        changelog: { type: "boolean" }
       },
       ["package"]
     ),
@@ -5724,19 +6005,19 @@ var TOOLS = [
   },
   {
     name: "list_models",
-    description: "The local model fleet discovered on disk (Ollama / LM Studio / gguf). Offline, no launch.",
+    description: "Local models on disk (Ollama / LM Studio / gguf).",
     inputSchema: obj({}),
     handler: () => ({ models: discoverModels() })
   },
   {
     name: "resolve_library",
-    description: "Resolve a library name/query to its canonical id + the version for YOUR project (version-correct + drift-annotated).",
+    description: "Resolve a library to its canonical id and the version YOUR project uses (drift-annotated).",
     // Canonical §4: `query` (+ optional `context_project`). `name` kept as a back-compat alias.
     inputSchema: obj(
       {
-        query: { type: "string", description: "library name or natural-language query" },
-        name: { type: "string", description: "alias for query (back-compat)" },
-        context_project: { type: "string", description: "optional lockfile/manifest context (informational; the local server uses the project root)" }
+        query: { type: "string", description: "library name or query" },
+        name: { type: "string" },
+        context_project: { type: "string" }
       },
       []
     ),
@@ -5779,19 +6060,19 @@ var TOOLS = [
   },
   {
     name: "library_docs",
-    description: "Version-correct, drift-annotated usage docs for a library \u2014 from the committed catalog or the installed package on disk.",
+    description: "Version-correct usage docs for a library, sliced to a token budget.",
     // Canonical §4: `targetId`/`query`, `verbosity`, `max_tokens`. `name`/`tokens` kept as aliases.
     inputSchema: obj(
       {
-        targetId: { type: "string", description: "canonical id from resolve_library" },
+        targetId: { type: "string", description: "id from resolve_library" },
         query: { type: "string", description: "library name or query" },
-        name: { type: "string", description: "alias for query (back-compat)" },
-        context_project: { type: "string", description: "optional project context (informational)" },
-        verbosity: { type: "string", enum: ["concise", "balanced", "exhaustive"], description: "detail level (sets the default token budget)" },
-        max_tokens: { type: "number", description: "explicit token budget (overrides verbosity)" },
-        tokens: { type: "number", description: "alias for max_tokens (back-compat)" },
-        enterprise_strict: { type: "boolean", description: "reserved (enterprise policy enforcement \u2014 hosted surface)" },
-        follow_up: { type: "boolean", description: "reserved (next slice \u2014 hosted surface)" }
+        name: { type: "string" },
+        context_project: { type: "string" },
+        verbosity: { type: "string", enum: ["concise", "balanced", "exhaustive"] },
+        max_tokens: { type: "number", description: "token budget" },
+        tokens: { type: "number" },
+        enterprise_strict: { type: "boolean" },
+        follow_up: { type: "boolean" }
       },
       []
     ),
@@ -5886,15 +6167,15 @@ var TOOLS = [
   }
 ];
 var VERBOSITY_BUDGET = { concise: 1500, balanced: 4e3, exhaustive: 12e3 };
-function summarize(graph) {
+function summarize(graph, top = 10) {
   return {
     counts: graph.meta.counts,
     languages: graph.meta.languages,
     cluster: graph.meta.cluster,
     resolver: graph.provenance.resolver,
     generatedAt: graph.generatedAt,
-    topAreas: [...graph.areas].sort((a, b) => b.size - a.size).slice(0, 10).map((a) => ({ id: a.id, label: a.label, size: a.size })),
-    topHubs: graph.nodes.filter((n) => n.isHub).sort((a, b) => b.importance - a.importance).slice(0, 10).map((n) => ({ name: n.qualifiedName, file: n.file, importance: n.importance }))
+    topAreas: [...graph.areas].sort((a, b) => b.size - a.size).slice(0, top).map((a) => ({ id: a.id, label: a.label, size: a.size })),
+    topHubs: graph.nodes.filter((n) => n.isHub).sort((a, b) => b.importance - a.importance).slice(0, top).map((n) => ({ name: n.qualifiedName, file: n.file, importance: n.importance }))
   };
 }
 function stripId(item) {
@@ -5925,6 +6206,19 @@ function numOrU(v) {
 function uniqueNames(xs) {
   return [...new Set(xs)];
 }
+var HOT_TOOLS = ["orient", "search_symbols", "query_graph", "get_node"];
+function deferredToolNames() {
+  const hot = new Set(HOT_TOOLS);
+  return TOOLS.map((t) => t.name).filter((n) => !hot.has(n));
+}
+function navigationToolsetConfig(serverName = "vibgrate") {
+  return {
+    type: "mcp_toolset",
+    mcp_server_name: serverName,
+    default_config: { defer_loading: true },
+    configs: Object.fromEntries(HOT_TOOLS.map((n) => [n, { defer_loading: false }]))
+  };
+}
 var LEDGER = "savings.jsonl";
 var PER_FILE_TOKENS = 400;
 function ledgerPath(root) {
@@ -6047,7 +6341,13 @@ function createServer(source, opts = {}) {
   const seen = /* @__PURE__ */ new Set();
   const server = new Server(
     { name: "vg", version: VERSION },
-    { capabilities: { tools: {} } }
+    {
+      capabilities: { tools: {} },
+      // Routing guidance once at the server level (hosts that surface
+      // `instructions` get it at zero per-step schema cost): the flashlight
+      // vs the map.
+      instructions: 'vg is a code map. Use search_symbols to find a known name or literal string fast. Use orient/query_graph for meaning: symptoms, relationships, and what-breaks-if. Responses are concise by default; pass response_format:"detailed" only when a node proves load-bearing. Navigate as little as possible: one good search/query usually locates the code. As soon as you have the file and line, read that file and make the edit \u2014 do not call further graph tools unless the edit fails or the match was wrong.'
+    }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOLS.map((t) => ({
@@ -6086,6 +6386,7 @@ function createServer(source, opts = {}) {
 async function serveStdio(graphPath, opts = {}) {
   const source = new GraphSource(graphPath, opts.refresh !== false);
   const server = createServer(source, opts);
+  warmEmbedderInBackground(opts.local);
   await server.connect(new StdioServerTransport());
 }
 function sleep(ms) {
@@ -6310,6 +6611,18 @@ function writeFileEnsured(file, content) {
   fs18.mkdirSync(path18.dirname(file), { recursive: true });
   fs18.writeFileSync(file, content);
 }
+function writeNavigationConfig(root) {
+  const rel2 = path18.join(".vibgrate", "mcp-navigation.json");
+  const doc = {
+    _readme: "Deferred-loading config for agents embedding `vg serve` via the Claude API (defer_loading + tool-search). The hot navigation core stays in context; the rest load on demand \u2014 ~350-450 schema tokens/step vs ~1,881 for the full set. Hosts without defer_loading ignore this and serve the whole (already optimized) tool set. See docs/graph/VG-NAVIGATION-PROFILE.md.",
+    hot_core: [...HOT_TOOLS],
+    deferred: deferredToolNames(),
+    toolset: navigationToolsetConfig()
+  };
+  writeFileEnsured(path18.join(root, rel2), `${JSON.stringify(doc, null, 2)}
+`);
+  return rel2;
+}
 function upsertMcp(file, target, launch) {
   const config = readJson(file);
   const entry = mcpServerEntry(launch);
@@ -6399,6 +6712,8 @@ function formatForExt(ext) {
       return "dot";
     case ".cypher":
       return "cypher";
+    case ".sql":
+      return "sql";
     case ".md":
       return "md";
     case ".html":
@@ -6423,6 +6738,8 @@ function exportGraph(format, ctx) {
       return dot(ctx.graph);
     case "cypher":
       return cypher(ctx.graph);
+    case "sql":
+      return sql(ctx);
     case "cyclonedx":
       return cyclonedx(ctx);
     case "spdx":
@@ -6485,6 +6802,66 @@ function cypherLabel(s) {
 function q(s) {
   return JSON.stringify(s);
 }
+function sql(ctx) {
+  const graph = ctx.graph;
+  const lines = [];
+  lines.push("BEGIN;");
+  lines.push("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);");
+  const meta = [
+    ["schemaVersion", graph.schemaVersion],
+    ["generatedAt", ctx.generatedAt],
+    ["corpusHash", graph.provenance.corpusHash],
+    ["tool", graph.provenance.tool],
+    ["toolVersion", graph.provenance.version],
+    ["resolver", graph.provenance.resolver.join(",")],
+    ["fingerprint", graph.provenance.toolchain?.fingerprint ?? null]
+  ];
+  for (const [k, v] of meta) lines.push(`INSERT INTO meta VALUES (${sqlStr(k)}, ${sqlStr(v)});`);
+  lines.push(
+    "CREATE TABLE IF NOT EXISTS nodes (id TEXT PRIMARY KEY, kind TEXT, name TEXT, qualified_name TEXT, file TEXT, span_start INTEGER, span_end INTEGER, lang TEXT, visibility TEXT, signature TEXT, importance REAL, area INTEGER, is_hub INTEGER, tested INTEGER, coverage REAL);"
+  );
+  for (const n of graph.nodes) {
+    lines.push(
+      `INSERT INTO nodes VALUES (${sqlStr(n.id)}, ${sqlStr(n.kind)}, ${sqlStr(n.name)}, ${sqlStr(n.qualifiedName)}, ${sqlStr(n.file)}, ${sqlNum(n.span.start)}, ${sqlNum(n.span.end)}, ${sqlStr(n.lang)}, ${sqlStr(n.visibility)}, ${sqlStr(n.signature)}, ${sqlNum(n.importance)}, ${sqlNum(n.area)}, ${sqlBool(n.isHub)}, ${sqlBool(n.tested)}, ${sqlNum(n.coverage)});`
+    );
+  }
+  lines.push(
+    'CREATE TABLE IF NOT EXISTS edges (id TEXT PRIMARY KEY, kind TEXT, src TEXT, dst TEXT, resolution TEXT, confidence REAL, epistemic TEXT, surprise REAL, "count" INTEGER);'
+  );
+  for (const e of graph.edges) {
+    lines.push(
+      `INSERT INTO edges VALUES (${sqlStr(e.id)}, ${sqlStr(e.kind)}, ${sqlStr(e.src)}, ${sqlStr(e.dst)}, ${sqlStr(e.resolution)}, ${sqlNum(e.confidence)}, ${sqlStr(e.epistemic)}, ${sqlNum(e.surprise)}, ${sqlNum(e.count)});`
+    );
+  }
+  lines.push("CREATE TABLE IF NOT EXISTS areas (id INTEGER PRIMARY KEY, label TEXT, size INTEGER, cohesion REAL, external_edges INTEGER);");
+  lines.push("CREATE TABLE IF NOT EXISTS area_members (area_id INTEGER, node_id TEXT);");
+  for (const a of graph.areas) {
+    lines.push(`INSERT INTO areas VALUES (${sqlNum(a.id)}, ${sqlStr(a.label)}, ${sqlNum(a.size)}, ${sqlNum(a.cohesion)}, ${sqlNum(a.externalEdges)});`);
+    for (const m of a.members) lines.push(`INSERT INTO area_members VALUES (${sqlNum(a.id)}, ${sqlStr(m)});`);
+  }
+  if (graph.facts && graph.facts.length) {
+    lines.push("CREATE TABLE IF NOT EXISTS facts (id TEXT PRIMARY KEY, kind TEXT, predicate_json TEXT, derived_by TEXT, confidence TEXT);");
+    lines.push("CREATE TABLE IF NOT EXISTS fact_subjects (fact_id TEXT, node_id TEXT);");
+    lines.push("CREATE TABLE IF NOT EXISTS fact_evidence (fact_id TEXT, file TEXT, span_start INTEGER, span_end INTEGER);");
+    for (const f of graph.facts) {
+      lines.push(`INSERT INTO facts VALUES (${sqlStr(f.id)}, ${sqlStr(f.kind)}, ${sqlStr(JSON.stringify(f.predicate))}, ${sqlStr(f.derivedBy)}, ${sqlStr(f.confidence)});`);
+      for (const s of f.subjectIds) lines.push(`INSERT INTO fact_subjects VALUES (${sqlStr(f.id)}, ${sqlStr(s)});`);
+      for (const ev of f.evidence) lines.push(`INSERT INTO fact_evidence VALUES (${sqlStr(f.id)}, ${sqlStr(ev.file)}, ${sqlNum(ev.span.start)}, ${sqlNum(ev.span.end)});`);
+    }
+  }
+  lines.push("COMMIT;");
+  return lines.join("\n") + "\n";
+}
+function sqlStr(v) {
+  if (v == null) return "NULL";
+  return `'${v.replace(/'/g, "''")}'`;
+}
+function sqlNum(v) {
+  return v == null || !Number.isFinite(v) ? "NULL" : String(v);
+}
+function sqlBool(v) {
+  return v == null ? "NULL" : v ? "1" : "0";
+}
 function cyclonedx(ctx) {
   const components = [];
   for (const d of ctx.deps ?? []) {
@@ -6524,6 +6901,6 @@ function spdx(ctx) {
   return JSON.stringify(doc, null, 2) + "\n";
 }
 
-export { ASSISTANTS, CliError, ECOSYSTEMS, ExitCode, FREE_PACK, GraphIndex, GraphSource, NPX_INVOCATION, ResourceLimitError, SCHEMA_VERSION, SKIP_DIRS, SKIP_FILES, TOOLS, UsageError, addLibrary, analyze, applyCoverage, applyStaticTestLinkage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, buildModuleResolver, cacheDir, catalogPath, clearModelCache, clearStoredCredentials, cosine, countPending, coveringTests, createServer, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, defaultGraphPath, detectRunner, detectServeLaunch, discover, discoverModels, driftCount, driftFor, dsnCommand, embeddingsCached, enrichOnline, ensureGitignored, exportGraph, fetchHostedDocs, findGitRoot, findNodes, formatForExt, getNodeEmbeddings, gitignoreEntryForCredentials, groundGraph, hasDrift, identifierParts, impactOf, installAssistant, inventory, isModelReady, isTestFile, libDir, libId, loadCatalog, loadCoverage, loadEmbedder, loadGraph, loadSnapshot, localApiSurface, localPackageDocs, modelCacheInfo, nodeById, nodeEmbedText, parseDsn, parseGraph, parseJsonc, probeFreshness, publishPrivateLibrary, pushCommand, queryGraph, queryGraphSemantic, readDoc, readSavings, readScanArtifact, recordSaving, refreshIfStale, relativeResolver, renderHtml, renderReport, resolveCliInvocation, resolveDsn, resolveEmbedModel, resolveIngestHost, resolveLib, resolveLimits, resolveOne, resolveVersion, saveCatalog, savingsRecorded, scipEdges, selectForBudget, serializeGraph, serveStdio, shortestPath, stableStringify, symbolsFromApi, testsToRun, unavailableMessage, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, vibgrateDir, writeArtifacts, writeSnapshot, writeStoredCredentials };
-//# sourceMappingURL=chunk-YODVLV37.js.map
-//# sourceMappingURL=chunk-YODVLV37.js.map
+export { ASSISTANTS, CliError, ECOSYSTEMS, ExitCode, FREE_PACK, GraphIndex, GraphSource, NPX_INVOCATION, ResourceLimitError, SCHEMA_VERSION, SKIP_DIRS, SKIP_FILES, TOOLS, UsageError, addLibrary, analyze, applyCoverage, applyStaticTestLinkage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, buildModuleResolver, cacheDir, catalogPath, clearModelCache, clearStoredCredentials, cosine, countPending, coveringTests, createServer, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, defaultGraphPath, detectRunner, detectServeLaunch, discover, discoverModels, driftCount, driftFor, dsnCommand, embeddingsCached, enrichOnline, ensureGitignored, epistemicBreakdown, exportGraph, fetchHostedDocs, findGitRoot, findNodes, formatForExt, getNodeEmbeddings, gitignoreEntryForCredentials, groundGraph, hasDrift, identifierParts, impactOf, ingestHostForRegionId, installAssistant, inventory, isModelReady, isTestFile, libDir, libId, loadCatalog, loadCoverage, loadEmbedder, loadGraph, loadSnapshot, localApiSurface, localPackageDocs, modelCacheInfo, nodeById, nodeEmbedText, parseDsn, parseGraph, parseJsonc, probeFreshness, publishPrivateLibrary, pushCommand, queryGraph, queryGraphSemantic, readDoc, readSavings, readScanArtifact, recordSaving, refreshIfStale, relativeResolver, renderHtml, renderReport, resolveCliInvocation, resolveDsn, resolveEmbedModel, resolveIngestHost, resolveLib, resolveLimits, resolveOne, resolveVersion, saveCatalog, savingsRecorded, scipEdges, selectForBudget, serializeGraph, serveStdio, shortestPath, stableStringify, symbolsFromApi, testsToRun, unavailableMessage, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, vibgrateDir, writeArtifacts, writeNavigationConfig, writeSnapshot, writeStoredCredentials };
+//# sourceMappingURL=chunk-2J7DPIAL.js.map
+//# sourceMappingURL=chunk-2J7DPIAL.js.map