@vibgrate/cli 2026.708.2 → 2026.709.1

package/dist/{chunk-AWEAREOE.js → chunk-MPKMAERO.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-ICBBG6U3.js';
-import * as fs18 from 'fs';
+import { writeTextFile, pathExists, readJsonFile, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-PXZ5KPVN.js';
+import * as fs19 from 'fs';
 import { execFileSync } from 'child_process';
-import * as path18 from 'path';
+import * as path19 from 'path';
 import ignore from 'ignore';
 import * as v8 from 'v8';
 import Graph from 'graphology';
@@ -38,9 +38,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 +50,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 +216,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 +237,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 +268,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 +434,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 +508,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 +517,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 +535,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 +553,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 +566,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 +588,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 +618,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 +632,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 +1137,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 +1153,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 +1490,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 +1545,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 +1585,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 +2002,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 +2019,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 +2042,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 +2075,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 +2103,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 +2121,7 @@ async function buildGraph(options) {
     }
     let hash = "";
     try {
-      hash = hashBytes(fs18.readFileSync(file.abs));
+      hash = hashBytes(fs19.readFileSync(file.abs));
     } catch {
       continue;
     }
@@ -2213,7 +2213,7 @@ async function buildGraph(options) {
       toolchain
     },
     meta: {
-      root: path18.basename(root) === "" ? "." : ".",
+      root: path19.basename(root) === "" ? "." : ".",
       languages,
       counts: {
         nodes: analysis.nodes.length,
@@ -2259,14 +2259,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 +2427,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 +2543,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 +2554,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 +2566,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 +2575,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 +2585,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 +2609,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 +2624,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 +2645,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 +2659,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 +2674,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 +2772,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 +2787,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 +2798,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 +2818,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 +2859,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 +2909,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 +2917,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 +2934,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 +3005,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 +3064,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 +3081,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 +3224,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 +3255,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 +3275,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 +3502,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 +3549,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 +3563,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 +3583,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 +3594,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 +3608,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 +3680,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 +3688,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 +3704,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 +3719,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 +3741,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 +3770,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 +3789,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 +3877,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 +3895,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 +3927,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 +3942,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 +3959,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 +3979,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 +4001,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 +4026,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 +4076,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 +4089,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 +4115,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 +4151,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 +4161,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 +4177,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 +4201,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 +4211,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 +4226,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 +4251,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 +4268,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 +4287,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 +4299,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 +4327,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 +4347,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 +4423,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 +4449,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 +4468,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 +4494,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 +4537,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 +4545,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 +4583,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 +4597,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 +4763,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 +4788,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 +4820,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 +5160,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 +5217,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;
   }
@@ -5570,14 +5730,14 @@ function scanFiles(root, needle, budget, seen, out) {
     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;
@@ -5585,13 +5745,13 @@ function scanFiles(root, needle, budget, seen, out) {
       if (++scanned > MAX_FILES_SCANNED) return true;
       let text;
       try {
-        if (fs18.statSync(abs).size > MAX_FILE_BYTES) continue;
-        text = fs18.readFileSync(abs, "utf8");
+        if (fs19.statSync(abs).size > MAX_FILE_BYTES) continue;
+        text = fs19.readFileSync(abs, "utf8");
       } catch {
         continue;
       }
       if (!text.toLowerCase().includes(lower)) continue;
-      const rel2 = path18.relative(root, abs);
+      const rel2 = path19.relative(root, abs);
       const lines = text.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (!lines[i].toLowerCase().includes(lower)) continue;
@@ -5787,7 +5947,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 +6433,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 +6443,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 +6459,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 +6495,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 },
@@ -6470,7 +6533,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 +6553,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 +6561,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 +6624,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 +6639,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
+
+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>"\` 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\`.
+- **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 +6668,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 +6677,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 +6793,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 +6815,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 +6863,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 +6872,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 +6895,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 +7130,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-AWEAREOE.js.map
-//# sourceMappingURL=chunk-AWEAREOE.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-MPKMAERO.js.map
+//# sourceMappingURL=chunk-MPKMAERO.js.map