@vibgrate/cli 2026.708.3 → 2026.709.2

package/dist/{chunk-2DJ3UXG7.js → chunk-3TCE6IGZ.js}

@@ -1,8 +1,8 @@
 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-QUELGOCR.js';
-import * as fs18 from 'fs';
-import { execFileSync } from 'child_process';
-import * as path18 from 'path';
+import { writeTextFile, pathExists, readJsonFile, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-PIWHQSAR.js';
+import * as fs19 from 'fs';
+import { spawnSync, execFileSync } from 'child_process';
+import * as path19 from 'path';
 import ignore from 'ignore';
 import * as v8 from 'v8';
 import Graph from 'graphology';
@@ -20,6 +20,7 @@ import chalk from 'chalk';
 import * as zlib from 'zlib';
 import { promisify } from 'util';
 import { encode, decode } from 'gpt-tokenizer/encoding/cl100k_base';
+import { Worker } from 'worker_threads';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
@@ -38,9 +39,9 @@ function whichOnPath(cmd) {
 }
 function isOwnBinary(binPath) {
   try {
-    const real = fs18.realpathSync(binPath);
+    const real = fs19.realpathSync(binPath);
     if (/[\\/]@vibgrate[\\/]cli[\\/]/.test(real)) return true;
-    const head = fs18.readFileSync(real, { encoding: "utf8" }).slice(0, 2048);
+    const head = fs19.readFileSync(real, { encoding: "utf8" }).slice(0, 2048);
     return head.includes("@vibgrate/cli") || head.includes("vibgrate");
   } catch {
     return false;
@@ -50,7 +51,7 @@ function isEphemeralNpxBinary(binPath) {
   const NPX_SEGMENT = /[\\/]_npx[\\/]/;
   if (NPX_SEGMENT.test(binPath)) return true;
   try {
-    return NPX_SEGMENT.test(fs18.realpathSync(binPath));
+    return NPX_SEGMENT.test(fs19.realpathSync(binPath));
   } catch {
     return false;
   }
@@ -216,19 +217,19 @@ var SKIP_FILES = /* @__PURE__ */ new Set([
   "flake.lock"
 ]);
 function toPosix(p) {
-  return p.split(path18.sep).join("/");
+  return p.split(path19.sep).join("/");
 }
 function buildRootIgnore(root, exclude) {
   const ig = ignore();
-  const gitignorePath = path18.join(root, ".gitignore");
-  if (fs18.existsSync(gitignorePath)) {
-    ig.add(fs18.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path19.join(root, ".gitignore");
+  if (fs19.existsSync(gitignorePath)) {
+    ig.add(fs19.readFileSync(gitignorePath, "utf8"));
   }
   if (exclude.length) ig.add(exclude);
   return ig;
 }
 function discover(options) {
-  const root = path18.resolve(options.root);
+  const root = path19.resolve(options.root);
   const onlyLangs = (options.only ?? []).filter(Boolean);
   const allowLang = (lang) => onlyLangs.length === 0 || onlyLangs.includes(lang.id);
   for (const id of onlyLangs) {
@@ -237,27 +238,27 @@ function discover(options) {
     }
   }
   const rootIg = buildRootIgnore(root, options.exclude ?? []);
-  const scopeAbs = (options.paths && options.paths.length ? options.paths.map((p) => path18.resolve(root, p)) : [root]).filter((p) => fs18.existsSync(p));
+  const scopeAbs = (options.paths && options.paths.length ? options.paths.map((p) => path19.resolve(root, p)) : [root]).filter((p) => fs19.existsSync(p));
   const found = /* @__PURE__ */ new Map();
   const considerFile = (abs) => {
-    const rel2 = toPosix(path18.relative(root, abs));
+    const rel2 = toPosix(path19.relative(root, abs));
     if (rel2.startsWith("..")) return;
     if (rel2 === "" || rootIg.ignores(rel2)) return;
-    if (SKIP_FILES.has(path18.basename(abs).toLowerCase())) return;
-    const lang = langForExtension(path18.extname(abs));
+    if (SKIP_FILES.has(path19.basename(abs).toLowerCase())) return;
+    const lang = langForExtension(path19.extname(abs));
     if (!lang || !allowLang(lang)) return;
     found.set(rel2, { rel: rel2, abs, lang });
   };
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs19.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const abs = path18.join(dir, entry.name);
-      const rel2 = toPosix(path18.relative(root, abs));
+      const abs = path19.join(dir, entry.name);
+      const rel2 = toPosix(path19.relative(root, abs));
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         if (rel2 && rootIg.ignores(`${rel2}/`)) continue;
@@ -268,7 +269,7 @@ function discover(options) {
     }
   };
   for (const scope of scopeAbs) {
-    const stat = fs18.statSync(scope);
+    const stat = fs19.statSync(scope);
     if (stat.isDirectory()) walk2(scope);
     else if (stat.isFile()) considerFile(scope);
   }
@@ -434,10 +435,10 @@ function buildModuleResolver(root, relSet) {
     resolve(fromRel, source) {
       if (source.includes("\\")) source = source.split("\\").join(".");
       if (source.startsWith("./") || source.startsWith("../")) {
-        return probe(posixJoin(path18.posix.dirname(fromRel), source));
+        return probe(posixJoin(path19.posix.dirname(fromRel), source));
       }
       if (/\.[A-Za-z0-9]+$/.test(source) && !source.startsWith("<")) {
-        const hit = probe(posixJoin(path18.posix.dirname(fromRel), source));
+        const hit = probe(posixJoin(path19.posix.dirname(fromRel), source));
         if (hit) return hit;
       }
       if (source.startsWith(".")) {
@@ -508,8 +509,8 @@ function resolvePyRelative(probe, fromRel, source) {
   let dots = 0;
   while (source[dots] === ".") dots++;
   const rest = source.slice(dots);
-  let dir = path18.posix.dirname(fromRel);
-  for (let i = 1; i < dots; i++) dir = path18.posix.dirname(dir);
+  let dir = path19.posix.dirname(fromRel);
+  for (let i = 1; i < dots; i++) dir = path19.posix.dirname(dir);
   const sub = rest.replace(/\./g, "/");
   return probe(sub ? posixJoin(dir, sub) : dir);
 }
@@ -517,7 +518,7 @@ function relativeResolver(relSet) {
   const probe = makeProbe(relSet);
   return {
     resolve(fromRel, source) {
-      if (source.startsWith(".")) return probe(posixJoin(path18.posix.dirname(fromRel), source));
+      if (source.startsWith(".")) return probe(posixJoin(path19.posix.dirname(fromRel), source));
       return resolveDotted(probe, source);
     }
   };
@@ -535,12 +536,12 @@ function makeProbe(relSet) {
   };
 }
 function normalizeRel(p) {
-  const norm = path18.posix.normalize(p);
+  const norm = path19.posix.normalize(p);
   const stripped = norm.startsWith("./") ? norm.slice(2) : norm;
   return stripped.startsWith("..") ? "" : stripped;
 }
 function posixJoin(a, b) {
-  return path18.posix.normalize(path18.posix.join(a, b));
+  return path19.posix.normalize(path19.posix.join(a, b));
 }
 function matchPattern(pattern, source) {
   const star = pattern.indexOf("*");
@@ -553,8 +554,8 @@ function matchPattern(pattern, source) {
 }
 function loadTsconfigPaths(root) {
   for (const name of ["tsconfig.base.json", "tsconfig.json"]) {
-    const file = path18.join(root, name);
-    if (fs18.existsSync(file)) {
+    const file = path19.join(root, name);
+    if (fs19.existsSync(file)) {
       const merged = readTsconfigChain(root, file, /* @__PURE__ */ new Set());
       if (merged && merged.paths.length) return merged;
     }
@@ -566,21 +567,21 @@ function readTsconfigChain(root, file, seen) {
   seen.add(file);
   let cfg;
   try {
-    cfg = parseJsonc(fs18.readFileSync(file, "utf8"));
+    cfg = parseJsonc(fs19.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
-  const dir = path18.dirname(file);
+  const dir = path19.dirname(file);
   let base = { baseUrlRel: "", paths: [] };
   if (cfg.extends && cfg.extends.startsWith(".")) {
-    const extPath = path18.resolve(dir, cfg.extends.endsWith(".json") ? cfg.extends : `${cfg.extends}.json`);
-    if (fs18.existsSync(extPath)) {
+    const extPath = path19.resolve(dir, cfg.extends.endsWith(".json") ? cfg.extends : `${cfg.extends}.json`);
+    if (fs19.existsSync(extPath)) {
       const inherited = readTsconfigChain(root, extPath, seen);
       if (inherited) base = inherited;
     }
   }
   const co = cfg.compilerOptions ?? {};
-  const baseUrlRel = co.baseUrl !== void 0 ? path18.relative(root, path18.resolve(dir, co.baseUrl)).split(path18.sep).join("/") : base.baseUrlRel;
+  const baseUrlRel = co.baseUrl !== void 0 ? path19.relative(root, path19.resolve(dir, co.baseUrl)).split(path19.sep).join("/") : base.baseUrlRel;
   const paths = [...base.paths];
   if (co.paths) for (const [k, v] of Object.entries(co.paths)) paths.push([k, v]);
   return { baseUrlRel, paths };
@@ -588,27 +589,27 @@ function readTsconfigChain(root, file, seen) {
 function loadWorkspacePackages(root) {
   const map = /* @__PURE__ */ new Map();
   const globs = [];
-  const rootPkg = path18.join(root, "package.json");
-  if (fs18.existsSync(rootPkg)) {
+  const rootPkg = path19.join(root, "package.json");
+  if (fs19.existsSync(rootPkg)) {
     try {
-      const pkg = JSON.parse(fs18.readFileSync(rootPkg, "utf8"));
+      const pkg = JSON.parse(fs19.readFileSync(rootPkg, "utf8"));
       const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
       if (ws) globs.push(...ws);
     } catch {
     }
   }
-  const pnpmWs = path18.join(root, "pnpm-workspace.yaml");
-  if (fs18.existsSync(pnpmWs)) {
-    for (const line of fs18.readFileSync(pnpmWs, "utf8").split("\n")) {
+  const pnpmWs = path19.join(root, "pnpm-workspace.yaml");
+  if (fs19.existsSync(pnpmWs)) {
+    for (const line of fs19.readFileSync(pnpmWs, "utf8").split("\n")) {
       const m = /^\s*-\s*['"]?([^'"\n]+)['"]?\s*$/.exec(line);
       if (m) globs.push(m[1].trim());
     }
   }
   for (const dir of expandWorkspaceGlobs(root, globs)) {
-    const pj = path18.join(dir, "package.json");
+    const pj = path19.join(dir, "package.json");
     try {
-      const name = JSON.parse(fs18.readFileSync(pj, "utf8")).name;
-      if (name) map.set(name, path18.relative(root, dir).split(path18.sep).join("/"));
+      const name = JSON.parse(fs19.readFileSync(pj, "utf8")).name;
+      if (name) map.set(name, path19.relative(root, dir).split(path19.sep).join("/"));
     } catch {
     }
   }
@@ -618,10 +619,10 @@ function expandWorkspaceGlobs(root, globs) {
   const out = /* @__PURE__ */ new Set();
   for (const glob of globs) {
     const clean = glob.replace(/\/\*\*$/, "").replace(/\/\*$/, "");
-    const baseDir = path18.join(root, clean);
+    const baseDir = path19.join(root, clean);
     const recurse = glob.endsWith("**");
     if (glob === clean) {
-      if (fs18.existsSync(path18.join(baseDir, "package.json"))) out.add(baseDir);
+      if (fs19.existsSync(path19.join(baseDir, "package.json"))) out.add(baseDir);
       continue;
     }
     collectPackageDirs(baseDir, recurse ? 4 : 1, out);
@@ -632,14 +633,14 @@ function collectPackageDirs(dir, depth, out) {
   if (depth < 0) return;
   let entries;
   try {
-    entries = fs18.readdirSync(dir, { withFileTypes: true });
+    entries = fs19.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (!e.isDirectory() || e.name === "node_modules" || e.name.startsWith(".")) continue;
-    const child = path18.join(dir, e.name);
-    if (fs18.existsSync(path18.join(child, "package.json"))) out.add(child);
+    const child = path19.join(dir, e.name);
+    if (fs19.existsSync(path19.join(child, "package.json"))) out.add(child);
     else collectPackageDirs(child, depth - 1, out);
   }
 }
@@ -1137,14 +1138,14 @@ var DEFAULT_PATHS = [
 ];
 function loadCoverage(root, explicit) {
   const candidates = (explicit && explicit.length ? explicit : DEFAULT_PATHS).map(
-    (p) => path18.resolve(root, p)
+    (p) => path19.resolve(root, p)
   );
-  const found = candidates.filter((p) => fs18.existsSync(p));
+  const found = candidates.filter((p) => fs19.existsSync(p));
   if (found.length === 0) return null;
   const map = /* @__PURE__ */ new Map();
   for (const file of found) {
     try {
-      const text = fs18.readFileSync(file, "utf8");
+      const text = fs19.readFileSync(file, "utf8");
       if (file.endsWith(".json")) mergeIstanbul(map, text, root);
       else mergeLcov(map, text, root);
     } catch {
@@ -1153,8 +1154,8 @@ function loadCoverage(root, explicit) {
   return map.size ? map : null;
 }
 function rel(root, p) {
-  const abs = path18.isAbsolute(p) ? p : path18.resolve(root, p);
-  return path18.relative(root, abs).split(path18.sep).join("/");
+  const abs = path19.isAbsolute(p) ? p : path19.resolve(root, p);
+  return path19.relative(root, abs).split(path19.sep).join("/");
 }
 function bump(map, file, line, hits) {
   let lh = map.get(file);
@@ -1490,7 +1491,7 @@ async function parseInline(files, options) {
   onProgress?.(0, files.length);
   for (const file of files) {
     try {
-      const source = fs18.readFileSync(file.abs, "utf8");
+      const source = fs19.readFileSync(file.abs, "utf8");
       out.push(await parseSource(file.rel, file.lang.id, source));
     } catch (err) {
       out.push(emptyParse(file, `parse failed: ${err.message}`));
@@ -1545,9 +1546,9 @@ function isWorkerOom(err) {
   return e?.code === "ERR_WORKER_OUT_OF_MEMORY" || /out of memory/i.test(e?.message ?? "");
 }
 function resolveWorkerFile() {
-  const here = path18.dirname(fileURLToPath(import.meta.url));
-  const candidate = path18.join(here, "parse-worker.js");
-  return fs18.existsSync(candidate) ? candidate : null;
+  const here = path19.dirname(fileURLToPath(import.meta.url));
+  const candidate = path19.join(here, "parse-worker.js");
+  return fs19.existsSync(candidate) ? candidate : null;
 }
 function chunk(items, buckets) {
   const out = Array.from({ length: Math.min(buckets, items.length || 1) }, () => []);
@@ -1585,7 +1586,7 @@ function resolve4(parses, resolver) {
     addNode(baseNodes, {
       id: fileId,
       kind: "file",
-      name: path18.posix.basename(p.rel),
+      name: path19.posix.basename(p.rel),
       qualifiedName: p.rel,
       file: p.rel,
       span: { start: 1, end: 1 },
@@ -2002,14 +2003,14 @@ function enclosing3(nodes, line) {
   return best;
 }
 function normalize2(p) {
-  return path18.resolve(p).split(path18.sep).join("/");
+  return path19.resolve(p).split(path19.sep).join("/");
 }
 var CACHE_VERSION = "vg-parse-cache/2";
 function cacheDir(root) {
-  return path18.join(root, ".vibgrate", "cache");
+  return path19.join(root, ".vibgrate", "cache");
 }
 function cachePath(root) {
-  return path18.join(cacheDir(root), "parse-cache.json");
+  return path19.join(cacheDir(root), "parse-cache.json");
 }
 function loadCache(root, opts) {
   const file = cachePath(root);
@@ -2019,9 +2020,9 @@ function loadCache(root, opts) {
     grammars: opts.grammars,
     entries: {}
   };
-  if (!opts.disabled && fs18.existsSync(file)) {
+  if (!opts.disabled && fs19.existsSync(file)) {
     try {
-      const loaded = JSON.parse(fs18.readFileSync(file, "utf8"));
+      const loaded = JSON.parse(fs19.readFileSync(file, "utf8"));
       if (loaded.version === CACHE_VERSION && loaded.toolVersion === opts.toolVersion && loaded.grammars === opts.grammars && loaded.entries) {
         data = loaded;
       }
@@ -2042,8 +2043,8 @@ function loadCache(root, opts) {
       }
     },
     save() {
-      fs18.mkdirSync(cacheDir(root), { recursive: true });
-      fs18.writeFileSync(file, stableStringify(data, 0));
+      fs19.mkdirSync(cacheDir(root), { recursive: true });
+      fs19.writeFileSync(file, stableStringify(data, 0));
     }
   };
 }
@@ -2075,7 +2076,7 @@ function epistemicBreakdown(edges) {
 // src/engine/build.ts
 async function buildGraph(options) {
   const start = nowMs();
-  const root = path18.resolve(options.root);
+  const root = path19.resolve(options.root);
   const files = discover({
     root,
     only: options.only,
@@ -2103,7 +2104,7 @@ async function buildGraph(options) {
   for (const file of files) {
     let stat;
     try {
-      stat = fs18.statSync(file.abs);
+      stat = fs19.statSync(file.abs);
     } catch {
       continue;
     }
@@ -2121,7 +2122,7 @@ async function buildGraph(options) {
     }
     let hash = "";
     try {
-      hash = hashBytes(fs18.readFileSync(file.abs));
+      hash = hashBytes(fs19.readFileSync(file.abs));
     } catch {
       continue;
     }
@@ -2213,7 +2214,7 @@ async function buildGraph(options) {
       toolchain
     },
     meta: {
-      root: path18.basename(root) === "" ? "." : ".",
+      root: path19.basename(root) === "" ? "." : ".",
       languages,
       counts: {
         nodes: analysis.nodes.length,
@@ -2259,14 +2260,14 @@ function toRepoRel(p) {
 function loadScipIndex(root, explicit) {
   const candidates = [
     explicit,
-    path18.join(root, "index.scip"),
-    path18.join(root, ".vibgrate", "index.scip")
+    path19.join(root, "index.scip"),
+    path19.join(root, ".vibgrate", "index.scip")
   ].filter((p) => Boolean(p));
   for (const file of candidates) {
-    const abs = path18.isAbsolute(file) ? file : path18.resolve(root, file);
-    if (!fs18.existsSync(abs)) continue;
+    const abs = path19.isAbsolute(file) ? file : path19.resolve(root, file);
+    if (!fs19.existsSync(abs)) continue;
     try {
-      const index = decodeScipIndex(new Uint8Array(fs18.readFileSync(abs)));
+      const index = decodeScipIndex(new Uint8Array(fs19.readFileSync(abs)));
       if (index.documents.length) {
         return { index, tool: index.toolVersion ? `${index.toolName} ${index.toolVersion}` : index.toolName };
       }
@@ -2427,46 +2428,46 @@ 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");
+  return path19.join(root, ".vibgrate");
 }
 function defaultGraphPath(root) {
-  return path18.join(vibgrateDir(root), "graph.json");
+  return path19.join(vibgrateDir(root), "graph.json");
 }
 function writeArtifacts(graph, options) {
   const dir = vibgrateDir(options.root);
-  fs18.mkdirSync(dir, { recursive: true });
+  fs19.mkdirSync(dir, { recursive: true });
   const graphPath = options.graphPath ?? defaultGraphPath(options.root);
-  fs18.mkdirSync(path18.dirname(graphPath), { recursive: true });
+  fs19.mkdirSync(path19.dirname(graphPath), { recursive: true });
   const tmp = `${graphPath}.${process.pid}.tmp`;
   try {
-    fs18.writeFileSync(tmp, serializeGraph(graph));
-    fs18.renameSync(tmp, graphPath);
+    fs19.writeFileSync(tmp, serializeGraph(graph));
+    fs19.renameSync(tmp, graphPath);
   } catch (err) {
-    fs18.rmSync(tmp, { force: true });
+    fs19.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));
+    const reportPath = path19.join(dir, "GRAPH_REPORT.md");
+    fs19.writeFileSync(reportPath, renderReport(graph));
     written.reportPath = reportPath;
   }
   if (options.html !== false) {
-    const htmlPath = path18.join(dir, "graph.html");
-    fs18.writeFileSync(htmlPath, renderHtml(graph));
+    const htmlPath = path19.join(dir, "graph.html");
+    fs19.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");
+    const factsPath = path19.join(dir, "facts.jsonl");
+    fs19.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"));
+  if (!fs19.existsSync(file)) return null;
+  return parseGraph(fs19.readFileSync(file, "utf8"));
 }
 
 // src/engine/verify.ts
@@ -2543,7 +2544,7 @@ function isProcessAlive(pid) {
 }
 function lockIsStale(file, staleMs) {
   try {
-    const { pid, at } = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const { pid, at } = JSON.parse(fs19.readFileSync(file, "utf8"));
     if (typeof at === "number" && Date.now() - at > staleMs) return true;
     if (typeof pid === "number" && !isProcessAlive(pid)) return true;
     return false;
@@ -2554,10 +2555,10 @@ function lockIsStale(file, staleMs) {
 function acquireLock(file, staleMs = DEFAULT_LOCK_STALE_MS) {
   const write = () => {
     try {
-      fs18.mkdirSync(path18.dirname(file), { recursive: true });
-      const fd = fs18.openSync(file, "wx");
-      fs18.writeFileSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
-      fs18.closeSync(fd);
+      fs19.mkdirSync(path19.dirname(file), { recursive: true });
+      const fd = fs19.openSync(file, "wx");
+      fs19.writeFileSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+      fs19.closeSync(fd);
       return true;
     } catch {
       return false;
@@ -2566,7 +2567,7 @@ function acquireLock(file, staleMs = DEFAULT_LOCK_STALE_MS) {
   if (write()) return true;
   if (lockIsStale(file, staleMs)) {
     try {
-      fs18.rmSync(file, { force: true });
+      fs19.rmSync(file, { force: true });
     } catch {
     }
     return write();
@@ -2575,7 +2576,7 @@ function acquireLock(file, staleMs = DEFAULT_LOCK_STALE_MS) {
 }
 function releaseLock(file) {
   try {
-    fs18.rmSync(file, { force: true });
+    fs19.rmSync(file, { force: true });
   } catch {
   }
 }
@@ -2585,14 +2586,14 @@ function resolveEmbedModel(model) {
   return model ?? "bge-small-en-v1.5";
 }
 function modelCacheDir() {
-  const base = process.env.XDG_CACHE_HOME || path18.join(os.homedir(), ".cache");
-  return path18.join(base, "vibgrate", "models");
+  const base = process.env.XDG_CACHE_HOME || path19.join(os.homedir(), ".cache");
+  return path19.join(base, "vibgrate", "models");
 }
 function modelReadyMarker(modelId) {
-  return path18.join(modelCacheDir(), `.ready-${safe(modelId)}`);
+  return path19.join(modelCacheDir(), `.ready-${safe(modelId)}`);
 }
 function isModelReady(modelId = resolveEmbedModel()) {
-  return fs18.existsSync(modelReadyMarker(modelId));
+  return fs19.existsSync(modelReadyMarker(modelId));
 }
 function unavailableMessage(reason) {
   switch (reason) {
@@ -2609,13 +2610,13 @@ function unavailableMessage(reason) {
 }
 function modelCacheInfo(modelId = resolveEmbedModel()) {
   const dir = modelCacheDir();
-  return { dir, present: isModelReady(modelId) || fs18.existsSync(dir), bytes: dirSize(dir) };
+  return { dir, present: isModelReady(modelId) || fs19.existsSync(dir), bytes: dirSize(dir) };
 }
 function clearModelCache() {
   const dir = modelCacheDir();
   const bytes = dirSize(dir);
   try {
-    fs18.rmSync(dir, { recursive: true, force: true });
+    fs19.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
   return bytes;
@@ -2624,16 +2625,16 @@ function dirSize(dir) {
   let total = 0;
   let entries;
   try {
-    entries = fs18.readdirSync(dir, { withFileTypes: true });
+    entries = fs19.readdirSync(dir, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const e of entries) {
-    const p = path18.join(dir, e.name);
+    const p = path19.join(dir, e.name);
     if (e.isDirectory()) total += dirSize(p);
     else {
       try {
-        total += fs18.statSync(p).size;
+        total += fs19.statSync(p).size;
       } catch {
       }
     }
@@ -2645,7 +2646,7 @@ function isPermissionError(e) {
   return code === "EACCES" || code === "EPERM" || code === "EROFS";
 }
 function embeddingsCached(root, modelId) {
-  return fs18.existsSync(path18.join(cacheDir(root), `embeddings-${safe(modelId)}.json`));
+  return fs19.existsSync(path19.join(cacheDir(root), `embeddings-${safe(modelId)}.json`));
 }
 async function loadEmbedder(options = {}) {
   if (options.local) return null;
@@ -2659,7 +2660,7 @@ async function loadEmbedder(options = {}) {
   if (!mod?.FlagEmbedding) return fail("not-installed");
   const cache = modelCacheDir();
   try {
-    fs18.mkdirSync(cache, { recursive: true });
+    fs19.mkdirSync(cache, { recursive: true });
   } catch (e) {
     return fail(isPermissionError(e) ? "no-permission" : "init-failed");
   }
@@ -2674,7 +2675,7 @@ async function loadEmbedder(options = {}) {
       "embedding model init timed out"
     );
     try {
-      fs18.writeFileSync(modelReadyMarker(modelId), (/* @__PURE__ */ new Date(0)).toISOString());
+      fs19.writeFileSync(modelReadyMarker(modelId), (/* @__PURE__ */ new Date(0)).toISOString());
     } catch {
     }
     return {
@@ -2772,7 +2773,7 @@ function cosine(a, b) {
 var EMBED_CHUNK = 256;
 var CACHE_WRITE_INTERVAL_MS = 1500;
 function vectorCachePath(root, modelId) {
-  return path18.join(cacheDir(root), `embeddings-${safe(modelId)}.json`);
+  return path19.join(cacheDir(root), `embeddings-${safe(modelId)}.json`);
 }
 function countPending(graph, root, modelId) {
   const entries = readCacheEntries(vectorCachePath(root, modelId), modelId);
@@ -2787,9 +2788,9 @@ function countPending(graph, root, modelId) {
   return pending;
 }
 function readCacheEntries(file, modelId) {
-  if (!fs18.existsSync(file)) return {};
+  if (!fs19.existsSync(file)) return {};
   try {
-    const loaded = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const loaded = JSON.parse(fs19.readFileSync(file, "utf8"));
     if (loaded.model === modelId && loaded.entries) return loaded.entries;
   } catch {
   }
@@ -2798,9 +2799,9 @@ function readCacheEntries(file, modelId) {
 async function getNodeEmbeddings(graph, embedder, root, onProgress) {
   const file = vectorCachePath(root, embedder.id);
   let cache = { model: embedder.id, entries: {} };
-  if (fs18.existsSync(file)) {
+  if (fs19.existsSync(file)) {
     try {
-      const loaded = JSON.parse(fs18.readFileSync(file, "utf8"));
+      const loaded = JSON.parse(fs19.readFileSync(file, "utf8"));
       if (loaded.model === embedder.id && loaded.entries) cache = loaded;
     } catch {
     }
@@ -2818,10 +2819,10 @@ async function getNodeEmbeddings(graph, embedder, root, onProgress) {
   }
   const persist = () => {
     try {
-      fs18.mkdirSync(cacheDir(root), { recursive: true });
+      fs19.mkdirSync(cacheDir(root), { recursive: true });
       const tmp = `${file}.tmp.${process.pid}`;
-      fs18.writeFileSync(tmp, JSON.stringify(cache));
-      fs18.renameSync(tmp, file);
+      fs19.writeFileSync(tmp, JSON.stringify(cache));
+      fs19.renameSync(tmp, file);
     } catch {
     }
   };
@@ -2859,21 +2860,21 @@ function safe(id) {
 }
 var SNAPSHOT_VERSION = "vg-freshness/1";
 function snapshotPath(root) {
-  return path18.join(cacheDir(root), "freshness.json");
+  return path19.join(cacheDir(root), "freshness.json");
 }
 function writeSnapshot(root, corpusHash, fileStats, scope = {}) {
   const files = {};
   for (const f of fileStats) files[f.rel] = { size: f.size, mtimeMs: f.mtimeMs, hash: f.hash };
   const snapshot = { version: SNAPSHOT_VERSION, corpusHash, scope: pruneScope(scope), files };
   try {
-    fs18.mkdirSync(cacheDir(root), { recursive: true });
-    fs18.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+    fs19.mkdirSync(cacheDir(root), { recursive: true });
+    fs19.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
   } catch {
   }
 }
 function loadSnapshot(root) {
   try {
-    const loaded = JSON.parse(fs18.readFileSync(snapshotPath(root), "utf8"));
+    const loaded = JSON.parse(fs19.readFileSync(snapshotPath(root), "utf8"));
     if (loaded.version === SNAPSHOT_VERSION && loaded.files && typeof loaded.corpusHash === "string") {
       return { ...loaded, scope: loaded.scope ?? {} };
     }
@@ -2909,7 +2910,7 @@ function probeFreshness(root) {
     }
     let stat;
     try {
-      stat = fs18.statSync(file.abs);
+      stat = fs19.statSync(file.abs);
     } catch {
       drift.removed.push(file.rel);
       continue;
@@ -2917,7 +2918,7 @@ function probeFreshness(root) {
     if (stat.size === entry.size && stat.mtimeMs === entry.mtimeMs) continue;
     let hash = "";
     try {
-      hash = hashBytes(fs18.readFileSync(file.abs));
+      hash = hashBytes(fs19.readFileSync(file.abs));
     } catch {
       drift.removed.push(file.rel);
       continue;
@@ -2934,7 +2935,7 @@ function probeFreshness(root) {
   }
   if (absorbed && !hasDrift(drift)) {
     try {
-      fs18.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+      fs19.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
     } catch {
     }
   }
@@ -3005,6 +3006,15 @@ function push2(map, key, value) {
   if (list) list.push(value);
   else map.set(key, [value]);
 }
+var INDEX_CACHE = /* @__PURE__ */ new WeakMap();
+function indexFor(graph) {
+  let idx = INDEX_CACHE.get(graph);
+  if (!idx) {
+    idx = new GraphIndex(graph);
+    INDEX_CACHE.set(graph, idx);
+  }
+  return idx;
+}
 
 // src/engine/query.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -3055,7 +3065,7 @@ function queryGraph(graph, question, options = {}) {
   const limit = options.limit ?? 12;
   const terms = tokenize(question);
   const weightOf = termWeights(graph, terms);
-  const index = new GraphIndex(graph);
+  const index = indexFor(graph);
   const scored = [];
   for (const node of graph.nodes) {
     if (node.kind === "file" || node.kind === "external") continue;
@@ -3072,7 +3082,7 @@ async function queryGraphSemantic(graph, question, options) {
   const limit = options.limit ?? 12;
   const terms = tokenize(question);
   const weightOf = termWeights(graph, terms);
-  const index = new GraphIndex(graph);
+  const index = indexFor(graph);
   const queryVec = await options.embedder.embedQuery(question);
   const lexRaw = /* @__PURE__ */ new Map();
   let lexMax = 0;
@@ -3215,7 +3225,7 @@ function round2(x) {
 }
 var REFRESH_LOCK_STALE_MS = 10 * 60 * 1e3;
 function refreshLockPath(root) {
-  return path18.join(cacheDir(root), "refresh.lock");
+  return path19.join(cacheDir(root), "refresh.lock");
 }
 async function refreshIfStale(root, opts = {}) {
   const probe = probeFreshness(root);
@@ -3246,8 +3256,8 @@ async function refreshIfStale(root, opts = {}) {
       const dir = vibgrateDir(root);
       writeArtifacts(result.graph, {
         root,
-        report: fs18.existsSync(path18.join(dir, "GRAPH_REPORT.md")),
-        html: fs18.existsSync(path18.join(dir, "graph.html"))
+        report: fs19.existsSync(path19.join(dir, "GRAPH_REPORT.md")),
+        html: fs19.existsSync(path19.join(dir, "graph.html"))
       });
     }
     writeSnapshot(root, result.graph.provenance.corpusHash, result.fileStats, scope);
@@ -3266,6 +3276,157 @@ async function refreshIfStale(root, opts = {}) {
     releaseLock(lock);
   }
 }
+var LEDGER = "savings.jsonl";
+var PER_FILE_TOKENS = 400;
+var SAVINGS_TOOLS = /* @__PURE__ */ new Set(["query_graph", "get_node"]);
+var CLI_TOOL_ALIASES = {
+  ask: "query_graph",
+  show: "get_node",
+  impact: "impact_of",
+  path: "find_path",
+  hubs: "list_hubs",
+  areas: "list_areas",
+  tree: "tree"
+};
+function sanitizeClient(name) {
+  if (typeof name !== "string") return "unknown";
+  const cleaned = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return cleaned || "unknown";
+}
+function recordCliCall(root, entry, now) {
+  recordSaving(
+    root,
+    {
+      tool: entry.tool,
+      source: "cli",
+      client: sanitizeClient(entry.client),
+      outcome: entry.outcome,
+      vgTokens: entry.vgTokens ?? 0,
+      baselineTokens: (entry.baselineFiles ?? 0) * PER_FILE_TOKENS
+    },
+    now
+  );
+}
+function ledgerPath(root) {
+  return path19.join(cacheDir(root), LEDGER);
+}
+function savingsRecorded(root) {
+  return fs19.existsSync(ledgerPath(root));
+}
+function recordSaving(root, entry, now) {
+  try {
+    fs19.mkdirSync(cacheDir(root), { recursive: true });
+    const line = JSON.stringify({ ts: now, ...entry });
+    fs19.appendFileSync(ledgerPath(root), line + "\n");
+  } catch {
+  }
+}
+var DEFAULT_RATE_PER_M = 3;
+var DEFAULT_RATE_LABEL = "input @ $3/1M";
+function readSavings(root, days, now, ratePerM = DEFAULT_RATE_PER_M) {
+  const file = ledgerPath(root);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  let queries = 0;
+  let vgTokens = 0;
+  let baselineTokens = 0;
+  if (fs19.existsSync(file)) {
+    for (const line of fs19.readFileSync(file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.ts < cutoff) continue;
+        if (!SAVINGS_TOOLS.has(e.tool)) continue;
+        queries++;
+        vgTokens += e.vgTokens;
+        baselineTokens += e.baselineTokens;
+      } catch {
+      }
+    }
+  }
+  const estCostVg = vgTokens / 1e6 * ratePerM;
+  const estCostBaseline = baselineTokens / 1e6 * ratePerM;
+  return {
+    enabled: savingsRecorded(root),
+    days,
+    queries,
+    vgTokens,
+    baselineTokens,
+    ratio: vgTokens > 0 ? Math.round(baselineTokens / vgTokens * 100) / 100 : 0,
+    estCostVg: round22(estCostVg),
+    estCostBaseline: round22(estCostBaseline),
+    saved: round22(estCostBaseline - estCostVg),
+    rateLabel: DEFAULT_RATE_LABEL
+  };
+}
+function round22(x) {
+  return Math.round(x * 100) / 100;
+}
+function toDimensionStats(byKey) {
+  return [...byKey.entries()].map(([key, r]) => {
+    const calls = r.complete + r.partial + r.miss;
+    return {
+      key,
+      calls,
+      complete: r.complete,
+      partial: r.partial,
+      miss: r.miss,
+      successPct: calls ? Math.round((r.complete + r.partial) / calls * 100) : 0
+    };
+  }).sort((a, b) => b.calls - a.calls || a.key.localeCompare(b.key));
+}
+function readUsage(root, days, now) {
+  const file = ledgerPath(root);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  const byTool = /* @__PURE__ */ new Map();
+  const bySource = /* @__PURE__ */ new Map();
+  const byClient = /* @__PURE__ */ new Map();
+  const bump2 = (m, key, outcome) => {
+    const row = m.get(key) ?? { complete: 0, partial: 0, miss: 0 };
+    row[outcome]++;
+    m.set(key, row);
+  };
+  if (fs19.existsSync(file)) {
+    for (const line of fs19.readFileSync(file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.ts < cutoff) continue;
+        const outcome = e.outcome ?? "complete";
+        bump2(byTool, e.tool, outcome);
+        bump2(bySource, e.source ?? "mcp", outcome);
+        bump2(byClient, e.client ?? "unknown", outcome);
+      } catch {
+      }
+    }
+  }
+  const commands = toDimensionStats(byTool).map((d) => ({
+    tool: d.key,
+    calls: d.calls,
+    complete: d.complete,
+    partial: d.partial,
+    miss: d.miss,
+    successPct: d.successPct
+  }));
+  const totals = commands.reduce(
+    (t, c) => ({
+      calls: t.calls + c.calls,
+      complete: t.complete + c.complete,
+      partial: t.partial + c.partial,
+      miss: t.miss + c.miss
+    }),
+    { calls: 0, complete: 0, partial: 0, miss: 0 }
+  );
+  const avgSuccessPct = commands.length ? Math.round(commands.reduce((s, c) => s + c.successPct, 0) / commands.length) : 0;
+  return {
+    enabled: savingsRecorded(root),
+    days,
+    commands,
+    sources: toDimensionStats(bySource),
+    clients: toDimensionStats(byClient),
+    totals,
+    avgSuccessPct
+  };
+}
 
 // src/engine/lookup.ts
 function findNodes(graph, query) {
@@ -3342,7 +3503,7 @@ function shortestPath(graph, srcId, dstId) {
 var DEPEND_EDGES = /* @__PURE__ */ new Set(["call", "import", "extends", "implements", "references"]);
 function impactOf(graph, rootId, opts = {}) {
   const maxDepth = Math.max(1, opts.depth ?? 4);
-  const index = new GraphIndex(graph);
+  const index = indexFor(graph);
   const root = index.node(rootId);
   const affected = /* @__PURE__ */ new Map();
   let minEdgeConfidence = 1;
@@ -3389,7 +3550,7 @@ function round3(x) {
   return Math.round(x * 1e6) / 1e6;
 }
 function coveringTests(graph, node, index) {
-  const idx = index ?? new GraphIndex(graph);
+  const idx = index ?? indexFor(graph);
   const byId = idx.nodeById;
   const out = /* @__PURE__ */ new Map();
   for (const e of idx.in(node.id, "test")) {
@@ -3403,7 +3564,7 @@ function coveringTests(graph, node, index) {
   return [...out.values()].sort((a, b) => b.confidence - a.confidence || a.file.localeCompare(b.file));
 }
 function testsToRun(graph, rootId, depth = 4) {
-  const idx = new GraphIndex(graph);
+  const idx = indexFor(graph);
   const impact = impactOf(graph, rootId, { depth });
   const affectedIds = /* @__PURE__ */ new Set([rootId, ...impact.affected.map((a) => a.id)]);
   const testFiles = /* @__PURE__ */ new Set();
@@ -3423,10 +3584,10 @@ function testsToRun(graph, rootId, depth = 4) {
   };
 }
 function detectRunner(root, lang) {
-  const pkgPath = path18.join(root, "package.json");
-  if (fs18.existsSync(pkgPath)) {
+  const pkgPath = path19.join(root, "package.json");
+  if (fs19.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs18.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.vitest) return { name: "vitest", command: (f) => `npx vitest run ${f.join(" ")}`.trim() };
       if (deps.jest) return { name: "jest", command: (f) => `npx jest ${f.join(" ")}`.trim() };
@@ -3434,10 +3595,10 @@ function detectRunner(root, lang) {
     } catch {
     }
   }
-  if (lang === "py" || fs18.existsSync(path18.join(root, "pyproject.toml")) || fs18.existsSync(path18.join(root, "pytest.ini"))) {
+  if (lang === "py" || fs19.existsSync(path19.join(root, "pyproject.toml")) || fs19.existsSync(path19.join(root, "pytest.ini"))) {
     return { name: "pytest", command: (f) => `pytest ${f.join(" ")}`.trim() };
   }
-  if (lang === "go" || fs18.existsSync(path18.join(root, "go.mod"))) {
+  if (lang === "go" || fs19.existsSync(path19.join(root, "go.mod"))) {
     return { name: "go test", command: () => "go test ./..." };
   }
   if (lang === "cs" || hasFile(root, /\.csproj$/) || hasFile(root, /\.sln$/)) {
@@ -3448,7 +3609,7 @@ function detectRunner(root, lang) {
 }
 function hasFile(root, re) {
   try {
-    return fs18.readdirSync(root).some((f) => re.test(f));
+    return fs19.readdirSync(root).some((f) => re.test(f));
   } catch {
     return false;
   }
@@ -3520,7 +3681,7 @@ function findManifests(root) {
     if (depth > 8 || scanned > MAX_ENTRIES) return;
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs19.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3528,11 +3689,11 @@ function findManifests(root) {
       scanned++;
       if (scanned > MAX_ENTRIES) break;
       if (e.isDirectory()) {
-        if (!SKIP_DIRS2.has(e.name) && !e.name.startsWith(".")) walk2(path18.join(dir, e.name), depth + 1);
+        if (!SKIP_DIRS2.has(e.name) && !e.name.startsWith(".")) walk2(path19.join(dir, e.name), depth + 1);
         continue;
       }
       const eco = MANIFEST_BY_FILE[e.name] ?? (/\.(cs|fs)proj$/i.test(e.name) ? "dotnet" : void 0);
-      if (eco) set[eco].push(path18.join(dir, e.name));
+      if (eco) set[eco].push(path19.join(dir, e.name));
     }
   };
   walk2(root, 0);
@@ -3544,11 +3705,11 @@ function npmDeps(files) {
   for (const file of files) {
     let pkg;
     try {
-      pkg = JSON.parse(fs18.readFileSync(file, "utf8"));
+      pkg = JSON.parse(fs19.readFileSync(file, "utf8"));
     } catch {
       continue;
     }
-    const dir = path18.dirname(file);
+    const dir = path19.dirname(file);
     const all = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const [name, declared] of Object.entries(all)) {
       out.push({ name, ecosystem: "npm", declared, installed: installedNpmVersion(dir, name) });
@@ -3559,12 +3720,12 @@ function npmDeps(files) {
 function installedNpmVersion(dir, name) {
   let cur = dir;
   for (let i = 0; i < 12; i++) {
-    const p = path18.join(cur, "node_modules", name, "package.json");
+    const p = path19.join(cur, "node_modules", name, "package.json");
     try {
-      return JSON.parse(fs18.readFileSync(p, "utf8")).version;
+      return JSON.parse(fs19.readFileSync(p, "utf8")).version;
     } catch {
     }
-    const parent = path18.dirname(cur);
+    const parent = path19.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -3581,21 +3742,21 @@ function normalizePep503(name) {
 function sitePackagesDirs(base) {
   const out = [];
   try {
-    for (const d of fs18.readdirSync(path18.join(base, "lib"))) {
-      if (d.startsWith("python")) out.push(path18.join(base, "lib", d, "site-packages"));
+    for (const d of fs19.readdirSync(path19.join(base, "lib"))) {
+      if (d.startsWith("python")) out.push(path19.join(base, "lib", d, "site-packages"));
     }
   } catch {
   }
-  out.push(path18.join(base, "Lib", "site-packages"));
+  out.push(path19.join(base, "Lib", "site-packages"));
   return out;
 }
 function installedPypiVersion(root, name) {
   const target = normalizePep503(name);
   for (const venv of [".venv", "venv", "env", ".tox"]) {
-    for (const sp of sitePackagesDirs(path18.join(root, venv))) {
+    for (const sp of sitePackagesDirs(path19.join(root, venv))) {
       let entries;
       try {
-        entries = fs18.readdirSync(sp);
+        entries = fs19.readdirSync(sp);
       } catch {
         continue;
       }
@@ -3610,7 +3771,7 @@ function installedPypiVersion(root, name) {
 function installedPhpVersion(root, name) {
   let data;
   try {
-    data = JSON.parse(fs18.readFileSync(path18.join(root, "vendor", "composer", "installed.json"), "utf8"));
+    data = JSON.parse(fs19.readFileSync(path19.join(root, "vendor", "composer", "installed.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -3629,11 +3790,11 @@ function pypiDeps(files) {
   for (const file of files) {
     let text;
     try {
-      text = fs18.readFileSync(file, "utf8");
+      text = fs19.readFileSync(file, "utf8");
     } catch {
       continue;
     }
-    if (path18.basename(file) === "requirements.txt") {
+    if (path19.basename(file) === "requirements.txt") {
       for (const line of text.split("\n")) {
         const t = line.trim();
         if (!t || t.startsWith("#") || t.startsWith("-")) continue;
@@ -3717,7 +3878,7 @@ function goDeps(files) {
   for (const mod of files) {
     let text;
     try {
-      text = fs18.readFileSync(mod, "utf8");
+      text = fs19.readFileSync(mod, "utf8");
     } catch {
       continue;
     }
@@ -3735,7 +3896,7 @@ function cargoDeps(files) {
   for (const file of files) {
     let text;
     try {
-      text = fs18.readFileSync(file, "utf8");
+      text = fs19.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -3767,7 +3928,7 @@ function rubyDeps(files) {
   for (const file of files) {
     let text;
     try {
-      text = fs18.readFileSync(file, "utf8");
+      text = fs19.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -3782,7 +3943,7 @@ function phpDeps(files) {
   for (const file of files) {
     let pkg;
     try {
-      pkg = JSON.parse(fs18.readFileSync(file, "utf8"));
+      pkg = JSON.parse(fs19.readFileSync(file, "utf8"));
     } catch {
       continue;
     }
@@ -3799,7 +3960,7 @@ function dotnetDeps(files) {
   for (const file of files) {
     let text;
     try {
-      text = fs18.readFileSync(file, "utf8");
+      text = fs19.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -3819,7 +3980,7 @@ function swiftDeps(files) {
   for (const file of files) {
     let text;
     try {
-      text = fs18.readFileSync(file, "utf8");
+      text = fs19.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -3841,7 +4002,7 @@ function dartDeps(files) {
   for (const file of files) {
     let text;
     try {
-      text = fs18.readFileSync(file, "utf8");
+      text = fs19.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -3866,11 +4027,11 @@ function javaDeps(files) {
   for (const file of files) {
     let text;
     try {
-      text = fs18.readFileSync(file, "utf8");
+      text = fs19.readFileSync(file, "utf8");
     } catch {
       continue;
     }
-    if (path18.basename(file) === "pom.xml") {
+    if (path19.basename(file) === "pom.xml") {
       for (const block of text.match(/<dependency>[\s\S]*?<\/dependency>/g) ?? []) {
         const g = /<groupId>([^<]+)<\/groupId>/.exec(block);
         const a = /<artifactId>([^<]+)<\/artifactId>/.exec(block);
@@ -3916,10 +4077,10 @@ function discoverModels(home = os.homedir()) {
   );
 }
 function ollama(home) {
-  const base = path18.join(home, ".ollama", "models", "manifests");
+  const base = path19.join(home, ".ollama", "models", "manifests");
   const out = [];
   walk(base, 4, (file) => {
-    const rel2 = path18.relative(base, file).split(path18.sep);
+    const rel2 = path19.relative(base, file).split(path19.sep);
     if (rel2.length >= 2) {
       const tag = rel2[rel2.length - 1];
       const model = rel2[rel2.length - 2];
@@ -3929,24 +4090,24 @@ function ollama(home) {
   return dedupe(out);
 }
 function lmStudio(home) {
-  const bases = [path18.join(home, ".lmstudio", "models"), path18.join(home, ".cache", "lm-studio", "models")];
+  const bases = [path19.join(home, ".lmstudio", "models"), path19.join(home, ".cache", "lm-studio", "models")];
   const out = [];
   for (const base of bases) {
     walk(base, 5, (file) => {
       if (!file.endsWith(".gguf")) return;
-      const rel2 = path18.relative(base, file).replace(/\\/g, "/");
+      const rel2 = path19.relative(base, file).replace(/\\/g, "/");
       out.push({ runtime: "lm-studio", name: rel2, path: file });
     });
   }
   return dedupe(out);
 }
 function looseGguf(home) {
-  const bases = [path18.join(home, "models"), path18.join(home, ".cache", "huggingface")];
+  const bases = [path19.join(home, "models"), path19.join(home, ".cache", "huggingface")];
   const out = [];
   for (const base of bases) {
     walk(base, 4, (file) => {
       if (!file.endsWith(".gguf")) return;
-      out.push({ runtime: "gguf", name: path18.basename(file), path: file });
+      out.push({ runtime: "gguf", name: path19.basename(file), path: file });
     });
   }
   return dedupe(out);
@@ -3955,12 +4116,12 @@ function walk(dir, depth, onFile) {
   if (depth < 0) return;
   let entries;
   try {
-    entries = fs18.readdirSync(dir, { withFileTypes: true });
+    entries = fs19.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    const abs = path18.join(dir, e.name);
+    const abs = path19.join(dir, e.name);
     if (e.isDirectory()) walk(abs, depth - 1, onFile);
     else if (e.isFile()) onFile(abs);
   }
@@ -3991,7 +4152,7 @@ function lockfileVersion(root, ecosystem, name) {
 function gradleLock(root, name) {
   let text;
   try {
-    text = fs18.readFileSync(path18.join(root, "gradle.lockfile"), "utf8");
+    text = fs19.readFileSync(path19.join(root, "gradle.lockfile"), "utf8");
   } catch {
     return void 0;
   }
@@ -4001,7 +4162,7 @@ function gradleLock(root, name) {
 function packageResolved(root, name) {
   let data;
   try {
-    data = JSON.parse(fs18.readFileSync(path18.join(root, "Package.resolved"), "utf8"));
+    data = JSON.parse(fs19.readFileSync(path19.join(root, "Package.resolved"), "utf8"));
   } catch {
     return void 0;
   }
@@ -4017,7 +4178,7 @@ function packageResolved(root, name) {
 function pubspecLock(root, name) {
   let text;
   try {
-    text = fs18.readFileSync(path18.join(root, "pubspec.lock"), "utf8");
+    text = fs19.readFileSync(path19.join(root, "pubspec.lock"), "utf8");
   } catch {
     return void 0;
   }
@@ -4041,7 +4202,7 @@ function escapeRegExp(s) {
 function gemfileLock(root, name) {
   let text;
   try {
-    text = fs18.readFileSync(path18.join(root, "Gemfile.lock"), "utf8");
+    text = fs19.readFileSync(path19.join(root, "Gemfile.lock"), "utf8");
   } catch {
     return void 0;
   }
@@ -4051,7 +4212,7 @@ function gemfileLock(root, name) {
 function composerLock(root, name) {
   let data;
   try {
-    data = JSON.parse(fs18.readFileSync(path18.join(root, "composer.lock"), "utf8"));
+    data = JSON.parse(fs19.readFileSync(path19.join(root, "composer.lock"), "utf8"));
   } catch {
     return void 0;
   }
@@ -4066,7 +4227,7 @@ function composerLock(root, name) {
 function packagesLock(root, name) {
   let data;
   try {
-    data = JSON.parse(fs18.readFileSync(path18.join(root, "packages.lock.json"), "utf8"));
+    data = JSON.parse(fs19.readFileSync(path19.join(root, "packages.lock.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -4091,7 +4252,7 @@ function pypiLockVersion(root, name) {
 function tomlPackageLock(root, file, name, normalize3) {
   let text;
   try {
-    text = fs18.readFileSync(path18.join(root, file), "utf8");
+    text = fs19.readFileSync(path19.join(root, file), "utf8");
   } catch {
     return void 0;
   }
@@ -4108,7 +4269,7 @@ function tomlPackageLock(root, file, name, normalize3) {
 function pipfileLock(root, name) {
   let data;
   try {
-    data = JSON.parse(fs18.readFileSync(path18.join(root, "Pipfile.lock"), "utf8"));
+    data = JSON.parse(fs19.readFileSync(path19.join(root, "Pipfile.lock"), "utf8"));
   } catch {
     return void 0;
   }
@@ -4127,7 +4288,7 @@ function pipfileLock(root, name) {
 function packageLockVersion(root, name) {
   let data;
   try {
-    data = JSON.parse(fs18.readFileSync(path18.join(root, "package-lock.json"), "utf8"));
+    data = JSON.parse(fs19.readFileSync(path19.join(root, "package-lock.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -4139,7 +4300,7 @@ function packageLockVersion(root, name) {
 function yarnLockVersion(root, name) {
   let text;
   try {
-    text = fs18.readFileSync(path18.join(root, "yarn.lock"), "utf8");
+    text = fs19.readFileSync(path19.join(root, "yarn.lock"), "utf8");
   } catch {
     return void 0;
   }
@@ -4167,19 +4328,19 @@ function headerNamesPackage(header, name) {
 // src/engine/lib.ts
 var LIB_SCHEMA = "vg-lib/1.0";
 function catalogPath(root) {
-  return path18.join(root, "vibgrate.lib.json");
+  return path19.join(root, "vibgrate.lib.json");
 }
 function libDir(root) {
-  return path18.join(root, ".vibgrate", "lib");
+  return path19.join(root, ".vibgrate", "lib");
 }
 function libId(name) {
   return name.trim().toLowerCase().replace(/^@/, "").replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
 }
 function loadCatalog(root) {
   const file = catalogPath(root);
-  if (fs18.existsSync(file)) {
+  if (fs19.existsSync(file)) {
     try {
-      const data = JSON.parse(fs18.readFileSync(file, "utf8"));
+      const data = JSON.parse(fs19.readFileSync(file, "utf8"));
       if (data.schemaVersion === LIB_SCHEMA && data.libraries) return data;
     } catch {
     }
@@ -4187,7 +4348,7 @@ function loadCatalog(root) {
   return { schemaVersion: LIB_SCHEMA, libraries: {} };
 }
 function saveCatalog(root, catalog) {
-  fs18.writeFileSync(catalogPath(root), `${stableStringify(catalog, 2)}
+  fs19.writeFileSync(catalogPath(root), `${stableStringify(catalog, 2)}
 `);
 }
 function resolveLib(catalog, name) {
@@ -4263,23 +4424,23 @@ async function addLibrary(source, opts) {
     content = await res.text();
     type = source.endsWith("llms.txt") ? "llms.txt" : source.endsWith(".json") ? "openapi" : "website";
   } else {
-    const abs = path18.resolve(root, source);
-    if (!fs18.existsSync(abs)) throw new Error(`source not found: ${source}`);
+    const abs = path19.resolve(root, source);
+    if (!fs19.existsSync(abs)) throw new Error(`source not found: ${source}`);
     content = readLocal(abs);
     type = "local";
   }
   const name = opts.name ?? inferName(source);
   const id = libId(name);
   const version = opts.version ?? installedVersion(root, name) ?? "*";
-  fs18.mkdirSync(libDir(root), { recursive: true });
-  const docFileAbs = path18.join(libDir(root), `${id}.md`);
-  fs18.writeFileSync(docFileAbs, content);
+  fs19.mkdirSync(libDir(root), { recursive: true });
+  const docFileAbs = path19.join(libDir(root), `${id}.md`);
+  fs19.writeFileSync(docFileAbs, content);
   const entry = {
     id,
     name,
     version,
     source: { type, location: source },
-    docFile: path18.relative(root, docFileAbs).split(path18.sep).join("/"),
+    docFile: path19.relative(root, docFileAbs).split(path19.sep).join("/"),
     docHash: hashString(content),
     bytes: Buffer.byteLength(content, "utf8")
   };
@@ -4289,15 +4450,15 @@ async function addLibrary(source, opts) {
   return entry;
 }
 function readDoc(root, entry) {
-  const abs = path18.resolve(root, entry.docFile);
-  return fs18.existsSync(abs) ? fs18.readFileSync(abs, "utf8") : "";
+  const abs = path19.resolve(root, entry.docFile);
+  return fs19.existsSync(abs) ? fs19.readFileSync(abs, "utf8") : "";
 }
 function npmPackageDir(root, name) {
   let cur = root;
   for (let i = 0; i < 12; i++) {
-    const dir = path18.join(cur, "node_modules", name);
-    if (fs18.existsSync(path18.join(dir, "package.json"))) return dir;
-    const parent = path18.dirname(cur);
+    const dir = path19.join(cur, "node_modules", name);
+    if (fs19.existsSync(path19.join(dir, "package.json"))) return dir;
+    const parent = path19.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -4308,24 +4469,24 @@ function localPackageDocs(root, name) {
   if (!dir) return void 0;
   const version = resolveVersion(root, name).served;
   for (const f of ["llms.txt", "README.md", "README.mdx", "README", "readme.md"]) {
-    const p = path18.join(dir, f);
+    const p = path19.join(dir, f);
     try {
-      const docs = fs18.readFileSync(p, "utf8");
+      const docs = fs19.readFileSync(p, "utf8");
       if (docs.trim()) {
-        return { docs, version, source: path18.relative(root, p).split(path18.sep).join("/") };
+        return { docs, version, source: path19.relative(root, p).split(path19.sep).join("/") };
       }
     } catch {
     }
   }
   try {
-    const pkg = JSON.parse(fs18.readFileSync(path18.join(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs19.readFileSync(path19.join(dir, "package.json"), "utf8"));
     if (pkg.description?.trim()) {
       return {
         docs: `# ${name}
 
 ${pkg.description}`,
         version: version ?? pkg.version,
-        source: path18.relative(root, path18.join(dir, "package.json")).split(path18.sep).join("/")
+        source: path19.relative(root, path19.join(dir, "package.json")).split(path19.sep).join("/")
       };
     }
   } catch {
@@ -4334,17 +4495,17 @@ ${pkg.description}`,
 }
 function dtsEntry(dir) {
   try {
-    const pkg = JSON.parse(fs18.readFileSync(path18.join(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs19.readFileSync(path19.join(dir, "package.json"), "utf8"));
     const rel2 = pkg.types ?? pkg.typings;
     if (typeof rel2 === "string") {
-      const p = path18.join(dir, rel2);
-      if (fs18.existsSync(p)) return p;
+      const p = path19.join(dir, rel2);
+      if (fs19.existsSync(p)) return p;
     }
   } catch {
   }
   for (const c of ["index.d.ts", "dist/index.d.ts", "lib/index.d.ts", "types/index.d.ts"]) {
-    const p = path18.join(dir, c);
-    if (fs18.existsSync(p)) return p;
+    const p = path19.join(dir, c);
+    if (fs19.existsSync(p)) return p;
   }
   return void 0;
 }
@@ -4377,7 +4538,7 @@ function localApiSurface(root, name) {
   if (!dts) return void 0;
   let src;
   try {
-    src = fs18.readFileSync(dts, "utf8");
+    src = fs19.readFileSync(dts, "utf8");
   } catch {
     return void 0;
   }
@@ -4385,36 +4546,36 @@ function localApiSurface(root, name) {
   return decls.length ? decls.join("\n\n") : void 0;
 }
 function cloneAndReadGit(url) {
-  const dir = fs18.mkdtempSync(path18.join(os.tmpdir(), "vg-lib-git-"));
+  const dir = fs19.mkdtempSync(path19.join(os.tmpdir(), "vg-lib-git-"));
   try {
     execFileSync("git", ["clone", "--depth", "1", "--quiet", url, dir], {
       stdio: ["ignore", "ignore", "pipe"]
     });
   } catch (err) {
-    fs18.rmSync(dir, { recursive: true, force: true });
+    fs19.rmSync(dir, { recursive: true, force: true });
     const detail = err instanceof Error && err.message ? `: ${err.message.split("\n")[0]}` : "";
     throw new Error(`git clone failed for ${url}${detail}`);
   }
   try {
     return readGitDocs(dir);
   } finally {
-    fs18.rmSync(dir, { recursive: true, force: true });
+    fs19.rmSync(dir, { recursive: true, force: true });
   }
 }
 function readGitDocs(dir) {
-  const docsDir = path18.join(dir, "docs");
-  if (fs18.existsSync(docsDir) && fs18.statSync(docsDir).isDirectory()) return readLocal(docsDir);
-  const readme = ["README.md", "README.mdx", "README.txt", "README.rst", "readme.md"].map((f) => path18.join(dir, f)).find((p) => fs18.existsSync(p));
-  if (readme) return fs18.readFileSync(readme, "utf8");
+  const docsDir = path19.join(dir, "docs");
+  if (fs19.existsSync(docsDir) && fs19.statSync(docsDir).isDirectory()) return readLocal(docsDir);
+  const readme = ["README.md", "README.mdx", "README.txt", "README.rst", "readme.md"].map((f) => path19.join(dir, f)).find((p) => fs19.existsSync(p));
+  if (readme) return fs19.readFileSync(readme, "utf8");
   return readLocal(dir);
 }
 function readLocal(abs) {
-  const stat = fs18.statSync(abs);
-  if (stat.isFile()) return fs18.readFileSync(abs, "utf8");
+  const stat = fs19.statSync(abs);
+  if (stat.isFile()) return fs19.readFileSync(abs, "utf8");
   const parts = [];
-  const files = fs18.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isFile() && /\.(md|mdx|txt|rst)$/i.test(e.name)).map((e) => e.name).sort();
+  const files = fs19.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isFile() && /\.(md|mdx|txt|rst)$/i.test(e.name)).map((e) => e.name).sort();
   for (const f of files) parts.push(`<!-- ${f} -->
-${fs18.readFileSync(path18.join(abs, f), "utf8")}`);
+${fs19.readFileSync(path19.join(abs, f), "utf8")}`);
   return parts.join("\n\n");
 }
 function inferName(source) {
@@ -4423,10 +4584,10 @@ function inferName(source) {
   return base.replace(/\.(md|mdx|txt|rst|json)$/i, "").replace(/^llms$/, "docs");
 }
 function findGitRoot(startDir = process.cwd()) {
-  let dir = path18.resolve(startDir);
+  let dir = path19.resolve(startDir);
   for (; ; ) {
-    if (fs18.existsSync(path18.join(dir, ".git"))) return dir;
-    const parent = path18.dirname(dir);
+    if (fs19.existsSync(path19.join(dir, ".git"))) return dir;
+    const parent = path19.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -4437,19 +4598,19 @@ function normalizeEntry(line) {
 function ensureGitignored(entry, startDir = process.cwd()) {
   const root = findGitRoot(startDir);
   if (!root) return { status: "not-a-repo", entry };
-  const gitignorePath = path18.join(root, ".gitignore");
+  const gitignorePath = path19.join(root, ".gitignore");
   const target = normalizeEntry(entry);
   let existing = "";
   let fileExisted = true;
   try {
-    existing = fs18.readFileSync(gitignorePath, "utf8");
+    existing = fs19.readFileSync(gitignorePath, "utf8");
   } catch {
     fileExisted = false;
   }
   const alreadyPresent = existing.split(/\r?\n/).some((line) => normalizeEntry(line) === target);
   if (alreadyPresent) return { status: "present", entry, gitignorePath };
   const needsLeadingNewline = existing.length > 0 && !existing.endsWith("\n");
-  fs18.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
+  fs19.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
 `, "utf8");
   return { status: fileExisted ? "added" : "created", entry, gitignorePath };
 }
@@ -4603,14 +4764,14 @@ dsnCommand.command("create").description("Create a new DSN token").option("--ing
     console.log(chalk.dim("The secret must be registered on your Vibgrate ingest API."));
   }
   if (opts.write) {
-    const writePath = path18.resolve(opts.write);
+    const writePath = path19.resolve(opts.write);
     await writeTextFile(writePath, dsn + "\n");
     console.log("");
     console.log(chalk.green("\u2714") + ` DSN written to ${opts.write}`);
-    const root = findGitRoot(path18.dirname(writePath));
-    const rel2 = root ? path18.relative(root, writePath).split(path18.sep).join("/") : "";
+    const root = findGitRoot(path19.dirname(writePath));
+    const rel2 = root ? path19.relative(root, writePath).split(path19.sep).join("/") : "";
     if (root && rel2 && !rel2.startsWith("..")) {
-      const res = ensureGitignored(rel2, path18.dirname(writePath));
+      const res = ensureGitignored(rel2, path19.dirname(writePath));
       if (res.status === "created") {
         console.log(chalk.green("\u2714") + ` Created .gitignore and ignored ${rel2}`);
       } else if (res.status === "added") {
@@ -4628,30 +4789,30 @@ dsnCommand.command("create").description("Create a new DSN token").option("--ing
 var STORE_DIRNAME = ".vibgrate";
 var STORE_FILENAME = "credentials.json";
 function homeCredentialsPath() {
-  return path18.join(os.homedir(), STORE_DIRNAME, STORE_FILENAME);
+  return path19.join(os.homedir(), STORE_DIRNAME, STORE_FILENAME);
 }
 function projectCredentialsPath(cwd = process.cwd()) {
   const root = findGitRoot(cwd) ?? cwd;
-  return path18.join(root, STORE_DIRNAME, STORE_FILENAME);
+  return path19.join(root, STORE_DIRNAME, STORE_FILENAME);
 }
 function credentialsPath(opts = {}) {
   const override = process.env.VIBGRATE_CREDENTIALS?.trim();
-  if (override) return path18.resolve(override);
+  if (override) return path19.resolve(override);
   const local = projectCredentialsPath(opts.cwd);
   if (opts.local) return local;
-  if (fs18.existsSync(local)) return local;
+  if (fs19.existsSync(local)) return local;
   return homeCredentialsPath();
 }
 function gitignoreEntryForCredentials(repoRoot, credsFile = credentialsPath()) {
-  const rel2 = path18.relative(repoRoot, credsFile);
-  if (rel2 && !rel2.startsWith("..") && !path18.isAbsolute(rel2)) {
-    return rel2.split(path18.sep).join("/");
+  const rel2 = path19.relative(repoRoot, credsFile);
+  if (rel2 && !rel2.startsWith("..") && !path19.isAbsolute(rel2)) {
+    return rel2.split(path19.sep).join("/");
   }
   return `${STORE_DIRNAME}/${STORE_FILENAME}`;
 }
 function readStoredCredentials(opts = {}) {
   try {
-    const raw = fs18.readFileSync(credentialsPath(opts), "utf8");
+    const raw = fs19.readFileSync(credentialsPath(opts), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed.dsn === "string" && parsed.dsn ? parsed : null;
   } catch {
@@ -4660,16 +4821,16 @@ function readStoredCredentials(opts = {}) {
 }
 function writeStoredCredentials(creds, opts = {}) {
   const file = credentialsPath(opts);
-  fs18.mkdirSync(path18.dirname(file), { recursive: true });
-  fs18.writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  fs19.mkdirSync(path19.dirname(file), { recursive: true });
+  fs19.writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 384 });
   try {
-    fs18.chmodSync(file, 384);
+    fs19.chmodSync(file, 384);
   } catch {
   }
 }
 function clearStoredCredentials(opts = {}) {
   try {
-    fs18.rmSync(credentialsPath(opts));
+    fs19.rmSync(credentialsPath(opts));
     return true;
   } catch {
     return false;
@@ -5000,7 +5161,7 @@ var pushCommand = new Command("push").description("Push scan results to Vibgrate
     if (opts.strict) process.exit(1);
     return;
   }
-  const filePath = path18.resolve(opts.file);
+  const filePath = path19.resolve(opts.file);
   if (!await pathExists(filePath)) {
     console.error(chalk.red(`Scan artifact not found: ${filePath}`));
     console.error(chalk.dim('Run "vibgrate scan" first.'));
@@ -5057,8 +5218,8 @@ var pushCommand = new Command("push").description("Push scan results to Vibgrate
 });
 function readScanArtifact(root) {
   try {
-    const file = path18.join(root, ".vibgrate", "scan_result.json");
-    return JSON.parse(fs18.readFileSync(file, "utf8"));
+    const file = path19.join(root, ".vibgrate", "scan_result.json");
+    return JSON.parse(fs19.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -5511,19 +5672,165 @@ 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) {
+var NUL = "\0";
+var PARALLEL_MIN_BYTES = 64e6;
+var PARALLEL_MIN_FILES = 2e3;
+var ROW_CAP = 1e4;
+async function scanCandidates(root, files, needle, opts) {
+  const needleLower = needle.toLowerCase();
+  if (!needleLower || files.length === 0) return { hits: [], total: 0, truncated: false };
+  if (!opts.collectAll) return scanInline(root, files, needleLower, opts.budget, true, void 0);
+  if (files.length < PARALLEL_MIN_FILES && !process.env.VG_PARALLEL_MIN_BYTES) {
+    return scanInline(root, files, needleLower, ROW_CAP, false, void 0);
+  }
+  const { over, sizes } = measure(root, files);
+  if (!over) return scanInline(root, files, needleLower, ROW_CAP, false, sizes);
+  return scanParallel(root, files, needleLower);
+}
+function parallelMinBytes() {
+  const v = Number(process.env.VG_PARALLEL_MIN_BYTES);
+  return Number.isFinite(v) && v >= 0 ? v : PARALLEL_MIN_BYTES;
+}
+function measure(root, files) {
+  const threshold = parallelMinBytes();
+  const sizes = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const rel2 of files) {
+    let size;
+    try {
+      size = fs19.statSync(path19.join(root, rel2)).size;
+    } catch {
+      continue;
+    }
+    sizes.set(rel2, size);
+    if (size <= MAX_FILE_BYTES) total += size;
+    if (total >= threshold) return { over: true, sizes };
+  }
+  return { over: false, sizes };
+}
+function matchLines(text, needleLower) {
+  const low = text.toLowerCase();
+  if (!low.includes(needleLower)) return [];
+  const lowLines = low.split("\n");
+  const rawLines = text.split("\n");
+  const hits = [];
+  for (let i = 0; i < lowLines.length; i++) {
+    if (lowLines[i].includes(needleLower)) hits.push({ line: i + 1, preview: rawLines[i].trim().slice(0, PREVIEW_CHARS) });
+  }
+  return hits;
+}
+function readCandidate(abs, knownSize) {
+  try {
+    const size = knownSize ?? fs19.statSync(abs).size;
+    if (size > MAX_FILE_BYTES) return null;
+    const text = fs19.readFileSync(abs, "utf8");
+    return text.includes(NUL) ? null : text;
+  } catch {
+    return null;
+  }
+}
+function scanInline(root, files, needleLower, cap, stopAtCap, sizes) {
+  const hits = [];
+  let total = 0;
+  let truncated = false;
+  for (const rel2 of files) {
+    const text = readCandidate(path19.join(root, rel2), sizes?.get(rel2));
+    if (text === null) continue;
+    for (const h of matchLines(text, needleLower)) {
+      total++;
+      if (hits.length < cap) hits.push({ file: rel2, line: h.line, preview: h.preview });
+      else {
+        truncated = true;
+        if (stopAtCap) return { hits, total, truncated };
+      }
+    }
+  }
+  return { hits, total, truncated };
+}
+async function scanParallel(root, files, needleLower) {
+  const n = Math.min(files.length, Math.max(2, Math.min(8, os.cpus().length - 1)));
+  const shards = Array.from({ length: n }, () => []);
+  files.forEach((f, i) => shards[i % n].push(f));
+  let results;
+  try {
+    results = await Promise.all(shards.map((shard) => runWorker(root, shard, needleLower)));
+  } catch {
+    return scanInline(root, files, needleLower, ROW_CAP, false, void 0);
+  }
+  const hits = [];
+  let total = 0;
+  let truncated = false;
+  for (const r of results) {
+    total += r.total;
+    truncated = truncated || r.truncated;
+    for (const h of r.hits) hits.push(h);
+  }
+  hits.sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : a.line - b.line);
+  if (hits.length > ROW_CAP) {
+    hits.length = ROW_CAP;
+    truncated = true;
+  }
+  return { hits, total, truncated };
+}
+var WORKER_SOURCE = [
+  "const { parentPort, workerData } = require('worker_threads');",
+  "const fs = require('fs');",
+  "const path = require('path');",
+  `const MAX = ${MAX_FILE_BYTES};`,
+  `const PREVIEW = ${PREVIEW_CHARS};`,
+  `const CAP = ${ROW_CAP};`,
+  "const NUL = String.fromCharCode(0);",
+  "const NL = String.fromCharCode(10);",
+  "const { root, files, needleLower } = workerData;",
+  "const hits = []; let total = 0, truncated = false;",
+  "for (const rel of files) {",
+  "  const abs = path.join(root, rel);",
+  "  let text;",
+  '  try { if (fs.statSync(abs).size > MAX) continue; text = fs.readFileSync(abs, "utf8"); } catch { continue; }',
+  "  if (text.includes(NUL)) continue;",
+  "  const low = text.toLowerCase();",
+  "  if (!low.includes(needleLower)) continue;",
+  "  const lowLines = low.split(NL); const rawLines = text.split(NL);",
+  "  for (let i = 0; i < lowLines.length; i++) {",
+  "    if (!lowLines[i].includes(needleLower)) continue;",
+  "    total++;",
+  "    if (hits.length < CAP) hits.push({ file: rel, line: i + 1, preview: rawLines[i].trim().slice(0, PREVIEW) });",
+  "    else truncated = true;",
+  "  }",
+  "}",
+  "parentPort.postMessage({ hits, total, truncated });"
+].join("\n");
+function runWorker(root, files, needleLower) {
+  return new Promise((resolve12, reject) => {
+    const w = new Worker(WORKER_SOURCE, { eval: true, workerData: { root, files, needleLower } });
+    let settled = false;
+    w.once("message", (m) => {
+      settled = true;
+      resolve12(m);
+    });
+    w.once("error", reject);
+    w.once("exit", (code) => {
+      if (!settled && code !== 0) reject(new Error(`literal-scan worker exited with code ${code}`));
+    });
+  });
+}
+
+// src/engine/search.ts
+var IGNORE_DIRS = /* @__PURE__ */ new Set([".git", ".vibgrate", "node_modules", "dist", "build", "out", "target", "vendor", "__pycache__"]);
+var MAX_FILES_SCANNED = 2e4;
+async function searchSymbols(graph, root, query, limit) {
   const q2 = query.trim();
   if (!q2) return { matches: [], moreAvailable: false, hint: "query is required" };
+  const isPhrase = /\s/.test(q2);
   let nodes = findNodes(graph, q2).filter((n) => n.kind !== "file");
   if (nodes.length === 0) {
     const tokens = queryTokens(q2);
     if (tokens.length >= 2) nodes = multiTokenNodes(graph, tokens);
   }
-  const symbolHits = nodes.slice(0, limit).map((n, i) => ({
+  const symbolCap = isPhrase ? Math.max(1, Math.floor(limit / 3)) : limit;
+  const symbolHits = nodes.slice(0, symbolCap).map((n, i) => ({
     kind: n.kind,
     name: n.qualifiedName,
     file: n.file,
@@ -5533,9 +5840,12 @@ function searchSymbols(graph, root, query, limit) {
   const spare = limit - symbolHits.length;
   const textHits = [];
   let truncatedScan = false;
+  let totalTextMatches;
   if (spare > 0) {
     const seen = new Set(symbolHits.map((h) => `${h.file}:${h.line}`));
-    truncatedScan = scanFiles(root, q2, spare, seen, textHits);
+    const scan = await scanFiles(root, q2, spare, seen, textHits, isPhrase);
+    truncatedScan = scan.truncated;
+    if (isPhrase) totalTextMatches = scan.total;
   }
   const matches = [...symbolHits, ...textHits];
   if (matches.length === 0) {
@@ -5545,7 +5855,14 @@ function searchSymbols(graph, root, query, limit) {
       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 };
+  const literalTruncated = totalTextMatches !== void 0 && totalTextMatches > textHits.length;
+  const moreAvailable = isPhrase ? literalTruncated || truncatedScan : nodes.length > symbolHits.length || truncatedScan;
+  const result = { matches, moreAvailable };
+  if (totalTextMatches !== void 0) result.totalTextMatches = totalTextMatches;
+  if (literalTruncated) {
+    result.hint = `showing ${textHits.length} of ${totalTextMatches}${truncatedScan ? "+" : ""} literal matches \u2014 raise limit or narrow the query to get them all`;
+  }
+  return result;
 }
 function queryTokens(q2) {
   return [...new Set(q2.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2))];
@@ -5562,48 +5879,84 @@ function multiTokenNodes(graph, tokens) {
   }
   return [...cov.values()].sort((a, b) => b.hits - a.hits || b.node.importance - a.node.importance).map((e) => e.node);
 }
-function scanFiles(root, needle, budget, seen, out) {
-  const lower = needle.toLowerCase();
-  let scanned = 0;
+async function scanFiles(root, needle, budget, seen, out, countAll) {
+  const listing = listCandidateFiles(root, needle);
+  const outcome = await scanCandidates(root, listing.files, needle, { collectAll: countAll, budget });
+  let overlap = 0;
+  for (const h of outcome.hits) {
+    if (seen.has(`${h.file}:${h.line}`)) {
+      overlap++;
+      continue;
+    }
+    seen.add(`${h.file}:${h.line}`);
+    if (out.length < budget) out.push({ kind: "text", file: h.file, line: h.line, preview: h.preview });
+  }
+  return { total: outcome.total - overlap, truncated: listing.truncated || outcome.truncated };
+}
+function listCandidateFiles(root, needle) {
+  return ripgrepCandidates(root, needle) ?? walkCandidates(root);
+}
+function walkCandidates(root) {
+  const files = [];
+  let truncated = false;
   const stack = [root];
   while (stack.length) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs19.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);
+      const abs = path19.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 {
+      if (files.length >= MAX_FILES_SCANNED) {
+        truncated = true;
         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;
-      }
+      files.push(path19.relative(root, abs));
     }
   }
-  return false;
+  files.sort();
+  return { files, truncated };
+}
+var rgAvailable;
+function hasRipgrep() {
+  if (process.env.VG_DISABLE_RIPGREP) return false;
+  if (rgAvailable === void 0) {
+    try {
+      rgAvailable = spawnSync("rg", ["--version"], { stdio: "ignore", timeout: 3e3 }).status === 0;
+    } catch {
+      rgAvailable = false;
+    }
+  }
+  return rgAvailable;
+}
+function ripgrepCandidates(root, needle) {
+  if (!hasRipgrep()) return null;
+  const globs = [...IGNORE_DIRS].flatMap((d) => ["--glob", `!**/${d}/**`, "--glob", `!${d}/**`]);
+  const res = spawnSync(
+    "rg",
+    ["--files-with-matches", "--fixed-strings", "--ignore-case", "--no-ignore", "--no-messages", ...globs, "--", needle, "."],
+    { cwd: root, encoding: "utf8", timeout: 15e3, maxBuffer: 32 * 1024 * 1024 }
+  );
+  if (res.error || res.status !== 0 && res.status !== 1 || res.signal) return null;
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of res.stdout.split("\n")) {
+    const rel2 = raw.startsWith("./") ? raw.slice(2) : raw;
+    if (!rel2) continue;
+    const segs = rel2.split("/");
+    if (segs.some((s) => s.startsWith(".") || IGNORE_DIRS.has(s))) continue;
+    seen.add(rel2);
+  }
+  const files = [...seen].sort();
+  if (files.length > MAX_FILES_SCANNED) return { files: files.slice(0, MAX_FILES_SCANNED), truncated: true };
+  return { files, truncated: false };
 }
 
 // src/mcp/tools.ts
@@ -5722,16 +6075,16 @@ var TOOLS = [
   },
   {
     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.",
+    description: "Find a known name or literal string fast: ranked symbol lookup, plus a complete literal file-search for any quoted/multi-word phrase (config keys, log lines, UI copy). A phrase query reports totalTextMatches so you know you have every occurrence \u2014 use it instead of grep. 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: { type: "string", maxLength: 120, description: "a symbol name, or a literal phrase to sweep for every occurrence of" },
+        limit: { type: "number", description: "default 8, max 50 (raise it to fetch a whole literal sweep in one call)" }
       },
       ["query"]
     ),
-    handler: (graph, args, ctx) => {
-      const limit = Math.min(20, numOr(args.limit, 8));
+    handler: async (graph, args, ctx) => {
+      const limit = Math.min(50, numOr(args.limit, 8));
       return searchSymbols(graph, ctx.root, String(args.query ?? ""), limit);
     }
   },
@@ -5787,7 +6140,7 @@ var TOOLS = [
     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 index = indexFor(graph);
       const edgeOk = edgeRecordFilter(args);
       const calleeRecs = index.callees(node.id).filter(edgeOk);
       const callerRecs = index.callers(node.id).filter(edgeOk);
@@ -6273,104 +6626,6 @@ function navigationToolsetConfig(serverName = "vibgrate") {
     configs: Object.fromEntries(HOT_TOOLS.map((n) => [n, { defer_loading: false }]))
   };
 }
-var LEDGER = "savings.jsonl";
-var PER_FILE_TOKENS = 400;
-var SAVINGS_TOOLS = /* @__PURE__ */ new Set(["query_graph", "get_node"]);
-function ledgerPath(root) {
-  return path18.join(cacheDir(root), LEDGER);
-}
-function savingsRecorded(root) {
-  return fs18.existsSync(ledgerPath(root));
-}
-function recordSaving(root, entry, now) {
-  try {
-    fs18.mkdirSync(cacheDir(root), { recursive: true });
-    const line = JSON.stringify({ ts: now, ...entry });
-    fs18.appendFileSync(ledgerPath(root), line + "\n");
-  } catch {
-  }
-}
-var DEFAULT_RATE_PER_M = 3;
-var DEFAULT_RATE_LABEL = "input @ $3/1M";
-function readSavings(root, days, now, ratePerM = DEFAULT_RATE_PER_M) {
-  const file = ledgerPath(root);
-  const cutoff = now - days * 24 * 60 * 60 * 1e3;
-  let queries = 0;
-  let vgTokens = 0;
-  let baselineTokens = 0;
-  if (fs18.existsSync(file)) {
-    for (const line of fs18.readFileSync(file, "utf8").split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const e = JSON.parse(line);
-        if (e.ts < cutoff) continue;
-        if (!SAVINGS_TOOLS.has(e.tool)) continue;
-        queries++;
-        vgTokens += e.vgTokens;
-        baselineTokens += e.baselineTokens;
-      } catch {
-      }
-    }
-  }
-  const estCostVg = vgTokens / 1e6 * ratePerM;
-  const estCostBaseline = baselineTokens / 1e6 * ratePerM;
-  return {
-    enabled: savingsRecorded(root),
-    days,
-    queries,
-    vgTokens,
-    baselineTokens,
-    ratio: vgTokens > 0 ? Math.round(baselineTokens / vgTokens * 100) / 100 : 0,
-    estCostVg: round22(estCostVg),
-    estCostBaseline: round22(estCostBaseline),
-    saved: round22(estCostBaseline - estCostVg),
-    rateLabel: DEFAULT_RATE_LABEL
-  };
-}
-function round22(x) {
-  return Math.round(x * 100) / 100;
-}
-function readUsage(root, days, now) {
-  const file = ledgerPath(root);
-  const cutoff = now - days * 24 * 60 * 60 * 1e3;
-  const byTool = /* @__PURE__ */ new Map();
-  if (fs18.existsSync(file)) {
-    for (const line of fs18.readFileSync(file, "utf8").split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const e = JSON.parse(line);
-        if (e.ts < cutoff) continue;
-        const outcome = e.outcome ?? "complete";
-        const row = byTool.get(e.tool) ?? { complete: 0, partial: 0, miss: 0 };
-        row[outcome]++;
-        byTool.set(e.tool, row);
-      } catch {
-      }
-    }
-  }
-  const commands = [...byTool.entries()].map(([tool, r]) => {
-    const calls = r.complete + r.partial + r.miss;
-    return {
-      tool,
-      calls,
-      complete: r.complete,
-      partial: r.partial,
-      miss: r.miss,
-      successPct: calls ? Math.round((r.complete + r.partial) / calls * 100) : 0
-    };
-  }).sort((a, b) => b.calls - a.calls || a.tool.localeCompare(b.tool));
-  const totals = commands.reduce(
-    (t, c) => ({
-      calls: t.calls + c.calls,
-      complete: t.complete + c.complete,
-      partial: t.partial + c.partial,
-      miss: t.miss + c.miss
-    }),
-    { calls: 0, complete: 0, partial: 0, miss: 0 }
-  );
-  const avgSuccessPct = commands.length ? Math.round(commands.reduce((s, c) => s + c.successPct, 0) / commands.length) : 0;
-  return { enabled: savingsRecorded(root), days, commands, totals, avgSuccessPct };
-}
 var PROBE_INTERVAL_MS = 2e3;
 var MAX_PROBE_INTERVAL_MS = 3e4;
 var PROBE_DUTY_FACTOR = 20;
@@ -6381,7 +6636,7 @@ var GraphSource = class {
     this.graphPath = graphPath;
     this.refresh = refresh;
     this.tuning = tuning;
-    this.root = path18.dirname(path18.dirname(graphPath));
+    this.root = path19.dirname(path19.dirname(graphPath));
   }
   graphPath;
   refresh;
@@ -6397,9 +6652,9 @@ var GraphSource = class {
   /** Current graph: auto-refreshed if the tree drifted, reloaded if the file changed. */
   async get() {
     if (this.refresh) await this.maybeRefresh();
-    const stat = fs18.statSync(this.graphPath);
+    const stat = fs19.statSync(this.graphPath);
     if (stat.mtimeMs !== this.cachedMtimeMs || !this.cached) {
-      this.cached = parseGraph(fs18.readFileSync(this.graphPath, "utf8"));
+      this.cached = parseGraph(fs19.readFileSync(this.graphPath, "utf8"));
       this.cachedMtimeMs = stat.mtimeMs;
     }
     return this.cached;
@@ -6433,8 +6688,9 @@ var GraphSource = class {
   }
 };
 function createServer(source, opts = {}) {
-  const { savings = false, local = false, dedup = false } = opts;
-  const root = path18.dirname(path18.dirname(source.graphPath));
+  const { savings = false, shareStats = false, local = false, dedup = false } = opts;
+  const record = savings || shareStats;
+  const root = path19.dirname(path19.dirname(source.graphPath));
   const seen = /* @__PURE__ */ new Set();
   const server = new Server(
     { name: "vg", version: VERSION },
@@ -6443,7 +6699,7 @@ function createServer(source, opts = {}) {
       // 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.'
+      instructions: 'vg is a code map. Use search_symbols to find a known name or literal string fast \u2014 a multi-word/quoted phrase runs a complete literal sweep and reports totalTextMatches, so reach for it instead of grep even for plain-string "find every occurrence" lookups. 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 () => ({
@@ -6470,7 +6726,7 @@ function createServer(source, opts = {}) {
     try {
       const args = request.params.arguments ?? {};
       const result = await tool.handler(graph, args, { root, local, dedup, seen });
-      if (savings) recordUsage(root, tool.name, result);
+      if (record) recordUsage(root, tool.name, result, detectClient(server));
       return renderToolResult(result);
     } catch (err) {
       return errorResult(`tool "${tool.name}" failed: ${err.message}`);
@@ -6490,7 +6746,7 @@ function sleep(ms) {
     timer.unref?.();
   });
 }
-function recordUsage(root, tool, result) {
+function recordUsage(root, tool, result, client) {
   const outcome = classifyOutcome(result);
   let vgTokens = 0;
   let baselineTokens = 0;
@@ -6498,7 +6754,19 @@ function recordUsage(root, tool, result) {
     vgTokens = countTokens(renderedText(renderToolResult(result)));
     baselineTokens = referencedFiles(result).size * PER_FILE_TOKENS;
   }
-  recordSaving(root, { tool, outcome, vgTokens, baselineTokens }, Date.now());
+  recordSaving(
+    root,
+    { tool, outcome, vgTokens, baselineTokens, source: "mcp", client: sanitizeClient(client) },
+    Date.now()
+  );
+}
+function detectClient(server) {
+  try {
+    const info = server.getClientVersion?.();
+    return typeof info?.name === "string" ? info.name : void 0;
+  } catch {
+    return void 0;
+  }
 }
 function classifyOutcome(result) {
   if (Array.isArray(result)) return result.length === 0 ? "miss" : "complete";
@@ -6549,7 +6817,11 @@ function errorResult(message) {
 // src/install/content.ts
 var NUDGE_BEGIN = "<!-- vg:begin -->";
 var NUDGE_END = "<!-- vg:end -->";
-function skillMarkdown() {
+function clientFlag(client) {
+  return client ? `--client=${client}` : "--client=<your-ai>";
+}
+function skillMarkdown(client) {
+  const cf = clientFlag(client);
   return `---
 name: vg
 description: Query the local code graph (vg) for structure, impact, and navigation instead of grepping/reading many files.
@@ -6560,13 +6832,26 @@ description: Query the local code graph (vg) for structure, impact, and navigati
 This repo has a deterministic code graph built by \`vg\`. Prefer it over reading or
 grepping many files \u2014 it is smaller, more relevant context, and free.
 
-## When to use it
+## Prefer the MCP tools
+
+If the \`vg\` MCP server is registered (it is after \`vg install\`), call its
+read-only tools directly \u2014 they are the **fastest** path. The server keeps the
+map parsed, the relation index warm, and the embedding model loaded across calls,
+so each query is cheaper than spawning the CLI fresh. Use:
+\`query_graph\`, \`get_node\`, \`impact_of\`, \`find_path\`, \`list_hubs\`, \`list_areas\`,
+\`get_graph_summary\`, \`search_symbols\`. They are side-effect-free and
+auto-approvable, and the server records which client is calling automatically.
+
+## If you use the \`vg\` CLI instead
 
-- **Understand code:** \`vg "<question>"\` returns a budget-bounded, fact-annotated
-  context block. Start here instead of opening files blindly.
-- **Find a symbol:** \`vg show <name>\` \u2014 what it is, what it calls, what calls it.
-- **Before changing something:** \`vg impact <name>\` \u2014 what breaks if you change it.
-- **Navigate:** \`vg path <A> <B>\`, \`vg tree <name>\`, \`vg hubs\`, \`vg areas\`.
+When the MCP server isn't available, use the CLI \u2014 and **always pass \`${cf}\`**
+so your calls are counted (that's how the CLI-vs-MCP split is measured and the
+tools improved):
+
+- **Understand code:** \`vg "<question>" ${cf}\` \u2014 a budget-bounded, fact-annotated context block.
+- **Find a symbol:** \`vg show <name> ${cf}\` \u2014 what it is, what it calls, what calls it.
+- **Before changing something:** \`vg impact <name> ${cf}\` \u2014 what breaks if you change it.
+- **Navigate:** \`vg path <A> <B> ${cf}\`, \`vg tree <name> ${cf}\`.
 
 ## Dependencies & library docs
 
@@ -6576,12 +6861,6 @@ grepping many files \u2014 it is smaller, more relevant context, and free.
 - **Version-correct docs:** \`vg lib <name>\` returns drift-annotated, version-
   specific usage docs for a library \u2014 inject these instead of guessing an API.
 
-## Via MCP
-
-If the \`vg\` MCP server is registered, call its read-only tools directly:
-\`query_graph\`, \`get_node\`, \`impact_of\`, \`find_path\`, \`list_hubs\`, \`list_areas\`,
-\`get_graph_summary\`. They are side-effect-free and auto-approvable.
-
 ## Keep it fresh
 
 The map keeps itself fresh: \`vg ask\` and the MCP tools detect changed files
@@ -6591,28 +6870,33 @@ The map lives at \`.vibgrate/graph.json\` and is deterministic (byte-identical
 across machines).
 `;
 }
-function nudgeMarkdown(smallRepo) {
+function nudgeMarkdown(smallRepo, client) {
+  const cf = clientFlag(client);
   if (smallRepo) {
     return `${NUDGE_BEGIN}
 ## Code navigation (vg)
 
 This repo is small enough that searching files directly is fine. Still, before a
-change, \`vg impact <name>\` shows what it breaks, and \`vg "<question>"\` gives a
-compact, cited context block when you want one.
+change, \`vg impact <name> ${cf}\` shows what it breaks, and \`vg "<question>" ${cf}\`
+gives a compact, cited context block when you want one. Prefer the \`vg\` MCP tools
+when the server is registered; when you use the CLI, pass \`${cf}\` so the call is
+counted.
 ${NUDGE_END}`;
   }
   return `${NUDGE_BEGIN}
 ## Code navigation (vg) \u2014 prefer the map
 
 A deterministic code graph is available. It is usually the faster, cheaper path
-than reading or grepping many files:
+than reading or grepping many files. Prefer the \`vg\` MCP tools when the server is
+registered (fastest \u2014 the map and model stay warm across calls). When you use the
+CLI instead, pass \`${cf}\` so the call is counted:
 
-- \`vg "<question>"\` \u2014 a compact, fact-annotated context block for a question.
-- \`vg show <name>\` \u2014 what a symbol is, its callers and callees.
-- \`vg impact <name>\` \u2014 what breaks if you change it.
+- \`vg "<question>" ${cf}\` \u2014 a compact, fact-annotated context block for a question.
+- \`vg show <name> ${cf}\` \u2014 what a symbol is, its callers and callees.
+- \`vg impact <name> ${cf}\` \u2014 what breaks if you change it.
 
-Prefer these (or the \`vg\` MCP tools) before opening many files. This is advisory,
-not mandatory \u2014 remove it with \`vg uninstall\` (or delete this block).
+This is advisory, not mandatory \u2014 remove it with \`vg uninstall\` (or delete this
+block).
 ${NUDGE_END}`;
 }
 function mcpServerEntry(launch = { command: "vg", args: ["serve"] }) {
@@ -6702,19 +6986,19 @@ function installAssistant(a, opts) {
   const skipped = [];
   let note;
   if (a.skill) {
-    writeFileEnsured(path18.join(opts.root, a.skill), skillMarkdown());
+    writeFileEnsured(path19.join(opts.root, a.skill), skillMarkdown(a.id));
     wrote.push(a.skill);
   }
   if (a.mcp) {
     const launch = opts.launch ?? detectServeLaunch();
-    upsertMcp(path18.join(opts.root, a.mcp.file), a.mcp, launch);
+    upsertMcp(path19.join(opts.root, a.mcp.file), a.mcp, launch);
     wrote.push(a.mcp.file);
     note = launch.note;
   } else {
     skipped.push("mcp (host-specific setup)");
   }
   if (a.nudge && opts.hook !== false) {
-    writeNudge(path18.join(opts.root, a.nudge.file), a.nudge, opts.smallRepo);
+    writeNudge(path19.join(opts.root, a.nudge.file), a.nudge, opts.smallRepo, a.id);
     wrote.push(a.nudge.file);
   } else if (a.nudge) {
     skipped.push("nudge (--no-hook)");
@@ -6724,40 +7008,40 @@ function installAssistant(a, opts) {
 function uninstallAssistant(a, root, purge) {
   const removed = [];
   if (a.mcp) {
-    const file = path18.join(root, a.mcp.file);
+    const file = path19.join(root, a.mcp.file);
     if (removeMcp(file, a.mcp)) removed.push(a.mcp.file);
   }
   if (a.nudge) {
-    const file = path18.join(root, a.nudge.file);
+    const file = path19.join(root, a.nudge.file);
     if (a.nudge.kind === "block") {
       if (removeBlock(file)) removed.push(a.nudge.file);
-    } else if (fs18.existsSync(file)) {
-      fs18.rmSync(file);
+    } else if (fs19.existsSync(file)) {
+      fs19.rmSync(file);
       removed.push(a.nudge.file);
     }
   }
   if (purge && a.skill) {
-    const file = path18.join(root, a.skill);
-    if (fs18.existsSync(file)) {
-      fs18.rmSync(file);
+    const file = path19.join(root, a.skill);
+    if (fs19.existsSync(file)) {
+      fs19.rmSync(file);
       removed.push(a.skill);
     }
   }
   return removed;
 }
 function writeFileEnsured(file, content) {
-  fs18.mkdirSync(path18.dirname(file), { recursive: true });
-  fs18.writeFileSync(file, content);
+  fs19.mkdirSync(path19.dirname(file), { recursive: true });
+  fs19.writeFileSync(file, content);
 }
 function writeNavigationConfig(root) {
-  const rel2 = path18.join(".vibgrate", "mcp-navigation.json");
+  const rel2 = path19.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)}
+  writeFileEnsured(path19.join(root, rel2), `${JSON.stringify(doc, null, 2)}
 `);
   return rel2;
 }
@@ -6772,7 +7056,7 @@ function upsertMcp(file, target, launch) {
 `);
 }
 function removeMcp(file, target) {
-  if (!fs18.existsSync(file)) return false;
+  if (!fs19.existsSync(file)) return false;
   const config = readJson(file);
   const bag = config[target.key];
   if (!bag || !(bag.vg !== void 0)) return false;
@@ -6781,22 +7065,22 @@ function removeMcp(file, target) {
 `);
   return true;
 }
-function writeNudge(file, target, smallRepo) {
+function writeNudge(file, target, smallRepo, client) {
   if (target.kind === "file") {
     const body = file.endsWith(".mdc") ? `---
 description: vg code graph
 alwaysApply: true
 ---
-${stripMarkers(nudgeMarkdown(smallRepo))}` : stripMarkers(nudgeMarkdown(smallRepo));
+${stripMarkers(nudgeMarkdown(smallRepo, client))}` : stripMarkers(nudgeMarkdown(smallRepo, client));
     writeFileEnsured(file, `${body}
 `);
     return;
   }
-  upsertBlock(file, nudgeMarkdown(smallRepo));
+  upsertBlock(file, nudgeMarkdown(smallRepo, client));
 }
 function upsertBlock(file, block) {
-  fs18.mkdirSync(path18.dirname(file), { recursive: true });
-  let existing = fs18.existsSync(file) ? fs18.readFileSync(file, "utf8") : "";
+  fs19.mkdirSync(path19.dirname(file), { recursive: true });
+  let existing = fs19.existsSync(file) ? fs19.readFileSync(file, "utf8") : "";
   const re = new RegExp(`${escapeRe(NUDGE_BEGIN)}[\\s\\S]*?${escapeRe(NUDGE_END)}`);
   if (re.test(existing)) existing = existing.replace(re, block);
   else existing = existing.length ? `${existing.replace(/\s*$/, "")}
@@ -6804,20 +7088,20 @@ function upsertBlock(file, block) {
 ${block}
 ` : `${block}
 `;
-  fs18.writeFileSync(file, existing);
+  fs19.writeFileSync(file, existing);
 }
 function removeBlock(file) {
-  if (!fs18.existsSync(file)) return false;
-  const existing = fs18.readFileSync(file, "utf8");
+  if (!fs19.existsSync(file)) return false;
+  const existing = fs19.readFileSync(file, "utf8");
   const re = new RegExp(`\\n*${escapeRe(NUDGE_BEGIN)}[\\s\\S]*?${escapeRe(NUDGE_END)}\\n*`);
   if (!re.test(existing)) return false;
-  fs18.writeFileSync(file, existing.replace(re, "\n"));
+  fs19.writeFileSync(file, existing.replace(re, "\n"));
   return true;
 }
 function readJson(file) {
-  if (!fs18.existsSync(file)) return {};
+  if (!fs19.existsSync(file)) return {};
   try {
-    const parsed = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs19.readFileSync(file, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -7039,6 +7323,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, 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, readUsage, 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-2DJ3UXG7.js.map
-//# sourceMappingURL=chunk-2DJ3UXG7.js.map
+export { ASSISTANTS, CLI_TOOL_ALIASES, 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, countTokens, 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, indexFor, 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, readUsage, recordCliCall, 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-3TCE6IGZ.js.map
+//# sourceMappingURL=chunk-3TCE6IGZ.js.map